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

4.3.1.7.5.6.5.2.        处理format属性

对于printf，scanf等类型的函数，真正的检查要在调用处进行。在其声明中，只进行少许检查，由handle_format_attribute 执行。现在参数args是节点ATTR_PRINTF_1_0，而传入的no_add_attrs是0。

 

2741   tree

2742   handle_format_attribute (tree *node, tree name ATTRIBUTE_UNUSED,      in c-format.c

2743                      tree args, int flags, bool *no_add_attrs)

2744   {

2745     tree type = *node;

2746     function_format_info info;

2747     tree argument;

2748  

2749     if (!decode_format_attr (args, &info, 0))

2750     {

2751       *no_add_attrs = true;

2752       return NULL_TREE;

2753     }

 

第一步是验证属性ATTR_PRINTF_1_0。工作很简单——检查要求的格式是有效的，所带的实参是合理的。编译器定义了下面的类型来携带所需要的信息。

 

58      enum format_type { printf_format_type, asm_fprintf_format_type,                     in c-format.c

59                     gcc_diag_format_type, gcc_cdiag_format_type,

60                     gcc_cxxdiag_format_type,

61                     scanf_format_type, strftime_format_type,

62                     strfmon_format_type, format_type_error };

 

64      typedef struct function_format_info

65      {

66        enum format_type format_type;     /* type of format (printf, scanf, etc.) */

67        unsigned HOST_WIDE_INT format_num;    /* number of format argument */

68        unsigned HOST_WIDE_INT first_arg_num; /* number of first arg (zero for varargs) */

69      } function_format_info;

 

178    static bool

179    decode_format_attr (tree args, function_format_info *info, int validated_p) in c-format.c

180    {

181      tree format_type_id = TREE_VALUE (args);

182      tree format_num_expr = TREE_VALUE (TREE_CHAIN (args));

183      tree first_arg_num_expr

184        = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (args)));

185   

186      if (TREE_CODE (format_type_id) != IDENTIFIER_NODE)

187      {

188        if (validated_p)

189          abort ();

190        error ("unrecognized format specifier");

191         return false;

192      }

193      else

194      {

195        const char *p = IDENTIFIER_POINTER (format_type_id);

196   

197        info->format_type = decode_format_type (p);

198   

199        if (info->format_type == format_type_error)

200        {

201          if (validated_p)

202            abort ();

203          warning ("`%s' is an unrecognized format function type", p);

204          return false;

205        }

206      }

 

验证格式的类型简单明了。为了保存所有格式类型的信息，GCC维护了一个全局数组format_types，该数组以format_type为索引。在format_types中找出格式所对应的名字就能得到答案。

 

1036   static enum format_type

1037   decode_format_type (const char *s)                                                           in c-format.c

1038   {

1039     int i;

1040     int slen;

1041     slen = strlen (s);

1042     for (i = 0; i < (int) format_type_error; i++)

1043     {

1044       int alen;

1045      if (!strcmp (s, format_types[i].name))

1046         break;

1047       alen = strlen (format_types[i].name);

1048       if (slen == alen + 4 && s[0] == '_' && s[1] == '_'

1049           && s[slen - 1] == '_' && s[slen - 2] == '_'

1050           && !strncmp (s + 2, format_types[i].name, alen))

1051         break;

1052     }

1053     return ((enum format_type) i);

1054   }

 

而对于格式属性的参数的要求是，它们必须是常量，而且格式字符串必须出现在要被格式的参数之前（如果有的话，记住0表示不使用）。

 

decode_format_attr (continue)

 

208      if (!get_constant (format_num_expr, &info->format_num, validated_p))

209      {

210        error ("format string has invalid operand number");

211         return false;

212      }

213   

214      if (!get_constant (first_arg_num_expr, &info->first_arg_num, validated_p))

215      {

216        error ("'...' has invalid operand number");

217        return false;

218      }

219   

220      if (info->first_arg_num != 0 && info->first_arg_num <= info->format_num)

