[PATCH 07/16] Add test-functions.c to unittests

[David Malcolm <dmalcolm@redhat.com>]

gcc/testsuite/ChangeLog:
	* unittests/test-functions.c: New file.
---
 gcc/testsuite/unittests/test-functions.c | 645 +++++++++++++++++++++++++++++++
 1 file changed, 645 insertions(+)
 create mode 100644 gcc/testsuite/unittests/test-functions.c

diff --git a/gcc/testsuite/unittests/test-functions.c b/gcc/testsuite/unittests/test-functions.c
new file mode 100644
index 0000000..56630b5
--- /dev/null
+++ b/gcc/testsuite/unittests/test-functions.c
@@ -0,0 +1,645 @@
+/* Unit tests for function-handling.
+   Copyright (C) 2015 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
+
+#include "config.h"
+#include "gtest/gtest.h"
+#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
+#include "opts.h"
+#include "signop.h"
+#include "hash-set.h"
+#include "fixed-value.h"
+#include "alias.h"
+#include "flags.h"
+#include "symtab.h"
+#include "tree-core.h"
+#include "stor-layout.h"
+#include "tree.h"
+#include "stringpool.h"
+#include "stor-layout.h"
+#include "rtl.h"
+#include "predict.h"
+#include "vec.h"
+#include "hashtab.h"
+#include "hash-set.h"
+#include "machmode.h"
+#include "hard-reg-set.h"
+#include "input.h"
+#include "function.h"
+#include "dominance.h"
+#include "cfg.h"
+#include "cfganal.h"
+#include "basic-block.h"
+#include "tree-ssa-alias.h"
+#include "internal-fn.h"
+#include "gimple-fold.h"
+#include "gimple-expr.h"
+#include "toplev.h"
+#include "print-tree.h"
+#include "tree-iterator.h"
+#include "gimplify.h"
+#include "tree-cfg.h"
+#include "basic-block.h"
+#include "double-int.h"
+#include "alias.h"
+#include "symtab.h"
+#include "wide-int.h"
+#include "inchash.h"
+#include "tree.h"
+#include "fold-const.h"
+#include "stor-layout.h"
+#include "stmt.h"
+#include "hash-table.h"
+#include "tree-ssa-alias.h"
+#include "internal-fn.h"
+#include "gimple-expr.h"
+#include "is-a.h"
+#include "gimple.h"
+#include "tree-pass.h"
+#include "context.h"
+#include "hash-map.h"
+#include "plugin-api.h"
+#include "ipa-ref.h"
+#include "cgraph.h"
+
+namespace {
+
+class function_test : public ::testing::Test
+{
+ protected:
+  tree
+  make_fndecl (tree return_type,
+	       const char *name,
+	       vec <tree> &param_types,
+	       bool is_variadic = false)
+  {
+    tree fn_type;
+    if (is_variadic)
+      fn_type = build_varargs_function_type_array (return_type,
+						   param_types.length (),
+						   param_types.address ());
+    else
+      fn_type = build_function_type_array (return_type,
+					   param_types.length (),
+					   param_types.address ());
+    /* FIXME: this uses input_location: */
+    tree fndecl = build_fn_decl (name, fn_type);
+
+    return fndecl;
+  }
+};
+
+TEST_F (function_test, fndecl_int_void)
+{
+  auto_vec <tree> param_types;
+  tree fndecl = make_fndecl (integer_type_node,
+			     "test_fndecl_int_void",
+			     param_types);
+  ASSERT_TRUE (fndecl != NULL);
+  if (0)
+    debug_tree (fndecl);
+
+  /* Verify name of decl.  */
+  tree declname = DECL_NAME (fndecl);
+  ASSERT_TRUE (declname != NULL);
+  EXPECT_EQ (IDENTIFIER_NODE, TREE_CODE (declname));
+  /* We expect it to use a *copy* of the string we passed in.  */
+  const char *identifier_ptr = IDENTIFIER_POINTER (declname);
+  EXPECT_NE ("test_fndecl_int_void", identifier_ptr);
+  EXPECT_EQ (0, strcmp ("test_fndecl_int_void", identifier_ptr));
+
+  /* Verify type of fndecl.  */
+  EXPECT_EQ (FUNCTION_DECL, TREE_CODE (fndecl));
+  tree fntype = TREE_TYPE (fndecl);
+  EXPECT_EQ (FUNCTION_TYPE, TREE_CODE (fntype));
+
+  /* Verify return type.  */
+  EXPECT_EQ (integer_type_node, TREE_TYPE (fntype));
+
+  /* Verify "void" args.  */
+  tree argtypes = TYPE_ARG_TYPES (fntype);
+  EXPECT_EQ (TREE_LIST, TREE_CODE (argtypes));
+  EXPECT_EQ (void_type_node, TREE_VALUE (argtypes));
+  EXPECT_EQ (NULL, TREE_CHAIN (argtypes));
+}
+
+TEST_F (function_test, fndecl_float_intchar)
+{
+  auto_vec <tree> param_types;
+  param_types.safe_push (integer_type_node);
+  param_types.safe_push (char_type_node);
+  tree fndecl = make_fndecl (float_type_node,
+			     "test_fndecl_float_intchar",
+			     param_types);
+  ASSERT_TRUE (fndecl != NULL);
+  if (0)
+    debug_tree (fndecl);
+
+  /* Verify name of decl.  */
+  tree declname = DECL_NAME (fndecl);
+  ASSERT_TRUE (declname != NULL);
+  EXPECT_EQ (IDENTIFIER_NODE, TREE_CODE (declname));
+  /* We expect it to use a *copy* of the string we passed in.  */
+  const char *identifier_ptr = IDENTIFIER_POINTER (declname);
+  EXPECT_NE ("test_fndecl_float_intchar", identifier_ptr);
+  EXPECT_EQ (0, strcmp ("test_fndecl_float_intchar", identifier_ptr));
+
+  /* Verify type of fndecl.  */
+  EXPECT_EQ (FUNCTION_DECL, TREE_CODE (fndecl));
+  tree fntype = TREE_TYPE (fndecl);
+  EXPECT_EQ (FUNCTION_TYPE, TREE_CODE (fntype));
+
+  /* Verify return type.  */
+  EXPECT_EQ (float_type_node, TREE_TYPE (fntype));
+
+  /* Verify "(int, char)" args.  */
+  tree arg0 = TYPE_ARG_TYPES (fntype);
+  EXPECT_EQ (TREE_LIST, TREE_CODE (arg0));
+  EXPECT_EQ (integer_type_node, TREE_VALUE (arg0));
+  tree arg1 = TREE_CHAIN (arg0);
+  ASSERT_TRUE (arg1 != NULL);
+  EXPECT_EQ (TREE_LIST, TREE_CODE (arg1));
+  EXPECT_EQ (char_type_node, TREE_VALUE (arg1));
+  tree argterm = TREE_CHAIN (arg1);
+  ASSERT_TRUE (argterm != NULL);
+  EXPECT_EQ (TREE_LIST, TREE_CODE (argterm));
+  EXPECT_EQ (void_type_node, TREE_VALUE (argterm));
+  EXPECT_EQ (NULL, TREE_CHAIN (argterm));
+}
+
+/* The test cases using this fixture take a trivial function:
+
+     int test_fn (void) { return 42; }
+
+   and test various conversions done to it:
+
+   - gimplification
+   - construction of the CFG
+   - conversion to SSA form
+   - expansion to RTL form
+
+   In avoid having one overlong test case, this is broken
+   up into separate test cases for each stage, with helper methods
+   in this fixture to minimize code duplication.
+
+   Another approach would be to attempt to directly construct a function
+   in the appropriate representation at each stage, though presumably
+   that would exhibit different kinds of failure compared to this
+   approach.  */
+
+class representation_test : public function_test
+{
+ protected:
+  /* Construct this function:
+       int test_fn (void) { return 42; }
+     in generic tree form.  Return the fndecl.  */
+  tree
+  build_trivial_generic_function ()
+  {
+    auto_vec <tree> param_types;
+    tree fndecl = make_fndecl (integer_type_node,
+			       "test_fn",
+			       param_types);
+    EXPECT_TRUE (fndecl != NULL);
+
+    /* Populate the function.  */
+    tree retval = build_decl (UNKNOWN_LOCATION, RESULT_DECL,
+			      NULL_TREE, integer_type_node);
+    DECL_ARTIFICIAL (retval) = 1;
+    DECL_IGNORED_P (retval) = 1;
+    DECL_RESULT (fndecl) = retval;
+
+    /* Create a BIND_EXPR, and within it, a statement list.  */
+    tree stmt_list = alloc_stmt_list ();
+    tree_stmt_iterator stmt_iter = tsi_start (stmt_list);
+    tree block = make_node (BLOCK);
+    tree bind_expr =
+      build3 (BIND_EXPR, void_type_node, NULL, stmt_list, block);
+
+    tree modify_retval = build2 (MODIFY_EXPR,
+				 integer_type_node,
+				 retval,
+				 build_int_cst (integer_type_node, 42));
+    tree return_stmt = build1 (RETURN_EXPR,
+			       integer_type_node,
+			       modify_retval);
+    tsi_link_after (&stmt_iter, return_stmt, TSI_CONTINUE_LINKING);
+
+    DECL_INITIAL (fndecl) = block;
+
+    /* how to add to function? the following appears to be how to
+       set the body of a fndecl: */
+    DECL_SAVED_TREE(fndecl) = bind_expr;
+
+    /* Ensure that locals appear in the debuginfo.  */
+    BLOCK_VARS (block) = BIND_EXPR_VARS (bind_expr);
+
+    if (0)
+      debug_tree (fndecl);
+
+    return fndecl;
+  }
+
+  /* Construct this function:
+       int test_fn (void) { return 42; }
+     in "high gimple" form.  Return the fndecl.  */
+  tree
+  build_trivial_high_gimple_function ()
+  {
+    /* Construct a trivial function, and gimplify it: */
+    tree fndecl = build_trivial_generic_function ();
+    gimplify_function_tree (fndecl);
+    return fndecl;
+  }
+
+  /* Build a CFG for a function in gimple form.  */
+  void
+  build_cfg (tree fndecl)
+  {
+    function *fun = DECL_STRUCT_FUNCTION (fndecl);
+    ASSERT_TRUE (fun != NULL);
+    EXPECT_EQ (fndecl, fun->decl);
+
+    /* We first have to lower control flow; for our trivial test function
+       this gives us:
+	 test_fn ()
+	 {
+	   D.56 = 42;
+	   goto <D.57>;
+	   <D.57>:
+	   return D.56;
+	 }
+    */
+    gimple_opt_pass *lower_cf_pass = make_pass_lower_cf (g);
+    push_cfun (fun);
+    lower_cf_pass->execute (fun);
+    pop_cfun ();
+    if (0)
+      dump_function_to_file (fndecl, stderr, 0);
+
+    /* We can now convert to CFG form; for our trivial test function this
+       gives us:
+	 test_fn ()
+	 {
+	   <bb 2>:
+	   D.56 = 42;
+	   return D.56;
+	 }
+    */
+    gimple_opt_pass *build_cfg_pass = make_pass_build_cfg (g);
+    push_cfun (fun);
+    build_cfg_pass->execute (fun);
+    pop_cfun ();
+    if (0)
+      dump_function_to_file (fndecl, stderr, 0);
+  }
+
+  /* Convert a gimple+CFG function to SSA form.  */
+  void
+  convert_to_ssa (tree fndecl)
+  {
+    function *fun = DECL_STRUCT_FUNCTION (fndecl);
+    ASSERT_TRUE (fun != NULL);
+    EXPECT_EQ (fndecl, fun->decl);
+
+    gimple_opt_pass *pass_init_datastructures =
+      make_pass_init_datastructures (g);
+    gimple_opt_pass *build_ssa_pass = make_pass_build_ssa (g);
+    push_cfun (fun);
+    pass_init_datastructures->execute (fun);
+    build_ssa_pass->execute (fun);
+    pop_cfun ();
+  }
+
+  /* Assuming we have a simple 3-block CFG like this:
+       [ENTRY] -> [block2] -> [EXIT]
+     get the "real" basic block (block 2).  */
+  basic_block
+  get_real_block (function *fun)
+  {
+    EXPECT_TRUE (fun->cfg != NULL);
+    EXPECT_EQ (3, n_basic_blocks_for_fn (fun));
+    basic_block bb2 = (*fun->cfg->x_basic_block_info)[2];
+    EXPECT_TRUE (bb2 != NULL);
+    return bb2;
+  }
+
+  /* Verify that we have a simple 3-block CFG: the two "fake" ones, and
+     a "real" one:
+     [ENTRY] -> [block2] -> [EXIT].  */
+  void
+  verify_three_block_cfg (function *fun)
+  {
+    ASSERT_TRUE (fun->cfg != NULL);
+    EXPECT_EQ (3, n_basic_blocks_for_fn (fun));
+    EXPECT_EQ (2, n_edges_for_fn (fun));
+
+    /* The "fake" basic blocks.  */
+    basic_block entry = ENTRY_BLOCK_PTR_FOR_FN (fun);
+    ASSERT_TRUE (entry != NULL);
+    EXPECT_EQ (ENTRY_BLOCK, entry->index);
+
+    basic_block exit = EXIT_BLOCK_PTR_FOR_FN (fun);
+    ASSERT_TRUE (exit != NULL);
+    EXPECT_EQ (EXIT_BLOCK, exit->index);
+
+    /* The "real" basic block.  */
+    basic_block bb2 = get_real_block (fun);
+    ASSERT_TRUE (bb2 != NULL);
+    EXPECT_EQ (2, bb2->index);
+
+    /* Verify connectivity.  */
+    EXPECT_EQ (NULL, entry->preds);
+    EXPECT_EQ (1, entry->succs->length ());
+
+    edge from_entry_to_bb2 = (*entry->succs)[0];
+    EXPECT_EQ (entry, from_entry_to_bb2->src);
+    EXPECT_EQ (bb2, from_entry_to_bb2->dest);
+
+    EXPECT_EQ (1, bb2->preds->length ());
+    EXPECT_EQ (from_entry_to_bb2, (*bb2->preds)[0]);
+    EXPECT_EQ (1, bb2->succs->length ());
+
+    edge from_bb2_to_exit = (*bb2->succs)[0];
+    EXPECT_EQ (bb2, from_bb2_to_exit->src);
+    EXPECT_EQ (exit, from_bb2_to_exit->dest);
+
+    EXPECT_EQ (1, exit->preds->length ());
+    EXPECT_EQ (from_bb2_to_exit, (*exit->preds)[0]);
+    EXPECT_EQ (NULL, exit->succs);
+  }
+
+  /* As above, but additionally verify the gimple statements are sane.  */
+  void
+  verify_three_block_gimple_cfg (function *fun)
+  {
+    verify_three_block_cfg (fun);
+
+    /* The "fake" basic blocks should be flagged as gimple, but with have no
+       statements.  */
+    basic_block entry = ENTRY_BLOCK_PTR_FOR_FN (fun);
+    ASSERT_TRUE (entry != NULL);
+    EXPECT_EQ (0, entry->flags & BB_RTL);
+    EXPECT_EQ (NULL, bb_seq (entry));
+
+    basic_block exit = EXIT_BLOCK_PTR_FOR_FN (fun);
+    ASSERT_TRUE (exit != NULL);
+    EXPECT_EQ (0, entry->flags & BB_RTL);
+    EXPECT_EQ (NULL, bb_seq (exit));
+
+    /* The "real" basic block should be flagged as gimple, and have one
+       or more statements.  */
+    basic_block bb2 = get_real_block (fun);
+    ASSERT_TRUE (bb2 != NULL);
+    EXPECT_EQ (0, entry->flags & BB_RTL);
+    EXPECT_TRUE (bb_seq (bb2) != NULL);
+  }
+
+  /* As above, but additionally verify the RTL insns are sane.  */
+  void
+  verify_three_block_rtl_cfg (function *fun)
+  {
+    verify_three_block_cfg (fun);
+
+    /* The "fake" basic blocks should be flagged as RTL, but with no
+       insns.  */
+    basic_block entry = ENTRY_BLOCK_PTR_FOR_FN (fun);
+    ASSERT_TRUE (entry != NULL);
+    EXPECT_EQ (BB_RTL, entry->flags & BB_RTL);
+    EXPECT_EQ (NULL, BB_HEAD (entry));
+
+    basic_block exit = EXIT_BLOCK_PTR_FOR_FN (fun);
+    ASSERT_TRUE (exit != NULL);
+    EXPECT_EQ (BB_RTL, entry->flags & BB_RTL);
+    EXPECT_EQ (NULL, BB_HEAD (exit));
+
+    /* The "real" basic block should be flagged as RTL, and have one
+       or more insns.  */
+    basic_block bb2 = get_real_block (fun);
+    ASSERT_TRUE (bb2 != NULL);
+    EXPECT_EQ (BB_RTL, entry->flags & BB_RTL);
+    EXPECT_TRUE (BB_HEAD (bb2) != NULL);
+  }
+
+};
+
+/* Test converting our trivial function:
+     int test_fn (void) { return 42; }
+   to gimple form.  */
+
+TEST_F (representation_test, gimplification)
+{
+  tree fndecl = build_trivial_generic_function ();
+
+  /* Convert to gimple: */
+  gimplify_function_tree (fndecl);
+
+  if (0)
+    dump_function_to_file (fndecl, stderr, 0);
+
+  /* Verify that we got gimple out of it.  */
+
+  /* The function is now in GIMPLE form but the CFG has not been
+     built yet.  */
+
+  /* We should have a struct function for the decl.  */
+  function *fun = DECL_STRUCT_FUNCTION (fndecl);
+  ASSERT_TRUE (fun != NULL);
+  EXPECT_EQ (fndecl, fun->decl);
+
+  /* We expect a GIMPLE_BIND, with two gimple statements within it:
+       tmp = 42;
+       return tmp;  */
+
+  gimple_seq seq_fn_body = gimple_body (fndecl);
+  EXPECT_TRUE (seq_fn_body != NULL);
+  gimple *bind_stmt = gimple_seq_first_stmt (seq_fn_body);
+  EXPECT_EQ (GIMPLE_BIND, gimple_code (bind_stmt));
+  EXPECT_EQ (NULL, bind_stmt->next);
+
+  gimple_seq seq_bind_body = gimple_bind_body (as_a <gbind *> (bind_stmt));
+
+  /* Verify that we have the 2 statements we expect.  */
+  EXPECT_TRUE (seq_bind_body != NULL);
+  gimple *stmt1 = gimple_seq_first_stmt (seq_bind_body);
+  ASSERT_TRUE (stmt1 != NULL);
+  EXPECT_EQ (GIMPLE_ASSIGN, gimple_code (stmt1));
+  gimple *stmt2 = stmt1->next;
+  ASSERT_TRUE (stmt2 != NULL);
+  EXPECT_EQ (stmt1, stmt2->prev);
+  EXPECT_EQ (GIMPLE_RETURN, gimple_code (stmt2));
+}
+
+/* Test of building a CFG for a function in high gimple form.  */
+
+TEST_F (representation_test, building_cfg)
+{
+  /* Construct a trivial function, and gimplify it: */
+  tree fndecl = build_trivial_high_gimple_function ();
+  function *fun = DECL_STRUCT_FUNCTION (fndecl);
+  ASSERT_TRUE (fun != NULL);
+
+  /* Build a CFG.  */
+  build_cfg (fndecl);
+
+  /* The CFG-building code constructs a 4-block cfg (with
+     ENTRY and EXIT):
+       test_fn ()
+       {
+         <bb 2>:
+	 D.65 = 42;
+
+	 <bb 3>:
+	 return D.65;
+       }
+     and then ought to merge blocks 2 and 3 in cleanup_tree_cfg.
+
+     Hence we should end up with a simple 3-block cfg, the two "fake" ones,
+     and a "real" one:
+       [ENTRY] -> [block2] -> [EXIT]
+     with code like this:
+	 test_fn ()
+	 {
+	   <bb 2>:
+	   D.56 = 42;
+	   return D.56;
+	 }
+  */
+  verify_three_block_gimple_cfg (fun);
+
+  /* Verify the statements within the "real" block.  */
+  basic_block bb2 = get_real_block (fun);
+  gimple *stmt_a = gimple_seq_first_stmt (bb_seq (bb2));
+  EXPECT_EQ (GIMPLE_ASSIGN, gimple_code (stmt_a));
+  gimple *stmt_b = stmt_a->next;
+  EXPECT_EQ (GIMPLE_RETURN, gimple_code (stmt_b));
+  EXPECT_EQ (NULL, stmt_b->next);
+}
+
+/* Test of conversion of gimple to SSA form.  */
+TEST_F (representation_test, conversion_to_ssa)
+{
+  /* As above, construct a trivial function, gimplify it, and build a CFG: */
+  tree fndecl = build_trivial_high_gimple_function ();
+  function *fun = DECL_STRUCT_FUNCTION (fndecl);
+  ASSERT_TRUE (fun != NULL);
+  build_cfg (fndecl);
+
+  convert_to_ssa (fndecl);
+
+  verify_three_block_gimple_cfg (fun);
+
+  /* For out trivial test function we should now have something like
+     this:
+       test_fn ()
+       {
+	 <bb 2>:
+	 _1 = 42;
+	 return _1;
+       }
+  */
+  if (0)
+    dump_function_to_file (fndecl, stderr, 0);
+  basic_block bb2 = get_real_block (fun);
+  gimple *stmt_a = gimple_seq_first_stmt (bb_seq (bb2));
+  EXPECT_EQ (GIMPLE_ASSIGN, gimple_code (stmt_a));
+
+  gimple *stmt_b = stmt_a->next;
+  EXPECT_EQ (GIMPLE_RETURN, gimple_code (stmt_b));
+  EXPECT_EQ (NULL, stmt_b->next);
+
+  greturn *return_stmt = as_a <greturn *> (stmt_b);
+  EXPECT_EQ (SSA_NAME, TREE_CODE (gimple_return_retval (return_stmt)));
+}
+
+/* Test of expansion from gimple-ssa to RTL.  */
+
+TEST_F (representation_test, expansion_to_rtl)
+{
+  /* As above, construct a trivial function, gimplify it, build a CFG,
+     and convert to SSA: */
+  tree fndecl = build_trivial_high_gimple_function ();
+  function *fun = DECL_STRUCT_FUNCTION (fndecl);
+  ASSERT_TRUE (fun != NULL);
+  build_cfg (fndecl);
+  convert_to_ssa (fndecl);
+
+  /* We need a cgraph_node for it.  */
+  cgraph_node::get_create (fndecl);
+  /* Normally, cgraph_node::expand () would call
+     init_function_start (and a bunch of other stuff),
+     and invoke the expand pass, but it also runs
+     all of the other passes.  So just do the minimum
+     needed to get from gimple-SSA to RTL.  */
+  rtl_opt_pass *expand_pass = make_pass_expand (g);
+  push_cfun (fun);
+  init_function_start (fndecl);
+  expand_pass->execute (fun);
+  pop_cfun ();
+
+  /* On x86_64, I get this:
+       (note 3 1 2 2 [bb 2] NOTE_INSN_BASIC_BLOCK)
+       (note 2 3 5 2 NOTE_INSN_FUNCTION_BEG)
+       (insn 5 2 6 2 (set (reg:SI 87 [ D.59 ])
+			  (const_int 42 [0x2a])) -1 (nil))
+       (insn 6 5 10 2 (set (reg:SI 88 [ <retval> ])
+			   (reg:SI 87 [ D.59 ])) -1 (nil))
+       (insn 10 6 11 2 (set (reg/i:SI 0 ax)
+			    (reg:SI 88 [ <retval> ])) -1 (nil))
+       (insn 11 10 0 2 (use (reg/i:SI 0 ax)) -1 (nil))
+   */
+  if (0)
+    dump_function_to_file (fndecl, stderr, 0);
+
+  verify_three_block_rtl_cfg (fun);
+
+  /* Verify as much of the RTL as we can whilst avoiding
+     target-specific behavior.  */
+  basic_block bb2 = get_real_block (fun);
+
+  /* Expect a NOTE_INSN_BASIC_BLOCK... */
+  rtx_insn *insn = BB_HEAD (bb2);
+  ASSERT_TRUE (insn != NULL);
+  EXPECT_EQ (NOTE, insn->code);
+  EXPECT_EQ (NOTE_INSN_BASIC_BLOCK, NOTE_KIND (insn));
+  EXPECT_EQ (bb2, NOTE_BASIC_BLOCK (insn));
+
+  /* ...followed by a NOTE_INSN_FUNCTION_BEG...  */
+  insn = NEXT_INSN (insn);
+  ASSERT_TRUE (insn != NULL);
+  EXPECT_EQ (NOTE, insn->code);
+  EXPECT_EQ (NOTE_INSN_FUNCTION_BEG, NOTE_KIND (insn));
+
+  /* ...followed by a SET of a reg to the const value.  */
+  insn = NEXT_INSN (insn);
+  ASSERT_TRUE (insn != NULL);
+  EXPECT_EQ (INSN, insn->code);
+  rtx pat = PATTERN (insn);
+  ASSERT_TRUE (pat != NULL);
+  EXPECT_EQ (SET, pat->code);
+  EXPECT_EQ (REG, SET_DEST (pat)->code);
+  EXPECT_EQ (CONST_INT, SET_SRC (pat)->code);
+  EXPECT_EQ (42, INTVAL (SET_SRC (pat)));
+
+  /* ...etc; any further checks are likely to over-specify things
+     and run us into target dependencies.  */
+}
+
+}  // anon namespace
-- 
1.8.5.3