GCC-3.4.6源代码学习笔记（170）

5.13.5.2.2.1.1.3.    发布汇编代码

回到 output_constant_def_contents ，如果变量有大于 1 字节的对齐要求，还要调用 ASM_OUTPUT_ALIGN 来输出这个信息，这里输出的是以 2 为底对齐量的对数。对于 x86 ，这个宏的定义是：

 

54    #define ASM_OUTPUT_ALIGN (FILE,LOG)       /                                                in att.h

55        if ((LOG)!=0) fprintf ((FILE), "/t.align %d/n", 1<<(LOG))

 

前面在 build_constant_desc 中，为常量构建了可作为符号使用的内部标签，现在要在这个常量之前输出这个标签。这里是通过下面的宏。

 

151  #ifndef ASM_OUTPUT_LABEL                                                                   in default.h

152  #define ASM_OUTPUT_LABEL (FILE,NAME) /

153    do { assemble_name ((FILE), (NAME)); fputs (":/n", (FILE)); } while (0)

154  #endif

 

注意，在 153 行，在标签后还要加上“ :/n ”。

 

1699 void

1700 assemble_name (FILE *file, const char *name)                                            in varasm.c

1701 {

1702   const char *real_name;

1703   tree id;

1704

1705   real_name = (* targetm .strip_name_encoding) (name);

1706

1707   id = maybe_get_identifier (real_name);

1708   if (id)

1709     mark_referenced (id);

1710

1711   if (name[0] == '*')

1712     fputs (&name[1], file);

1713   else

1714     ASM_OUTPUT_LABELREF (file, name);

1715 }

 

在 1705 行，缺省钩子 strip_name_encoding 不做任何事，只是除去开头的‘ * ’标记。然后 maybe_get_identifier 尝试得到 name 的标识符，如果它不是标识符就返回 NULL 。

 

129  tree

130  maybe_get_identifier (const char *text)                                                        in stringpool.c

131  {

132    hashnode ht_node;

133 

134    ht_node = ht_lookup (ident_hash , (const unsigned char *) text,

135                       strlen (text), HT_NO_INSERT);

136    if (ht_node)

137      return HT_IDENT_TO_GCC_IDENT (ht_node);

138 

139    return NULL_TREE;

140  }

 

如果 name 对应着一个被设置，就应该把它标记为正被引用。下面当整个编译单元已经被分析过了，标记 cgraph_global_info_ready 是非 0 值，无疑，在此处，它仍然是 0 。

 

1671 void

1672 mark_referenced (tree id)                                                                           in varasm.c

1673 {

1674   if (!TREE_SYMBOL_REFERENCED (id))

1675   {

1676     struct cgraph_node *node;

1677     struct cgraph_varpool_node *vnode;

1678

1679     if (!cgraph_global_info_ready )

1680     {

1681       node = cgraph_node_for_identifier (id);

1682       if (node)

1683         cgraph_mark_needed_node (node);

1684     }

1685

1686     vnode = cgraph_varpool_node_for_identifier (id);

1687     if (vnode)

1688       cgraph_varpool_mark_needed_node (vnode);

1689   }

1690   TREE_SYMBOL_REFERENCED (id) = 1;

1691 }

 

一个标识符可能是一个函数或变量的名字；因此在 1681 行， cgraph_node_for_identifier 获取了函数名相关 FUNCTION_DECL 的 cgraph_node ；而在 1686 行， cgraph_varpool_node_for_identifier 获取了变量名相关 VAR_DECL 的 cgraph_varpool_node 。

 

133  struct cgraph_node *

134  cgraph_node_for_identifier (tree id)                                                             in cgraph.c

135  {

136    struct cgraph_node **slot;

137 

138    if (TREE_CODE (id) != IDENTIFIER_NODE)

139      abort ();

140 

141    if (!cgraph_hash )

142      return NULL;

143 

144    slot = (struct cgraph_node **)

145      htab_find_slot_with_hash (cgraph_hash , id,

146                            IDENTIFIER_HASH_VALUE (id), NO_INSERT);

147    if (!slot)

148      return NULL;

149    return *slot;

150  }

 