221      {

222        if (validated_p)

223          abort ();

224        error ("format string arg follows the args to be formatted");

225        return false;

226      }

227   

228      return true;

229    }

 

现在下面的type是builtin_types [BT_FN_INT_CONST_STRING_VALIST_ARG]——内建函数“__builtin_vprintf”的类型。对于对应格式字符串的参数，它应该是const_string_type_node，这个类型在c_common_nodes_and_builtins中创建，是代表“const char*”的节点。

 

handle_format_attribute (continue)

 

2755     argument = TYPE_ARG_TYPES (type);

2756     if (argument)

2757     {

2758       if (!check_format_string (argument, info.format_num, flags,

2759                            no_add_attrs))

2760         return NULL_TREE;

2761  

2762       if (info.first_arg_num != 0)

2763       {

2764         unsigned HOST_WIDE_INT arg_num = 1;

2765  

2766         /* Verify that first_arg_num points to the last arg,

2767           the ...  */

2768         while (argument)

2769           arg_num++, argument = TREE_CHAIN (argument);

2770  

2771         if (arg_num != info.first_arg_num)

2772         {

2773           if (!(flags & (int) ATTR_FLAG_BUILT_IN))

2774             error ("args to be formatted is not '...'");

2775           *no_add_attrs = true;

2776           return NULL_TREE;

2777         }

2778       }

2779     }

        ...

2816     return NULL_TREE;

2817   }

 

这里除了确认格式字符串真的是字符串外，没有别的事可做。

 

121    static bool

122    check_format_string (tree argument,                                                                in c-format.c

123                    unsigned HOST_WIDE_INT format_num, int flags, bool *no_add_attrs)

124    {

125      unsigned HOST_WIDE_INT i;

126   

127      for (i = 1; i != format_num; i++)

128      {

129        if (argument == 0)

130          break;

131        argument = TREE_CHAIN (argument);

132      }

133   

134      if (!argument

135          || TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE

136          || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (argument)))

137            != char_type_node))

138      {

139        if (!(flags & (int) ATTR_FLAG_BUILT_IN))

140          error ("format string arg not a string type");

141        *no_add_attrs = true;

142        return false;

143      }

144   

145      return true;

146    }

4.3.1.7.5.6.5.3.        设置format属性

一旦格式属性的有效性得到验证，该属性就应该被加入到相应节点的attribute链表中。注意在这里anode指向builtin_types [BT_FN_INT_CONST_STRING_VALIST_ARG]，因为这个属性是应用于类型的。

 

decl_attributes (continue)

 

260        /* Layout the decl in case anything changed.  */

261        if (spec->type_required && DECL_P (*node)

262           && (TREE_CODE (*node) == VAR_DECL

263               || TREE_CODE (*node) == PARM_DECL

264               || TREE_CODE (*node) == RESULT_DECL))

265        {

266          /* Force a recalculation of mode and size.  */

267          DECL_MODE (*node) = VOIDmode;

268          DECL_SIZE (*node) = 0;

269          if (!DECL_USER_ALIGN (*node))

270            DECL_ALIGN (*node) = 0;

271   

272          layout_decl (*node, 0);

273        }

274   

275        if (!no_add_attrs)

276        {

277          tree old_attrs;

278          tree a;

279   

280          if (DECL_P (*anode))

281            old_attrs = DECL_ATTRIBUTES (*anode);

282          else

283            old_attrs = TYPE_ATTRIBUTES (*anode);

284   

285          for (a = lookup_attribute (spec->name, old_attrs);

286              a != NULL_TREE;

287             a = lookup_attribute (spec->name, TREE_CHAIN (a)))

288          {

289            if (simple_cst_equal (TREE_VALUE (a), args) == 1)

290              break;

291         }

292   

293          if (a == NULL_TREE)

294         {

295            /* This attribute isn't already in the list.  */

296            if (DECL_P (*anode))

297              DECL_ATTRIBUTES (*anode) = tree_cons (name, args, old_attrs);

298            else if (flags & (int) ATTR_FLAG_TYPE_IN_PLACE)

299              TYPE_ATTRIBUTES (*anode) = tree_cons (name, args, old_attrs);

300            else

301              *anode = build_type_attribute_variant (*anode,

302                                              tree_cons (name, args,

303                                                       old_attrs));

304          }

305        }

