GCC后端及汇编发布（30）

9.6. 输出生成文件

9.6.1. 处理属性

9.6.1.1.    统一属性

虽然我们构建了生成最小化 DFA 所需的数据，但收集的属性尚未处理。我们需要把它们转换为统一的形式，并如下打包有用的信息。

 

main (continued)

 

6137   printf ("#include /"config.h/"/n");

6138   printf ("#include /"system.h/"/n");

6139   printf ("#include /"coretypes.h/"/n");

6140   printf ("#include /"tm.h/"/n");

6141   printf ("#include /"rtl.h/"/n");

6142   printf ("#include /"tm_p.h/"/n");

6143   printf ("#include /"insn-config.h/"/n");

6144   printf ("#include /"recog.h/"/n");

6145   printf ("#include /"regs.h/"/n");

6146   printf ("#include /"real.h/"/n");

6147   printf ("#include /"output.h/"/n");

6148   printf ("#include /"insn-attr.h/"/n");

6149   printf ("#include /"toplev.h/"/n");

6150   printf ("#include /"flags.h/"/n");

6151   printf ("#include /"function.h/"/n");

6152   printf ("/n");

6153   printf ("#define operands recog_data.operand/n/n");

6154

6155   /* Make `insn_alternatives'.  */

6156   insn_alternatives = oballoc (insn_code_number * sizeof (int));

6157   for (id = defs ; id; id = id->next)

6158     if (id->insn_code >= 0)

6159       insn_alternatives [id->insn_code] = (1 << id->num_alternatives) - 1;

6160

6161   /* Make `insn_n_alternatives'.  */

6162   insn_n_alternatives = oballoc (insn_code_number * sizeof (int));

6163   for (id = defs ; id; id = id->next)

6164     if (id->insn_code >= 0)

6165       insn_n_alternatives [id->insn_code] = id->num_alternatives;

6166

6167   /* Prepare to write out attribute subroutines by checking everything stored

6168     away and building the attribute cases.  */

6169

6170   check_defs ();

 

上面在 6159 行， insn_alternatives 保存着，对于每个指令编码，一个位图，每个可能的替代对应其中的一个比特。而在 6162 行， insn_n_alternatives 保存着，对于每个指令编码，约束替代的数目。在 6170 行 check_defs 扫描所有的定义，检查有效性，并把所有的 SET_ATTR 及 SET_ATTR_ALTERNATIVE 表达式转换为对应的 SET 表达式。

首先，看一下 SET_ATTR 及 SET_ATTR_ALTERNATIVE 表达式，以下摘自注释

在 DEFINE_INSN 及 DEFINE_PEEPHOLE 最后的操作数中，这可以被用于，根据被匹配的替代，指出将被用在赋值的属性值。

以下的三个表达式是等效的：

   (set (attr "att") (cond [(eq_attrq "alternative" "1") (const_string "a1")

                   (eq_attrq "alternative" "2") (const_string "a2")]

                  (const_string "a3")))

   (set_attr_alternative "att" [(const_string "a1") (const_string "a2")

                        (const_string "a3")])

   (set_attr "att" "a1,a2,a3")

check_defs 将把后两个形式转换为第一个形式。

 

1313 static void

1314 check_defs (void)                                                                               in genattrtab.c