如果一个标识符不是全局可见的，它将不被 cgraph_hash 或 cgraph_varpool_hash 所记录。而如果一个标识符是全局可见的，需要把它标记为“需要的”，那么后面的优化不会删除它。

队列 cgraph_nodes_queue 记录了在用的函数。而类似的队列 cgraph_varpool_nodes_queue 记录了在用的全局变量。

 

547  struct cgraph_varpool_node *

548  cgraph_varpool_node_for_identifier (tree id)                                                        in cgraph.c

549  {

550    struct cgraph_varpool_node **slot;

551 

552    if (TREE_CODE (id) != IDENTIFIER_NODE)

553      abort ();

554 

555    if (!cgraph_varpool_hash )

556      return NULL;

557 

558    slot = (struct cgraph_varpool_node **)

559      htab_find_slot_with_hash (cgraph_varpool_hash , id,

560                            IDENTIFIER_HASH_VALUE (id), NO_INSERT);

561    if (!slot)

562      return NULL;

563    return *slot;

564  }

 

回到 assemble_name ，可以看出前端自己生成的内部名字都以‘ * ’开头，对这些名字直接输出其除‘ * ’以外的部分。而其它名字则由 ASM_OUTPUT_LABELREF 输出，在我们的目标平台上，其定义如下。

 

158  #ifndef ASM_OUTPUT_LABELREF                                                             in default.h

159  #define ASM_OUTPUT_LABELREF (FILE,NAME)  asm_fprintf ((FILE), "%U%s", (NAME))

160  #endif

 

在函数 asm_fprintf 中，格式串“ %U ”表示打印出 user_label_prefix 的内容，它在我们的目标平台上是 ”” （空字符串）。

再次回到 output_constant_def_contents ，最后调用 output_constant 来输出常量的内容。

 

3730 void

3731 output_constant (tree exp, unsigned HOST_WIDE_INT size, unsigned int align) in varasm.c

