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

5.2. 命令行上的宏及断言

命令行上定义的宏定义的构建先于源代码中的宏定义。如果命令行及源代码给出同名的宏定义，编译器将给出警告，并且源文件的定义将覆盖命令行上的定义。

 

finish_options (continue)

 

1422     /* We're about to send user input to cpplib, so make it warn for

1423       things that we previously (when we sent it internal definitions)

1424       told it to not warn.

1425

1426       C99 permits implementation-defined characters in identifiers.

1427       The documented meaning of -std= is to turn off extensions that

1428       conflict with the specified standard, and since a strictly

1429       conforming program cannot contain a '$', we do not condition

1430       their acceptance on the -std= setting.  */

1431     cpp_opts->warn_dollars = (cpp_opts->pedantic && !cpp_opts->c99);

1432

1433     cpp_change_file (parse_in, LC_RENAME, _("<command line>"));

1434     for (i = 0; i < deferred_count; i++)

1435     {

1436       struct deferred_opt *opt = &deferred_opts[i];

1437

1438       if (opt->code == OPT_D)

1439         cpp_define (parse_in, opt->arg);

1440       else if (opt->code == OPT_U)

1441         cpp_undef (parse_in, opt->arg);

1442       else if (opt->code == OPT_A)

1443       {

1444         if (opt->arg[0] == '-')

1445           cpp_unassert (parse_in, opt->arg + 1);

1446         else

1447           cpp_assert (parse_in, opt->arg);

1448       }

1449     }

5.3. 由-imacros引入的宏定义及断言

命令行选项“–imacro file” 指示GCC包含入file中的宏定义。这些宏定义应该排在在-D或-U选项后面来处理。

 

finish_options (continue)

 

1451     /* Handle -imacros after -D and -U.  */

1452     for (i = 0; i < deferred_count; i++)

1453     {

1454       struct deferred_opt *opt = &deferred_opts[i];

1455

1456       if (opt->code == OPT_imacros

1457          && cpp_push_include (parse_in, opt->arg))

1458       {

1459         /* Disable push_command_line_include callback for now.  */

1460         include_cursor = deferred_count + 1;

1461         cpp_scan_nooutput (parse_in);

1462       }

1463     }

1464   }

 

给定这个文件名，GCC在读入前，需要定位它。

 

1049   bool

1050   cpp_push_include (cpp_reader *pfile, const char *fname)                            in cppfiles.c

1051   {

1052     /* Make the command line directive take up a line.  */

1053     pfile->line++;

1054     return _cpp_stack_include (pfile, fname, false, IT_CMDLINE);

1055   }

 

注意到，当调用cpp_push_include时，参数angle_brackets是false，表示由–imacros引入的头文件应当视为用户定义文件。

 

750    bool

751    _cpp_stack_include (cpp_reader *pfile, const char *fname, int angle_brackets, in cppfiles.c

752                    enum include_type type)

753    {

754      struct cpp_dir *dir;

755   

756      dir = search_path_head (pfile, fname, angle_brackets, type);

757      if (!dir)

758        return false;

759   

760      return _cpp_stack_file (pfile, _cpp_find_file (pfile, fname, dir, false,

761                                           angle_brackets),

762                         type == IT_IMPORT);

763    }

 

文件定位由search_path_head完成。回忆在cpp_reader中，域angle_brackets保存系统头文件的查找目录，quote_include保存用户定义文件的查找目录，而no_search_path保存包含文件的绝对路径。

 

692  static struct cpp_dir *

693  search_path_head (cpp_reader *pfile, const char *fname, int angle_brackets,    in cppfiles.c

694           enum include_type type)