306   

307        if (fn_ptr_tmp)

308        {

309          /* Rebuild the function pointer type and put it in the

310            appropriate place.  */

311           fn_ptr_tmp = build_pointer_type (fn_ptr_tmp);

312          if (DECL_P (*node))

313            TREE_TYPE (*node) = fn_ptr_tmp;

314          else if (TREE_CODE (*node) == POINTER_TYPE)

315            *node = fn_ptr_tmp;

316          else

317            abort ();

318        }

319      }

320   

321      return returned_attrs;

322    }

 

应用了属性的类型应视为一个新的类型（至少从C++语言的角度来说）。这个新类型由build_type_attribute_variant来构建。注意到anode将被这个将要创建的节点所更新。同时看到参数attribute是在302行更新过的属性链表。

 

2632   tree

2633   build_type_attribute_variant (tree ttype, tree attribute)                                       in tree.c

2634   {

2635     if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute))

2636     {

2637       unsigned int hashcode;

2638       tree ntype;

2639  

2640       ntype = copy_node (ttype);

2641  

2642       TYPE_POINTER_TO (ntype) = 0;

2643       TYPE_REFERENCE_TO (ntype) = 0;

2644       TYPE_ATTRIBUTES (ntype) = attribute;

2645  

2646       /* Create a new main variant of TYPE.  */

2647       TYPE_MAIN_VARIANT (ntype) = ntype;

2648       TYPE_NEXT_VARIANT (ntype) = 0;

2649       set_type_quals (ntype, TYPE_UNQUALIFIED);

2650  

2651       hashcode = (TYPE_HASH (TREE_CODE (ntype))

2652                 + TYPE_HASH (TREE_TYPE (ntype))

2653                 + attribute_hash_list (attribute));

2654  

2655       switch (TREE_CODE (ntype))

2656       {

2657         case FUNCTION_TYPE:

2658           hashcode += TYPE_HASH (TYPE_ARG_TYPES (ntype));

2659           break;

2660         case ARRAY_TYPE:

2661           hashcode += TYPE_HASH (TYPE_DOMAIN (ntype));

2662           break;

2663         case INTEGER_TYPE:

2664           hashcode += TYPE_HASH (TYPE_MAX_VALUE (ntype));

2665           break;

2666         case REAL_TYPE:

2667           hashcode += TYPE_HASH (TYPE_PRECISION (ntype));

2668           break;

2669         default:

2670           break;

2671       }

2672  

2673       ntype = type_hash_canon (hashcode, ntype);

2674       ttype = build_qualified_type (ntype, TYPE_QUALS (ttype));

2675     }

2676  

2677     return ttype;

2678   }

 

而在307行，若fn_ptr_tmp不为NULL，表明

4.3.1.7.5.6.5.4.        处理nonnull属性

属性nonnull表示参数（指针）不能是NULL。同样，检实参是否为空，只能在函数调用处进行。handle_nonnull_attributes所能做的，只是验证属性的声明是有效的，并且在函数类型声明中，相应的参数是指针类型。

在这里参数node是，在设置format属性中，为格式属性所构建的FUNCTION_TYPE节点，因为属性nonnull要求的是类型或函数类型。而args是ATTR_NOTHROW_NONNULL_1.

 

5305   static tree

5306   handle_nonnull_attribute (tree *node, tree name ATTRIBUTE_UNUSED, in c-common.c

5307                        tree args, int flags ATTRIBUTE_UNUSED,

5308                        bool *no_add_attrs)