3732 {

3733   enum tree_code code;

3734   unsigned HOST_WIDE_INT thissize;

3735

3736   /* Some front-ends use constants other than the standard language-independent

3737     varieties, but which may still be output directly. Give the front-end a

3738     chance to convert EXP to a language-independent representation.  */

3739   exp = (*lang_hooks .expand_constant) (exp);

3740

3741   if (size == 0 || flag_syntax_only )

3742     return ;

3743

3744   /* Eliminate any conversions since we'll be outputting the underlying

3745     constant.  */

3746   while (TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR

3747         || TREE_CODE (exp) == NON_LVALUE_EXPR

3748         || TREE_CODE (exp) == VIEW_CONVERT_EXPR)

3749     exp = TREE_OPERAND (exp, 0);

3750

3751   code = TREE_CODE (TREE_TYPE (exp));

3752   thissize = int_size_in_bytes (TREE_TYPE (exp));

3753

3754   /* Allow a constructor with no elements for any data type.

3755     This means to fill the space with zeros.  */

3756   if (TREE_CODE (exp) == CONSTRUCTOR && CONSTRUCTOR_ELTS (exp) == 0)

3757   {

3758     assemble_zeros (size);

3759     return ;

3760   }

 

同样，在上面 3739 行， C++ 钩子函数 cplus_expand_constant 把成员指针常量 PTRMEM_CST 转换为更合适的形式（ PLUS_EXPR 或另一个 PTRMEM_CST ）。

5.13.5.2.2.1.1.3.1.            全0 的内容

上面的 3756 行，如果聚集类具有空的初始值（不是没有初始值），就意味着初始化为全 0 。下面的函数可以输出留出 size 字节的 0 的汇编代码。

 

1155 void

1156 assemble_zeros (unsigned HOST_WIDE_INT size)                                       in varasm.c

1157 {

1158   /* Do no output if -fsyntax-only.  */

1159   if (flag_syntax_only )

1160     return ;

1161

1162 #ifdef ASM_NO_SKIP_IN_TEXT

1163   /* The `space' pseudo in the text section outputs nop insns rather than 0s,

1164     so we must output 0s explicitly in the text section.  */

1165   if (ASM_NO_SKIP_IN_TEXT && in_text_section ())

1166   {

1167       unsigned HOST_WIDE_INT i;

1168       for (i = 0; i < size; i++)

1169         assemble_integer (const0_rtx, 1, BITS_PER_UNIT, 1);

1170     }

1171   else

1172 #endif

1173     if (size > 0)

1174       ASM_OUTPUT_SKIP (asm_out_file , size);

1175 }

 

如果在代码节及数据节中处理的方式不同，就要定义 ASM_NO_SKIP_IN_TEXT 宏；否则就会使用 ASM_OUTPUT_SKIP 来处理。在 x86/Linux 上需要不同的处理方式，其中 ASM_OUTPUT_SKIP 被定义为（它首先在 att.h 中定义，但于下面的文件中被重新定义）：

 

104  #undef   ASM_OUTPUT_SKIP                                                                    i n elfos.h

105  #define ASM_OUTPUT_SKIP(FILE, SIZE) /

106     fprintf ((FILE), "%s"HOST_WIDE_INT_PRINT_UNSIGNED"/n",/

107             SKIP_ASM_OP, (SIZE))

 

上面的 SKIP_ASM_OP 是“ /t.zero/t ”，而 HOST_WIDE_INT_PRINT_UNSIGNED 实际上是“ llu ”，由于 C++ 中相邻的字符串常量将被合并，因此 106 行 fprintf 的第二个参数实际上就是“ %llu/n ”。

如果不能通过改变位置计数器（ location counter ）来留出所需的字节，就要通过 assemble_integer 真正地输出数据。这个函数我们很快就会看到。

5.13.5.2.2.1.1.3.2.            整数

x86/Linux 不使用函数描述符（ function descriptor ），因此宏 ASM_OUTPUT_FDESC 没有定义。如果出现了 FDESC_EXPR ，将会调用 3769 行的 abort 退出编译。

 

output_constant (continue)

 

3762   if (TREE_CODE (exp) == FDESC_EXPR)

3763   {

3764 #ifdef ASM_OUTPUT_FDESC

3765     HOST_WIDE_INT part = tree_low_cst (TREE_OPERAND (exp, 1), 0);

3766     tree decl = TREE_OPERAND (exp, 0);

3767     ASM_OUTPUT_FDESC (asm_out_file , decl, part);

3768 #else

3769     abort ();

3770 #endif

3771     return ;

3772   }

3773

3774   /* Now output the underlying data. If we've handling the padding, return.

3775     Otherwise, break and ensure THISSIZE is the size written.  */

3776   switch (code)

3777   {

3778     case CHAR_TYPE:

3779     case BOOLEAN_TYPE:

3780     case INTEGER_TYPE:

3781     case ENUMERAL_TYPE:

3782     case POINTER_TYPE:

3783     case REFERENCE_TYPE:

3784     case OFFSET_TYPE:

3785       if (! assemble_integer (expand_expr (exp, NULL_RTX, VOIDmode,

3786                                      EXPAND_INITIALIZER),

3787                         size, align, 0))

3788         error ("initializer for integer value is too complicated");

3789       break ;

 

在 3785 行的 expand_expr 把给定的前端节点转换为 RTL 节点，这是个非常复杂的函数，我们这里暂时不看它。对于数值常量（非 VECTOR 类型），都将被构建为 CONST_DOUBLE 的 RTL 节点；而算术表达式则亦有对应的 RTL 节点。

 

1873 bool

1874 assemble_integer (rtx x, unsigned int size, unsigned int align, int force)           in varasm.c

1875 {

1876   int aligned_p;

1877

1878   aligned_p = (align >= MIN (size * BITS_PER_UNIT, BIGGEST_ALIGNMENT));

1879

1880   /* See if the target hook can handle this kind of object.  */

1881   if ((*targetm .asm_out.integer ) (x, size, aligned_p))

1882     return true;

1883

1884   /* If the object is a multi-byte one, try splitting it up. Split

1885     it into words it if is multi-word, otherwise split it into bytes. */

1886   if (size > 1)

1887   {

1888     enum machine_mode omode, imode;

1889     unsigned int subalign;

1890     unsigned int subsize, i;

1891

1892     subsize = size > UNITS_PER_WORD? UNITS_PER_WORD : 1;

1893     subalign = MIN (align, subsize * BITS_PER_UNIT);

1894     omode = mode_for_size (subsize * BITS_PER_UNIT, MODE_INT, 0);

1895     imode = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);

1896

1897     for (i = 0; i < size; i += subsize)

1898     {

1899        rtx partial = simplify_subreg (omode, x, imode, i);

1900        if (!partial || !assemble_integer (partial, subsize, subalign, 0))

1901          break ;

1902     }

1903     if (i == size)

1904       return true;

1905

1906     /* If we've printed some of it, but not all of it, there's no going

1907        back now. */

1908     if (i > 0)

1909       abort ();

1910   }

1911

1912   if (force)

1913     abort ();

1914

1915   return false;

1916 }

 

在 1881 行的钩子，对于我们的目标平台上，与下面的函数绑定。

 

1859 bool

1860 default_assemble_integer (rtx x ATTRIBUTE_UNUSED,                                in varasm.c

1861                       unsigned int size ATTRIBUTE_UNUSED,

1862                       int aligned_p ATTRIBUTE_UNUSED)

1863 {

1864   const char *op = integer_asm_op (size, aligned_p);

1865   return op && (assemble_integer_with_op (op, x), true);

1866 }

 

1819 const char *

1820 integer_asm_op (int size, int aligned_p)                                                        in varasm.c

1821 {

1822   struct asm_int_op *ops;

1823

1824   if (aligned_p)

1825     ops = &targetm .asm_out.aligned_op;

1826   else

1827     ops = &targetm .asm_out.unaligned_op;

1828

1829   switch (size)

1830   {

1831     case 1:

1832       return targetm .asm_out.byte_op;

1833     case 2:           

1834       return ops->hi;

1835     case 4:

1836       return ops->si;

1837     case 8:

1838       return ops->di;

1839     case 16:

1840       return ops->ti;

1841     default :

1842       return NULL;

1843   }

1844 }

 

对于 x86/Linux ，无符号、有符号的钩子都是相同的： HI 模式对应 ASM_SHORT ， SI 模式对应 ASM_LONG ， DI 模式对应 ASM_QUAD 。它们的定义分别为：

 

30    #define ASM_SHORT "/t.value/t"                                                                        in att.h

31    #define ASM_LONG "/t.long/t"

32    #define ASM_QUAD "/t.quad/t"   /* Should not be used for 32bit compilation.  */

 

而 byte_op 钩子，在绝大多数情形下，使用默认的定义：

 

35    #define TARGET_ASM_BYTE_OP "/t.byte/t"                                        in target-def.h

 

如果钩子不是定义为 NULL ，就执行下面的函数（由 C++ 优化的规则，一旦 1865 行的 op 是 NULL ，就不会执行 assemble_integer_with_op ）。

 

1849 void

1850 assemble_integer_with_op (const char *op, rtx x)                                        in varasm.c

1851 {

1852   fputs (op, asm_out_file );

1853   output_addr_const (asm_out_file , x);

1854   fputc ('/n', asm_out_file );

1855 }

 

op 的内容首先被输出，它在汇编代码中声明了常量的大小。下面的函数则处理常量的内容。注意 LABEL_REF 用于表示用户定义的 label ，其操作数是 CODE_LABEL 。 CODE_LABEL 还可被编译器用来表示汇编代码中因为（条件）跳转指令所需要的额外的、非用户定义的 label 。看到这些 label 的命名是“ *LLn ”（前面常量 label 的名字是“ *LLCn ”）。

 

3163 void

3164 output_addr_const (FILE *file, rtx x)                                                           in final.c

3165 {

3166   char buf[256];

3167

3168 restart:

3169   switch (GET_CODE (x))

3170   {

3171     case PC:

3172       putc ('.', file);

3173       break ;

3174

3175     case SYMBOL_REF:

3176 #ifdef ASM_OUTPUT_SYMBOL_REF

3177       ASM_OUTPUT_SYMBOL_REF (file, x);

3178 #else

3179       assemble_name (file, XSTR (x, 0));

3180 #endif

3181       break ;

3182

3183     case LABEL_REF:

3184       x = XEXP (x, 0);

3185        /* Fall through.  */

3186     case CODE_LABEL:

3187       ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (x));

3188 #ifdef ASM_OUTPUT_LABEL_REF

3189       ASM_OUTPUT_LABEL_REF (file, buf);

3190 #else

3191       assemble_name (file, buf);

3192 #endif

3193       break ;

3194

3195     case CONST_INT:

3196       fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (x));

3197       break ;

3198

3199     case CONST:

3200       /* This used to output parentheses around the expression,

3201          but that does not work on the 386 (either ATT or BSD assembler).  */

3202        output_addr_const (file, XEXP (x, 0));

3203       break ;

3204

3205     case CONST_DOUBLE:

3206       if (GET_MODE (x) == VOIDmode)

3207       {

3208          /* We can use %d if the number is one word and positive.  */

3209          if (CONST_DOUBLE_HIGH (x))

3210            fprintf (file, HOST_WIDE_INT_PRINT_DOUBLE_HEX,

3211                  CONST_DOUBLE_HIGH (x), CONST_DOUBLE_LOW (x));

3212          else if (CONST_DOUBLE_LOW (x) < 0)

3213            fprintf (file, HOST_WIDE_INT_PRINT_HEX, CONST_DOUBLE_LOW (x));

3214          else

3215              fprintf (file, HOST_WIDE_INT_PRINT_DEC, CONST_DOUBLE_LOW (x));

3216       }

3217       else

3218         /* We can't handle floating point constants;

3219             PRINT_OPERAND must handle them.  */

3220         output_operand_lossage ("floating constant misused");

3221       break ;

3222

3223     case PLUS:

3224        /* Some assemblers need integer constants to appear last (eg masm).  */

3225       if (GET_CODE (XEXP (x, 0)) == CONST_INT)

3226       {

3227          output_addr_const (file, XEXP (x, 1));

3228          if (INTVAL (XEXP (x, 0)) >= 0)

3229            fprintf (file, "+");

3230          output_addr_const (file, XEXP (x, 0));

3231       }

3232       else

3233       {

3234          output_addr_const (file, XEXP (x, 0));

3235          if (GET_CODE (XEXP (x, 1)) != CONST_INT

3236             || INTVAL (XEXP (x, 1)) >= 0)

3237            fprintf (file, "+");

3238          output_addr_const (file, XEXP (x, 1));

3239       }

3240       break ;

3241

3242     case MINUS:

3243       /* Avoid outputting things like x-x or x+5-x,

3244          since some assemblers can't handle that.  */

3245       x = simplify_subtraction (x);

3246       if (GET_CODE (x) != MINUS)

3247         goto restart;

3248

3249       output_addr_const (file, XEXP (x, 0));

3250       fprintf (file, "-");

3251       if ((GET_CODE (XEXP (x, 1)) == CONST_INT && INTVAL (XEXP (x, 1)) >= 0)

3252           || GET_CODE (XEXP (x, 1)) == PC

3253           || GET_CODE (XEXP (x, 1)) == SYMBOL_REF)

3254         output_addr_const (file, XEXP (x, 1));

3255       else

3256       {

3257          fputs (targetm .asm_out.open_paren, file);

3258          output_addr_const (file, XEXP (x, 1));

3259          fputs (targetm .asm_out.close_paren, file);

3260       }

3261       break ;

3262

3263     case ZERO_EXTEND:

3264     case SIGN_EXTEND:

3265     case SUBREG:

3266       output_addr_const (file, XEXP (x, 0));

3267       break ;

3268

3269     default :

3270 #ifdef OUTPUT_ADDR_CONST_EXTRA

3271        OUTPUT_ADDR_CONST_EXTRA (file, x, fail);

3272       break ;

3273

3274     fail:

3275 #endif

3276       output_operand_lossage ("invalid expression as operand");

3277   }