1315 {

1316   struct insn_def *id;

1317   struct attr_desc *attr;

1318   int i;

1319   rtx value;

1320

1321   for (id = defs ; id; id = id->next)

1322   {

1323     if (XVEC (id->def, id->vec_idx) == NULL)

1324       continue ;

1325

1326     for (i = 0; i < XVECLEN (id->def, id->vec_idx); i++)

1327     {

1328        value = XVECEXP (id->def, id->vec_idx, i);

1329        switch (GET_CODE (value))

1330        {

1331          case SET:

1332            if (GET_CODE (XEXP (value, 0)) != ATTR)

1333           {

1334              message_with_line (id->lineno, "bad attribute set");

1335              have_error = 1;

1336              value = NULL_RTX;

1337           }

1338            break ;

1339

1340          case SET_ATTR_ALTERNATIVE:

1341            value = convert_set_attr_alternative (value, id);

1342            break ;

1343

1344          case SET_ATTR:

1345            value = convert_set_attr (value, id);

1346             break ;

1347

1348          default :

1349            message_with_line (id->lineno, "invalid attribute code %s",

1350                  GET_RTX_NAME (GET_CODE (value)));

1351            have_error = 1;

1352             value = NULL_RTX;

1353        }

1354        if (value == NULL_RTX)

1355          continue ;

1356

1357        if ((attr = find_attr (&XSTR (XEXP (value, 0), 0), 0)) == NULL)

1358        {

1359          message_with_line (id->lineno, "unknown attribute %s",

1360                     XSTR (XEXP (value, 0), 0));

1361          have_error = 1;

1362          continue ;

1363        }

1364

1365        XVECEXP (id->def, id->vec_idx, i) = value;

1366        XEXP (value, 1) = check_attr_value (XEXP (value, 1), attr);

1367     }

1368   }

1369 }

 

上面在 1323 行， def 指向这个 insn_def 所属的 rtx 对象， vec_idx 显示属性向量在这个 def 中的位置，这个值是硬编码的。对于 define_insn ，它是 4 。对于 define_peephole ，它是 3 。对于 define_asm_attribute ，它是 0 。模式中的属性部分是可选的，如果不存在，意味着使用该属性的缺省值。

SET_ATTR_ALTERNATIVE 的 RTL 格式是 “ sE ” 。使用以下的例子，

(set_attr_alternative "att" [(const_string "a1") (const_string "a2")

                        (const_string "a3")])

其中“ att ”是格式的“ s ”部分，而“ […] ”是“ E ”部分，它是应该含有 3 个元素的向量。正如我们已知的，格式“ s ”对应 CONST_STRING 的 rtx 对象，而格式“ E ”对应 RTVEC 的 rtx 对象。

 

1244 static rtx

1245 convert_set_attr_alternative (rtx exp, struct insn_def *id)                        in genattrtab.c

1246 {

1247   int num_alt = id->num_alternatives;

1248   rtx condexp;

1249   int i;

1250

1251   if (XVECLEN (exp, 1) != num_alt)

1252   {

1253     message_with_line (id->lineno,

1254              "bad number of entries in SET_ATTR_ALTERNATIVE");

1255     have_error = 1;

1256     return NULL_RTX;

1257   }

1258

1259   /* Make a COND with all tests but the last. Select the last value via the

1260     default.  */

1261   condexp = rtx_alloc (COND);

1262   XVEC (condexp, 0) = rtvec_alloc ((num_alt - 1) * 2);

1263

1264   for (i = 0; i < num_alt - 1; i++)

1265   {

1266     const char *p;

1267     p = attr_numeral (i);

1268

1269     XVECEXP (condexp, 0, 2 * i) = attr_eq (alternative_name , p);

1270     XVECEXP (condexp, 0, 2 * i + 1) = XVECEXP (exp, 1, i);

1271   }

1272

1273   XEXP (condexp, 1) = XVECEXP (exp, 1, i);

1274

1275   return attr_rtx (SET, attr_rtx (ATTR, XSTR (exp, 0)), condexp);

1276 }

 

SET_ATTR 的 RTL 格式是“ ss ”。所有以下的例子， (set_attr "att" "a1,a2,a3") 。其中，“ ss ”对应“ att ”，及“ a1, a2, a3” 。首先把这个 SET_ATTR 对象转换到对应的 SET_ATTR_ALTERNATIVE 对象。然后通过上面的 convert_set_attr_alternatives ，这个 SET_ATTR_ALTERNATIVE 对象进一步转换到 SET 对象。

 

1281 static rtx

1282 convert_set_attr (rtx exp, struct insn_def *id)                                        in genattrtab.c