695  {

696    cpp_dir *dir;

697    _cpp_file *file;

698 

699    if (IS_ABSOLUTE_PATH (fname))

700      return &pfile->no_search_path;

701 

702   /* pfile->buffer is NULL when processing an -include command-line flag.  */

703    file = pfile->buffer == NULL ? pfile->main_file : pfile->buffer->file;

704 

705    /* For #include_next, skip in the search path past the dir in which

706      the current file was found, but if it was found via an absolute

707      path use the normal search logic.  */

708    if (type == IT_INCLUDE_NEXT && file->dir)

709      dir = file->dir->next;

710    else if (angle_brackets)

711       dir = pfile->bracket_include;

712    else if (type == IT_CMDLINE)

713      /* -include and -imacros use the #include "" chain with the

714        preprocessor's cwd prepended.  */

715      return make_cpp_dir (pfile, "./", false);

716    else if (pfile->quote_ignores_source_dir)

717      dir = pfile->quote_include;

718    else

719      return make_cpp_dir (pfile, dir_name_of_file (file), pfile->map->sysp);

720 

721    if (dir == NULL)

722      cpp_error (pfile, CPP_DL_ERROR,

723           "no include path in which to search for %s", fname);

724 

725    return dir;

726  }

 

看到对由–imacros引入的文件，起始的查找点是当前目录，不过这只是建议，在上面_cpp_stack_include中760行的_cpp_find_file将按照dir链表查找，直到找出一个结果。

在708行，处理的是#include_next指示，它用在一个头文件中来包含另一个文件，它使得对新的头文件的查找，从当前头文件所在目录后的目录开始。例如，如果一个头文件的正常查找次序是目录A，B，C，D和E，如果当前头文件在目录B中找到，当前头文件中的#include_next指示将使得，在目录C，D和E中，查找这个新的头文件。

还要注意，对于普通文件，如果没有建议开始地方，将从该文件所在目录开始查找头文件。

当头文件被找到时，760行的_cpp_stack_file将读入文件，参考读入文件一节。

5.3.1. 符号提取

由–imacros包含的文件仅提取宏定义。因此cpp_scan_nooutput调用cpp_get_token来获取宏定义直到到达文件末尾。cpp_get_token也是预处理器的核心部分，是预处理的主要场所。因此，在这里我们花力气研究它。

 

1136 void

1137 cpp_scan_nooutput (cpp_reader *pfile)                                                 in cppmacro.c

1138 {

1139   /* Request a CPP_EOF token at the end of this file, rather than

1140     transparently continuing with the including file.  */

1141   pfile->buffer->return_at_eof = true;

1142

1143   if (CPP_OPTION (pfile, traditional))

1144     while (_cpp_read_logical_line_trad (pfile))

1145       ;

1146   else

1147     while (cpp_get_token (pfile)->type != CPP_EOF)

1148       ;

1149 }

 

cpp_reader中的context域是一个链表，它构成一系列相对独立的上下文。如果链表中仅有一个节点，这就是所谓的基本上下文，函数直接从文件中提取符号；而其他节点则包含一组的符号，代表特定的处理上下文，这样的例子有，宏展开、宏实参替换等。由这个context链表及精心设计的cpp_hashnode，cpp_get_token实现了看到宏的同时（非定义处）即将其展开。

 

1049 const cpp_token *

1050 cpp_get_token (cpp_reader *pfile)                                                               in cppmacro.c