3278 }

 

注意 3243 行的注释，记住表达式来到 RTX 形式时已经采用了前序（ prefix ）形式（波兰记法），那么 x+5-x 就是“ -(+(x, 5), x) ”——最外层的节点是 MINUS 。

 

2857 rtx

2858 simplify_subtraction (rtx x)                                                                         in varasm.c

2859 {

2860   struct rtx_const val0, val1;

2861

2862   decode_rtx_const (GET_MODE (x), XEXP (x, 0), &val0);

2863   decode_rtx_const (GET_MODE (x), XEXP (x, 1), &val1);

2864

2865   if (val0.kind >= RTX_INT

2866       && val0.kind == val1.kind

2867       && val0.un.addr.base == val1.un.addr.base

2868       && val0.un.addr.symbol == val1.un.addr.symbol)

2869     return GEN_INT (val0.un.addr.offset - val1.un.addr.offset);

2870

2871   return x;

2872 }

 

在 RTX 形式中， x+5 是一个 CONST 节点（因为这是个右值，其内容不可改变），其中的‘ x ’是一个具有汇编名（即修饰名）的 SYMBOL_REF 节点，‘ 5 ’则是一个 CONST_INT 节点。注意， RTX 形式比前端的中间树节点更接近于汇编，在这里已经看不到 DECL 及 TYPE 这样的节点了。

 