1283 {

1284   rtx newexp;

1285   const char *name_ptr;

1286   char *p;

1287   int n;

1288

1289   /* See how many alternative specified.  */

1290   n = n_comma_elts (XSTR (exp, 1));

1291   if (n == 1)

1292     return attr_rtx (SET,

1293            attr_rtx (ATTR, XSTR (exp, 0)),

1294            attr_rtx (CONST_STRING, XSTR (exp, 1)));

1295

1296   newexp = rtx_alloc (SET_ATTR_ALTERNATIVE);

1297   XSTR (newexp, 0) = XSTR (exp, 0);

1298   XVEC (newexp, 1) = rtvec_alloc (n);

1299

1300   /* Process each comma-separated name.  */

1301   name_ptr = XSTR (exp, 1);

1302   n = 0;

1303   while ((p = next_comma_elt (&name_ptr)) != NULL)

1304     XVECEXP (newexp, 1, n++) = attr_rtx (CONST_STRING, p);

1305

1306   return convert_set_attr_alternative (newexp, id);

1307 }

 

现在，因为由于处理 SET_ATTR_ALTERNATIVE 及 SET_ATTR 对象，某些属性被改变了，因此需要下面 6175 行的 check_attr_value 来再一次验证属性。

 

main (continued)

 

6172   for (i = 0; i < MAX_ATTRS_INDEX; i++)

6173     for (attr = attrs [i]; attr; attr = attr->next)

6174       attr->default_val->value

6175           = check_attr_value (attr->default_val->value, attr);

6176

6177   if (have_error )

6178     return FATAL_EXIT_CODE;

6179

6180   for (i = 0; i < MAX_ATTRS_INDEX; i++)

6181     for (attr = attrs [i]; attr; attr = attr->next)

6182       fill_attr (attr);

6183

6184   /* Construct extra attributes for `length'.  */

6185   make_length_attrs ();

6186

6187   /* Perform any possible optimizations to speed up compilation.  */

6188   optimize_attrs ();

 

9.6.1.2.    完成属性

对于数值属性，在其模式定义中，它必须具有空的 LIST-OF-VALUE 部分（至于 define_attr 的细节，可以参考 读入 DEFINE_ATTR模式 一节）。

对于这些数值属性， fill_attr 用于从模式中收集这些值。除此之外，对于所有的属性，这个函数将构建一个列表，它把所有使用同一个属性的指令链接起来。

 

2263 static void

2264 fill_attr (struct attr_desc *attr)                                                             in genattrtab.c

2265 {

2266   struct attr_value *av;

2267   struct insn_ent *ie;

2268   struct insn_def *id;

2269   int i;

2270   rtx value;

2271

2272   /* Don't fill constant attributes. The value is independent of

2273     any particular insn.  */

2274   if (attr->is_const)

2275     return ;

2276

2277   for (id = defs ; id; id = id->next)

2278   {

2279     /* If no value is specified for this insn for this attribute, use the

2280       default.  */

2281     value = NULL;

2282     if (XVEC (id->def, id->vec_idx))

2283       for (i = 0; i < XVECLEN (id->def, id->vec_idx); i++)

2284         if (! strcmp_check (XSTR ( XEXP (XVECEXP (id->def, id->vec_idx, i), 0), 0),

2285                         attr->name))

2286           value = XEXP (XVECEXP (id->def, id->vec_idx, i), 1);

2287

2288     if (value == NULL)

2289       av = attr->default_val;

2290     else

2291       av = get_attr_value (value, attr, id->insn_code);

2292

2293     ie = oballoc (sizeof (struct insn_ent ));

2294     ie->insn_code = id->insn_code;

2295     ie->insn_index = id->insn_code;

2296     insert_insn_ent (av, ie);

2297   }

2298 }

 

在 fill_attr 的 2274 行 ， 属性视为常量 ， 如果其值是 SYMBOL_REF 或 CONST_INT 。在 2277 行， defs 已经链接了所有的 define_insn ， define_peephole 及 define_asm_attributes （参见 gen_insn ）。因此在 2283 行的 FOR 循环遍历模式的属性部分，并调用 get_attr_value 来向属性的值列表加入新发现的值（注意对于具有以星号（ * ）开头，由系统产生的属性，它们将以相同的值，为每个指令所添加。这是因为，首先没有指令会包含匹配这个名字的属性，其次，所有这些属性由 make_internal_attr 构建，并具有单个的值）。而在 2296 行， insert_insn_ent 的定义如下，它把使用相同属性值的指令链接起来。

 

