GCC后端及汇编发布（24）

9.5.7.5.

处理
decl
的第五、第六个循环
– DECL_PRESENCE

，
DECL_ABSENCE

类似的，第五个循环把
present_set
模式的
decl
与对应的
define_cpu_unit
模式的
decls
。这个处理与第四个循环所做的相似（参考
DEFINE_INSN_RESERVATION模式的概览

）。

process_decls (continued)

2992

/* Check presence
set declarations and form presence sets.

*/

2993

for
(i = 0; i
< description

->decls_num;
i++)

2994

{

2995

decl = description

->decls [i];

2996

if (decl->mode == dm_presence)

2997

{

2998

unit_set_el_t

unit_set_el_list;

2999

pattern_set_el_t pattern_set_el_list;

3000

3001

unit_set_el_list

3002

= process_presence_absence_names

3003

(DECL_PRESENCE (decl)->names, DECL_PRESENCE
(decl)->names_num,

3004

decl->pos,
TRUE, DECL_PRESENCE (decl)->final_p);

3005

pattern_set_el_list

3006

= process_presence_absence_patterns

3007

(DECL_PRESENCE (decl)->patterns,

3008

DECL_PRESENCE (decl)->patterns_num,

3009

decl->pos, TRUE, DECL_PRESENCE
(decl)->final_p);

3010

add_presence_absence
(unit_set_el_list, pattern_set_el_list,

3011

decl->pos, TRUE,

3012

DECL_PRESENCE
(decl)->final_p);

3013

}

3014

}

然后第六个循环把
absent_set
模式的
decl
与
define_cpu_unit
模式的
decl
绑定起来。这个处理与上个循环的处理相似
（
参见
DEFINE_INSN_RESERVATION
模式的概览

）
。

process_decls (continued)

3016

/* Check absence
set declarations and form absence sets.

*/

3017

for
(i = 0; i
< description

->decls_num;
i++)

3018

{

3019

decl = description

->decls [i];

3020

if (decl->mode == dm_absence)

3021

{

3022

unit_set_el_t

unit_set_el_list;

3023

pattern_set_el_t
pattern_set_el_list;

3024

3025

unit_set_el_list

3026

= process_presence_absence_names

3027

(DECL_ABSENCE (decl)->names,
DECL_ABSENCE (decl)->names_num,

3028

decl->pos, FALSE, DECL_ABSENCE (decl)->final_p);

3029

pattern_set_el_list

3030

= process_presence_absence_patterns

3031

(DECL_ABSENCE (decl)->patterns,

3032

DECL_ABSENCE (decl)->patterns_num,

3033

decl->pos, FALSE, DECL_ABSENCE (decl)->final_p);

3034

add_presence_absence
(unit_set_el_list,
pattern_set_el_list,

3035

decl->pos, FALSE,

3036

DECL_ABSENCE
(decl)->final_p);

3037

}

3038

}

3039

}

在
3023
行的
pattern_set_el_t
被
typedef
为以下
pattern_set_el
的指针类型
，
这个结构体将构成一个链表。因为这些模式的第二个操作数是一个列表
，
而其中的每个元素又是由空格分隔的功能单元列表
，
所以在
1056
行的
unit_decls

被声明为
unit_decl**
。

1051

struct
pattern_set_el

1052

{

1053

/* The number of
units in unit_decls.
*/

1054

int units_num;

1055

/* The units
forming the pattern.
*/

1056

struct
unit_decl **unit_decls;

1057

pattern_set_el_t next_pattern_set_el;

1058

};

在
读入

EXCLUSION_SET模式

一节，我们知道参数
names

是记录模式第一个操作数的数组，这里通过
process_presence_absence_names

从这个数组构建出一个
unit_set_el_t
链表，绑定了对应功能单元的
decl
。

2546

static
unit_set_el_t

2547

process_presence_absence_names

(char **names, int num,

2548

pos_t req_pos
ATTRIBUTE_UNUSED,

2549

int presence_p,
int final_p)

2550