2029 enum kind { RTX_UNKNOWN, RTX_DOUBLE, RTX_VECTOR, RTX_INT, RTX_UNSPEC };

2030 struct rtx_const GTY(())                                                                                   in varasm.c

2031 {

2032   ENUM_BITFIELD(kind) kind : 16;

2033   ENUM_BITFIELD(machine_mode) mode : 16;

2034   union rtx_const_un {

2035     REAL_VALUE_TYPE GTY ((tag ("4"))) du;

2036     struct rtx_const_u_addr {

2037       rtx base;

2038       const char *symbol;

2039       HOST_WIDE_INT offset;

2040     } GTY ((tag ("1"))) addr;

2041     struct rtx_const_u_di {

2042       HOST_WIDE_INT high;

2043       HOST_WIDE_INT low;

2044     } GTY ((tag ("0"))) di;

2045

2046     /* The max vector size we have is 16 wide; two variants for

2047        integral and floating point vectors.  */

2048     struct rtx_const_int_vec {

2049       HOST_WIDE_INT high;

2050       HOST_WIDE_INT low;

2051     } GTY ((tag ("2"))) int_vec[16];

2052

2053     REAL_VALUE_TYPE GTY ((tag ("3"))) fp_vec[8];

2054

2055   } GTY ((desc ("%1.kind >= RTX_INT"), descbits ("1"))) un;

2056 };

 