5309   {

5310     tree type = *node;

5311     unsigned HOST_WIDE_INT attr_arg_num;

5312  

5313     /* If no arguments are specified, all pointer arguments should be

5314       non-null. Verify a full prototype is given so that the arguments

5315       will have the correct types when we actually check them later.  */

5316     if (! args)

5317     {

5318       if (! TYPE_ARG_TYPES (type))

5319       {

5320         error ("nonnull attribute without arguments on a non-prototype");

5321        *no_add_attrs = true;

5322       }

5323       return NULL_TREE;

5324     }

5325  

5326    /* Argument list specified. Verify that each argument number references

5327       a pointer argument.  */

5328     for (attr_arg_num = 1; args; args = TREE_CHAIN (args))

5329     {

5330       tree argument;

5331       unsigned HOST_WIDE_INT arg_num, ck_num;

5332  

5333       if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))

5334       {

5335         error ("nonnull argument has invalid operand number (arg %lu)",

5336              (unsigned long) attr_arg_num);

5337         *no_add_attrs = true;

5338         return NULL_TREE;

5339       }

5340  

5341       argument = TYPE_ARG_TYPES (type);

5342       if (argument)

5343       {

5344         for (ck_num = 1; ; ck_num++)

5345         {

5346           if (! argument || ck_num == arg_num)

5347             break;

5348           argument = TREE_CHAIN (argument);

5349         }

5350  

5351         if (! argument

5352            || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)

5353         {

5354           error ("nonnull argument with out-of-range operand number (arg %lu, operand %lu)",

5355                (unsigned long) attr_arg_num, (unsigned long) arg_num);

5356           *no_add_attrs = true;

5357           return NULL_TREE;

5358         }

5359  

5360         if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)

5361         {

5362           error ("nonnull argument references non-pointer operand (arg %lu, operand %lu)",

5363                (unsigned long) attr_arg_num, (unsigned long) arg_num);

5364           *no_add_attrs = true;

5365           return NULL_TREE;

5366         }

5367       }

5368     }

5369  

5370     return NULL_TREE;

5371   }

 

属性的参数如果出现，必须是整型常量而且大于0。这由get_nonnull_operand来保证。而且该函数还会获取声明不为空的参数的序号（从1算起）。

 

5449   static bool

5450   get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp) in c-common.c

5451   {

5452    /* Strip any conversions from the arg number and verify they

5453       are constants.  */

5454     while (TREE_CODE (arg_num_expr) == NOP_EXPR

5455        || TREE_CODE (arg_num_expr) == CONVERT_EXPR

5456        || TREE_CODE (arg_num_expr) == NON_LVALUE_EXPR)

5457       arg_num_expr = TREE_OPERAND (arg_num_expr, 0);

5458  

5459     if (TREE_CODE (arg_num_expr) != INTEGER_CST

5460         || TREE_INT_CST_HIGH (arg_num_expr) != 0)

5461       return false;

5462  

5463     *valp = TREE_INT_CST_LOW (arg_num_expr);

5464     return true;

5465   }

 

然后根据由get_nonnull_operand所获取的参数的序号，这里为1， handle_nonnull_attribute检查在那个位置的参数是否为指针类型（vprintf类型的参数1是类型builtin_types [BT_CONST_STRING]——“const char*”）。

4.3.1.7.5.6.5.5.        设置nonnull属性

设置这个属性和设置格式属性一样。现在所对应的FUNCTION_TYPE的属性链表中包含了format及nonnull。

4.3.1.7.5.6.5.6.        处理nothrow属性

属性nothrow应该应用于FUNCTION_DECL，此处参数node是为__builtin_vprintf在创建FUNCTION_DECL节点中所构建的FUNCTION_DECL节点。

 

5470   static tree

5471   handle_nothrow_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED, in c-common.c

5472                        int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)

5473   {

5474     if (TREE_CODE (*node) == FUNCTION_DECL)

5475       TREE_NOTHROW (*node) = 1;

5476     /* ??? TODO: Support types.  */

5477     else

5478     {

5479       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));

