3. genrecog 工具
3.1. 代码输出的准备
工具 genrecog 用于产生识别及转换 RTL 到汇编的转换引擎。在这里我们看到该工具如何从机器描述文件构建出这个引擎——我们以 i386 系统为例子，这个机器描述文件是 i386.md 。
2612 int
2613 main (int argc, char **argv) in genrecog.c
2614 {
2615 rtx desc;
2616 struct decision_head recog_tree, split_tree, peephole2_tree, h;
2617
2618 progname = "genrecog";
2619
2620 memset (&recog_tree, 0, sizeof recog_tree);
2621 memset (&split_tree, 0, sizeof split_tree);
2622 memset (&peephole2_tree, 0, sizeof peephole2_tree);
2623
2624 if (argc <= 1)
2625 fatal ("no input file name");
在 2616 行，结构体 decision_head 保存了转换引擎的决策树（ decision tree ）。它具有如下的定义。
73 struct decision_head in genrecog.c
74 {
75 struct decision *first;
76 struct decision *last;
77 };
而在上面 75 行， decision 的定义如下。
125 struct decision in genrecog.c
126 {
127 struct decision_head success; /* Nodes to test on success. */
128 struct decision *next; /* Node to test on failure. */
129 struct decision *prev; /* Node whose failure tests us. */
130 struct decision *afterward; /* Node to test on success,
131 but failure of successor nodes. */
132
133 const char *position; /* String denoting position in pattern. */
134
135 struct decision_test *tests; /* The tests for this node. */
136
137 int number; /* Node number, used for labels */
138 int subroutine_number; /* Number of subroutine this node starts */
139 int need_label; /* Label needs to be output. */
140 };
在 135 行， decision_test 保存了决策所需要的测试及其结果。
83 struct decision_test in genrecog.c
84 {
85 /* A linked list through the tests attached to a node. */
86 struct decision_test *next;
87
88 /* These types are roughly in the order in which we'd like to test them. */
90 {
91 DT_mode, DT_code, DT_veclen,
92 DT_elt_zero_int, DT_elt_one_int, DT_elt_zero_wide, DT_elt_zero_wide_safe,
93 DT_veclen_ge, DT_dup, DT_pred, DT_c_test,
94 DT_accept_op, DT_accept_insn
95 } type;
96
97 union
98 {
99 enum machine_mode mode; /* Machine mode of node. */
100 RTX_CODE code; /* Code to test. */
101
102 struct
103 {
104 const char *name; /* Predicate to call. */
105 int index; /* Index into `preds' or -1. */
106 enum machine_mode mode; /* Machine mode for node. */
107 } pred;
108
109 const char *c_test; /* Additional test to perform. */
110 int veclen; /* Length of vector. */
111 int dup; /* Number of operand to compare against. */
112 HOST_WIDE_INT intval; /* Value for XINT for XWINT. */
113 int opno; /* Operand number matched. */
114
115 struct {
116 int code_number; /* Insn number matched. */
117 int lineno; /* Line number of the insn. */
118 int num_clobbers_to_add; /* Number of CLOBBERs to be added. */
119 } insn;
120 } u;
121 };
首先我们初始化 recog_tree ， split_tree ， peephole2_tree 及 h 的所有 decision_head 实例为 0 。然后需要初始化读入器来读入机器描述文件（ md 文件）。
main (continued, genrecog)
2627 if (init_md_reader_args (argc, argv) != SUCCESS_EXIT_CODE)
2628 return (FATAL_EXIT_CODE);
2629
2630 next_insn_code = 0;
2631 next_index = 0;
2632
2633 write_header ();
在 2627 行，函数 init_md_reader_args 处理命令行选项。对于 genrecog 工具，它仅接受 -I 选项。这个选项显示了查找 md 文件的附加路径。然后该函数调用 init_md_reader 。这个函数我们已经在 genconditions工具 一节中看过。它从 md 文件中读入模式，构建相应的 rtx 对象并链入指定的链表。
注意到在 init_md_reader 的从 928 到 933 行， genrecog 现在把由 genconditions 构建的 insn-conditions 放入哈希表 condition_table 中。并且记住访问的次序是： define_attr ， define_insn ，然后其它。
3.2. 读入 rtl 形式的定义
3.2.1. 选择合适的模式
所有的工具都有这一步，不过对于除 genconditions 以外的其它工具，可以进行一些优化，因为它们可以，通过由 genconditions 产生的 insn_conditions ，过滤出不活动的模式。
main (continued, genrecog)
2635 /* Read the machine description. */
2636
2637 while (1)
2638 {
2639 desc = read_md_rtx (&pattern_lineno , &next_insn_code );
2640 if (desc == NULL)
2641 break ;
2642
2643 if (GET_CODE (desc) == DEFINE_INSN)
2644 {
2645 h = make_insn_sequence (desc, RECOG);
2646 merge_trees (&recog_tree, &h);
2647 }
2648 else if (GET_CODE (desc) == DEFINE_SPLIT)
2649 {
2650 h = make_insn_sequence (desc, SPLIT);
2651 merge_trees (&split_tree, &h);
2652 }
2653 else if (GET_CODE (desc) == DEFINE_PEEPHOLE2)
2654 {
2655 h = make_insn_sequence (desc, PEEPHOLE2);
2656 merge_trees (&peephole2_tree, &h);
2657 }
2658
2659 next_index ++;
2660 }
在 genconditions工具 一节我们已经碰到了 read_md_rtx ，现在我们仔细看一下它做什么。
965 rtx
966 read_md_rtx (int *lineno, int *seqnr) in gensupport.c
967 {
968 struct queue_elem **queue, *elem;
969 rtx desc;
970
971 discard:
972
973 /* Read all patterns from a given queue before moving on to the next. */
974 if (define_attr_queue != NULL)
975 queue = &define_attr_queue ;
976 else if (define_insn_queue != NULL)
977 queue = &define_insn_queue ;
978 else if (other_queue != NULL)
979 queue = &other_queue ;
980 else
981 return NULL_RTX;
982
983 elem = *queue;
984 *queue = elem->next;
985 desc = elem->data;
986 read_rtx_filename = elem->filename;
987 *lineno = elem->lineno;
988 *seqnr = sequence_num ;
989
990 free (elem);
991
992 /* Discard insn patterns which we know can never match (because
993 their C test is provably always false). If insn_elision is
994 false, our caller needs to see all the patterns. Note that the
995 elided patterns are never counted by the sequence numbering; it
996 it is the caller's responsibility, when insn_elision is false, not
997 to use elided pattern numbers for anything. */
998 switch (GET_CODE (desc))
999 {
1000 case DEFINE_INSN:
1001 case DEFINE_EXPAND:
1002 if (maybe_eval_c_test (XSTR (desc, 2)) != 0)
1003 sequence_num ++;
1004 else if (insn_elision )
1005 goto discard;
1006 break ;
1007
1008 case DEFINE_SPLIT:
1009 case DEFINE_PEEPHOLE:
1010 case DEFINE_PEEPHOLE2:
1011 if (maybe_eval_c_test (XSTR (desc, 1)) != 0)
1012 sequence_num ++;
1013 else if (insn_elision )
1014 goto discard;
1015 break ;
1016
1017 default :
1018 break ;
1019 }
1020
1021 return desc;
1022 }
在 genrecog 中， maybe_eval_c_test 可能为模式执行非平凡（ non-trivial ）的测试。
1067 int
1068 maybe_eval_c_test (const char *expr) in gensupport.c
1069 {
1070 const struct c_test *test;
1071 struct c_test dummy;
1072
1073 if (expr[0] == 0)
1074 return 1;
1075
1076 if (insn_elision_unavailable)
1077 return -1;
1078
1079 dummy.expr = expr;
1080 test = htab_find (condition_table , &dummy);
1081 if (!test)
1082 abort ();
1083
1084 return test->value;
1085 }
注意到在 1084 行， test 从 condtion_table 获取，其内容来自由 genconditions 产生的 insn_condition ，正如我们在 init_md_reader 看到那样。 test 的 value 在 genconditions工具 一节中确定。在 write_one_condition 的 157 行， value 由 MAYBE_EVAL(expr) 返回。 MAYBE_EVAL 也是由 genconditions 按以下方式定义：
123 puts ("/ in genconditions.c
124 /* If we don't have __builtin_constant_p, or it's not acceptable in/n/
125 array initializers, fall back to assuming that all conditions/n/
126 potentially vary at run time. It works in 3.0.1 and later; 3.0/n/
127 only when not optimizing. */ /n/
128 #if (GCC_VERSION >= 3001) || ((GCC_VERSION == 3000) && !__OPTIMIZE__)/n/
129 # define MAYBE_EVAL(expr) (__builtin_constant_p(expr) ? (int) (expr) : -1)/n/
130 #else /n/
131 # define MAYBE_EVAL(expr) -1/n/
132 #endif /n");
__builtin_constant_p 返回整数 1 ，如果该参数已知是一个编译时常量；返回 0 ，如果它不能确定为编译时常量。一个 0 返回值不表示这个值不是一个常量，仅是表明 GCC 不能证明，在给定的 -O 选项（优化）值下，它是一个常量。
因此在 read_md_rtx 的 1011 行，在工具处理这个机器描述文件过程中，跳过那些条件测试部分已知为 false 的模式。这可以节省处理时间，并减小产生出来文件的大小。而那些条件测试部分已知为 true ，或那些条件测试部分不能确信为常量的模式，为 read_md_rtx 返回，并将由 make_insn_sequence 处理。
2413 static struct decision_head
2414 make_insn_sequence (rtx insn, enum routine_type type) in genrecog.c
2415 {
2416 rtx x;
2417 const char *c_test = XSTR (insn, type == RECOG ? 2 : 1);
2418 int truth = maybe_eval_c_test (c_test);
2419 struct decision *last;
2420 struct decision_test *test, **place;
2421 struct decision_head head;
2422 char c_test_pos[2];
2423
2424 /* We should never see an insn whose C test is false at compile time. */
2425 if (truth == 0)
2426 abort ();
2427
2428 record_insn_name (next_insn_code , (type == RECOG? XSTR (insn, 0): NULL));
对于 define_insn 模式，模式名由函数 record_insn_name 记录。而对于其它匿名模式，该函数将为之构建一个 insn+’codeno’ 形式的名字。所有这些名字被保存在全局数组 insn_name_ptr 中。
2685 static void
2686 record_insn_name (int code, const char *name) in genrecog.c
2687 {
2688 static const char *last_real_name = "insn";
2689 static int last_real_code = 0;
2690 char *new;
2691
2692 if (insn_name_ptr_size <= code)
2693 {
2694 int new_size;
2695 new_size = (insn_name_ptr_size ? insn_name_ptr_size * 2 : 512);
2696 insn_name_ptr = xrealloc (insn_name_ptr , sizeof (char *) * new_size);
2697 memset (insn_name_ptr + insn_name_ptr_size , 0,
2698 sizeof (char *) * (new_size - insn_name_ptr_size ));
2699 insn_name_ptr_size = new_size;
2700 }
2701
2702 if (!name || name[0] == '/0')
2703 {
2704 new = xmalloc (strlen (last_real_name) + 10);
2705 sprintf (new, "%s+%d", last_real_name, code - last_real_code);
2706 }
2707 else
2708 {
2709 last_real_name = new = xstrdup (name);
2710 last_real_code = code;
2711 }
2712
2713 insn_name_ptr [code] = new;
2714 }
下面在 make_insn_sequence 中，模式 define_peephole2 描述了特定的指令序列，通过由指定的输出序列替代之，体现了优化的机会。这里我们跳过这个模式。
make_insn_sequence (continued)
2430 c_test_pos[0] = '/0';
2431 if (type == PEEPHOLE2)
2432 {
2433 int i, j;
2434
2435 /* peephole2 gets special treatment:
2436 - X always gets an outer parallel even if it's only one entry
2437 - we remove all traces of outer-level match_scratch and match_dup
2438 expressions here. */
2439 x = rtx_alloc (PARALLEL);
2440 PUT_MODE (x, VOIDmode);
2441 XVEC (x, 0) = rtvec_alloc (XVECLEN (insn, 0));
2442 for (i = j = 0; i < XVECLEN (insn, 0); i++)
2443 {
2444 rtx tmp = XVECEXP (insn, 0, i);
2445 if (GET_CODE (tmp) != MATCH_SCRATCH && GET_CODE (tmp) != MATCH_DUP)
2446 {
2447 XVECEXP (x, 0, j) = tmp;
2448 j++;
2449 }
2450 }
2451 XVECLEN (x, 0) = j;
2452
2453 c_test_pos[0] = 'A' + j - 1;
2454 c_test_pos[1] = '/0';
2455 }
2456 else if (XVECLEN (insn, type == RECOG) == 1)
2457 x = XVECEXP (insn, type == RECOG, 0);
2458 else
2459 {
2460 x = rtx_alloc (PARALLEL);
2461 XVEC (x, 0) = XVEC (insn, type == RECOG);
2462 PUT_MODE (x, VOIDmode);
2463 }
2464
2465 validate_pattern (x, insn, NULL_RTX, 0);
上面 ， 获取了模式的 RTL 模板 （ template ） 部分 （ RTL 模板的定义参考 DEFINE_INSN模式的概览 一节）。对于那些具有多个指令的 RTL 模板， 2458 到 2463 行为之构建了一个 rtx 的 PARALLEL 对象。
在机器描述文件中的指令描述模式的 RTL 模板，在提取后，将由 validate_pattern 来验证有效性。这里我们再次使用上面的例子（注意：实际上这个例子将在 read_md_rtx 中被过滤掉，因为 maybe_eval_c_test 对其条件测试部分返回 0 。我们可以在 genextract工具 一节确认这一点。不过，这个事实并不影响它在这里作为例子）。
467 (define_insn "cmpdi_ccno_1_rex64" in i386.md
468 [(set (reg 17)
469 (compare (match_operand:DI 0 "nonimmediate_operand" "r,?mr")
470 (match_operand:DI 1 "const0_operand" "n,n")))]
471 "TARGET_64BIT && ix86_match_ccmode (insn, CCNOmode)"
472 "@
473 test{q}/t{%0, %0|%0, %0}
474 cmp{q}/t{%1, %0|%0, %1}"
475 [(set_attr "type" "test,icmp")
476 (set_attr "length_immediate" "0,1")
477 (set_attr "mode" "DI")])
定义中的 RTL 模板是：
[(set (reg 17)
(compare (match_operand:DI 0 "nonimmediate_operand" "r,?mr")
(match_operand:DI 1 "const0_operand" "n,n")))]
实际上，这里的这个模式已经被转换成 rtx 对象，如 图 1 所示。不过树的结构仍被保留。
从上面的模式我们可以看到，首先为了方便从模式构建 rtx 树，模式采用了后序记法（ prefix notation ）。其次， RTL 语言接近于汇编语言，它采用了容易转换为汇编的形式。因为它处于高级编程语言及汇编语言之间，其关键字更类似于编程语言，但行为上类似汇编，并且没有编程语言中 for 及 if 语句的对应物。其关键字可以粗略地分为：
赋值 - “set”
算术操作 - “plus, minus, mul, div, mod”
逻辑操作 - “and, or, xor, ior”
位操作 - “ashift, lshift”
函数调用 - “call”
函数退出 - “return”
操作符选择子 - “match_operand, match_dup, match_scratch”
操作数选择子 - “match_operator, match_op_dup”
类型转换 - “zero_extract, sign_extract, strict_low_part, strict_high_part”
取址 - “label_ref, symbol_ref”
比较 - “compare, test”
其它 - “clobber”
3.2.2. 验证模式的 RTL 模板
好了，现在看一下 validate_pattern 可以为我们做什么。
460 static void
461 validate_pattern (rtx pattern, rtx insn, rtx set, int set_code) in genrecog.c
462 {
463 const char *fmt;
464 RTX_CODE code;
465 size_t i, len;
466 int j;
467
468 code = GET_CODE (pattern);
469 switch (code)
470 {
471 case MATCH_SCRATCH:
472 return ;
473 case MATCH_DUP:
474 case MATCH_OP_DUP:
475 case MATCH_PAR_DUP:
476 if (find_operand (insn, XINT (pattern, 0), pattern) == pattern)
477 {
478 message_with_line (pattern_lineno ,
479 "operand %i duplicated before defined",
480 XINT (pattern, 0));
481 error_count ++;
482 }
483 break ;
484 case MATCH_INSN:
485 case MATCH_OPERAND:
486 case MATCH_OPERATOR:
487 {
…
635 }
636
637 case SET:
638 {
639 enum machine_mode dmode, smode;
640 rtx dest, src;
641
642 dest = SET_DEST (pattern);
643 src = SET_SRC (pattern);
644
645 /* STRICT_LOW_PART is a wrapper. Its argument is the real
646 destination, and it's mode should match the source. */
647 if (GET_CODE (dest) == STRICT_LOW_PART)
648 dest = XEXP (dest, 0);
649
650 /* Find the referent for a DUP. */
651
652 if (GET_CODE (dest) == MATCH_DUP
653 || GET_CODE (dest) == MATCH_OP_DUP
654 || GET_CODE (dest) == MATCH_PAR_DUP)
655 dest = find_operand (insn, XINT (dest, 0), NULL);
656
657 if (GET_CODE (src) == MATCH_DUP
658 || GET_CODE (src) == MATCH_OP_DUP
659 || GET_CODE (src) == MATCH_PAR_DUP)
660 src = find_operand (insn, XINT (src, 0), NULL);
661
662 dmode = GET_MODE (dest);
663 smode = GET_MODE (src);
664
665 /* The mode of an ADDRESS_OPERAND is the mode of the memory
666 reference, not the mode of the address. */
667 if (GET_CODE (src) == MATCH_OPERAND
668 && ! strcmp (XSTR (src, 1), "address_operand"))
669 ;
670
671 /* The operands of a SET must have the same mode unless one
672 is VOIDmode. */
673 else if (dmode != VOIDmode && smode != VOIDmode && dmode != smode)
674 {
675 message_with_line (pattern_lineno ,
676 "mode mismatch in set: %smode vs %smode",
677 GET_MODE_NAME (dmode), GET_MODE_NAME (smode));
678 error_count ++;
679 }
680
681 /* If only one of the operands is VOIDmode, and PC or CC0 is
682 not involved, it's probably a mistake. */
683 else if (dmode != smode
684 && GET_CODE (dest) != PC
685 && GET_CODE (dest) != CC0
686 && GET_CODE (src) != PC
687 && GET_CODE (src) != CC0
688 && GET_CODE (src) != CONST_INT)
689 {
690 const char *which;
691 which = (dmode == VOIDmode ? "destination" : "source");
692 message_with_line (pattern_lineno ,
693 "warning: %s missing a mode?", which);
694 }
695
696 if (dest != SET_DEST (pattern))
697 validate_pattern (dest, insn, pattern, '=');
698 validate_pattern (SET_DEST (pattern), insn, pattern, '=');
699 validate_pattern (SET_SRC (pattern), insn, NULL_RTX, 0);
700 return ;
701 }
对于我们的模式例子，它首先进入 637 行。在 642 及 643 行，获取了 insn 的，对应源及目的，的 rtx 对象。这里它们是：
目的： (reg 17)
源：
(compare (match_operand:DI 0 "nonimmediate_operand" "r,?mr")
(match_operand:DI 1 "const0_operand" "n,n"))
对于这些 rtx 对象，我们将跳过上面的 652 及 657 行。在 662 及 663 行获取了这些 rtx 对象的 mode 。不过在构建这些 rtx 对象时，没有给它们指定 mode ，因此这个值应该是 0 – 即 VOIDmode 。因而代码直接跑到 698 行，递归地验证“源”及“目的” rtx 对象。
validate_pattern (continued)
703 case CLOBBER:
704 validate_pattern (SET_DEST (pattern), insn, pattern, '=');
705 return ;
706
707 case ZERO_EXTRACT:
708 validate_pattern ( XEXP (pattern, 0), insn, set, set ? '+' : 0);
709 validate_pattern ( XEXP (pattern, 1), insn, NULL_RTX, 0);
710 validate_pattern ( XEXP (pattern, 2), insn, NULL_RTX, 0);
711 return ;
712
713 case STRICT_LOW_PART:
714 validate_pattern ( XEXP (pattern, 0), insn, set, set ? '+' : 0);
715 return ;
716
717 case LABEL_REF:
718 if (GET_MODE ( XEXP (pattern, 0)) != VOIDmode)
719 {
720 message_with_line (pattern_lineno ,
721 "operand to label_ref %smode not VOIDmode",
722 GET_MODE_NAME (GET_MODE (XEXP (pattern, 0))));
723 error_count ++;
724 }
725 break ;
726
727 default :
728 break ;
729 }
对于我们的“源”及“目的” rtx 对象，它们将进入上面代码的 727 行。然后它们的内容将被根据它们的 rtx 格式进行验证。
对于“目的”对象，格式是“ i00 ”，它将通过 746 行，但不做任何事。对于“源”对象，其格式是“ ee ”，它两次通过 737 行来处理其两个孩子。
validate_pattern (continued)
731 fmt = GET_RTX_FORMAT (code);
732 len = GET_RTX_LENGTH (code);
733 for (i = 0; i < len; i++)
734 {
735 switch (fmt[i])
736 {
737 case 'e': case 'u':
738 validate_pattern (XEXP (pattern, i), insn, NULL_RTX, 0);
739 break ;
740
741 case 'E':
742 for (j = 0; j < XVECLEN (pattern, i); j++)
743 validate_pattern (XVECEXP (pattern, i, j), insn, NULL_RTX, 0);
744 break ;
745
746 case 'i': case 'w': case '0': case 's':
747 break ;
748
749 default :
750 abort ();
751 }
752 }
753 }
我们只看第一个孩子。它是：“ match_operand:DI 0 "nonimmediate_operand" "r,?mr" ”。在进入 validate_pattern 之后，它将通过 485 行。下面的代码包含在 validate_pattern 中 484~486 行的 case 语句中。注意到下面， insn 仍然指向机器描述文件中的指令描述模式。这里是这个 define_insn 。
validate_pattern (continued)
488 const char *pred_name = XSTR (pattern, 1);
489 int allows_non_lvalue = 1, allows_non_const = 1;
490 int special_mode_pred = 0;
491 const char *c_test;
492
493 if (GET_CODE (insn) == DEFINE_INSN)
494 c_test = XSTR (insn, 2);
495 else
496 c_test = XSTR (insn, 1);
497
498 if (pred_name[0] != 0)
499 {
500 for (i = 0; i < NUM_KNOWN_PREDS; i++)
501 if (! strcmp (preds [i].name, pred_name))
502 break ;
503
504 if (i < NUM_KNOWN_PREDS)
505 {
506 int j;
507
508 allows_non_lvalue = allows_non_const = 0;
509 for (j = 0; preds [i].codes[j] != 0; j++)
510 {
511 RTX_CODE c = preds [i].codes[j];
512 if (c != LABEL_REF
513 && c != SYMBOL_REF
514 && c != CONST_INT
515 && c != CONST_DOUBLE
516 && c != CONST
517 && c != HIGH
518 && c != CONSTANT_P_RTX)
519 allows_non_const = 1;
520
521 if (c != REG
522 && c != SUBREG
523 && c != MEM
524 && c != ADDRESSOF
525 && c != CONCAT
526 && c != PARALLEL
527 && c != STRICT_LOW_PART)
528 allows_non_lvalue = 1;
529 }
530 }
531 else
532 {
533 #ifdef PREDICATE_CODES
534 /* If the port has a list of the predicates it uses but
535 omits one, warn. */
536 message_with_line (pattern_lineno ,
537 "warning: `%s' not in PREDICATE_CODES",
538 pred_name);
539 #endif
540 }
541
542 for (i = 0; i < NUM_SPECIAL_MODE_PREDS; ++i)
543 if (strcmp (pred_name, special_mode_pred_table [i]) == 0)
544 {
545 special_mode_pred = 1;
546 break ;
547 }
548 }
上面在 488 行，提取了“ nonimmediate_operand ”，它是匹配操作数的断言（ predicate ）。在 501 行的 preds 具有如下的定义。其 codes 域包含了一个 rtl 编码的列表，这些编码可能匹配一个定义在 recog.c 中的断言。
186 static const struct pred_table in genrecog.c
187 {
188 const char *const name;
189 const RTX_CODE codes[NUM_RTX_CODE];
190 } preds [] = {
191 {"general_operand", {CONST_INT, CONST_DOUBLE, CONST, SYMBOL_REF,
192 LABEL_REF, SUBREG, REG, MEM, ADDRESSOF}},
193 #ifdef PREDICATE_CODES
194 PREDICATE_CODES
195 #endif
196 {"address_operand", {CONST_INT, CONST_DOUBLE, CONST, SYMBOL_REF,
197 LABEL_REF, SUBREG, REG, MEM, ADDRESSOF,
198 PLUS, MINUS, MULT}},
199 {"register_operand", {SUBREG, REG, ADDRESSOF}},
200 {"pmode_register_operand", {SUBREG, REG, ADDRESSOF}},
201 {"scratch_operand", {SCRATCH, REG}},
202 {"immediate_operand", {CONST_INT, CONST_DOUBLE, CONST, SYMBOL_REF,
203 LABEL_REF}},
204 {"const_int_operand", {CONST_INT}},
205 {"const_double_operand", {CONST_INT, CONST_DOUBLE}},
206 {"nonimmediate_operand", {SUBREG, REG, MEM, ADDRESSOF}},
207 {"nonmemory_operand", {CONST_INT, CONST_DOUBLE, CONST, SYMBOL_REF,
208 LABEL_REF, SUBREG, REG, ADDRESSOF}},
209 {"push_operand", {MEM}},
210 {"pop_operand", {MEM}},
211 {"memory_operand", {SUBREG, MEM}},
212 {"indirect_operand", {SUBREG, MEM}},
213 {"comparison_operator", {EQ, NE, LE, LT, GE, GT, LEU, LTU, GEU, GTU,
214 UNORDERED, ORDERED, UNEQ, UNGE, UNGT, UNLE,
215 UNLT, LTGT}}
216 };
“ nonimmediate_operand ” 在 206 行。根据其内容， 521 行将被跳过。而 allows_non_const 在 519 行被设置。显然， allows_non_const 只是表示该断言是否接受非常量参数，而 allows_non_lvalue 显示该断言是否接受非左值参数。为某些需要特殊的处理的 mode 定义了 special_mode_pred_table 。它具有如下定义：
220 static const char *const special_mode_pred_table [] = { in genrecog.c
221 #ifdef SPECIAL_MODE_PREDICATES
223 #endif
224 "pmode_register_operand"
225 };
SPECIAL_MODE_PREDICATES 是特定于目标系统的。它记录了目标系统要求的特殊 mode 。对于 i386 系统，它有如下定义：
3000 #define SPECIAL_MODE_PREDICATES / in i386.c
3001 "ext_register_operand",
通过 special_mode_pred_table 没有发现匹配。我们将进入下面的 550 行。并注意到在 569 行， set 是 RTX_NULL 。
validate_pattern (continued)
550 if (code == MATCH_OPERAND)
551 {
552 const char constraints0 = XSTR (pattern, 2)[0];
553
554 /* In DEFINE_EXPAND, DEFINE_SPLIT, and DEFINE_PEEPHOLE2, we
555 don't use the MATCH_OPERAND constraint, only the predicate.
556 This is confusing to folks doing new ports, so help them
557 not make the mistake. */
558 if (GET_CODE (insn) == DEFINE_EXPAND
559 || GET_CODE (insn) == DEFINE_SPLIT
560 || GET_CODE (insn) == DEFINE_PEEPHOLE2)
561 {
562 if (constraints0)
563 message_with_line (pattern_lineno ,
564 "warning: constraints not supported in %s",
565 rtx_name [GET_CODE (insn)]);
566 }
567
568 /* A MATCH_OPERAND that is a SET should have an output reload. */
569 else if (set && constraints0)
570 {
571 if (set_code == '+')
572 {
573 if (constraints0 == '+')
574 ;
575 /* If we've only got an output reload for this operand,
576 we'd better have a matching input operand. */
577 else if (constraints0 == '='
578 && find_matching_operand (insn, XINT (pattern, 0)))
579 ;
580 else
581 {
582 message_with_line (pattern_lineno ,
583 "operand %d missing in-out reload",
584 XINT (pattern, 0));
585 error_count ++;
586 }
587 }
588 else if (constraints0 != '=' && constraints0 != '+')
589 {
590 message_with_line (pattern_lineno ,
591 "operand %d missing output reload",
592 XINT (pattern, 0));
593 error_count ++;
594 }
595 }
596 }
597
598 /* Allowing non-lvalues in destinations -- particularly CONST_INT --
599 while not likely to occur at runtime, results in less efficient
600 code from insn-recog.c. */
601 if (set
602 && pred_name[0] != '/0'
603 && allows_non_lvalue)
604 {
605 message_with_line (pattern_lineno ,
606 "warning: destination operand %d allows non-lvalue",
607 XINT (pattern, 0));
608 }
609
610 /* A modeless MATCH_OPERAND can be handy when we can
611 check for multiple modes in the c_test. In most other cases,
612 it is a mistake. Only DEFINE_INSN is eligible, since SPLIT
613 and PEEP2 can FAIL within the output pattern. Exclude
614 address_operand, since its mode is related to the mode of
615 the memory not the operand. Exclude the SET_DEST of a call
616 instruction, as that is a common idiom. */
617
618 if (GET_MODE (pattern) == VOIDmode
619 && code == MATCH_OPERAND
620 && GET_CODE (insn) == DEFINE_INSN
621 && allows_non_const
622 && ! special_mode_pred
623 && pred_name[0] != '/0'
624 && strcmp (pred_name, "address_operand") != 0
625 && strstr (c_test, "operands") == NULL
626 && ! (set
627 && GET_CODE (set) == SET
628 && GET_CODE (SET_SRC (set)) == CALL))
629 {
630 message_with_line (pattern_lineno ,
631 "warning: operand %d missing mode?",
632 XINT (pattern, 0));
633 }
634 return ;
上面在 552 行，提取了约束“ r,?mr ”。在 md 文件中，某些字符被用于修改约束。其中一个是‘ = ’，它意味着该操作数对于该指令是“只写的”：前一个值被输出数据所替代。另一个是‘ + ’，它表示该操作数是该指令可读写的。没有这两个修改符，其他所有的操作数都被假定为只读的。
对于我们的约束，它通过了验证。对于其它模式，也是类似的，你可以自己走一遍这个过程。
make_insn_sequence (continued)
2465 memset(&head, 0, sizeof (head));
2466 last = add_to_sequence (x, &head, "", type, 1);
1439
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