为了能简化表达式，那么必须能把不同类型的 RTL 节点以相同的方式表达出来，比如上面的“ x+5-x ”中“ x+5 ”是 CONST 节点，“ x ”则是 SYMBOL_REF 节点，要简化这个表达式，必须把“ x+5 ”与“ x ”以相同方式表达出来，从而可以进行进一步的处理。

这个形式就是上面的 rtx_const 结构，它把 RTL 节点归为 5 种，由枚举类型 kind 所描述。转换则由下面的函数完成。

 

2679 static void

2680 decode_rtx_const (enum machine_mode mode, rtx x, struct rtx_const *value)       in varasm.c

2681 {

2682   /* Clear the whole structure, including any gaps.  */

2683   memset (value, 0, sizeof (struct rtx_const));

2684

2685   value->kind = RTX_INT;  /* Most usual kind.  */

2686   value->mode = mode;

2687

2688   switch (GET_CODE (x))

2689   {

2690     case CONST_DOUBLE:

2691       value->kind = RTX_DOUBLE;

2692       if (GET_MODE (x) != VOIDmode)

2693       {

2694          const REAL_VALUE_TYPE *r = CONST_DOUBLE_REAL_VALUE (x);

2695

2696          value->mode = GET_MODE (x);

2697

2698          /* Copy the REAL_VALUE_TYPE by members so that we don't

2699            copy garbage from the original structure into our

2700            carefully cleaned hashing structure.  */

2701          value->un.du.class = r->class;

2702          value->un.du.sign = r->sign;

2703          switch (r->class)

2704          {

2705            case rvc_zero:

2706            case rvc_inf:

2707              break ;

2708            case rvc_normal:

2709              value->un.du.exp = r->exp;

2710            /* Fall through.  */

2711            case rvc_nan:

2712              memcpy (value->un.du.sig, r->sig, sizeof (r->sig));

2713              break ;

2714            default :

2715              abort ();

2716           }

2717       }

2718       else

2719       {

2720          value->un.di.low = CONST_DOUBLE_LOW (x);

2721          value->un.di.high = CONST_DOUBLE_HIGH (x);

2722       }

2723       break ;

2724

2725     case CONST_VECTOR:

2726     {

2727       int units, i;

2728

2729       units = CONST_VECTOR_NUNITS (x);

2730       value->kind = RTX_VECTOR;

2731       value->mode = mode;

2732

2733       if (GET_MODE_CLASS (mode) == MODE_VECTOR_INT)

2734         {

2735          for (i = 0; i < units; ++i)

2736           {

2737            rtx elt = CONST_VECTOR_ELT (x, i);

2738            if (GET_CODE (elt) == CONST_INT)

2739           {

2740              value->un.int_vec[i].low = INTVAL (elt);

2741              value->un.int_vec[i].high = 0;

2742            }

2743           else

2744           {

2745              value->un.int_vec[i].low = CONST_DOUBLE_LOW (elt);

2746              value->un.int_vec[i].high = CONST_DOUBLE_HIGH (elt);

2747            }

2748          }

2749        }

2750       else if (GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)

2751        {

2752          for (i = 0; i < units; ++i)

2753          {

2754           const REAL_VALUE_TYPE *r

2755               = CONST_DOUBLE_REAL_VALUE (CONST_VECTOR_ELT (x, i));

2756           REAL_VALUE_TYPE *d = &value->un.fp_vec[i];

2757

2758             /* Copy the REAL_VALUE_TYPE by members so that we don't

2759              copy garbage from the original structure into our

2760              carefully cleaned hashing structure.  */

2761            d->class = r->class;

2762            d->sign = r->sign;

2763            switch (r->class)

2764           {

2765              case rvc_zero:

2766              case rvc_inf:

2767                break ;

2768              case rvc_normal:

2769                d->exp = r->exp;

2770                /* Fall through.  */

2771              case rvc_nan:

2772                memcpy (d->sig, r->sig, sizeof (r->sig));

2773                break ;

2774              default :

2775                abort ();

2776           }

2777          }

2778        }

2779       else

2780          abort ();

2781     }

2782     break ;

2783

2784     case CONST_INT:

2785       value->un.addr.offset = INTVAL (x);

2786       break ;

2787

2788     case SYMBOL_REF:

2789     case LABEL_REF:

2790     case PC:

2791       value->un.addr.base = x;

2792       break ;

2793

2794     case CONST:

2795       x = XEXP (x, 0);

2796       if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 1)) == CONST_INT)