2632 static void

2633 insert_insn_ent (struct attr_value *av, struct insn_ent *ie)                       in genattrtab.c

2634 {

2635   ie->next = av->first_insn;

2636   av->first_insn = ie;

2637   av->num_insns++;

2638   if (ie->insn_code == -1)

2639     av->has_asm_insn = 1;

2640

2641   num_insn_ents ++;

2642 }

 

insn_ent 构成了具有相同属性值指令的链表，它具有如下定义。

 

161  struct insn_ent                                                                                      in genattrtab.c

162  {

163    struct insn_ent *next; /* Next in chain.  */

164    int insn_code;            /* Instruction number.  */

165    int insn_index;           /* Index of definition in file */

166    int lineno;                 /* Line number.  */

167  };

 

继续 main ，为了更好地了解 6185 行的 make_length_attr ，首先看一下以下摘自 gccint 的段落。

对于许多机器而言，它们提供了多种跳转指令，每个对应不同跳转偏移。在绝大多数情形下，汇编器将选择使用正确的指令。不过，当汇编器做不到这一点时， GCC 可以，当一个特殊的属性——‘ length ’属性被定义时。这个属性必须，通过在其‘ define_attr ’中指定一个空字符串，来定义为具有数字值。

就‘ length ’属性而言，允许在测试表达式中使用另外两个形式的算术项：

(match_dup N)

这指向当前指令操作数 N 的地址，它必须是一个‘ label_re. ’。

(pc)

这指向当前指令的地址。其他的用法把它作为下一个指令的地址可能更符合，不过因为当前指令的长度会被计入，这可能会让人困扰。

对于普通的指令，长度将由‘ length ’属性的值来决定。在‘ addr_vec ’及‘ addr_diff_vec ’指令模式中，其长度通过向量的数量乘以每个向量的大小来计算。

长度以可取址储存单元（ byte ）为单位来计量。

下面的宏可以用于细化长度计算：

ADJUST_INSN_LENGTH (INSN, LENGTH)

如果定义了，作为一个其所被应用的上下文中的一个函数，修改赋予指令 INSN 的长度。 LENGTH 是一个左值（ lvalue ），它包含了该指令初始计算的长度，并将为该指令正确的长度所更新。

这个宏通常是不要求的。要求它的一个情形是 ROMP 。在这个机器中，一个‘ addr_vec ’指令的长度必须加上 2 ，来补偿可能要求对齐的这个事实。

返回‘ get_attr_length ’（‘ length ’属性的值）的函数，可以被输出函数所使用，来确定所要写出的跳转指令的形式，如下面例子所显示的。

作为一个可变长度跳转说明的例子，考虑 IBM 360 。如果我们采用约定，一个寄存器将被设置为一个函数的起始地址，我们可以，使用一个 4 字节指令，跳转到距起始地址 4k 内的 label 。否则，我们需要一个 6 字节序列，来从内存载入地址，然后跳转到这个地址。