{

2551

unit_set_el_t

el_list;

2552

unit_set_el_t last_el;

2553

unit_set_el_t new_el;

2554

decl_t decl_in_table;

2555

int i;

2556

2557

el_list = NULL;

2558

last_el = NULL;

2559

for
(i = 0; i
< num; i++)

2560

{

2561

decl_in_table = find_decl (names [i]);

2562

if (decl_in_table == NULL)

2563

error ((presence_p

2564

? (final_p

2565

?
"unit
`%s' in final presence set is not declared"

2566

: "unit `%s' in presence set is not
declared")

2567

: (final_p

2568

? "unit `%s' in final absence set is
not declared"

2569

: "unit `%s' in absence set is not
declared")), names [i]);

2570

else if (decl_in_table->mode != dm_unit)

2571

error ((presence_p

2572

? (final_p

2573

?
"`%s'
in final presence set is not unit"

2574

: "`%s' in presence set is not
unit")

2575

: (final_p

2576

? "`%s' in final absence set is not unit"

2577

: "`%s' in absence set is not
unit")), names [i]);

2578

else

2579

{

2580

new_el = create_node (sizeof
(struct
unit_set_el));

2581

new_el->unit_decl = DECL_UNIT
(decl_in_table);

2582

new_el->next_unit_set_el = NULL;

2583

if
(last_el == NULL)

2584

el_list = last_el = new_el;

2585

else

2586

{

2587

last_el->next_unit_set_el = new_el;

2588

last_el = last_el->next_unit_set_el;

2589

}

2590

}

2591

}

2592

return
el_list;

2593

}

类似的，参数
patterns

则是记录模式第二个操作数的数组，这里面也只有代表模式名的字符串，需要通过
process_presence_absence_patterns

来绑定对应的功能单元的
decl

。

2598

static
pattern_set_el_t

2599

process_presence_absence_patterns

(char ***patterns, int num,

2600

pos_t req_pos ATTRIBUTE_UNUSED,

2601

int presence_p, int final_p)

2602

{

2603

pattern_set_el_t el_list;

2604

pattern_set_el_t last_el;

2605

pattern_set_el_t new_el;

2606

decl_t decl_in_table;

2607

int i, j;

2608

2609

el_list = NULL;

2610

last_el = NULL;

2611

for
(i = 0; i < num; i++)

2612

{

2613

for
(j = 0; patterns [i] [j] !=
NULL; j++)

2614

;

2615

new_el = create_node (sizeof
(struct
pattern_set_el)

2616

+ sizeof
(struct
unit_decl *) * j);

2617

new_el->unit_decls

2618

= (struct
unit_decl **) ((char *) new_el

2619

+ sizeof
(struct
pattern_set_el));

2620

new_el->next_pattern_set_el = NULL;

2621

if (last_el == NULL)

2622

el_list = last_el = new_el;

2623

else

2624

{

2625

last_el->next_pattern_set_el = new_el;

2626

last_el = last_el->next_pattern_set_el;

2627

}

2628

new_el->units_num = 0;

2629

for
(j = 0; patterns [i] [j] != NULL; j++)

2630

{

2631

decl_in_table = find_decl (patterns [i] [j]);

2632

if
(decl_in_table == NULL)

2633

error
((presence_p

2634

? (final_p

2635

?
"unit `%s'
in final presence set is not declared"

2636

: "unit `%s' in presence set is not
declared")

2637

: (final_p

2638

? "unit `%s' in final absence set is
not declared"

2639

: "unit `%s' in absence set is not
declared")),

2640

patterns [i] [j]);

2641

else if (decl_in_table->mode != dm_unit)

2642

error ((presence_p

2643

? (final_p

2644

?
"`%s'
in final presence set is not unit"

2645

: "`%s' in presence set is not
unit")

2646

: (final_p

2647

? "`%s' in final absence set is not
unit"

2648

: "`%s' in absence set is not
unit")),

2649

patterns [i] [j]);

2650

else

2651

{

2652

new_el->unit_decls
[new_el->units_num]

2653

= DECL_UNIT (decl_in_table);

2654

new_el->units_num++;

2655

}

2656

}

2657

}

2658

return
el_list;

2659

}

注意
pattern_set_el
结构体中
unit_decls

域所需的内存也在
2618
行一起分配了。因为每个这样的模式只是管中窥豹，要把这些局部视角组合起来，才能看到这个功能单元整体的约束情况。因此需要
add_presence_absence

来整合这些信息。

2669

static
void

2670

add_presence_absence

(
unit_set_el_t

dest_list,

2671

pattern_set_el_t
pattern_list,

2672

pos_t req_pos ATTRIBUTE_UNUSED,

2673

int presence_p, int final_p)

2674

{

2675

unit_set_el_t dst;

2676

pattern_set_el_t pat;

2677

struct
unit_decl *unit;

2678

unit_set_el_t curr_excl_el;

2679

pattern_set_el_t curr_pat_el;

2680

pattern_set_el_t prev_el;

2681

pattern_set_el_t copy;

2682

int i;

2683

int no_error_flag;

2684

2685

for
(dst = dest_list; dst !=
NULL;
dst = dst->next_unit_set_el)

2686

for
(pat = pattern_list; pat !=
NULL; pat = pat->next_pattern_set_el)

2687

{

2688

for
(i = 0; i < pat->units_num;
i++)

2689

{

2690

unit = pat->unit_decls [i];

2691

if (dst->unit_decl == unit &&
pat->units_num == 1 && !presence_p)

2692

{

2693

error ("unit `%s' requires own
absence", unit->name);

2694

continue
;

2695

}

2696

if (dst->unit_decl->automaton_name !=
NULL

2697

&& unit->automaton_name
!= NULL

2698

&& strcmp
(dst->unit_decl->automaton_name,

2699

unit->automaton_name) != 0)

2700

{

2701

error ((presence_p

2702

? (final_p

2703

? "units `%s' and `%s' in final
presence set belong to different automata"

2704

:
"units `%s' and `%s' in presence set belong to different automata")

2705

: (final_p

2706

? "units `%s' and `%s' in final absence
set belong to different automata"

2707

: "units `%s' and `%s' in absence set
belong to different automata")),

2708

unit->name,
dst->unit_decl->name);

2709

continue
;

2710

}

2711

no_error_flag = 1;

2712

if
(presence_p)

2713

for
(curr_excl_el = dst->unit_decl->excl_list;

2714

curr_excl_el != NULL;

2715

curr_excl_el =
curr_excl_el->next_unit_set_el)

2716

{

2717

if
(unit == curr_excl_el->unit_decl && pat->units_num == 1)

2718

{

2719

if
(!w_flag

)

2720

{

2721

error
("unit `%s' excludes and requires presence of `%s'",

2722

dst->unit_decl->name,
unit->name);

2723

no_error_flag = 0;

2724

}

2725

else

2726

warning

2727

("unit `%s' excludes and requires
presence of `%s'",

2728

dst->unit_decl->name, unit->name);

2729

}

2730

}

2731

else if (pat->units_num == 1)

2732

for
(curr_pat_el =
dst->unit_decl->presence_list;

2733

curr_pat_el != NULL;

2734

curr_pat_el =
curr_pat_el->next_pattern_set_el)

2735

if (curr_pat_el->units_num == 1

2736

&& unit ==
curr_pat_el->unit_decls [0])

2737

{

2738

if (!w_flag

)

2739

{

2740

error

2741

("unit `%s' requires absence and
presence of `%s'",

2742

dst->unit_decl->name, unit->name);

2743

no_error_flag = 0;

2744

}

2745

else

2746

warning

2747

("unit `%s' requires
absence and presence of `%s'",

2748

dst->unit_decl->name,
unit->name);

2749

}

2750

if (no_error_flag)

2751

{

2752

for
(prev_el = (presence_p

2753

? (final_p

2754

? dst->unit_decl->final_presence_list

2755

: dst->unit_decl->final_presence_list)

2756

: (final_p

2757

? dst->unit_decl->final_absence_list

2758

: dst->unit_decl->absence_list));

2759

prev_el != NULL &&
prev_el->next_pattern_set_el != NULL;

2760

prev_el
= prev_el->next_pattern_set_el)

2761

;

2762

copy = copy_node (pat, sizeof
(*pat));

2763

copy->next_pattern_set_el = NULL;

2764

if (prev_el == NULL)

2765

{

2766

if (presence_p)

2767

{

2768

if (final_p)

2769

dst->unit_decl->final_presence_list =
copy;

2770

else

2771

dst->unit_decl->presence_list = copy;

2772

}

2773

else if (final_p)

2774

dst->unit_decl->final_absence_list
= copy;

2775

else

2776

dst->unit_decl->absence_list = copy;

2777

}

2778

else

2779

prev_el->next_pattern_set_el = copy;

2780

}

2781

}

2782

}

2783

}

看到在
2713
行的“
dst->unit_decl->excl_list
”是在上一节准备的。注意上面
presence
及
absence
约束之间的矛盾，只要不会导致致命的错误，是不加处理的，因为由此生成的自动机是可以识别及避开这些矛盾的。

9.5.7.6.

验证
decl

注意到所有的
decl
仍旧保留在
decls

数组中。上述的循环只是把相关的
decl
绑定在一起。之后
check_automaton_usage

检查是否有未被使用的自动机——即没有绑定
CPU
单元（参考
处理

decl的第二个循环

–

DECL_UNIT

，
2875
行）。

3044

static
void

3045

check_automaton_usage

(void)
in
genautomata.c

3046

{

3047

decl_t

decl;

3048

int i;

3049

3050

for
(i = 0; i < description

->decls_num; i++)

3051

{

3052

decl = description

->decls [i];

3053

if (decl->mode == dm_automaton

3054

&& !DECL_AUTOMATON
(decl)->automaton_is_used)

3055

{

3056

if (!w_flag

)

3057

error ("automaton `%s' is not
used", DECL_AUTOMATON (decl)->name);

3058

else

3059

warning ("automaton `%s' is not
used",

3060

DECL_AUTOMATON
(decl)->name);

3061

}

3062

}

3063

}

9.5.7.7.

处理
DECL_RESERV
及
DECL_INSN_RESERV

我们已经看过，
define_insn_reservation
的
decl
的
regexp

部分描述了在
CPU
周期中，指令所使用的
CPU
单元。
process_regexp_decls

把所有感兴趣的单元的
decl
放入哈希表
decl_table

中，并在
define_reservation
及
define_insn_reserv
里绑定对应单元的
decl
。

3125

static
void

3126

process_regexp_decls

(void)

in genautomata.c

3127

{

3128

decl_t

decl;

3129

int i;

3130

3131

for
(i = 0; i < description

->decls_num; i++)

3132

{

3133

decl = description

->decls [i];

3134

if (decl->mode == dm_reserv)

3135

DECL_RESERV (decl)->regexp

3136

= process_regexp
(DECL_RESERV (decl)->regexp);

3137

else if (decl->mode == dm_insn_reserv)

3138

DECL_INSN_RESERV (decl)->regexp

3139

= process_regexp
(DECL_INSN_RESERV (decl)->regexp);

3140

}

3141

}

regexp

部分的生成参考
读入

DEFINE_RESERVATION模式

一节。在机器描述文件里，模式
DEFINE_RESERVATION
，在使用处，与普通的单元无二无别，在构建入
regexp

时，它将给定为
rm_unit
类型。不过，对应单元的
decl
可以明白告知，因此在
3088
行要进行检查，并更新之。

3070

static
regexp_t

3071

process_regexp

(regexp_t
regexp)
in
genautomata.c

3072

{

3073

decl_t
decl_in_table;

3074

regexp_t
new_regexp;

3075

int i;

3076

3077

if (regexp->mode == rm_unit)

3078

{

3079

decl_in_table = find_decl (REGEXP_UNIT
(regexp)->name);

3080

if (decl_in_table == NULL)

3081

error ("undeclared unit or
reservation `%s'",

3082

REGEXP_UNIT (regexp)->name);

3083

else if (decl_in_table->mode == dm_unit)

3084

{

3085

DECL_UNIT
(decl_in_table)->unit_is_used = 1;

3086

REGEXP_UNIT (regexp)->unit_decl =
DECL_UNIT (decl_in_table);

3087

}

3088

else if (decl_in_table->mode ==
dm_reserv)

3089

{

3090

DECL_RESERV
(decl_in_table)->reserv_is_used = 1;

3091

new_regexp = create_node (sizeof
(struct
regexp));

3092

new_regexp->mode = rm_reserv;

3093

new_regexp->pos = regexp->pos;

3094

REGEXP_RESERV (new_regexp)->name =
REGEXP_UNIT (regexp)->name;

3095

REGEXP_RESERV
(new_regexp)->reserv_decl

3096

= DECL_RESERV (decl_in_table);

3097

regexp = new_regexp;

3098

}

3099

else

3100

abort ();

3101

}

3102

else if (regexp->mode == rm_sequence)

3103

for
(i = 0; i <REGEXP_SEQUENCE
(regexp)->regexps_num; i++)

3104

REGEXP_SEQUENCE (regexp)->regexps [i]

3105

= process_regexp
(REGEXP_SEQUENCE (regexp)->regexps [i]);

3106

else if (regexp->mode == rm_allof)

3107

for
(i = 0;
i < REGEXP_ALLOF (regexp)->regexps_num; i++)

3108

REGEXP_ALLOF (regexp)->regexps [i]

3109

= process_regexp
(REGEXP_ALLOF (regexp)->regexps [i]);

3110

else if (regexp->mode == rm_oneof)

3111

for
(i = 0; i < REGEXP_ONEOF
(regexp)->regexps_num; i++)

3112

REGEXP_ONEOF (regexp)->regexps [i]

3113

= process_regexp
(REGEXP_ONEOF (regexp)->regexps [i]);

3114

else if (regexp->mode == rm_repeat)

3115

REGEXP_REPEAT (regexp)->regexp

3116

= process_regexp
(REGEXP_REPEAT (regexp)->regexp);

3117

else if (regexp->mode != rm_nothing)

3118

abort ();

3119

return
regexp;

3120

}

最后，我们可以得到以下的数据结构。



图
70

：
DEFINE_INSN_RESERVATION
模式的
decl
的例子

接下来，
check_usage

检查是否存在未被引用的
CPU
单元。

3147

static
void

3148

check_usage

(void)
in
genautomata.c

3149

{

3150

decl_t

decl;

3151

int
i;

3152

3153

for
(i = 0; i < description

->decls_num; i++)

3154

{

3155

decl = description

->decls [i];

3156

if (decl->mode == dm_unit &&
!DECL_UNIT (decl)->unit_is_used)

3157

{

3158

if (!w_flag

)

3159

error ("unit `%s' is not
used", DECL_UNIT (decl)->name);

3160

else

3161

warning ("unit `%s' is not
used", DECL_UNIT (decl)->name);

3162

}

3163

else if (decl->mode == dm_reserv
&& !DECL_RESERV (decl)->reserv_is_used)

3164

{

3165

if (!w_flag

)

3166

error ("reservation `%s' is not
used", DECL_RESERV (decl)->name);

3167

else

3168

warning ("reservation `%s' is not
used", DECL_RESERV (decl)->name);

3169

}

3170

}

3171

}

引入
define_reservation
带来了在这类模式中循环引用的危险性。这种错误是致命的，因此我们需要在这里检查这个情况。

3239

static
void

3240

check_loops_in_regexps

(void)
in
genautomata.c

3241

{

3242

decl_t

decl;

3243

int i;

3244

3245

for
(i = 0; i < description

->decls_num; i++)

3246

{

3247

decl = description

->decls [i];

3248

if (decl->mode == dm_reserv)

3249

DECL_RESERV
(decl)->loop_pass_num = 0;

3250

}

3251

for
(i = 0; i < description

->decls_num; i++)

3252

{

3253

decl = description

->decls [i];

3254

curr_loop_pass_num

= i;

3255

3256

if (decl->mode == dm_reserv)

3257

{

3258

DECL_RESERV
(decl)->loop_pass_num = curr_loop_pass_num

;

3259

if (loop_in_regexp
(DECL_RESERV (decl)->regexp, decl))

3260

{

3261

if (DECL_RESERV (decl)->regexp ==
NULL)

3262

abort ();

3263

error ("cycle in definition of
reservation `%s'",

3264

DECL_RESERV (decl)->name);

3265

}

3266

}

3267

}

3268

}

在
process_regexp

里，
define_reservation
仅展开一次。如果存在
define_reservation
模式
A
及
B
，它们相互引用。由
process_regexp

，我们将得到如下的展开形式（
à

表示引用，
ßß

表示展开到所引用部分）：

a
à

A
à

B
ßß

A (decl_reserv)

b
à

B
à

A
ßß

B (decl_reserv)

这是我们必须要防止的情形。在
check_loops_in_regexps

里，首先把所有
define_reservation
模式的
loop_pass_num
重置为
0
。在
3251
行的
FOR

循环里，相互引用的
define_reservation
模式必有一个首先得到处理，此时它所引用的
define_reservation
模式的
loop_pass_num
仍然为
0
，将进入
3198
行的
ELSE
块，对这个模式进行处理。因为
start_decl
总是第一个模式，
3191
行条件满足，查出了循环引用。而
3194
行的条件则是允许对
define_reservation
模式的多次非循环的引用。

3180

static
int

3181

loop_in_regexp

(regexp_t
regexp, decl_t
start_decl)
in genautomata.c

3182

{

3183

int i;

3184

3185

if (regexp == NULL)

3186

return
0;

3187

if (regexp->mode == rm_unit)

3188

return
0;

3189

else if (regexp->mode == rm_reserv)

3190

{

3191

if (start_decl->mode == dm_reserv

3192

&& REGEXP_RESERV
(regexp)->reserv_decl == DECL_RESERV (start_decl))

3193

return
1;

3194

else if (REGEXP_RESERV
(regexp)->reserv_decl->loop_pass_num

3195

== curr_loop_pass_num

)

3196

/* declaration has been processed.
*/

3197

return
0;

3198

else

3199

{

3200

REGEXP_RESERV
(regexp)->reserv_decl->loop_pass_num

3201

= curr_loop_pass_num

;

3202

return
loop_in_regexp
(REGEXP_RESERV
(regexp)->reserv_decl->regexp,

3203

start_decl);

3204

}

3205

}

3206

else if (regexp->mode == rm_sequence)

3207

{

3208

for
(i = 0; i <REGEXP_SEQUENCE
(regexp)->regexps_num; i++)

3209

if (loop_in_regexp
(REGEXP_SEQUENCE (regexp)->regexps [i], start_decl))

3210

return
1;

3211

return
0;

3212

}

3213

else if (regexp->mode == rm_allof)

3214

{

3215

for
(i = 0; i < REGEXP_ALLOF
(regexp)->regexps_num; i++)

3216

if (loop_in_regexp
(REGEXP_ALLOF (regexp)->regexps [i], start_decl))

3217

return
1;

3218

return
0;

3219

}

3220

else if (regexp->mode == rm_oneof)

3221

{

3222

for
(i = 0; i < REGEXP_ONEOF
(regexp)->regexps_num; i++)

3223

if (loop_in_regexp
(REGEXP_ONEOF (regexp)->regexps [i], start_decl))

3224

return
1;

3225

return
0;

3226

}

3227

else if (regexp->mode == rm_repeat)

3228

return
loop_in_regexp
(REGEXP_REPEAT (regexp)->regexp,
start_decl);

3229

else

3230

{

3231

if (regexp->mode != rm_nothing)

3232

abort ();

3233

return
0;

3234

}

3235

}

接着，在
check_all_description

中，
evaluate_max_reserv_cycles

被调用，其中的全局变量
description

将记录在
define_insn_reservation
模式中出现的最大周期数。

3362

static
void

3363

evaluate_max_reserv_cycles

(void)
in
genautomata.c

3364

{

3365

int max_insn_cycles_num;

3366

int
min_insn_cycles_num;

3367

decl_t

decl;

3368

int i;

3369

3370

description

->max_insn_reserv_cycles
= 0;

3371

for
(i = 0; i < description

->decls_num; i++)

3372

{

3373

decl = description

->decls [i];

3374

if (decl->mode == dm_insn_reserv)

3375

{

3376

process_regexp_cycles
(DECL_INSN_RESERV (decl)->regexp, 0, 0,

3377

&max_insn_cycles_num,
&min_insn_cycles_num);

3378

if (description

->max_insn_reserv_cycles
< max_insn_cycles_num)

3379

description

->max_insn_reserv_cycles
= max_insn_cycles_num;

3380

}

3381

}

3382

description

->max_insn_reserv_cycles++;

3383

}

我们需要最大及最小周期数，因为在下面，将构建一个位图并与每个状态关联来显示资源的分配（使用）。这个位图的大小由功能单元数乘以（最大周期数
-
最小周期数）来确定。

process_regexp_cycles

递归进入
regexp

，并相应地设置
unit_decl
的
max_occ_cycle_num

及
min_occ_cycle_num

域。

3272

static
void

3273

process_regexp_cycles

(regexp_t
regexp, int max_start_cycle,

in
genautomata.c

3274

int min_start_cycle, int
*max_finish_cycle,

3275

int *min_finish_cycle)

3276

{

3277

int i;

3278

3279

if (regexp->mode == rm_unit)

3280

{

3281

if (REGEXP_UNIT
(regexp)->unit_decl->max_occ_cycle_num < max_start_cycle)

3282

REGEXP_UNIT (regexp)->unit_decl->max_occ_cycle_num
= max_start_cycle;

3283

if (REGEXP_UNIT
(regexp)->unit_decl->min_occ_cycle_num > min_start_cycle

3284

|| REGEXP_UNIT
(regexp)->unit_decl->min_occ_cycle_num == -1)

3285

REGEXP_UNIT
(regexp)->unit_decl->min_occ_cycle_num = min_start_cycle;

3286

*max_finish_cycle = max_start_cycle;

3287

*min_finish_cycle = min_start_cycle;

3288

}

3289

else if (regexp->mode == rm_reserv)

3290

process_regexp_cycles
(REGEXP_RESERV (regexp)->reserv_decl->regexp,

3291

max_start_cycle,
min_start_cycle,

3292

max_finish_cycle,
min_finish_cycle);

3293

else if (regexp->mode == rm_repeat)

3294

{

3295

for
(i = 0; i < REGEXP_REPEAT (regexp)->repeat_num;
i++)

3296

{

3297

process_regexp_cycles
(REGEXP_REPEAT (regexp)->regexp,

3298

max_start_cycle,
min_start_cycle,

3299

max_finish_cycle,
min_finish_cycle);

3300

max_start_cycle = *max_finish_cycle + 1;

3301

min_start_cycle = *min_finish_cycle + 1;

3302

}

3303

}

3304

else if (regexp->mode == rm_sequence)

3305

{

3306

for
(i = 0; i <REGEXP_SEQUENCE
(regexp)->regexps_num; i++)

3307

{

3308

process_regexp_cycles
(REGEXP_SEQUENCE (regexp)->regexps [i],

3309

max_start_cycle,
min_start_cycle,

3310

max_finish_cycle,
min_finish_cycle);

3311

max_start_cycle = *max_finish_cycle + 1;

3312

min_start_cycle = *min_finish_cycle + 1;

3313

}

3314

}

3315

else if (regexp->mode == rm_allof)

3316

{

3317

int max_cycle = 0;

3318

int min_cycle = 0;

3319

3320

for
(i = 0; i < REGEXP_ALLOF
(regexp)->regexps_num; i++)

3321

{

3322

process_regexp_cycles
(REGEXP_ALLOF (regexp)->regexps [i],

3323

max_start_cycle,
min_start_cycle,

3324

max_finish_cycle,
min_finish_cycle);

3325

if (max_cycle < *max_finish_cycle)

3326

max_cycle = *max_finish_cycle;

3327

if (i == 0 || min_cycle >
*min_finish_cycle)

3328

min_cycle = *min_finish_cycle;

3329

}

3330

*max_finish_cycle = max_cycle;

3331

*min_finish_cycle = min_cycle;

3332

}

3333

else if (regexp->mode == rm_oneof)

3334

{

3335

int max_cycle = 0;

3336

int min_cycle = 0;

3337

3338

for
(i = 0; i < REGEXP_ONEOF (regexp)->regexps_num;
i++)

3339

{

3340

process_regexp_cycles
(REGEXP_ONEOF (regexp)->regexps [i],

3341

max_start_cycle,
min_start_cycle,

3342

max_finish_cycle,
min_finish_cycle);

3343

if (max_cycle < *max_finish_cycle)

3344

max_cycle = *max_finish_cycle;

3345

if (i == 0 || min_cycle >
*min_finish_cycle)

3346

min_cycle = *min_finish_cycle;

3347

}

3348

*max_finish_cycle = max_cycle;

3349

*min_finish_cycle = min_cycle;

3350

}

3351

else

3352

{

3353

if (regexp->mode != rm_nothing)

3354

abort ();

3355

*max_finish_cycle = max_start_cycle;

3356

*min_finish_cycle = min_start_cycle;

3357

}

3358

}