2797       {

2798          value->un.addr.base = XEXP (x, 0);

2799          value->un.addr.offset = INTVAL (XEXP (x, 1));

2800       }

2801       else if (GET_CODE (x) == MINUS && GET_CODE (XEXP (x, 1)) == CONST_INT)

2802       {

2803          value->un.addr.base = XEXP (x, 0);

2804          value->un.addr.offset = - INTVAL (XEXP (x, 1));

2805       }

2806       else

2807       {

2808          value->un.addr.base = x;

2809          value->un.addr.offset = 0;

2810       }

2811       break ;

2812

2813     default :

2814       value->kind = RTX_UNKNOWN;

2815       break ;

2816   }

2817

2818   if (value->kind == RTX_INT && value->un.addr.base != 0

2819       && GET_CODE (value->un.addr.base) == UNSPEC)

2820   {

2821     /* For a simple UNSPEC, the base is set to the

2822        operand, the kind field is set to the index of

2823         the unspec expression.

2824        Together with the code below, in case that

2825        the operand is a SYMBOL_REF or LABEL_REF,

2826        the address of the string or the code_label

2827        is taken as base.  */

2828     if (XVECLEN (value->un.addr.base, 0) == 1)

2829     {

2830        value->kind = RTX_UNSPEC + XINT (value->un.addr.base, 1);

2831        value->un.addr.base = XVECEXP (value->un.addr.base, 0, 0);

2832     }

2833   }