1051 {

1052   const cpp_token *result;

1053

1054   for (;;)

1055   {

1056     cpp_hashnode *node;

1057     cpp_context *context = pfile->context;

1058

1059     /* Context->prev == 0 <=> base context.  */

1060     if (!context->prev)

1061       result = _cpp_lex_token (pfile);

1062     else if (FIRST (context).token != LAST (context).token)

1063     {

1064       if (context->direct_p)

1065         result = FIRST (context).token++;

1066       else

1067         result = *FIRST (context).ptoken++;

1068

1069       if (result->flags & PASTE_LEFT)

1070       {

1071         paste_all_tokens (pfile, result);

1072         if (pfile->state.in_directive)

1073           continue;

1074         return padding_token (pfile, result);

1075       }

1076     }

1077     else

1078     {

1079       _cpp_pop_context (pfile);

1080       if (pfile->state.in_directive)

1081         continue;

1082       return &pfile->avoid_paste;

1083     }

 

上面1062行，FIRST和LAST分别指向上下文中第一个和最后一个符号后的位置，如果2者相等，表明该上下文已经处理完成，通过1079行的_cpp_pop_context删除该上下文。1072及1080行的in_directive如果非0，表示我们正在处理指示（比如，#define，#ifdef等）。通常，处理完一个上下文时，其结果将被放入新的上下文中。

1082行的avoid_paste，其type是CPP_PADDING，其val.source是NULL，而1074行的padding_token则有如下定义：

 

900  static const cpp_token *

901  padding_token (cpp_reader *pfile, const cpp_token *source)                   in cppmacro.c

902  {

903    cpp_token *result = _cpp_temp_token (pfile);

904 

905    result->type = CPP_PADDING;

906    result->val.source = source;

907    result->flags = 0;

908    return result;

909  }

 

CPP_PADDING代表空白符号。以符号粘贴为例，当前gcc的实现是这样的。比如，宏的定义为：#define appA(PRE, A) PRE##A，随后调用appA (super, man)。而gcc的预处理器在一个新的上下文中，则为appA记录下展开体：super和man，并将super的flags置为PASTE_LEFT，随后返回一个CPP_PADDING（见下面cpp_get_token的1103行）。而调用cpp_get_token的程序一般会直接丢掉这个CPP_PADDING，继续从刚压入的新上下文中读入符号，这时上面1069行条件满足，super和man被粘贴paste_all_tokens成superman，并压入另一个新的上下文，而再次返回1个CPP_PADDING，这个空白符依然将被丢掉。而从这个新的上下文读入粘贴后的superman，而在下一次读入时，由于上下文已经空了，在1082行，也返回一个空白符，并移除这个上下文。现在，我们回到了宏展开体的上下文中，它已经是空的了，因而在下一次读入时，亦返回一个空白符，并回到基本上下文中。由此可见，这是一种强有力的隔离手段，能很好地保护上下文产生的结果（虽然在当前gcc里，这个保护似乎过分强大了）。而作为in_directive非0的情况，处理指示是直接使用基本上下文的，不存在上下文切换，不需要也不能插入空白符。

为了方便起见，我们把_cpp_lex_token的代码，在下面重新显示一次。

 

691    const cpp_token *

692    _cpp_lex_token (cpp_reader *pfile)                                                          in cpplex.c

693    {

694      cpp_token *result;

695   

696      for (;;)

697      {

698        if (pfile->cur_token == pfile->cur_run->limit)

699        {

700          pfile->cur_run = next_tokenrun (pfile->cur_run);

701          pfile->cur_token = pfile->cur_run->base;

702        }

703   

704        if (pfile->lookaheads)

705        {

706          pfile->lookaheads--;

707          result = pfile->cur_token++;

708        }

709        else

710          result = _cpp_lex_direct (pfile);

711    

712        if (result->flags & BOL)

713        {

714          /* Is this a directive. If _cpp_handle_directive returns

715            false, it is an assembler #.  */

716          if (result->type == CPP_HASH

717            /* 6.10.3 p 11: Directives in a list of macro arguments

718              gives undefined behavior. This implementation

719              handles the directive as normal.  */

720               && pfile->state.parsing_args != 1

721               && _cpp_handle_directive (pfile, result->flags & PREV_WHITE))

722            continue;

723          if (pfile->cb.line_change && !pfile->state.skipping)

724            pfile->cb.line_change (pfile, result, pfile->state.parsing_args);

725        }

726   

727        /* We don't skip tokens in directives.  */

728        if (pfile->state.in_directive)

729          break;

730   

731        /* Outside a directive, invalidate controlling macros. At file

732          EOF, _cpp_lex_direct takes care of popping the buffer, so we never

733          get here and MI optimization works.  */

734        pfile->mi_valid = false;

735   

736        if (!pfile->state.skipping || result->type == CPP_EOF)

737          break;

738      }

739   

740      return result;

741    }

 

上面的720行，域parsing_args表明我们解析宏的阶段。当解析其定义时，其值为0；而当进行宏替换并且正在查找左括号时，其值为1；当左括号找到后，其值为2。为了理解716行开始的条件，考虑下面的例子：

#define FUN(c) c

int main() {

   FUN(

#ifdef SMALL

           12,

#else

           24

#endif

           );

}

5.3.1.1.    处理指示

在721行，当看到FUN的定义时，_cpp_handle_directive将被调用。如果指示有缩进，参数indented是非0值，这种情况传统模式将发出警告或错误。在后面我们还会看到，当看到第5行的#ifdef时，_cpp_handle_directive将再一次被调用。

 

333    int

334    _cpp_handle_directive (cpp_reader *pfile, int indented)                              in cpplib.c

335    {

336      const directive *dir = 0;

337      const cpp_token *dname;

338      bool was_parsing_args = pfile->state.parsing_args;

339      int skip = 1;

340   

341      if (was_parsing_args)

342      {

343        if (CPP_OPTION (pfile, pedantic))

344          cpp_error (pfile, CPP_DL_PEDWARN,

345                   "embedding a directive within macro arguments is not portable");

346        pfile->state.parsing_args = 0;

347        pfile->state.prevent_expansion = 0;

348      }

349      start_directive (pfile);

350      dname = _cpp_lex_token (pfile);

351   

352      if (dname->type == CPP_NAME)

353      {

354        if (dname->val.node->is_directive)

355          dir = &dtable[dname->val.node->directive_index];

356      }

357      /* We do not recognize the # followed by a number extension in

358        assembler code.  */

359      else if (dname->type == CPP_NUMBER && CPP_OPTION (pfile, lang) != CLK_ASM)

360      {

361        dir = &linemarker_dir;

362        if (CPP_PEDANTIC (pfile) && ! CPP_OPTION (pfile, preprocessed)

363            && ! pfile->state.skipping)

364          cpp_error (pfile, CPP_DL_PEDWARN,

365                   "style of line directive is a GCC extension");

366      }

 

回忆directive类型的dtable是根据DIRECTIVE_TABLE来初始化的（参考_cpp_init_directives，相应的hashnode被创建并保存入ident_hash，因此在354行，dname的val.node 就是这个标识符）。

作为GCC的一个扩展，行标志（linemarker）具有形式#linenum filename flags，它被插入输出需要的地方（但不会在一个字符串或字符常量中），表示下面跟着的行来自文件filename从linenum行开始的地方。为了处理它，在系统中有一个全局的directive实例——linemarker_dir（上面361行），它包含了操作行标志的句柄——do_linemarker。注意到在362行，cpp_reader中opts的preprocessed如果非0，表示我们正在查看已经被预处理的代码（或者由选项–fpreprocessed设置来禁止预处理，即便命令行上的文件所具有的后缀，提示它需要被预处理），行标志不能出现，而cpp_reader中opts的pedantic如果非0，表示给出所有ANSI标准所要求的错误消息。

 

_cpp_handle_directive (continue)

 

368      if (dir)

369      {

370        /* If we have a directive that is not an opening conditional,

371          invalidate any control macro.  */

372        if (! (dir->flags & IF_COND))

373          pfile->mi_valid = false;

374   

375        /* Kluge alert. In order to be sure that code like this

376   

377          #define HASH #

378          HASH define foo bar

379   

380          does not cause '#define foo bar' to get executed when

381          compiled with -save-temps, we recognize directives in

382          -fpreprocessed mode only if the # is in column 1. cppmacro.c

383          puts a space in front of any '#' at the start of a macro.  */

384        if (CPP_OPTION (pfile, preprocessed)

385            && (indented || !(dir->flags & IN_I)))

386        {

387          skip = 0;

388          dir = 0;

389        }

390        else

391        {

392          /* In failed conditional groups, all non-conditional

393            directives are ignored. Before doing that, whether

394            skipping or not, we should lex angle-bracketed headers

395            correctly, and maybe output some diagnostics.  */

396          pfile->state.angled_headers = dir->flags & INCL;

397          pfile->state.directive_wants_padding = dir->flags & INCL;

398          if (!CPP_OPTION (pfile, preprocessed))

399            directive_diagnostics (pfile, dir, indented);

400          if (pfile->state.skipping && !(dir->flags & COND))

401            dir = 0;

402        }

403      }

404      else if (dname->type == CPP_EOF)

405        ;    /* CPP_EOF is the "null directive".  */

406      else

407      {

408        /* An unknown directive. Don't complain about it in assembly

409          source: we don't know where the comments are, and # may

410          introduce assembler pseudo-ops. Don't complain about invalid

411           directives in skipped conditional groups (6.10 p4).  */

412        if (CPP_OPTION (pfile, lang) == CLK_ASM)

413          skip = 0;

414        else if (!pfile->state.skipping)

415          cpp_error (pfile, CPP_DL_ERROR, "invalid preprocessing directive #%s",

416                   cpp_token_as_text (pfile, dname));

417      }

 

如果找到了指示对象，dir则不是NULL。在预处理中，这个指示要被诊断以发现不正确的使用，并给出错误消息。这个函数相当直观。

 

297    static void

298    directive_diagnostics (cpp_reader *pfile, const directive *dir, int indented)   in cpplib.c

299    {

300      /* Issue -pedantic warnings for extensions.  */

301      if (CPP_PEDANTIC (pfile)

302          && ! pfile->state.skipping

303          && dir->origin == EXTENSION)

304        cpp_error (pfile, CPP_DL_PEDWARN, "#%s is a GCC extension", dir->name);

305   

306      /* Traditionally, a directive is ignored unless its # is in

307        column 1. Therefore in code intended to work with K+R

308        compilers, directives added by C89 must have their #

309        indented, and directives present in traditional C must not.

310        This is true even of directives in skipped conditional

311         blocks. #elif cannot be used at all.  */

312      if (CPP_WTRADITIONAL (pfile))

313      {

314        if (dir == &dtable [T_ELIF])

315          cpp_error (pfile, CPP_DL_WARNING,

316                   "suggest not using #elif in traditional C");

317        else if (indented && dir->origin == KANDR)

318          cpp_error (pfile, CPP_DL_WARNING,

319                   "traditional C ignores #%s with the # indented",

320                   dir->name);

321        else if (!indented && dir->origin != KANDR)

322          cpp_error (pfile, CPP_DL_WARNING,

323                  "suggest hiding #%s from traditional C with an indented #",

324                  dir->name);

325      }

326    }

 

如果指示是有效的，它被存入cpp_reader的directive域。通过调用操作句柄，该指示得到执行。对于我们的案例，这是do_define，其核心函数是_cpp_create_definition（参考创建宏定义 – ISO模式一节）。

 

_cpp_handle_directive (continue)

 

419      pfile->directive = dir;

420      if (CPP_OPTION (pfile, traditional))

421        prepare_directive_trad (pfile);

422   

423      if (dir)

424        pfile->directive->handler (pfile);

425      else if (skip == 0)

426        _cpp_backup_tokens (pfile, 1);

427   

428      end_directive (pfile, skip);

429      if (was_parsing_args)

430      {

431        /* Restore state when within macro args.  */

432        pfile->state.parsing_args = 2;

433        pfile->state.prevent_expansion = 1;

434      }

435      return skip;

436    }

 

如果_cpp_handle_directive能处理指示并且能继续下去，它返回一个非0值，否则返回0，这个值通常表示错误的状态或遇到了汇编代码。因此，对于正常的情况，当从上面_cpp_lex_token 721处的_cpp_handle_directive返回后，该函数提前跟在宏定义后的第一个符号。这次这个符号不会再被认为是指示，它将返回给cpp_get_token。

 

cpp_get_token (continue)

 

1085     if (pfile->state.in_directive && result->type == CPP_COMMENT)

1086       continue;

1087

1088     if (result->type != CPP_NAME)

1089       break;

1090

1091     node = result->val.node;

1092

1093     if (node->type != NT_MACRO || (result->flags & NO_EXPAND))

1094       break;

1095

1096     if (!(node->flags & NODE_DISABLED))

1097     {

1098       if (!pfile->state.prevent_expansion

1099           && enter_macro_context (pfile, node))

1100       {

1101         if (pfile->state.in_directive)

1102           continue;

1103         return padding_token (pfile, result);

1104       }

1105     }

1106     else

1107     {

1108       /* Flag this token as always unexpandable. FIXME: move this

1109         to collect_args()?.  */

1110       cpp_token *t = _cpp_temp_token (pfile);

1111       t->type = result->type;

1112       t->flags = result->flags | NO_EXPAND;

1113       t->val.str = result->val.str;

1114       result = t;

1115     }

1116

1117     break;

1118   }

1119

1120   return result;

1121 }