在这样的一个机器上，一个用于一个跳转指令的模式可能被详细说明如下：

     (define_insn "jump"

       [(set (pc)

             (label_ref (match_operand 0 "" "")))]

       ""

         {

          return (get_attr_length (insn) == 4

                ? "b %l0" : "l r15,=a(%l0); br r15");

        }

       [(set (attr "length")

              (if_then_else (lt (minus (pc) (match_dup 0) (const_int 4096))

                           (const_int 4)

                           (const_int 6)))])

事实上，对于每个 define_insn ， define_peephole 及 define_asm_attribute 模式，如果它不显式设置一个属性，它将使用该属性的缺省值。在这里 make_length 为每个模式，根据其“ length ”属性，构建了 3 个额外的属性。它们是：

*insn_default_length

这是在调用 shorten_branches 之前，由返回的 get_attr_length 指令的长度。在长度依赖于相对地址的情形下，使用最大可能的那个。

*insn_variable_length_p

这返回 1 ，如果该指令的长度依赖于相对地址；否则返回 0 。

*insn_current_length

仅当已知该指令具有一个可变长度时，这才被调用，并基于相对地址返回当前长度。

 

2379 static void

2380 make_length_attrs (void)                                                                    in genattrtab.c

2381 {

2382   static const char *new_names[] =

2383   {

2384     "*insn_default_length",

2385      "*insn_variable_length_p",

2386     "*insn_current_length"

2387   };

2388   static rtx (*const no_address_fn[]) (rtx) = {identity_fn, zero_fn, zero_fn};

2389   static rtx (*const address_fn[]) (rtx) = {max_fn, one_fn, identity_fn};

2390   size_t i;

2391   struct attr_desc *length_attr, *new_attr;

2392   struct attr_value *av, *new_av;

2393   struct insn_ent *ie, *new_ie;

2394

2395   /* See if length attribute is defined. If so, it must be numeric. Make

2396     it special so we don't output anything for it.  */

2397   length_attr = find_attr (&length_str , 0);

2398   if (length_attr == 0)

2399     return ;

2400

2401   if (! length_attr->is_numeric)

2402     fatal ("length attribute must be numeric");

2403

2404   length_attr->is_const = 0;

2405   length_attr->is_special = 1;

2406

2407   /* Make each new attribute, in turn.  */

2408   for (i = 0; i < ARRAY_SIZE (new_names); i++)

2409   {

2410     make_internal_attr (new_names[i],

2411                     substitute_address (length_attr->default_val->value,

2412                                    no_address_fn[i], address_fn[i]),

2413                     ATTR_NONE);

2414     new_attr = find_attr (&new_names[i], 0);

2415     for (av = length_attr->first_value; av; av = av->next)

2416       for (ie = av->first_insn; ie; ie = ie->next)

2417       {

2418         new_av = get_attr_value ( substitute_address (av->value,

2419                              no_address_fn[i],

2420                              address_fn[i]),

2421                              new_attr, ie->insn_code);

2422         new_ie = oballoc (sizeof (struct insn_ent ));

2423         new_ie->insn_code = ie->insn_code;

2424         new_ie->insn_index = ie->insn_index;

2425         insert_insn_ent (new_av, new_ie);

2426       }

2427   }

2428 }

 

上面在 2411 行， substitute_address ，给定一个表达式 exp ，查看它是否是一个具有检查指令相对位置（使用 MATCH_DUP 或 PC ）测试的 COND 或 IF_THEN_ELSE 。如果是，使用通过把该表达式传递给 address_fn 所得到的结果来替代之。如果不是，但它是一个 COND 或 IF_THEN_ELSE ，在每个值上递归调用这个函数（包括缺省值）。否则，返回由应用在 exp 上的 no_address_fn 所返回的值。

 

2307 static rtx

2308 substitute_address (rtx exp, rtx (*no_address_fn) (rtx),                          in genattrtab.c

2309                 rtx (*address_fn) (rtx))

2310 {

2311   int i;

2312   rtx newexp;

2313

2314   if (GET_CODE (exp) == COND)

2315   {

2316     /* See if any tests use addresses.  */

2317     address_used = 0;

2318     for (i = 0; i < XVECLEN (exp, 0); i += 2)

2319       walk_attr_value (XVECEXP (exp, 0, i));

2320

2321     if (address_used )

2322       return (*address_fn) (exp);

2323

2324     /* Make a new copy of this COND, replacing each element.  */

2325     newexp = rtx_alloc (COND);

2326     XVEC (newexp, 0) = rtvec_alloc (XVECLEN (exp, 0));

2327     for (i = 0; i < XVECLEN (exp, 0); i += 2)

2328     {

2329       XVECEXP (newexp, 0, i) = XVECEXP (exp, 0, i);

2330       XVECEXP (newexp, 0, i + 1)

2331                 = substitute_address (XVECEXP (exp, 0, i + 1),

2332                                  no_address_fn, address_fn);

2333     }

2334

2335     XEXP (newexp, 1) = substitute_address ( XEXP (exp, 1),

2336                                       no_address_fn, address_fn);

2337

2338     return newexp;

2339   }

2340

2341   else if (GET_CODE (exp) == IF_THEN_ELSE)

2342   {

2343     address_used = 0;

2344     walk_attr_value ( XEXP (exp, 0));

2345     if (address_used )

2346       return (*address_fn) (exp);

2347

2348     return attr_rtx (IF_THEN_ELSE,

2349                 substitute_address ( XEXP (exp, 0),

2350                                 no_address_fn, address_fn),

2351                 substitute_address ( XEXP (exp, 1),

2352                                  no_address_fn, address_fn),

2353                 substitute_address ( XEXP (exp, 2),

2354                                 no_address_fn, address_fn));

2355   }

2356

2357   return (*no_address_fn) (exp);

2358 }

 

walk_attr_value 扫描属性值，这可能是个条件值（一个例外是下面 4979 行的 ATTR_FLAG ），并记录将要求什么动作来对它进行条件测试。

 

4934 static void

4935 walk_attr_value (rtx exp)                                                                     in genattrtab.c

4936 {

4937   int i, j;

4938   const char *fmt;

4939   RTX_CODE code;

4940

4941   if (exp == NULL)

4942     return ;

4943

4944   code = GET_CODE (exp);

4945   switch (code)

4946   {

4947     case SYMBOL_REF:

4948       if (! ATTR_IND_SIMPLIFIED_P (exp))

4949         /* Since this is an arbitrary expression, it can look at anything.

4950           However, constant expressions do not depend on any particular

4951           insn.  */

4952         must_extract = must_constrain = 1;

4953       return ;

4954

4955     case MATCH_OPERAND:

4956        must_extract = 1;

4957       return ;

4958

4959     case EQ_ATTR_ALT:

4960       must_extract = must_constrain = 1;

4961       break ;

4962

4963     case EQ_ATTR:

4964       if (XSTR (exp, 0) == alternative_name )

4965         must_extract = must_constrain = 1;

4966       else if (strcmp_check (XSTR (exp, 0), length_str ) == 0)

4967         length_used = 1;

4968       return ;

4969

4970     case MATCH_DUP:

4971       must_extract = 1;

4972       address_used = 1;

4973       return ;

4974

4975     case PC:

4976       address_used = 1;

4977       return ;

4978

4979     case ATTR_FLAG:

4980       return ;

4981

4982     default :

4983       break ;

4984   }

4985

4986   for (i = 0, fmt = GET_RTX_FORMAT (code); i < GET_RTX_LENGTH (code); i++)

4987     switch (*fmt++)

4988     {

4989       case 'e':

4990       case 'u':

4991         walk_attr_value ( XEXP (exp, i));

4992         break ;

4993

4994       case 'E':

4995         if (XVEC (exp, i) != NULL)

4996           for (j = 0; j < XVECLEN (exp, i); j++)

4997             walk_attr_value (XVECEXP (exp, i, j));

4998         break ;

4999    }

5000 }

 

在 4952 行， must_extract 表示我们是否需要提取指令的操作数， must_constrain 表示我们是否必须计算编译器变量 which_alternative 。在 4967 行， length_used 表示，是否使用了一个 (eq_attr "length" ...) ，而在 4972 行， address_used 显示是否使用了一个地址表达式。

最后，对两种指令类型的结果显示如下。

no_address_fn                            result of fn on exp                            attribute attached

identity_fn                            exp                                            "*insn_default_length"

zero_fn                                rtx object of 0                             "*insn_variable_length_p"

zero_fn                                rtx object of 0                             "*insn_current_length"

表 1 ：为其它指令构建的属性

address_fn                           result of fn on exp                            attribute attached

max_fn                                rtx object of max value in exp             "*insn_default_length"

one_fn                                 rtx object of 1                             "*insn_variable_length_p"

identify_fn                           exp                                            "*insn_current_length"

表 2 ：为相对位置指令构建的属性