2834

2835   if (value->kind >= RTX_INT && value->un.addr.base != 0)

2836     switch (GET_CODE (value->un.addr.base))

2837     {

2838       case SYMBOL_REF:

2839         /* Use the string's address, not the SYMBOL_REF's address,

2840            for the sake of addresses of library routines.  */

2841         value->un.addr.symbol = XSTR (value->un.addr.base, 0);

2842         value->un.addr.base = NULL_RTX;

2843         break ;

2844

2845       case LABEL_REF:

2846         /* For a LABEL_REF, compare labels.  */

2847         value->un.addr.base = XEXP (value->un.addr.base, 0);

2848

2849       default :

2850         break ;

2851     }

2852 }

 

首先在 2685 行， value 的 kind 被设置为 RTX_INT ，这是最有可能使用的值； kind 域接着会在 2691 行、 2730 行、 2814 行及 2830 行改写。因此形如“ x+5 ”的表达式的 kind 将是 RTX_INT ，同样的还有‘ x ’（ SYMBOL_REF ），“ goto label1 ”（ LABEL_REF ）。

在 2819 行， RTL 节点 UNSPEC 也是来自 CONST 节点中，它代表一个机器特定的操作。其第一个操作数是该操作所使用的一个操作数向量，因此可以任何需要的重新载入（ reload ）；其第二个操作数是一个唯一值，告知所要执行的一组机器特定操作中哪一个。那么 2830 行就使得 kind 与这些机器特定操作一一对应。

回到 simplify_subtraction 之后，看到只有 kind 是 RTX_INT ， RTX_UNSPEC 及之后（机器特定操作）才处理。其他，尤其是 RTX_CONST 是不管的，这是因为如果 RTX_CONST 节点的内容有优化的机会，它应该已经在前端的常量折叠优化中处理了。

上面是在目标机器中能高效支持的整数的处理。对于其它整数类型， assemble_integer 1881 行的钩子函数返回 false 。对于 x86/Linux ，这个整数模式是 TI 模式（ 16 字节，在 64 位整型运算中，其中间值就是 TI 模式，一般保存在 SSE 寄存器中，但若发生溅出，就会调用 assemble_ineger 写入栈）。对 TI 模式数据的处理是把它分解为 4 个字（ 4 字节），对于直接数（ CONST_INT ， CONST_DOUBLE 等），这通过 simplify_immed_subreg 来完成，然后通过 assemble_ineger 写入。 simplify_immed_subreg 所用到的处理方法，我们基本上都看过，并不复杂，这里跳过它。