5480       *no_add_attrs = true;

5481     }

5482  

5483     return NULL_TREE;

5484   }

4.3.1.7.5.6.5.7.        设置nothrow属性

属性nothrow应该应用于FUNCTION_DECL，因此它被整合入代表该声明的节点（参见decl_attributes的297行）。

4.3.1.7.5.6.6.              题外话 —— 编译内建函数

内建函数是一个很有趣的话题，在此我们稍稍偏离一下编译器目前的任务——完成初始化，看一下如何编译内建函数的调用。在后面我们会看到，对于函数调用，编译器将为之构建一个CALL_EXPR的节点，其中的操作数是调用的函数及实参列表。在经过前端一系列的处理，包括前端所能做的优化后，这个CALL_EXPR所在的表达式节点，被交给expand_expr_real来为后端产生其所期望的输入——RTX对象。在这个函数中，可以看到这样的片段：

 

6262   rtx

6263   expand_expr_real (tree exp, rtx target, enum machine_mode tmode,                    in expr.c

6264                   enum expand_modifier modifier, rtx *alt_rtl)

6265   {

        …

6361     switch (code)

6362     {

         …

7521       case CALL_EXPR:

7522         /* Check for a built-in function.  */

7523         if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR

7524            && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))

7525                 == FUNCTION_DECL)

7526            && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))

7527         {

7528           if (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))

7529              == BUILT_IN_FRONTEND)

7530             return (*lang_hooks.expand_expr) (exp, original_target,

7531                                          tmode, modifier,

7532                                           alt_rtl);

7533           else

7534             return expand_builtin (exp, target, subtarget, tmode, ignore);

7535         }

            …

9118     }

        …

9133   }

 

在expand_builtin中，正如我们已经了解的，对于有库函数版本的内建函数，如果展开函数expand_XXX（XXX为__builtin版本的内建函数名）不能给出满意的结果，那么expand_builtin最后将调用expand_call来构建RTX的CALL对象，注意这个CALL对象的对象，将是保存在DECL_ASSEMBLE_NAME域的标识符，对于有库函数版本的内建函数，这就是库函数名。在当前版本的GCC中，我们的例子“__builtin_vprintf”实际上还没有实现，expand_builtin直截了当地为其调用库函数。

作为一个有趣的例子，我们看一下__builtin_constant_p的实现。这个内建函数判定其参数是否是一个编译时常量，它没有对应的库函数，不过它的展开不可能失败。沿上面所示的调用路径，当expand_builtin看到内建函数的编码为BUILT_IN_CONSTANT_P时，函数expand_builtin_constant_p粉墨登场。

 

1146   static rtx

1147   expand_builtin_constant_p (tree arglist, enum machine_mode target_mode) in builtins.c

1148   {

1149     rtx tmp;

1150  

1151     if (arglist == 0)

1152       return const0_rtx;

1153     arglist = TREE_VALUE (arglist);

1154  

1155     /* We have taken care of the easy cases during constant folding.  This

1156       case is not obvious, so emit (constant_p_rtx (ARGLIST)) and let CSE

1157       get a chance to see if it can deduce whether ARGLIST is constant.

1158       If CSE isn't going to run, of course, don't bother waiting.  */

1159  

1160     if (cse_not_expected)

1161       return const0_rtx;

1162  

1163     current_function_calls_constant_p = 1;

1164  

1165     tmp = expand_expr (arglist, NULL_RTX, VOIDmode, 0);

1166     tmp = gen_rtx_CONSTANT_P_RTX (target_mode, tmp);

1167     return tmp;

1168   }

 

在1166行，该函数为__builtin_constant_p构建了一个RTX对象——CONSTANT_P_RTX。这是一个特殊的RTX对象，在随后的后端的处理中，只要能判定其参数是常量，就将其简化为const1_rtx。如果得不到简化，这个CONSTANT_P_RTX对象的参数，最终会被认为是一个非编译时常量。