1 /*
2 * Copyright (c) 1998, 2022, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 // FORMS.CPP - Definitions for ADL Parser Forms Classes
26 #include "adlc.hpp"
27
28 //==============================Instructions===================================
29 //------------------------------InstructForm-----------------------------------
30 InstructForm::InstructForm(const char *id, bool ideal_only)
31 : _ident(id), _ideal_only(ideal_only),
32 _localNames(cmpstr, hashstr, Form::arena),
33 _effects(cmpstr, hashstr, Form::arena),
34 _is_mach_constant(false),
35 _needs_constant_base(false),
36 _has_call(false)
37 {
38 _ftype = Form::INS;
39
40 _matrule = NULL;
41 _insencode = NULL;
42 _constant = NULL;
43 _is_postalloc_expand = false;
44 _opcode = NULL;
45 _size = NULL;
46 _attribs = NULL;
47 _predicate = NULL;
48 _exprule = NULL;
49 _rewrule = NULL;
50 _format = NULL;
51 _peephole = NULL;
52 _ins_pipe = NULL;
53 _uniq_idx = NULL;
54 _num_uniq = 0;
55 _cisc_spill_operand = Not_cisc_spillable;// Which operand may cisc-spill
56 _cisc_spill_alternate = NULL; // possible cisc replacement
57 _cisc_reg_mask_name = NULL;
58 _is_cisc_alternate = false;
59 _is_short_branch = false;
60 _short_branch_form = NULL;
61 _alignment = 1;
62 }
63
64 InstructForm::InstructForm(const char *id, InstructForm *instr, MatchRule *rule)
65 : _ident(id), _ideal_only(false),
66 _localNames(instr->_localNames),
67 _effects(instr->_effects),
68 _is_mach_constant(instr->_is_mach_constant),
69 _needs_constant_base(false),
70 _has_call(false)
71 {
72 _ftype = Form::INS;
73
74 _matrule = rule;
75 _insencode = instr->_insencode;
76 _constant = instr->_constant;
77 _is_postalloc_expand = instr->_is_postalloc_expand;
78 _opcode = instr->_opcode;
79 _size = instr->_size;
80 _attribs = instr->_attribs;
81 _predicate = instr->_predicate;
82 _exprule = instr->_exprule;
83 _rewrule = instr->_rewrule;
84 _format = instr->_format;
85 _peephole = instr->_peephole;
86 _ins_pipe = instr->_ins_pipe;
87 _uniq_idx = instr->_uniq_idx;
88 _num_uniq = instr->_num_uniq;
89 _cisc_spill_operand = Not_cisc_spillable; // Which operand may cisc-spill
90 _cisc_spill_alternate = NULL; // possible cisc replacement
91 _cisc_reg_mask_name = NULL;
92 _is_cisc_alternate = false;
93 _is_short_branch = false;
94 _short_branch_form = NULL;
95 _alignment = 1;
96 // Copy parameters
97 const char *name;
98 instr->_parameters.reset();
99 for (; (name = instr->_parameters.iter()) != NULL;)
100 _parameters.addName(name);
101 }
102
103 InstructForm::~InstructForm() {
104 }
105
106 InstructForm *InstructForm::is_instruction() const {
107 return (InstructForm*)this;
108 }
109
110 bool InstructForm::ideal_only() const {
111 return _ideal_only;
112 }
113
114 bool InstructForm::sets_result() const {
115 return (_matrule != NULL && _matrule->sets_result());
116 }
117
118 bool InstructForm::needs_projections() {
119 _components.reset();
120 for( Component *comp; (comp = _components.iter()) != NULL; ) {
121 if (comp->isa(Component::KILL)) {
122 return true;
123 }
124 }
125 return false;
126 }
127
128
129 bool InstructForm::has_temps() {
130 if (_matrule) {
131 // Examine each component to see if it is a TEMP
132 _components.reset();
133 // Skip the first component, if already handled as (SET dst (...))
134 Component *comp = NULL;
135 if (sets_result()) comp = _components.iter();
136 while ((comp = _components.iter()) != NULL) {
137 if (comp->isa(Component::TEMP)) {
138 return true;
139 }
140 }
141 }
142
143 return false;
144 }
145
146 uint InstructForm::num_defs_or_kills() {
147 uint defs_or_kills = 0;
148
149 _components.reset();
150 for( Component *comp; (comp = _components.iter()) != NULL; ) {
151 if( comp->isa(Component::DEF) || comp->isa(Component::KILL) ) {
152 ++defs_or_kills;
153 }
154 }
155
156 return defs_or_kills;
157 }
158
159 // This instruction has an expand rule?
160 bool InstructForm::expands() const {
161 return ( _exprule != NULL );
162 }
163
164 // This instruction has a late expand rule?
165 bool InstructForm::postalloc_expands() const {
166 return _is_postalloc_expand;
167 }
168
169 // This instruction has a peephole rule?
170 Peephole *InstructForm::peepholes() const {
171 return _peephole;
172 }
173
174 // This instruction has a peephole rule?
175 void InstructForm::append_peephole(Peephole *peephole) {
176 if( _peephole == NULL ) {
177 _peephole = peephole;
178 } else {
179 _peephole->append_peephole(peephole);
180 }
181 }
182
183
184 // ideal opcode enumeration
185 const char *InstructForm::ideal_Opcode( FormDict &globalNames ) const {
186 if( !_matrule ) return "Node"; // Something weird
187 // Chain rules do not really have ideal Opcodes; use their source
188 // operand ideal Opcode instead.
189 if( is_simple_chain_rule(globalNames) ) {
190 const char *src = _matrule->_rChild->_opType;
191 OperandForm *src_op = globalNames[src]->is_operand();
192 assert( src_op, "Not operand class of chain rule" );
193 if( !src_op->_matrule ) return "Node";
194 return src_op->_matrule->_opType;
195 }
196 // Operand chain rules do not really have ideal Opcodes
197 if( _matrule->is_chain_rule(globalNames) )
198 return "Node";
199 return strcmp(_matrule->_opType,"Set")
200 ? _matrule->_opType
201 : _matrule->_rChild->_opType;
202 }
203
204 // Recursive check on all operands' match rules in my match rule
205 bool InstructForm::is_pinned(FormDict &globals) {
206 if ( ! _matrule) return false;
207
208 int index = 0;
209 if (_matrule->find_type("Goto", index)) return true;
210 if (_matrule->find_type("If", index)) return true;
211 if (_matrule->find_type("CountedLoopEnd",index)) return true;
212 if (_matrule->find_type("Return", index)) return true;
213 if (_matrule->find_type("Rethrow", index)) return true;
214 if (_matrule->find_type("TailCall", index)) return true;
215 if (_matrule->find_type("TailJump", index)) return true;
216 if (_matrule->find_type("Halt", index)) return true;
217 if (_matrule->find_type("Jump", index)) return true;
218
219 return is_parm(globals);
220 }
221
222 // Recursive check on all operands' match rules in my match rule
223 bool InstructForm::is_projection(FormDict &globals) {
224 if ( ! _matrule) return false;
225
226 int index = 0;
227 if (_matrule->find_type("Goto", index)) return true;
228 if (_matrule->find_type("Return", index)) return true;
229 if (_matrule->find_type("Rethrow", index)) return true;
230 if (_matrule->find_type("TailCall",index)) return true;
231 if (_matrule->find_type("TailJump",index)) return true;
232 if (_matrule->find_type("Halt", index)) return true;
233
234 return false;
235 }
236
237 // Recursive check on all operands' match rules in my match rule
238 bool InstructForm::is_parm(FormDict &globals) {
239 if ( ! _matrule) return false;
240
241 int index = 0;
242 if (_matrule->find_type("Parm",index)) return true;
243
244 return false;
245 }
246
247 bool InstructForm::is_ideal_negD() const {
248 return (_matrule && _matrule->_rChild && strcmp(_matrule->_rChild->_opType, "NegD") == 0);
249 }
250
251 // Return 'true' if this instruction matches an ideal 'Copy*' node
252 int InstructForm::is_ideal_copy() const {
253 return _matrule ? _matrule->is_ideal_copy() : 0;
254 }
255
256 // Return 'true' if this instruction is too complex to rematerialize.
257 int InstructForm::is_expensive() const {
258 // We can prove it is cheap if it has an empty encoding.
259 // This helps with platform-specific nops like ThreadLocal and RoundFloat.
260 if (is_empty_encoding())
261 return 0;
262
263 if (is_tls_instruction())
264 return 1;
265
266 if (_matrule == NULL) return 0;
267
268 return _matrule->is_expensive();
269 }
270
271 // Has an empty encoding if _size is a constant zero or there
272 // are no ins_encode tokens.
273 int InstructForm::is_empty_encoding() const {
274 if (_insencode != NULL) {
275 _insencode->reset();
276 if (_insencode->encode_class_iter() == NULL) {
277 return 1;
278 }
279 }
280 if (_size != NULL && strcmp(_size, "0") == 0) {
281 return 1;
282 }
283 return 0;
284 }
285
286 int InstructForm::is_tls_instruction() const {
287 if (_ident != NULL &&
288 ( ! strcmp( _ident,"tlsLoadP") ||
289 ! strncmp(_ident,"tlsLoadP_",9)) ) {
290 return 1;
291 }
292
293 if (_matrule != NULL && _insencode != NULL) {
294 const char* opType = _matrule->_opType;
295 if (strcmp(opType, "Set")==0)
296 opType = _matrule->_rChild->_opType;
297 if (strcmp(opType,"ThreadLocal")==0) {
298 fprintf(stderr, "Warning: ThreadLocal instruction %s should be named 'tlsLoadP_*'\n",
299 (_ident == NULL ? "NULL" : _ident));
300 return 1;
301 }
302 }
303
304 return 0;
305 }
306
307
308 // Return 'true' if this instruction matches an ideal 'If' node
309 bool InstructForm::is_ideal_if() const {
310 if( _matrule == NULL ) return false;
311
312 return _matrule->is_ideal_if();
313 }
314
315 // Return 'true' if this instruction matches an ideal 'FastLock' node
316 bool InstructForm::is_ideal_fastlock() const {
317 if( _matrule == NULL ) return false;
318
319 return _matrule->is_ideal_fastlock();
320 }
321
322 // Return 'true' if this instruction matches an ideal 'MemBarXXX' node
323 bool InstructForm::is_ideal_membar() const {
324 if( _matrule == NULL ) return false;
325
326 return _matrule->is_ideal_membar();
327 }
328
329 // Return 'true' if this instruction matches an ideal 'LoadPC' node
330 bool InstructForm::is_ideal_loadPC() const {
331 if( _matrule == NULL ) return false;
332
333 return _matrule->is_ideal_loadPC();
334 }
335
336 // Return 'true' if this instruction matches an ideal 'Box' node
337 bool InstructForm::is_ideal_box() const {
338 if( _matrule == NULL ) return false;
339
340 return _matrule->is_ideal_box();
341 }
342
343 // Return 'true' if this instruction matches an ideal 'Goto' node
344 bool InstructForm::is_ideal_goto() const {
345 if( _matrule == NULL ) return false;
346
347 return _matrule->is_ideal_goto();
348 }
349
350 // Return 'true' if this instruction matches an ideal 'Jump' node
351 bool InstructForm::is_ideal_jump() const {
352 if( _matrule == NULL ) return false;
353
354 return _matrule->is_ideal_jump();
355 }
356
357 // Return 'true' if instruction matches ideal 'If' | 'Goto' | 'CountedLoopEnd'
358 bool InstructForm::is_ideal_branch() const {
359 if( _matrule == NULL ) return false;
360
361 return _matrule->is_ideal_if() || _matrule->is_ideal_goto();
362 }
363
364
365 // Return 'true' if this instruction matches an ideal 'Return' node
366 bool InstructForm::is_ideal_return() const {
367 if( _matrule == NULL ) return false;
368
369 // Check MatchRule to see if the first entry is the ideal "Return" node
370 int index = 0;
371 if (_matrule->find_type("Return",index)) return true;
372 if (_matrule->find_type("Rethrow",index)) return true;
373 if (_matrule->find_type("TailCall",index)) return true;
374 if (_matrule->find_type("TailJump",index)) return true;
375
376 return false;
377 }
378
379 // Return 'true' if this instruction matches an ideal 'Halt' node
380 bool InstructForm::is_ideal_halt() const {
381 int index = 0;
382 return _matrule && _matrule->find_type("Halt",index);
383 }
384
385 // Return 'true' if this instruction matches an ideal 'SafePoint' node
386 bool InstructForm::is_ideal_safepoint() const {
387 int index = 0;
388 return _matrule && _matrule->find_type("SafePoint",index);
389 }
390
391 // Return 'true' if this instruction matches an ideal 'Nop' node
392 bool InstructForm::is_ideal_nop() const {
393 return _ident && _ident[0] == 'N' && _ident[1] == 'o' && _ident[2] == 'p' && _ident[3] == '_';
394 }
395
396 bool InstructForm::is_ideal_control() const {
397 if ( ! _matrule) return false;
398
399 return is_ideal_return() || is_ideal_branch() || _matrule->is_ideal_jump() || is_ideal_halt();
400 }
401
402 // Return 'true' if this instruction matches an ideal 'Call' node
403 Form::CallType InstructForm::is_ideal_call() const {
404 if( _matrule == NULL ) return Form::invalid_type;
405
406 // Check MatchRule to see if the first entry is the ideal "Call" node
407 int idx = 0;
408 if(_matrule->find_type("CallStaticJava",idx)) return Form::JAVA_STATIC;
409 idx = 0;
410 if(_matrule->find_type("Lock",idx)) return Form::JAVA_STATIC;
411 idx = 0;
412 if(_matrule->find_type("Unlock",idx)) return Form::JAVA_STATIC;
413 idx = 0;
414 if(_matrule->find_type("CallDynamicJava",idx)) return Form::JAVA_DYNAMIC;
415 idx = 0;
416 if(_matrule->find_type("CallRuntime",idx)) return Form::JAVA_RUNTIME;
417 idx = 0;
418 if(_matrule->find_type("CallLeaf",idx)) return Form::JAVA_LEAF;
419 idx = 0;
420 if(_matrule->find_type("CallLeafNoFP",idx)) return Form::JAVA_LEAF;
421 idx = 0;
422 if(_matrule->find_type("CallLeafVector",idx)) return Form::JAVA_LEAF;
423 idx = 0;
424
425 return Form::invalid_type;
426 }
427
428 // Return 'true' if this instruction matches an ideal 'Load?' node
429 Form::DataType InstructForm::is_ideal_load() const {
430 if( _matrule == NULL ) return Form::none;
431
432 return _matrule->is_ideal_load();
433 }
434
435 // Return 'true' if this instruction matches an ideal 'LoadKlass' node
436 bool InstructForm::skip_antidep_check() const {
437 if( _matrule == NULL ) return false;
438
439 return _matrule->skip_antidep_check();
440 }
441
442 // Return 'true' if this instruction matches an ideal 'Load?' node
443 Form::DataType InstructForm::is_ideal_store() const {
444 if( _matrule == NULL ) return Form::none;
445
446 return _matrule->is_ideal_store();
447 }
448
449 // Return 'true' if this instruction matches an ideal vector node
450 bool InstructForm::is_vector() const {
451 if( _matrule == NULL ) return false;
452
453 return _matrule->is_vector();
454 }
455
456
457 // Return the input register that must match the output register
458 // If this is not required, return 0
459 uint InstructForm::two_address(FormDict &globals) {
460 uint matching_input = 0;
461 if(_components.count() == 0) return 0;
462
463 _components.reset();
464 Component *comp = _components.iter();
465 // Check if there is a DEF
466 if( comp->isa(Component::DEF) ) {
467 // Check that this is a register
468 const char *def_type = comp->_type;
469 const Form *form = globals[def_type];
470 OperandForm *op = form->is_operand();
471 if( op ) {
472 if( op->constrained_reg_class() != NULL &&
473 op->interface_type(globals) == Form::register_interface ) {
474 // Remember the local name for equality test later
475 const char *def_name = comp->_name;
476 // Check if a component has the same name and is a USE
477 do {
478 if( comp->isa(Component::USE) && strcmp(comp->_name,def_name)==0 ) {
479 return operand_position_format(def_name);
480 }
481 } while( (comp = _components.iter()) != NULL);
482 }
483 }
484 }
485
486 return 0;
487 }
488
489
490 // when chaining a constant to an instruction, returns 'true' and sets opType
491 Form::DataType InstructForm::is_chain_of_constant(FormDict &globals) {
492 const char *dummy = NULL;
493 const char *dummy2 = NULL;
494 return is_chain_of_constant(globals, dummy, dummy2);
495 }
496 Form::DataType InstructForm::is_chain_of_constant(FormDict &globals,
497 const char * &opTypeParam) {
498 const char *result = NULL;
499
500 return is_chain_of_constant(globals, opTypeParam, result);
501 }
502
503 Form::DataType InstructForm::is_chain_of_constant(FormDict &globals,
504 const char * &opTypeParam, const char * &resultParam) {
505 Form::DataType data_type = Form::none;
506 if ( ! _matrule) return data_type;
507
508 // !!!!!
509 // The source of the chain rule is 'position = 1'
510 uint position = 1;
511 const char *result = NULL;
512 const char *name = NULL;
513 const char *opType = NULL;
514 // Here base_operand is looking for an ideal type to be returned (opType).
515 if ( _matrule->is_chain_rule(globals)
516 && _matrule->base_operand(position, globals, result, name, opType) ) {
517 data_type = ideal_to_const_type(opType);
518
519 // if it isn't an ideal constant type, just return
520 if ( data_type == Form::none ) return data_type;
521
522 // Ideal constant types also adjust the opType parameter.
523 resultParam = result;
524 opTypeParam = opType;
525 return data_type;
526 }
527
528 return data_type;
529 }
530
531 // Check if a simple chain rule
532 bool InstructForm::is_simple_chain_rule(FormDict &globals) const {
533 if( _matrule && _matrule->sets_result()
534 && _matrule->_rChild->_lChild == NULL
535 && globals[_matrule->_rChild->_opType]
536 && globals[_matrule->_rChild->_opType]->is_opclass() ) {
537 return true;
538 }
539 return false;
540 }
541
542 // check for structural rematerialization
543 bool InstructForm::rematerialize(FormDict &globals, RegisterForm *registers ) {
544 bool rematerialize = false;
545
546 Form::DataType data_type = is_chain_of_constant(globals);
547 if( data_type != Form::none )
548 rematerialize = true;
549
550 // Constants
551 if( _components.count() == 1 && _components[0]->is(Component::USE_DEF) )
552 rematerialize = true;
553
554 // Pseudo-constants (values easily available to the runtime)
555 if (is_empty_encoding() && is_tls_instruction())
556 rematerialize = true;
557
558 // 1-input, 1-output, such as copies or increments.
559 if( _components.count() == 2 &&
560 _components[0]->is(Component::DEF) &&
561 _components[1]->isa(Component::USE) )
562 rematerialize = true;
563
564 // Check for an ideal 'Load?' and eliminate rematerialize option
565 if ( is_ideal_load() != Form::none || // Ideal load? Do not rematerialize
566 is_ideal_copy() != Form::none || // Ideal copy? Do not rematerialize
567 is_expensive() != Form::none) { // Expensive? Do not rematerialize
568 rematerialize = false;
569 }
570
571 // Always rematerialize the flags. They are more expensive to save &
572 // restore than to recompute (and possibly spill the compare's inputs).
573 if( _components.count() >= 1 ) {
574 Component *c = _components[0];
575 const Form *form = globals[c->_type];
576 OperandForm *opform = form->is_operand();
577 if( opform ) {
578 // Avoid the special stack_slots register classes
579 const char *rc_name = opform->constrained_reg_class();
580 if( rc_name ) {
581 if( strcmp(rc_name,"stack_slots") ) {
582 // Check for ideal_type of RegFlags
583 const char *type = opform->ideal_type( globals, registers );
584 if( (type != NULL) && !strcmp(type, "RegFlags") )
585 rematerialize = true;
586 } else
587 rematerialize = false; // Do not rematerialize things target stk
588 }
589 }
590 }
591
592 return rematerialize;
593 }
594
595 // loads from memory, so must check for anti-dependence
596 bool InstructForm::needs_anti_dependence_check(FormDict &globals) const {
597 if ( skip_antidep_check() ) return false;
598
599 // Machine independent loads must be checked for anti-dependences
600 if( is_ideal_load() != Form::none ) return true;
601
602 // !!!!! !!!!! !!!!!
603 // TEMPORARY
604 // if( is_simple_chain_rule(globals) ) return false;
605
606 // String.(compareTo/equals/indexOf) and Arrays.equals use many memorys edges,
607 // but writes none
608 if( _matrule && _matrule->_rChild &&
609 ( strcmp(_matrule->_rChild->_opType,"StrComp" )==0 ||
610 strcmp(_matrule->_rChild->_opType,"StrEquals" )==0 ||
611 strcmp(_matrule->_rChild->_opType,"StrIndexOf" )==0 ||
612 strcmp(_matrule->_rChild->_opType,"StrIndexOfChar" )==0 ||
613 strcmp(_matrule->_rChild->_opType,"CountPositives" )==0 ||
614 strcmp(_matrule->_rChild->_opType,"AryEq" )==0 ))
615 return true;
616
617 // Check if instruction has a USE of a memory operand class, but no defs
618 bool USE_of_memory = false;
619 bool DEF_of_memory = false;
620 Component *comp = NULL;
621 ComponentList &components = (ComponentList &)_components;
622
623 components.reset();
624 while( (comp = components.iter()) != NULL ) {
625 const Form *form = globals[comp->_type];
626 if( !form ) continue;
627 OpClassForm *op = form->is_opclass();
628 if( !op ) continue;
629 if( form->interface_type(globals) == Form::memory_interface ) {
630 if( comp->isa(Component::USE) ) USE_of_memory = true;
631 if( comp->isa(Component::DEF) ) {
632 OperandForm *oper = form->is_operand();
633 if( oper && oper->is_user_name_for_sReg() ) {
634 // Stack slots are unaliased memory handled by allocator
635 oper = oper; // debug stopping point !!!!!
636 } else {
637 DEF_of_memory = true;
638 }
639 }
640 }
641 }
642 return (USE_of_memory && !DEF_of_memory);
643 }
644
645
646 int InstructForm::memory_operand(FormDict &globals) const {
647 // Machine independent loads must be checked for anti-dependences
648 // Check if instruction has a USE of a memory operand class, or a def.
649 int USE_of_memory = 0;
650 int DEF_of_memory = 0;
651 const char* last_memory_DEF = NULL; // to test DEF/USE pairing in asserts
652 const char* last_memory_USE = NULL;
653 Component *unique = NULL;
654 Component *comp = NULL;
655 ComponentList &components = (ComponentList &)_components;
656
657 components.reset();
658 while( (comp = components.iter()) != NULL ) {
659 const Form *form = globals[comp->_type];
660 if( !form ) continue;
661 OpClassForm *op = form->is_opclass();
662 if( !op ) continue;
663 if( op->stack_slots_only(globals) ) continue;
664 if( form->interface_type(globals) == Form::memory_interface ) {
665 if( comp->isa(Component::DEF) ) {
666 last_memory_DEF = comp->_name;
667 DEF_of_memory++;
668 unique = comp;
669 } else if( comp->isa(Component::USE) ) {
670 if( last_memory_DEF != NULL ) {
671 assert(0 == strcmp(last_memory_DEF, comp->_name), "every memory DEF is followed by a USE of the same name");
672 last_memory_DEF = NULL;
673 }
674 // Handles same memory being used multiple times in the case of BMI1 instructions.
675 if (last_memory_USE != NULL) {
676 if (strcmp(comp->_name, last_memory_USE) != 0) {
677 USE_of_memory++;
678 }
679 } else {
680 USE_of_memory++;
681 }
682 last_memory_USE = comp->_name;
683
684 if (DEF_of_memory == 0) // defs take precedence
685 unique = comp;
686 } else {
687 assert(last_memory_DEF == NULL, "unpaired memory DEF");
688 }
689 }
690 }
691 assert(last_memory_DEF == NULL, "unpaired memory DEF");
692 assert(USE_of_memory >= DEF_of_memory, "unpaired memory DEF");
693 USE_of_memory -= DEF_of_memory; // treat paired DEF/USE as one occurrence
694 if( (USE_of_memory + DEF_of_memory) > 0 ) {
695 if( is_simple_chain_rule(globals) ) {
696 //fprintf(stderr, "Warning: chain rule is not really a memory user.\n");
697 //((InstructForm*)this)->dump();
698 // Preceding code prints nothing on sparc and these insns on intel:
699 // leaP8 leaP32 leaPIdxOff leaPIdxScale leaPIdxScaleOff leaP8 leaP32
700 // leaPIdxOff leaPIdxScale leaPIdxScaleOff
701 return NO_MEMORY_OPERAND;
702 }
703
704 if( DEF_of_memory == 1 ) {
705 assert(unique != NULL, "");
706 if( USE_of_memory == 0 ) {
707 // unique def, no uses
708 } else {
709 // // unique def, some uses
710 // // must return bottom unless all uses match def
711 // unique = NULL;
712 #ifdef S390
713 // This case is important for move instructions on s390x.
714 // On other platforms (e.g. x86), all uses always match the def.
715 unique = NULL;
716 #endif
717 }
718 } else if( DEF_of_memory > 0 ) {
719 // multiple defs, don't care about uses
720 unique = NULL;
721 } else if( USE_of_memory == 1) {
722 // unique use, no defs
723 assert(unique != NULL, "");
724 } else if( USE_of_memory > 0 ) {
725 // multiple uses, no defs
726 unique = NULL;
727 } else {
728 assert(false, "bad case analysis");
729 }
730 // process the unique DEF or USE, if there is one
731 if( unique == NULL ) {
732 return MANY_MEMORY_OPERANDS;
733 } else {
734 int pos = components.operand_position(unique->_name);
735 if( unique->isa(Component::DEF) ) {
736 pos += 1; // get corresponding USE from DEF
737 }
738 assert(pos >= 1, "I was just looking at it!");
739 return pos;
740 }
741 }
742
743 // missed the memory op??
744 if( true ) { // %%% should not be necessary
745 if( is_ideal_store() != Form::none ) {
746 fprintf(stderr, "Warning: cannot find memory opnd in instr.\n");
747 ((InstructForm*)this)->dump();
748 // pretend it has multiple defs and uses
749 return MANY_MEMORY_OPERANDS;
750 }
751 if( is_ideal_load() != Form::none ) {
752 fprintf(stderr, "Warning: cannot find memory opnd in instr.\n");
753 ((InstructForm*)this)->dump();
754 // pretend it has multiple uses and no defs
755 return MANY_MEMORY_OPERANDS;
756 }
757 }
758
759 return NO_MEMORY_OPERAND;
760 }
761
762 // This instruction captures the machine-independent bottom_type
763 // Expected use is for pointer vs oop determination for LoadP
764 bool InstructForm::captures_bottom_type(FormDict &globals) const {
765 if (_matrule && _matrule->_rChild &&
766 (!strcmp(_matrule->_rChild->_opType,"CastPP") || // new result type
767 !strcmp(_matrule->_rChild->_opType,"CastDD") ||
768 !strcmp(_matrule->_rChild->_opType,"CastFF") ||
769 !strcmp(_matrule->_rChild->_opType,"CastII") ||
770 !strcmp(_matrule->_rChild->_opType,"CastLL") ||
771 !strcmp(_matrule->_rChild->_opType,"CastVV") ||
772 !strcmp(_matrule->_rChild->_opType,"CastX2P") || // new result type
773 !strcmp(_matrule->_rChild->_opType,"DecodeN") ||
774 !strcmp(_matrule->_rChild->_opType,"EncodeP") ||
775 !strcmp(_matrule->_rChild->_opType,"DecodeNKlass") ||
776 !strcmp(_matrule->_rChild->_opType,"EncodePKlass") ||
777 !strcmp(_matrule->_rChild->_opType,"LoadN") ||
778 !strcmp(_matrule->_rChild->_opType,"LoadNKlass") ||
779 !strcmp(_matrule->_rChild->_opType,"CreateEx") || // type of exception
780 !strcmp(_matrule->_rChild->_opType,"CheckCastPP") ||
781 !strcmp(_matrule->_rChild->_opType,"GetAndSetP") ||
782 !strcmp(_matrule->_rChild->_opType,"GetAndSetN") ||
783 !strcmp(_matrule->_rChild->_opType,"RotateLeft") ||
784 !strcmp(_matrule->_rChild->_opType,"RotateRight") ||
785 #if INCLUDE_SHENANDOAHGC
786 !strcmp(_matrule->_rChild->_opType,"ShenandoahCompareAndExchangeP") ||
787 !strcmp(_matrule->_rChild->_opType,"ShenandoahCompareAndExchangeN") ||
788 #endif
789 !strcmp(_matrule->_rChild->_opType,"StrInflatedCopy") ||
790 !strcmp(_matrule->_rChild->_opType,"VectorCmpMasked")||
791 !strcmp(_matrule->_rChild->_opType,"VectorMaskGen")||
792 !strcmp(_matrule->_rChild->_opType,"CompareAndExchangeP") ||
793 !strcmp(_matrule->_rChild->_opType,"CompareAndExchangeN"))) return true;
794 else if ( is_ideal_load() == Form::idealP ) return true;
795 else if ( is_ideal_store() != Form::none ) return true;
796
797 if (needs_base_oop_edge(globals)) return true;
798
799 if (is_vector()) return true;
800 if (is_mach_constant()) return true;
801
802 return false;
803 }
804
805
806 // Access instr_cost attribute or return NULL.
807 const char* InstructForm::cost() {
808 for (Attribute* cur = _attribs; cur != NULL; cur = (Attribute*)cur->_next) {
809 if( strcmp(cur->_ident,AttributeForm::_ins_cost) == 0 ) {
810 return cur->_val;
811 }
812 }
813 return NULL;
814 }
815
816 // Return count of top-level operands.
817 uint InstructForm::num_opnds() {
818 int num_opnds = _components.num_operands();
819
820 // Need special handling for matching some ideal nodes
821 // i.e. Matching a return node
822 /*
823 if( _matrule ) {
824 if( strcmp(_matrule->_opType,"Return" )==0 ||
825 strcmp(_matrule->_opType,"Halt" )==0 )
826 return 3;
827 }
828 */
829 return num_opnds;
830 }
831
832 const char* InstructForm::opnd_ident(int idx) {
833 return _components.at(idx)->_name;
834 }
835
836 const char* InstructForm::unique_opnd_ident(uint idx) {
837 uint i;
838 for (i = 1; i < num_opnds(); ++i) {
839 if (unique_opnds_idx(i) == idx) {
840 break;
841 }
842 }
843 return (_components.at(i) != NULL) ? _components.at(i)->_name : "";
844 }
845
846 // Return count of unmatched operands.
847 uint InstructForm::num_post_match_opnds() {
848 uint num_post_match_opnds = _components.count();
849 uint num_match_opnds = _components.match_count();
850 num_post_match_opnds = num_post_match_opnds - num_match_opnds;
851
852 return num_post_match_opnds;
853 }
854
855 // Return the number of leaves below this complex operand
856 uint InstructForm::num_consts(FormDict &globals) const {
857 if ( ! _matrule) return 0;
858
859 // This is a recursive invocation on all operands in the matchrule
860 return _matrule->num_consts(globals);
861 }
862
863 // Constants in match rule with specified type
864 uint InstructForm::num_consts(FormDict &globals, Form::DataType type) const {
865 if ( ! _matrule) return 0;
866
867 // This is a recursive invocation on all operands in the matchrule
868 return _matrule->num_consts(globals, type);
869 }
870
871
872 // Return the register class associated with 'leaf'.
873 const char *InstructForm::out_reg_class(FormDict &globals) {
874 assert( false, "InstructForm::out_reg_class(FormDict &globals); Not Implemented");
875
876 return NULL;
877 }
878
879
880
881 // Lookup the starting position of inputs we are interested in wrt. ideal nodes
882 uint InstructForm::oper_input_base(FormDict &globals) {
883 if( !_matrule ) return 1; // Skip control for most nodes
884
885 // Need special handling for matching some ideal nodes
886 // i.e. Matching a return node
887 if( strcmp(_matrule->_opType,"Return" )==0 ||
888 strcmp(_matrule->_opType,"Rethrow" )==0 ||
889 strcmp(_matrule->_opType,"TailCall" )==0 ||
890 strcmp(_matrule->_opType,"TailJump" )==0 ||
891 strcmp(_matrule->_opType,"SafePoint" )==0 ||
892 strcmp(_matrule->_opType,"Halt" )==0 ||
893 strcmp(_matrule->_opType,"CallLeafNoFP")==0)
894 return AdlcVMDeps::Parms; // Skip the machine-state edges
895
896 if( _matrule->_rChild &&
897 ( strcmp(_matrule->_rChild->_opType,"AryEq" )==0 ||
898 strcmp(_matrule->_rChild->_opType,"StrComp" )==0 ||
899 strcmp(_matrule->_rChild->_opType,"StrEquals" )==0 ||
900 strcmp(_matrule->_rChild->_opType,"StrInflatedCopy" )==0 ||
901 strcmp(_matrule->_rChild->_opType,"StrCompressedCopy" )==0 ||
902 strcmp(_matrule->_rChild->_opType,"StrIndexOf")==0 ||
903 strcmp(_matrule->_rChild->_opType,"StrIndexOfChar")==0 ||
904 strcmp(_matrule->_rChild->_opType,"CountPositives")==0 ||
905 strcmp(_matrule->_rChild->_opType,"EncodeISOArray")==0)) {
906 // String.(compareTo/equals/indexOf) and Arrays.equals
907 // and sun.nio.cs.iso8859_1$Encoder.EncodeISOArray
908 // take 1 control and 1 memory edges.
909 // Also String.(compressedCopy/inflatedCopy).
910 return 2;
911 }
912
913 // Check for handling of 'Memory' input/edge in the ideal world.
914 // The AD file writer is shielded from knowledge of these edges.
915 int base = 1; // Skip control
916 base += _matrule->needs_ideal_memory_edge(globals);
917
918 // Also skip the base-oop value for uses of derived oops.
919 // The AD file writer is shielded from knowledge of these edges.
920 base += needs_base_oop_edge(globals);
921
922 return base;
923 }
924
925 // This function determines the order of the MachOper in _opnds[]
926 // by writing the operand names into the _components list.
927 //
928 // Implementation does not modify state of internal structures
929 void InstructForm::build_components() {
930 // Add top-level operands to the components
931 if (_matrule) _matrule->append_components(_localNames, _components);
932
933 // Add parameters that "do not appear in match rule".
934 bool has_temp = false;
935 const char *name;
936 const char *kill_name = NULL;
937 for (_parameters.reset(); (name = _parameters.iter()) != NULL;) {
938 OpClassForm *opForm = _localNames[name]->is_opclass();
939 assert(opForm != NULL, "sanity");
940
941 Effect* e = NULL;
942 {
943 const Form* form = _effects[name];
944 e = form ? form->is_effect() : NULL;
945 }
946
947 if (e != NULL) {
948 has_temp |= e->is(Component::TEMP);
949
950 // KILLs must be declared after any TEMPs because TEMPs are real
951 // uses so their operand numbering must directly follow the real
952 // inputs from the match rule. Fixing the numbering seems
953 // complex so simply enforce the restriction during parse.
954 if (kill_name != NULL &&
955 e->isa(Component::TEMP) && !e->isa(Component::DEF)) {
956 OpClassForm* kill = _localNames[kill_name]->is_opclass();
957 assert(kill != NULL, "sanity");
958 globalAD->syntax_err(_linenum, "%s: %s %s must be at the end of the argument list\n",
959 _ident, kill->_ident, kill_name);
960 } else if (e->isa(Component::KILL) && !e->isa(Component::USE)) {
961 kill_name = name;
962 }
963 }
964
965 const Component *component = _components.search(name);
966 if ( component == NULL ) {
967 if (e) {
968 _components.insert(name, opForm->_ident, e->_use_def, false);
969 component = _components.search(name);
970 if (component->isa(Component::USE) && !component->isa(Component::TEMP) && _matrule) {
971 const Form *form = globalAD->globalNames()[component->_type];
972 assert( form, "component type must be a defined form");
973 OperandForm *op = form->is_operand();
974 if (op->_interface && op->_interface->is_RegInterface()) {
975 globalAD->syntax_err(_linenum, "%s: illegal USE of non-input: %s %s\n",
976 _ident, opForm->_ident, name);
977 }
978 }
979 } else {
980 // This would be a nice warning but it triggers in a few places in a benign way
981 // if (_matrule != NULL && !expands()) {
982 // globalAD->syntax_err(_linenum, "%s: %s %s not mentioned in effect or match rule\n",
983 // _ident, opForm->_ident, name);
984 // }
985 _components.insert(name, opForm->_ident, Component::INVALID, false);
986 }
987 }
988 else if (e) {
989 // Component was found in the list
990 // Check if there is a new effect that requires an extra component.
991 // This happens when adding 'USE' to a component that is not yet one.
992 if ((!component->isa( Component::USE) && ((e->_use_def & Component::USE) != 0))) {
993 if (component->isa(Component::USE) && _matrule) {
994 const Form *form = globalAD->globalNames()[component->_type];
995 assert( form, "component type must be a defined form");
996 OperandForm *op = form->is_operand();
997 if (op->_interface && op->_interface->is_RegInterface()) {
998 globalAD->syntax_err(_linenum, "%s: illegal USE of non-input: %s %s\n",
999 _ident, opForm->_ident, name);
1000 }
1001 }
1002 _components.insert(name, opForm->_ident, e->_use_def, false);
1003 } else {
1004 Component *comp = (Component*)component;
1005 comp->promote_use_def_info(e->_use_def);
1006 }
1007 // Component positions are zero based.
1008 int pos = _components.operand_position(name);
1009 assert( ! (component->isa(Component::DEF) && (pos >= 1)),
1010 "Component::DEF can only occur in the first position");
1011 }
1012 }
1013
1014 // Resolving the interactions between expand rules and TEMPs would
1015 // be complex so simply disallow it.
1016 if (_matrule == NULL && has_temp) {
1017 globalAD->syntax_err(_linenum, "%s: TEMPs without match rule isn't supported\n", _ident);
1018 }
1019
1020 return;
1021 }
1022
1023 // Return zero-based position in component list; -1 if not in list.
1024 int InstructForm::operand_position(const char *name, int usedef) {
1025 return unique_opnds_idx(_components.operand_position(name, usedef, this));
1026 }
1027
1028 int InstructForm::operand_position_format(const char *name) {
1029 return unique_opnds_idx(_components.operand_position_format(name, this));
1030 }
1031
1032 // Return zero-based position in component list; -1 if not in list.
1033 int InstructForm::label_position() {
1034 return unique_opnds_idx(_components.label_position());
1035 }
1036
1037 int InstructForm::method_position() {
1038 return unique_opnds_idx(_components.method_position());
1039 }
1040
1041 // Return number of relocation entries needed for this instruction.
1042 uint InstructForm::reloc(FormDict &globals) {
1043 uint reloc_entries = 0;
1044 // Check for "Call" nodes
1045 if ( is_ideal_call() ) ++reloc_entries;
1046 if ( is_ideal_return() ) ++reloc_entries;
1047 if ( is_ideal_safepoint() ) ++reloc_entries;
1048
1049
1050 // Check if operands MAYBE oop pointers, by checking for ConP elements
1051 // Proceed through the leaves of the match-tree and check for ConPs
1052 if ( _matrule != NULL ) {
1053 uint position = 0;
1054 const char *result = NULL;
1055 const char *name = NULL;
1056 const char *opType = NULL;
1057 while (_matrule->base_operand(position, globals, result, name, opType)) {
1058 if ( strcmp(opType,"ConP") == 0 ) {
1059 ++reloc_entries;
1060 }
1061 ++position;
1062 }
1063 }
1064
1065 // Above is only a conservative estimate
1066 // because it did not check contents of operand classes.
1067 // !!!!! !!!!!
1068 // Add 1 to reloc info for each operand class in the component list.
1069 Component *comp;
1070 _components.reset();
1071 while ( (comp = _components.iter()) != NULL ) {
1072 const Form *form = globals[comp->_type];
1073 assert( form, "Did not find component's type in global names");
1074 const OpClassForm *opc = form->is_opclass();
1075 const OperandForm *oper = form->is_operand();
1076 if ( opc && (oper == NULL) ) {
1077 ++reloc_entries;
1078 } else if ( oper ) {
1079 // floats and doubles loaded out of method's constant pool require reloc info
1080 Form::DataType type = oper->is_base_constant(globals);
1081 if ( (type == Form::idealF) || (type == Form::idealD) ) {
1082 ++reloc_entries;
1083 }
1084 }
1085 }
1086
1087 // Float and Double constants may come from the CodeBuffer table
1088 // and require relocatable addresses for access
1089 // !!!!!
1090 // Check for any component being an immediate float or double.
1091 Form::DataType data_type = is_chain_of_constant(globals);
1092 if( data_type==idealD || data_type==idealF ) {
1093 reloc_entries++;
1094 }
1095
1096 return reloc_entries;
1097 }
1098
1099 // Utility function defined in archDesc.cpp
1100 extern bool is_def(int usedef);
1101
1102 // Return the result of reducing an instruction
1103 const char *InstructForm::reduce_result() {
1104 const char* result = "Universe"; // default
1105 _components.reset();
1106 Component *comp = _components.iter();
1107 if (comp != NULL && comp->isa(Component::DEF)) {
1108 result = comp->_type;
1109 // Override this if the rule is a store operation:
1110 if (_matrule && _matrule->_rChild &&
1111 is_store_to_memory(_matrule->_rChild->_opType))
1112 result = "Universe";
1113 }
1114 return result;
1115 }
1116
1117 // Return the name of the operand on the right hand side of the binary match
1118 // Return NULL if there is no right hand side
1119 const char *InstructForm::reduce_right(FormDict &globals) const {
1120 if( _matrule == NULL ) return NULL;
1121 return _matrule->reduce_right(globals);
1122 }
1123
1124 // Similar for left
1125 const char *InstructForm::reduce_left(FormDict &globals) const {
1126 if( _matrule == NULL ) return NULL;
1127 return _matrule->reduce_left(globals);
1128 }
1129
1130
1131 // Base class for this instruction, MachNode except for calls
1132 const char *InstructForm::mach_base_class(FormDict &globals) const {
1133 if( is_ideal_call() == Form::JAVA_STATIC ) {
1134 return "MachCallStaticJavaNode";
1135 }
1136 else if( is_ideal_call() == Form::JAVA_DYNAMIC ) {
1137 return "MachCallDynamicJavaNode";
1138 }
1139 else if( is_ideal_call() == Form::JAVA_RUNTIME ) {
1140 return "MachCallRuntimeNode";
1141 }
1142 else if( is_ideal_call() == Form::JAVA_LEAF ) {
1143 return "MachCallLeafNode";
1144 }
1145 else if (is_ideal_return()) {
1146 return "MachReturnNode";
1147 }
1148 else if (is_ideal_halt()) {
1149 return "MachHaltNode";
1150 }
1151 else if (is_ideal_safepoint()) {
1152 return "MachSafePointNode";
1153 }
1154 else if (is_ideal_if()) {
1155 return "MachIfNode";
1156 }
1157 else if (is_ideal_goto()) {
1158 return "MachGotoNode";
1159 }
1160 else if (is_ideal_fastlock()) {
1161 return "MachFastLockNode";
1162 }
1163 else if (is_ideal_nop()) {
1164 return "MachNopNode";
1165 }
1166 else if( is_ideal_membar()) {
1167 return "MachMemBarNode";
1168 }
1169 else if (is_ideal_jump()) {
1170 return "MachJumpNode";
1171 }
1172 else if (is_mach_constant()) {
1173 return "MachConstantNode";
1174 }
1175 else if (captures_bottom_type(globals)) {
1176 return "MachTypeNode";
1177 } else {
1178 return "MachNode";
1179 }
1180 assert( false, "ShouldNotReachHere()");
1181 return NULL;
1182 }
1183
1184 // Compare the instruction predicates for textual equality
1185 bool equivalent_predicates( const InstructForm *instr1, const InstructForm *instr2 ) {
1186 const Predicate *pred1 = instr1->_predicate;
1187 const Predicate *pred2 = instr2->_predicate;
1188 if( pred1 == NULL && pred2 == NULL ) {
1189 // no predicates means they are identical
1190 return true;
1191 }
1192 if( pred1 != NULL && pred2 != NULL ) {
1193 // compare the predicates
1194 if (ADLParser::equivalent_expressions(pred1->_pred, pred2->_pred)) {
1195 return true;
1196 }
1197 }
1198
1199 return false;
1200 }
1201
1202 // Check if this instruction can cisc-spill to 'alternate'
1203 bool InstructForm::cisc_spills_to(ArchDesc &AD, InstructForm *instr) {
1204 assert( _matrule != NULL && instr->_matrule != NULL, "must have match rules");
1205 // Do not replace if a cisc-version has been found.
1206 if( cisc_spill_operand() != Not_cisc_spillable ) return false;
1207
1208 int cisc_spill_operand = Maybe_cisc_spillable;
1209 char *result = NULL;
1210 char *result2 = NULL;
1211 const char *op_name = NULL;
1212 const char *reg_type = NULL;
1213 FormDict &globals = AD.globalNames();
1214 cisc_spill_operand = _matrule->matchrule_cisc_spill_match(globals, AD.get_registers(), instr->_matrule, op_name, reg_type);
1215 if( (cisc_spill_operand != Not_cisc_spillable) && (op_name != NULL) && equivalent_predicates(this, instr) ) {
1216 cisc_spill_operand = operand_position(op_name, Component::USE);
1217 int def_oper = operand_position(op_name, Component::DEF);
1218 if( def_oper == NameList::Not_in_list && instr->num_opnds() == num_opnds()) {
1219 // Do not support cisc-spilling for destination operands and
1220 // make sure they have the same number of operands.
1221 _cisc_spill_alternate = instr;
1222 instr->set_cisc_alternate(true);
1223 if( AD._cisc_spill_debug ) {
1224 fprintf(stderr, "Instruction %s cisc-spills-to %s\n", _ident, instr->_ident);
1225 fprintf(stderr, " using operand %s %s at index %d\n", reg_type, op_name, cisc_spill_operand);
1226 }
1227 // Record that a stack-version of the reg_mask is needed
1228 // !!!!!
1229 OperandForm *oper = (OperandForm*)(globals[reg_type]->is_operand());
1230 assert( oper != NULL, "cisc-spilling non operand");
1231 const char *reg_class_name = oper->constrained_reg_class();
1232 AD.set_stack_or_reg(reg_class_name);
1233 const char *reg_mask_name = AD.reg_mask(*oper);
1234 set_cisc_reg_mask_name(reg_mask_name);
1235 const char *stack_or_reg_mask_name = AD.stack_or_reg_mask(*oper);
1236 } else {
1237 cisc_spill_operand = Not_cisc_spillable;
1238 }
1239 } else {
1240 cisc_spill_operand = Not_cisc_spillable;
1241 }
1242
1243 set_cisc_spill_operand(cisc_spill_operand);
1244 return (cisc_spill_operand != Not_cisc_spillable);
1245 }
1246
1247 // Check to see if this instruction can be replaced with the short branch
1248 // instruction `short-branch'
1249 bool InstructForm::check_branch_variant(ArchDesc &AD, InstructForm *short_branch) {
1250 if (_matrule != NULL &&
1251 this != short_branch && // Don't match myself
1252 !is_short_branch() && // Don't match another short branch variant
1253 reduce_result() != NULL &&
1254 strstr(_ident, "restoreMask") == NULL && // Don't match side effects
1255 strcmp(reduce_result(), short_branch->reduce_result()) == 0 &&
1256 _matrule->equivalent(AD.globalNames(), short_branch->_matrule)) {
1257 // The instructions are equivalent.
1258
1259 // Now verify that both instructions have the same parameters and
1260 // the same effects. Both branch forms should have the same inputs
1261 // and resulting projections to correctly replace a long branch node
1262 // with corresponding short branch node during code generation.
1263
1264 bool different = false;
1265 if (short_branch->_components.count() != _components.count()) {
1266 different = true;
1267 } else if (_components.count() > 0) {
1268 short_branch->_components.reset();
1269 _components.reset();
1270 Component *comp;
1271 while ((comp = _components.iter()) != NULL) {
1272 Component *short_comp = short_branch->_components.iter();
1273 if (short_comp == NULL ||
1274 short_comp->_type != comp->_type ||
1275 short_comp->_usedef != comp->_usedef) {
1276 different = true;
1277 break;
1278 }
1279 }
1280 if (short_branch->_components.iter() != NULL)
1281 different = true;
1282 }
1283 if (different) {
1284 globalAD->syntax_err(short_branch->_linenum, "Instruction %s and its short form %s have different parameters\n", _ident, short_branch->_ident);
1285 }
1286 if (AD._adl_debug > 1 || AD._short_branch_debug) {
1287 fprintf(stderr, "Instruction %s has short form %s\n", _ident, short_branch->_ident);
1288 }
1289 _short_branch_form = short_branch;
1290 return true;
1291 }
1292 return false;
1293 }
1294
1295
1296 // --------------------------- FILE *output_routines
1297 //
1298 // Generate the format call for the replacement variable
1299 void InstructForm::rep_var_format(FILE *fp, const char *rep_var) {
1300 // Handle special constant table variables.
1301 if (strcmp(rep_var, "constanttablebase") == 0) {
1302 fprintf(fp, "char reg[128]; ra->dump_register(in(mach_constant_base_node_input()), reg);\n");
1303 fprintf(fp, " st->print(\"%%s\", reg);\n");
1304 return;
1305 }
1306 if (strcmp(rep_var, "constantoffset") == 0) {
1307 fprintf(fp, "st->print(\"#%%d\", constant_offset_unchecked());\n");
1308 return;
1309 }
1310 if (strcmp(rep_var, "constantaddress") == 0) {
1311 fprintf(fp, "st->print(\"constant table base + #%%d\", constant_offset_unchecked());\n");
1312 return;
1313 }
1314
1315 // Find replacement variable's type
1316 const Form *form = _localNames[rep_var];
1317 if (form == NULL) {
1318 globalAD->syntax_err(_linenum, "Unknown replacement variable %s in format statement of %s.",
1319 rep_var, _ident);
1320 return;
1321 }
1322 OpClassForm *opc = form->is_opclass();
1323 assert( opc, "replacement variable was not found in local names");
1324 // Lookup the index position of the replacement variable
1325 int idx = operand_position_format(rep_var);
1326 if ( idx == -1 ) {
1327 globalAD->syntax_err(_linenum, "Could not find replacement variable %s in format statement of %s.\n",
1328 rep_var, _ident);
1329 assert(strcmp(opc->_ident, "label") == 0, "Unimplemented");
1330 return;
1331 }
1332
1333 if (is_noninput_operand(idx)) {
1334 // This component isn't in the input array. Print out the static
1335 // name of the register.
1336 OperandForm* oper = form->is_operand();
1337 if (oper != NULL && oper->is_bound_register()) {
1338 const RegDef* first = oper->get_RegClass()->find_first_elem();
1339 fprintf(fp, " st->print_raw(\"%s\");\n", first->_regname);
1340 } else {
1341 globalAD->syntax_err(_linenum, "In %s can't find format for %s %s", _ident, opc->_ident, rep_var);
1342 }
1343 } else {
1344 // Output the format call for this operand
1345 fprintf(fp,"opnd_array(%d)->",idx);
1346 if (idx == 0)
1347 fprintf(fp,"int_format(ra, this, st); // %s\n", rep_var);
1348 else
1349 fprintf(fp,"ext_format(ra, this,idx%d, st); // %s\n", idx, rep_var );
1350 }
1351 }
1352
1353 // Search through operands to determine parameters unique positions.
1354 void InstructForm::set_unique_opnds() {
1355 uint* uniq_idx = NULL;
1356 uint nopnds = num_opnds();
1357 uint num_uniq = nopnds;
1358 uint i;
1359 _uniq_idx_length = 0;
1360 if (nopnds > 0) {
1361 // Allocate index array. Worst case we're mapping from each
1362 // component back to an index and any DEF always goes at 0 so the
1363 // length of the array has to be the number of components + 1.
1364 _uniq_idx_length = _components.count() + 1;
1365 uniq_idx = (uint*) AdlAllocateHeap(sizeof(uint) * _uniq_idx_length);
1366 for (i = 0; i < _uniq_idx_length; i++) {
1367 uniq_idx[i] = i;
1368 }
1369 }
1370 // Do it only if there is a match rule and no expand rule. With an
1371 // expand rule it is done by creating new mach node in Expand()
1372 // method.
1373 if (nopnds > 0 && _matrule != NULL && _exprule == NULL) {
1374 const char *name;
1375 uint count;
1376 bool has_dupl_use = false;
1377
1378 _parameters.reset();
1379 while ((name = _parameters.iter()) != NULL) {
1380 count = 0;
1381 uint position = 0;
1382 uint uniq_position = 0;
1383 _components.reset();
1384 Component *comp = NULL;
1385 if (sets_result()) {
1386 comp = _components.iter();
1387 position++;
1388 }
1389 // The next code is copied from the method operand_position().
1390 for (; (comp = _components.iter()) != NULL; ++position) {
1391 // When the first component is not a DEF,
1392 // leave space for the result operand!
1393 if (position==0 && (!comp->isa(Component::DEF))) {
1394 ++position;
1395 }
1396 if (strcmp(name, comp->_name) == 0) {
1397 if (++count > 1) {
1398 assert(position < _uniq_idx_length, "out of bounds");
1399 uniq_idx[position] = uniq_position;
1400 has_dupl_use = true;
1401 } else {
1402 uniq_position = position;
1403 }
1404 }
1405 if (comp->isa(Component::DEF) && comp->isa(Component::USE)) {
1406 ++position;
1407 if (position != 1)
1408 --position; // only use two slots for the 1st USE_DEF
1409 }
1410 }
1411 }
1412 if (has_dupl_use) {
1413 for (i = 1; i < nopnds; i++) {
1414 if (i != uniq_idx[i]) {
1415 break;
1416 }
1417 }
1418 uint j = i;
1419 for (; i < nopnds; i++) {
1420 if (i == uniq_idx[i]) {
1421 uniq_idx[i] = j++;
1422 }
1423 }
1424 num_uniq = j;
1425 }
1426 }
1427 _uniq_idx = uniq_idx;
1428 _num_uniq = num_uniq;
1429 }
1430
1431 // Generate index values needed for determining the operand position
1432 void InstructForm::index_temps(FILE *fp, FormDict &globals, const char *prefix, const char *receiver) {
1433 uint idx = 0; // position of operand in match rule
1434 int cur_num_opnds = num_opnds();
1435
1436 // Compute the index into vector of operand pointers:
1437 // idx0=0 is used to indicate that info comes from this same node, not from input edge.
1438 // idx1 starts at oper_input_base()
1439 if ( cur_num_opnds >= 1 ) {
1440 fprintf(fp," // Start at oper_input_base() and count operands\n");
1441 fprintf(fp," unsigned %sidx0 = %d;\n", prefix, oper_input_base(globals));
1442 fprintf(fp," unsigned %sidx1 = %d;", prefix, oper_input_base(globals));
1443 fprintf(fp," \t// %s\n", unique_opnd_ident(1));
1444
1445 // Generate starting points for other unique operands if they exist
1446 for ( idx = 2; idx < num_unique_opnds(); ++idx ) {
1447 if( *receiver == 0 ) {
1448 fprintf(fp," unsigned %sidx%d = %sidx%d + opnd_array(%d)->num_edges();",
1449 prefix, idx, prefix, idx-1, idx-1 );
1450 } else {
1451 fprintf(fp," unsigned %sidx%d = %sidx%d + %s_opnds[%d]->num_edges();",
1452 prefix, idx, prefix, idx-1, receiver, idx-1 );
1453 }
1454 fprintf(fp," \t// %s\n", unique_opnd_ident(idx));
1455 }
1456 }
1457 if( *receiver != 0 ) {
1458 // This value is used by generate_peepreplace when copying a node.
1459 // Don't emit it in other cases since it can hide bugs with the
1460 // use invalid idx's.
1461 fprintf(fp," unsigned %sidx%d = %sreq(); \n", prefix, idx, receiver);
1462 }
1463
1464 }
1465
1466 // ---------------------------
1467 bool InstructForm::verify() {
1468 // !!!!! !!!!!
1469 // Check that a "label" operand occurs last in the operand list, if present
1470 return true;
1471 }
1472
1473 void InstructForm::dump() {
1474 output(stderr);
1475 }
1476
1477 void InstructForm::output(FILE *fp) {
1478 fprintf(fp,"\nInstruction: %s\n", (_ident?_ident:""));
1479 if (_matrule) _matrule->output(fp);
1480 if (_insencode) _insencode->output(fp);
1481 if (_constant) _constant->output(fp);
1482 if (_opcode) _opcode->output(fp);
1483 if (_attribs) _attribs->output(fp);
1484 if (_predicate) _predicate->output(fp);
1485 if (_effects.Size()) {
1486 fprintf(fp,"Effects\n");
1487 _effects.dump();
1488 }
1489 if (_exprule) _exprule->output(fp);
1490 if (_rewrule) _rewrule->output(fp);
1491 if (_format) _format->output(fp);
1492 if (_peephole) _peephole->output(fp);
1493 }
1494
1495 void MachNodeForm::dump() {
1496 output(stderr);
1497 }
1498
1499 void MachNodeForm::output(FILE *fp) {
1500 fprintf(fp,"\nMachNode: %s\n", (_ident?_ident:""));
1501 }
1502
1503 //------------------------------build_predicate--------------------------------
1504 // Build instruction predicates. If the user uses the same operand name
1505 // twice, we need to check that the operands are pointer-eequivalent in
1506 // the DFA during the labeling process.
1507 Predicate *InstructForm::build_predicate() {
1508 const int buflen = 1024;
1509 char buf[buflen], *s=buf;
1510 Dict names(cmpstr,hashstr,Form::arena); // Map Names to counts
1511
1512 MatchNode *mnode =
1513 strcmp(_matrule->_opType, "Set") ? _matrule : _matrule->_rChild;
1514 if (mnode != NULL) mnode->count_instr_names(names);
1515
1516 uint first = 1;
1517 // Start with the predicate supplied in the .ad file.
1518 if (_predicate) {
1519 if (first) first = 0;
1520 strcpy(s, "("); s += strlen(s);
1521 strncpy(s, _predicate->_pred, buflen - strlen(s) - 1);
1522 s += strlen(s);
1523 strcpy(s, ")"); s += strlen(s);
1524 }
1525 for( DictI i(&names); i.test(); ++i ) {
1526 uintptr_t cnt = (uintptr_t)i._value;
1527 if( cnt > 1 ) { // Need a predicate at all?
1528 int path_bitmask = 0;
1529 assert( cnt == 2, "Unimplemented" );
1530 // Handle many pairs
1531 if( first ) first=0;
1532 else { // All tests must pass, so use '&&'
1533 strcpy(s," && ");
1534 s += strlen(s);
1535 }
1536 // Add predicate to working buffer
1537 sprintf(s,"/*%s*/(",(char*)i._key);
1538 s += strlen(s);
1539 mnode->build_instr_pred(s,(char*)i._key, 0, path_bitmask, 0);
1540 s += strlen(s);
1541 strcpy(s," == "); s += strlen(s);
1542 mnode->build_instr_pred(s,(char*)i._key, 1, path_bitmask, 0);
1543 s += strlen(s);
1544 strcpy(s,")"); s += strlen(s);
1545 }
1546 }
1547 if( s == buf ) s = NULL;
1548 else {
1549 assert( strlen(buf) < sizeof(buf), "String buffer overflow" );
1550 s = strdup(buf);
1551 }
1552 return new Predicate(s);
1553 }
1554
1555 //------------------------------EncodeForm-------------------------------------
1556 // Constructor
1557 EncodeForm::EncodeForm()
1558 : _encClass(cmpstr,hashstr, Form::arena) {
1559 }
1560 EncodeForm::~EncodeForm() {
1561 }
1562
1563 // record a new register class
1564 EncClass *EncodeForm::add_EncClass(const char *className) {
1565 EncClass *encClass = new EncClass(className);
1566 _eclasses.addName(className);
1567 _encClass.Insert(className,encClass);
1568 return encClass;
1569 }
1570
1571 // Lookup the function body for an encoding class
1572 EncClass *EncodeForm::encClass(const char *className) {
1573 assert( className != NULL, "Must provide a defined encoding name");
1574
1575 EncClass *encClass = (EncClass*)_encClass[className];
1576 return encClass;
1577 }
1578
1579 // Lookup the function body for an encoding class
1580 const char *EncodeForm::encClassBody(const char *className) {
1581 if( className == NULL ) return NULL;
1582
1583 EncClass *encClass = (EncClass*)_encClass[className];
1584 assert( encClass != NULL, "Encode Class is missing.");
1585 encClass->_code.reset();
1586 const char *code = (const char*)encClass->_code.iter();
1587 assert( code != NULL, "Found an empty encode class body.");
1588
1589 return code;
1590 }
1591
1592 // Lookup the function body for an encoding class
1593 const char *EncodeForm::encClassPrototype(const char *className) {
1594 assert( className != NULL, "Encode class name must be non NULL.");
1595
1596 return className;
1597 }
1598
1599 void EncodeForm::dump() { // Debug printer
1600 output(stderr);
1601 }
1602
1603 void EncodeForm::output(FILE *fp) { // Write info to output files
1604 const char *name;
1605 fprintf(fp,"\n");
1606 fprintf(fp,"-------------------- Dump EncodeForm --------------------\n");
1607 for (_eclasses.reset(); (name = _eclasses.iter()) != NULL;) {
1608 ((EncClass*)_encClass[name])->output(fp);
1609 }
1610 fprintf(fp,"-------------------- end EncodeForm --------------------\n");
1611 }
1612 //------------------------------EncClass---------------------------------------
1613 EncClass::EncClass(const char *name)
1614 : _localNames(cmpstr,hashstr, Form::arena), _name(name) {
1615 }
1616 EncClass::~EncClass() {
1617 }
1618
1619 // Add a parameter <type,name> pair
1620 void EncClass::add_parameter(const char *parameter_type, const char *parameter_name) {
1621 _parameter_type.addName( parameter_type );
1622 _parameter_name.addName( parameter_name );
1623 }
1624
1625 // Verify operand types in parameter list
1626 bool EncClass::check_parameter_types(FormDict &globals) {
1627 // !!!!!
1628 return false;
1629 }
1630
1631 // Add the decomposed "code" sections of an encoding's code-block
1632 void EncClass::add_code(const char *code) {
1633 _code.addName(code);
1634 }
1635
1636 // Add the decomposed "replacement variables" of an encoding's code-block
1637 void EncClass::add_rep_var(char *replacement_var) {
1638 _code.addName(NameList::_signal);
1639 _rep_vars.addName(replacement_var);
1640 }
1641
1642 // Lookup the function body for an encoding class
1643 int EncClass::rep_var_index(const char *rep_var) {
1644 uint position = 0;
1645 const char *name = NULL;
1646
1647 _parameter_name.reset();
1648 while ( (name = _parameter_name.iter()) != NULL ) {
1649 if ( strcmp(rep_var,name) == 0 ) return position;
1650 ++position;
1651 }
1652
1653 return -1;
1654 }
1655
1656 // Check after parsing
1657 bool EncClass::verify() {
1658 // 1!!!!
1659 // Check that each replacement variable, '$name' in architecture description
1660 // is actually a local variable for this encode class, or a reserved name
1661 // "primary, secondary, tertiary"
1662 return true;
1663 }
1664
1665 void EncClass::dump() {
1666 output(stderr);
1667 }
1668
1669 // Write info to output files
1670 void EncClass::output(FILE *fp) {
1671 fprintf(fp,"EncClass: %s", (_name ? _name : ""));
1672
1673 // Output the parameter list
1674 _parameter_type.reset();
1675 _parameter_name.reset();
1676 const char *type = _parameter_type.iter();
1677 const char *name = _parameter_name.iter();
1678 fprintf(fp, " ( ");
1679 for ( ; (type != NULL) && (name != NULL);
1680 (type = _parameter_type.iter()), (name = _parameter_name.iter()) ) {
1681 fprintf(fp, " %s %s,", type, name);
1682 }
1683 fprintf(fp, " ) ");
1684
1685 // Output the code block
1686 _code.reset();
1687 _rep_vars.reset();
1688 const char *code;
1689 while ( (code = _code.iter()) != NULL ) {
1690 if ( _code.is_signal(code) ) {
1691 // A replacement variable
1692 const char *rep_var = _rep_vars.iter();
1693 fprintf(fp,"($%s)", rep_var);
1694 } else {
1695 // A section of code
1696 fprintf(fp,"%s", code);
1697 }
1698 }
1699
1700 }
1701
1702 //------------------------------Opcode-----------------------------------------
1703 Opcode::Opcode(char *primary, char *secondary, char *tertiary)
1704 : _primary(primary), _secondary(secondary), _tertiary(tertiary) {
1705 }
1706
1707 Opcode::~Opcode() {
1708 }
1709
1710 Opcode::opcode_type Opcode::as_opcode_type(const char *param) {
1711 if( strcmp(param,"primary") == 0 ) {
1712 return Opcode::PRIMARY;
1713 }
1714 else if( strcmp(param,"secondary") == 0 ) {
1715 return Opcode::SECONDARY;
1716 }
1717 else if( strcmp(param,"tertiary") == 0 ) {
1718 return Opcode::TERTIARY;
1719 }
1720 return Opcode::NOT_AN_OPCODE;
1721 }
1722
1723 bool Opcode::print_opcode(FILE *fp, Opcode::opcode_type desired_opcode) {
1724 // Default values previously provided by MachNode::primary()...
1725 const char *description = NULL;
1726 const char *value = NULL;
1727 // Check if user provided any opcode definitions
1728 // Update 'value' if user provided a definition in the instruction
1729 switch (desired_opcode) {
1730 case PRIMARY:
1731 description = "primary()";
1732 if( _primary != NULL) { value = _primary; }
1733 break;
1734 case SECONDARY:
1735 description = "secondary()";
1736 if( _secondary != NULL ) { value = _secondary; }
1737 break;
1738 case TERTIARY:
1739 description = "tertiary()";
1740 if( _tertiary != NULL ) { value = _tertiary; }
1741 break;
1742 default:
1743 assert( false, "ShouldNotReachHere();");
1744 break;
1745 }
1746
1747 if (value != NULL) {
1748 fprintf(fp, "(%s /*%s*/)", value, description);
1749 }
1750 return value != NULL;
1751 }
1752
1753 void Opcode::dump() {
1754 output(stderr);
1755 }
1756
1757 // Write info to output files
1758 void Opcode::output(FILE *fp) {
1759 if (_primary != NULL) fprintf(fp,"Primary opcode: %s\n", _primary);
1760 if (_secondary != NULL) fprintf(fp,"Secondary opcode: %s\n", _secondary);
1761 if (_tertiary != NULL) fprintf(fp,"Tertiary opcode: %s\n", _tertiary);
1762 }
1763
1764 //------------------------------InsEncode--------------------------------------
1765 InsEncode::InsEncode() {
1766 }
1767 InsEncode::~InsEncode() {
1768 }
1769
1770 // Add "encode class name" and its parameters
1771 NameAndList *InsEncode::add_encode(char *encoding) {
1772 assert( encoding != NULL, "Must provide name for encoding");
1773
1774 // add_parameter(NameList::_signal);
1775 NameAndList *encode = new NameAndList(encoding);
1776 _encoding.addName((char*)encode);
1777
1778 return encode;
1779 }
1780
1781 // Access the list of encodings
1782 void InsEncode::reset() {
1783 _encoding.reset();
1784 // _parameter.reset();
1785 }
1786 const char* InsEncode::encode_class_iter() {
1787 NameAndList *encode_class = (NameAndList*)_encoding.iter();
1788 return ( encode_class != NULL ? encode_class->name() : NULL );
1789 }
1790 // Obtain parameter name from zero based index
1791 const char *InsEncode::rep_var_name(InstructForm &inst, uint param_no) {
1792 NameAndList *params = (NameAndList*)_encoding.current();
1793 assert( params != NULL, "Internal Error");
1794 const char *param = (*params)[param_no];
1795
1796 // Remove '$' if parser placed it there.
1797 return ( param != NULL && *param == '$') ? (param+1) : param;
1798 }
1799
1800 void InsEncode::dump() {
1801 output(stderr);
1802 }
1803
1804 // Write info to output files
1805 void InsEncode::output(FILE *fp) {
1806 NameAndList *encoding = NULL;
1807 const char *parameter = NULL;
1808
1809 fprintf(fp,"InsEncode: ");
1810 _encoding.reset();
1811
1812 while ( (encoding = (NameAndList*)_encoding.iter()) != 0 ) {
1813 // Output the encoding being used
1814 fprintf(fp,"%s(", encoding->name() );
1815
1816 // Output its parameter list, if any
1817 bool first_param = true;
1818 encoding->reset();
1819 while ( (parameter = encoding->iter()) != 0 ) {
1820 // Output the ',' between parameters
1821 if ( ! first_param ) fprintf(fp,", ");
1822 first_param = false;
1823 // Output the parameter
1824 fprintf(fp,"%s", parameter);
1825 } // done with parameters
1826 fprintf(fp,") ");
1827 } // done with encodings
1828
1829 fprintf(fp,"\n");
1830 }
1831
1832 //------------------------------Effect-----------------------------------------
1833 static int effect_lookup(const char *name) {
1834 if (!strcmp(name, "USE")) return Component::USE;
1835 if (!strcmp(name, "DEF")) return Component::DEF;
1836 if (!strcmp(name, "USE_DEF")) return Component::USE_DEF;
1837 if (!strcmp(name, "KILL")) return Component::KILL;
1838 if (!strcmp(name, "USE_KILL")) return Component::USE_KILL;
1839 if (!strcmp(name, "TEMP")) return Component::TEMP;
1840 if (!strcmp(name, "TEMP_DEF")) return Component::TEMP_DEF;
1841 if (!strcmp(name, "INVALID")) return Component::INVALID;
1842 if (!strcmp(name, "CALL")) return Component::CALL;
1843 assert(false,"Invalid effect name specified\n");
1844 return Component::INVALID;
1845 }
1846
1847 const char *Component::getUsedefName() {
1848 switch (_usedef) {
1849 case Component::INVALID: return "INVALID"; break;
1850 case Component::USE: return "USE"; break;
1851 case Component::USE_DEF: return "USE_DEF"; break;
1852 case Component::USE_KILL: return "USE_KILL"; break;
1853 case Component::KILL: return "KILL"; break;
1854 case Component::TEMP: return "TEMP"; break;
1855 case Component::TEMP_DEF: return "TEMP_DEF"; break;
1856 case Component::DEF: return "DEF"; break;
1857 case Component::CALL: return "CALL"; break;
1858 default: assert(false, "unknown effect");
1859 }
1860 return "Undefined Use/Def info";
1861 }
1862
1863 Effect::Effect(const char *name) : _name(name), _use_def(effect_lookup(name)) {
1864 _ftype = Form::EFF;
1865 }
1866
1867 Effect::~Effect() {
1868 }
1869
1870 // Dynamic type check
1871 Effect *Effect::is_effect() const {
1872 return (Effect*)this;
1873 }
1874
1875
1876 // True if this component is equal to the parameter.
1877 bool Effect::is(int use_def_kill_enum) const {
1878 return (_use_def == use_def_kill_enum ? true : false);
1879 }
1880 // True if this component is used/def'd/kill'd as the parameter suggests.
1881 bool Effect::isa(int use_def_kill_enum) const {
1882 return (_use_def & use_def_kill_enum) == use_def_kill_enum;
1883 }
1884
1885 void Effect::dump() {
1886 output(stderr);
1887 }
1888
1889 void Effect::output(FILE *fp) { // Write info to output files
1890 fprintf(fp,"Effect: %s\n", (_name?_name:""));
1891 }
1892
1893 //------------------------------ExpandRule-------------------------------------
1894 ExpandRule::ExpandRule() : _expand_instrs(),
1895 _newopconst(cmpstr, hashstr, Form::arena) {
1896 _ftype = Form::EXP;
1897 }
1898
1899 ExpandRule::~ExpandRule() { // Destructor
1900 }
1901
1902 void ExpandRule::add_instruction(NameAndList *instruction_name_and_operand_list) {
1903 _expand_instrs.addName((char*)instruction_name_and_operand_list);
1904 }
1905
1906 void ExpandRule::reset_instructions() {
1907 _expand_instrs.reset();
1908 }
1909
1910 NameAndList* ExpandRule::iter_instructions() {
1911 return (NameAndList*)_expand_instrs.iter();
1912 }
1913
1914
1915 void ExpandRule::dump() {
1916 output(stderr);
1917 }
1918
1919 void ExpandRule::output(FILE *fp) { // Write info to output files
1920 NameAndList *expand_instr = NULL;
1921 const char *opid = NULL;
1922
1923 fprintf(fp,"\nExpand Rule:\n");
1924
1925 // Iterate over the instructions 'node' expands into
1926 for(reset_instructions(); (expand_instr = iter_instructions()) != NULL; ) {
1927 fprintf(fp,"%s(", expand_instr->name());
1928
1929 // iterate over the operand list
1930 for( expand_instr->reset(); (opid = expand_instr->iter()) != NULL; ) {
1931 fprintf(fp,"%s ", opid);
1932 }
1933 fprintf(fp,");\n");
1934 }
1935 }
1936
1937 //------------------------------RewriteRule------------------------------------
1938 RewriteRule::RewriteRule(char* params, char* block)
1939 : _tempParams(params), _tempBlock(block) { }; // Constructor
1940 RewriteRule::~RewriteRule() { // Destructor
1941 }
1942
1943 void RewriteRule::dump() {
1944 output(stderr);
1945 }
1946
1947 void RewriteRule::output(FILE *fp) { // Write info to output files
1948 fprintf(fp,"\nRewrite Rule:\n%s\n%s\n",
1949 (_tempParams?_tempParams:""),
1950 (_tempBlock?_tempBlock:""));
1951 }
1952
1953
1954 //==============================MachNodes======================================
1955 //------------------------------MachNodeForm-----------------------------------
1956 MachNodeForm::MachNodeForm(char *id)
1957 : _ident(id) {
1958 }
1959
1960 MachNodeForm::~MachNodeForm() {
1961 }
1962
1963 MachNodeForm *MachNodeForm::is_machnode() const {
1964 return (MachNodeForm*)this;
1965 }
1966
1967 //==============================Operand Classes================================
1968 //------------------------------OpClassForm------------------------------------
1969 OpClassForm::OpClassForm(const char* id) : _ident(id) {
1970 _ftype = Form::OPCLASS;
1971 }
1972
1973 OpClassForm::~OpClassForm() {
1974 }
1975
1976 bool OpClassForm::ideal_only() const { return 0; }
1977
1978 OpClassForm *OpClassForm::is_opclass() const {
1979 return (OpClassForm*)this;
1980 }
1981
1982 Form::InterfaceType OpClassForm::interface_type(FormDict &globals) const {
1983 if( _oplst.count() == 0 ) return Form::no_interface;
1984
1985 // Check that my operands have the same interface type
1986 Form::InterfaceType interface;
1987 bool first = true;
1988 NameList &op_list = (NameList &)_oplst;
1989 op_list.reset();
1990 const char *op_name;
1991 while( (op_name = op_list.iter()) != NULL ) {
1992 const Form *form = globals[op_name];
1993 OperandForm *operand = form->is_operand();
1994 assert( operand, "Entry in operand class that is not an operand");
1995 if( first ) {
1996 first = false;
1997 interface = operand->interface_type(globals);
1998 } else {
1999 interface = (interface == operand->interface_type(globals) ? interface : Form::no_interface);
2000 }
2001 }
2002 return interface;
2003 }
2004
2005 bool OpClassForm::stack_slots_only(FormDict &globals) const {
2006 if( _oplst.count() == 0 ) return false; // how?
2007
2008 NameList &op_list = (NameList &)_oplst;
2009 op_list.reset();
2010 const char *op_name;
2011 while( (op_name = op_list.iter()) != NULL ) {
2012 const Form *form = globals[op_name];
2013 OperandForm *operand = form->is_operand();
2014 assert( operand, "Entry in operand class that is not an operand");
2015 if( !operand->stack_slots_only(globals) ) return false;
2016 }
2017 return true;
2018 }
2019
2020
2021 void OpClassForm::dump() {
2022 output(stderr);
2023 }
2024
2025 void OpClassForm::output(FILE *fp) {
2026 const char *name;
2027 fprintf(fp,"\nOperand Class: %s\n", (_ident?_ident:""));
2028 fprintf(fp,"\nCount = %d\n", _oplst.count());
2029 for(_oplst.reset(); (name = _oplst.iter()) != NULL;) {
2030 fprintf(fp,"%s, ",name);
2031 }
2032 fprintf(fp,"\n");
2033 }
2034
2035
2036 //==============================Operands=======================================
2037 //------------------------------OperandForm------------------------------------
2038 OperandForm::OperandForm(const char* id)
2039 : OpClassForm(id), _ideal_only(false),
2040 _localNames(cmpstr, hashstr, Form::arena) {
2041 _ftype = Form::OPER;
2042
2043 _matrule = NULL;
2044 _interface = NULL;
2045 _attribs = NULL;
2046 _predicate = NULL;
2047 _constraint= NULL;
2048 _construct = NULL;
2049 _format = NULL;
2050 }
2051 OperandForm::OperandForm(const char* id, bool ideal_only)
2052 : OpClassForm(id), _ideal_only(ideal_only),
2053 _localNames(cmpstr, hashstr, Form::arena) {
2054 _ftype = Form::OPER;
2055
2056 _matrule = NULL;
2057 _interface = NULL;
2058 _attribs = NULL;
2059 _predicate = NULL;
2060 _constraint= NULL;
2061 _construct = NULL;
2062 _format = NULL;
2063 }
2064 OperandForm::~OperandForm() {
2065 }
2066
2067
2068 OperandForm *OperandForm::is_operand() const {
2069 return (OperandForm*)this;
2070 }
2071
2072 bool OperandForm::ideal_only() const {
2073 return _ideal_only;
2074 }
2075
2076 Form::InterfaceType OperandForm::interface_type(FormDict &globals) const {
2077 if( _interface == NULL ) return Form::no_interface;
2078
2079 return _interface->interface_type(globals);
2080 }
2081
2082
2083 bool OperandForm::stack_slots_only(FormDict &globals) const {
2084 if( _constraint == NULL ) return false;
2085 return _constraint->stack_slots_only();
2086 }
2087
2088
2089 // Access op_cost attribute or return NULL.
2090 const char* OperandForm::cost() {
2091 for (Attribute* cur = _attribs; cur != NULL; cur = (Attribute*)cur->_next) {
2092 if( strcmp(cur->_ident,AttributeForm::_op_cost) == 0 ) {
2093 return cur->_val;
2094 }
2095 }
2096 return NULL;
2097 }
2098
2099 // Return the number of leaves below this complex operand
2100 uint OperandForm::num_leaves() const {
2101 if ( ! _matrule) return 0;
2102
2103 int num_leaves = _matrule->_numleaves;
2104 return num_leaves;
2105 }
2106
2107 // Return the number of constants contained within this complex operand
2108 uint OperandForm::num_consts(FormDict &globals) const {
2109 if ( ! _matrule) return 0;
2110
2111 // This is a recursive invocation on all operands in the matchrule
2112 return _matrule->num_consts(globals);
2113 }
2114
2115 // Return the number of constants in match rule with specified type
2116 uint OperandForm::num_consts(FormDict &globals, Form::DataType type) const {
2117 if ( ! _matrule) return 0;
2118
2119 // This is a recursive invocation on all operands in the matchrule
2120 return _matrule->num_consts(globals, type);
2121 }
2122
2123 // Return the number of pointer constants contained within this complex operand
2124 uint OperandForm::num_const_ptrs(FormDict &globals) const {
2125 if ( ! _matrule) return 0;
2126
2127 // This is a recursive invocation on all operands in the matchrule
2128 return _matrule->num_const_ptrs(globals);
2129 }
2130
2131 uint OperandForm::num_edges(FormDict &globals) const {
2132 uint edges = 0;
2133 uint leaves = num_leaves();
2134 uint consts = num_consts(globals);
2135
2136 // If we are matching a constant directly, there are no leaves.
2137 edges = ( leaves > consts ) ? leaves - consts : 0;
2138
2139 // !!!!!
2140 // Special case operands that do not have a corresponding ideal node.
2141 if( (edges == 0) && (consts == 0) ) {
2142 if( constrained_reg_class() != NULL ) {
2143 edges = 1;
2144 } else {
2145 if( _matrule
2146 && (_matrule->_lChild == NULL) && (_matrule->_rChild == NULL) ) {
2147 const Form *form = globals[_matrule->_opType];
2148 OperandForm *oper = form ? form->is_operand() : NULL;
2149 if( oper ) {
2150 return oper->num_edges(globals);
2151 }
2152 }
2153 }
2154 }
2155
2156 return edges;
2157 }
2158
2159
2160 // Check if this operand is usable for cisc-spilling
2161 bool OperandForm::is_cisc_reg(FormDict &globals) const {
2162 const char *ideal = ideal_type(globals);
2163 bool is_cisc_reg = (ideal && (ideal_to_Reg_type(ideal) != none));
2164 return is_cisc_reg;
2165 }
2166
2167 bool OpClassForm::is_cisc_mem(FormDict &globals) const {
2168 Form::InterfaceType my_interface = interface_type(globals);
2169 return (my_interface == memory_interface);
2170 }
2171
2172
2173 // node matches ideal 'Bool'
2174 bool OperandForm::is_ideal_bool() const {
2175 if( _matrule == NULL ) return false;
2176
2177 return _matrule->is_ideal_bool();
2178 }
2179
2180 // Require user's name for an sRegX to be stackSlotX
2181 Form::DataType OperandForm::is_user_name_for_sReg() const {
2182 DataType data_type = none;
2183 if( _ident != NULL ) {
2184 if( strcmp(_ident,"stackSlotI") == 0 ) data_type = Form::idealI;
2185 else if( strcmp(_ident,"stackSlotP") == 0 ) data_type = Form::idealP;
2186 else if( strcmp(_ident,"stackSlotD") == 0 ) data_type = Form::idealD;
2187 else if( strcmp(_ident,"stackSlotF") == 0 ) data_type = Form::idealF;
2188 else if( strcmp(_ident,"stackSlotL") == 0 ) data_type = Form::idealL;
2189 }
2190 assert((data_type == none) || (_matrule == NULL), "No match-rule for stackSlotX");
2191
2192 return data_type;
2193 }
2194
2195
2196 // Return ideal type, if there is a single ideal type for this operand
2197 const char *OperandForm::ideal_type(FormDict &globals, RegisterForm *registers) const {
2198 const char *type = NULL;
2199 if (ideal_only()) type = _ident;
2200 else if( _matrule == NULL ) {
2201 // Check for condition code register
2202 const char *rc_name = constrained_reg_class();
2203 // !!!!!
2204 if (rc_name == NULL) return NULL;
2205 // !!!!! !!!!!
2206 // Check constraints on result's register class
2207 if( registers ) {
2208 RegClass *reg_class = registers->getRegClass(rc_name);
2209 assert( reg_class != NULL, "Register class is not defined");
2210
2211 // Check for ideal type of entries in register class, all are the same type
2212 reg_class->reset();
2213 RegDef *reg_def = reg_class->RegDef_iter();
2214 assert( reg_def != NULL, "No entries in register class");
2215 assert( reg_def->_idealtype != NULL, "Did not define ideal type for register");
2216 // Return substring that names the register's ideal type
2217 type = reg_def->_idealtype + 3;
2218 assert( *(reg_def->_idealtype + 0) == 'O', "Expect Op_ prefix");
2219 assert( *(reg_def->_idealtype + 1) == 'p', "Expect Op_ prefix");
2220 assert( *(reg_def->_idealtype + 2) == '_', "Expect Op_ prefix");
2221 }
2222 }
2223 else if( _matrule->_lChild == NULL && _matrule->_rChild == NULL ) {
2224 // This operand matches a single type, at the top level.
2225 // Check for ideal type
2226 type = _matrule->_opType;
2227 if( strcmp(type,"Bool") == 0 )
2228 return "Bool";
2229 // transitive lookup
2230 const Form *frm = globals[type];
2231 OperandForm *op = frm->is_operand();
2232 type = op->ideal_type(globals, registers);
2233 }
2234 return type;
2235 }
2236
2237
2238 // If there is a single ideal type for this interface field, return it.
2239 const char *OperandForm::interface_ideal_type(FormDict &globals,
2240 const char *field) const {
2241 const char *ideal_type = NULL;
2242 const char *value = NULL;
2243
2244 // Check if "field" is valid for this operand's interface
2245 if ( ! is_interface_field(field, value) ) return ideal_type;
2246
2247 // !!!!! !!!!! !!!!!
2248 // If a valid field has a constant value, identify "ConI" or "ConP" or ...
2249
2250 // Else, lookup type of field's replacement variable
2251
2252 return ideal_type;
2253 }
2254
2255
2256 RegClass* OperandForm::get_RegClass() const {
2257 if (_interface && !_interface->is_RegInterface()) return NULL;
2258 return globalAD->get_registers()->getRegClass(constrained_reg_class());
2259 }
2260
2261
2262 bool OperandForm::is_bound_register() const {
2263 RegClass* reg_class = get_RegClass();
2264 if (reg_class == NULL) {
2265 return false;
2266 }
2267
2268 const char* name = ideal_type(globalAD->globalNames());
2269 if (name == NULL) {
2270 return false;
2271 }
2272
2273 uint size = 0;
2274 if (strcmp(name, "RegFlags") == 0) size = 1;
2275 if (strcmp(name, "RegI") == 0) size = 1;
2276 if (strcmp(name, "RegF") == 0) size = 1;
2277 if (strcmp(name, "RegD") == 0) size = 2;
2278 if (strcmp(name, "RegL") == 0) size = 2;
2279 if (strcmp(name, "RegN") == 0) size = 1;
2280 if (strcmp(name, "RegVectMask") == 0) size = globalAD->get_preproc_def("AARCH64") ? 1 : 2;
2281 if (strcmp(name, "VecX") == 0) size = 4;
2282 if (strcmp(name, "VecY") == 0) size = 8;
2283 if (strcmp(name, "VecZ") == 0) size = 16;
2284 if (strcmp(name, "RegP") == 0) size = globalAD->get_preproc_def("_LP64") ? 2 : 1;
2285 if (size == 0) {
2286 return false;
2287 }
2288 return size == reg_class->size();
2289 }
2290
2291
2292 // Check if this is a valid field for this operand,
2293 // Return 'true' if valid, and set the value to the string the user provided.
2294 bool OperandForm::is_interface_field(const char *field,
2295 const char * &value) const {
2296 return false;
2297 }
2298
2299
2300 // Return register class name if a constraint specifies the register class.
2301 const char *OperandForm::constrained_reg_class() const {
2302 const char *reg_class = NULL;
2303 if ( _constraint ) {
2304 // !!!!!
2305 Constraint *constraint = _constraint;
2306 if ( strcmp(_constraint->_func,"ALLOC_IN_RC") == 0 ) {
2307 reg_class = _constraint->_arg;
2308 }
2309 }
2310
2311 return reg_class;
2312 }
2313
2314
2315 // Return the register class associated with 'leaf'.
2316 const char *OperandForm::in_reg_class(uint leaf, FormDict &globals) {
2317 const char *reg_class = NULL; // "RegMask::Empty";
2318
2319 if((_matrule == NULL) || (_matrule->is_chain_rule(globals))) {
2320 reg_class = constrained_reg_class();
2321 return reg_class;
2322 }
2323 const char *result = NULL;
2324 const char *name = NULL;
2325 const char *type = NULL;
2326 // iterate through all base operands
2327 // until we reach the register that corresponds to "leaf"
2328 // This function is not looking for an ideal type. It needs the first
2329 // level user type associated with the leaf.
2330 for(uint idx = 0;_matrule->base_operand(idx,globals,result,name,type);++idx) {
2331 const Form *form = (_localNames[name] ? _localNames[name] : globals[result]);
2332 OperandForm *oper = form ? form->is_operand() : NULL;
2333 if( oper ) {
2334 reg_class = oper->constrained_reg_class();
2335 if( reg_class ) {
2336 reg_class = reg_class;
2337 } else {
2338 // ShouldNotReachHere();
2339 }
2340 } else {
2341 // ShouldNotReachHere();
2342 }
2343
2344 // Increment our target leaf position if current leaf is not a candidate.
2345 if( reg_class == NULL) ++leaf;
2346 // Exit the loop with the value of reg_class when at the correct index
2347 if( idx == leaf ) break;
2348 // May iterate through all base operands if reg_class for 'leaf' is NULL
2349 }
2350 return reg_class;
2351 }
2352
2353
2354 // Recursive call to construct list of top-level operands.
2355 // Implementation does not modify state of internal structures
2356 void OperandForm::build_components() {
2357 if (_matrule) _matrule->append_components(_localNames, _components);
2358
2359 // Add parameters that "do not appear in match rule".
2360 const char *name;
2361 for (_parameters.reset(); (name = _parameters.iter()) != NULL;) {
2362 OpClassForm *opForm = _localNames[name]->is_opclass();
2363 assert(opForm != NULL, "sanity");
2364
2365 if ( _components.operand_position(name) == -1 ) {
2366 _components.insert(name, opForm->_ident, Component::INVALID, false);
2367 }
2368 }
2369
2370 return;
2371 }
2372
2373 int OperandForm::operand_position(const char *name, int usedef) {
2374 return _components.operand_position(name, usedef, this);
2375 }
2376
2377
2378 // Return zero-based position in component list, only counting constants;
2379 // Return -1 if not in list.
2380 int OperandForm::constant_position(FormDict &globals, const Component *last) {
2381 // Iterate through components and count constants preceding 'constant'
2382 int position = 0;
2383 Component *comp;
2384 _components.reset();
2385 while( (comp = _components.iter()) != NULL && (comp != last) ) {
2386 // Special case for operands that take a single user-defined operand
2387 // Skip the initial definition in the component list.
2388 if( strcmp(comp->_name,this->_ident) == 0 ) continue;
2389
2390 const char *type = comp->_type;
2391 // Lookup operand form for replacement variable's type
2392 const Form *form = globals[type];
2393 assert( form != NULL, "Component's type not found");
2394 OperandForm *oper = form ? form->is_operand() : NULL;
2395 if( oper ) {
2396 if( oper->_matrule->is_base_constant(globals) != Form::none ) {
2397 ++position;
2398 }
2399 }
2400 }
2401
2402 // Check for being passed a component that was not in the list
2403 if( comp != last ) position = -1;
2404
2405 return position;
2406 }
2407 // Provide position of constant by "name"
2408 int OperandForm::constant_position(FormDict &globals, const char *name) {
2409 const Component *comp = _components.search(name);
2410 int idx = constant_position( globals, comp );
2411
2412 return idx;
2413 }
2414
2415
2416 // Return zero-based position in component list, only counting constants;
2417 // Return -1 if not in list.
2418 int OperandForm::register_position(FormDict &globals, const char *reg_name) {
2419 // Iterate through components and count registers preceding 'last'
2420 uint position = 0;
2421 Component *comp;
2422 _components.reset();
2423 while( (comp = _components.iter()) != NULL
2424 && (strcmp(comp->_name,reg_name) != 0) ) {
2425 // Special case for operands that take a single user-defined operand
2426 // Skip the initial definition in the component list.
2427 if( strcmp(comp->_name,this->_ident) == 0 ) continue;
2428
2429 const char *type = comp->_type;
2430 // Lookup operand form for component's type
2431 const Form *form = globals[type];
2432 assert( form != NULL, "Component's type not found");
2433 OperandForm *oper = form ? form->is_operand() : NULL;
2434 if( oper ) {
2435 if( oper->_matrule->is_base_register(globals) ) {
2436 ++position;
2437 }
2438 }
2439 }
2440
2441 return position;
2442 }
2443
2444
2445 const char *OperandForm::reduce_result() const {
2446 return _ident;
2447 }
2448 // Return the name of the operand on the right hand side of the binary match
2449 // Return NULL if there is no right hand side
2450 const char *OperandForm::reduce_right(FormDict &globals) const {
2451 return ( _matrule ? _matrule->reduce_right(globals) : NULL );
2452 }
2453
2454 // Similar for left
2455 const char *OperandForm::reduce_left(FormDict &globals) const {
2456 return ( _matrule ? _matrule->reduce_left(globals) : NULL );
2457 }
2458
2459
2460 // --------------------------- FILE *output_routines
2461 //
2462 // Output code for disp_is_oop, if true.
2463 void OperandForm::disp_is_oop(FILE *fp, FormDict &globals) {
2464 // Check it is a memory interface with a non-user-constant disp field
2465 if ( this->_interface == NULL ) return;
2466 MemInterface *mem_interface = this->_interface->is_MemInterface();
2467 if ( mem_interface == NULL ) return;
2468 const char *disp = mem_interface->_disp;
2469 if ( *disp != '$' ) return;
2470
2471 // Lookup replacement variable in operand's component list
2472 const char *rep_var = disp + 1;
2473 const Component *comp = this->_components.search(rep_var);
2474 assert( comp != NULL, "Replacement variable not found in components");
2475 // Lookup operand form for replacement variable's type
2476 const char *type = comp->_type;
2477 Form *form = (Form*)globals[type];
2478 assert( form != NULL, "Replacement variable's type not found");
2479 OperandForm *op = form->is_operand();
2480 assert( op, "Memory Interface 'disp' can only emit an operand form");
2481 // Check if this is a ConP, which may require relocation
2482 if ( op->is_base_constant(globals) == Form::idealP ) {
2483 // Find the constant's index: _c0, _c1, _c2, ... , _cN
2484 uint idx = op->constant_position( globals, rep_var);
2485 fprintf(fp," virtual relocInfo::relocType disp_reloc() const {");
2486 fprintf(fp, " return _c%d->reloc();", idx);
2487 fprintf(fp, " }\n");
2488 }
2489 }
2490
2491 // Generate code for internal and external format methods
2492 //
2493 // internal access to reg# node->_idx
2494 // access to subsumed constant _c0, _c1,
2495 void OperandForm::int_format(FILE *fp, FormDict &globals, uint index) {
2496 Form::DataType dtype;
2497 if (_matrule && (_matrule->is_base_register(globals) ||
2498 strcmp(ideal_type(globalAD->globalNames()), "RegFlags") == 0)) {
2499 // !!!!! !!!!!
2500 fprintf(fp," { char reg_str[128];\n");
2501 fprintf(fp," ra->dump_register(node,reg_str);\n");
2502 fprintf(fp," st->print(\"%cs\",reg_str);\n",'%');
2503 fprintf(fp," }\n");
2504 } else if (_matrule && (dtype = _matrule->is_base_constant(globals)) != Form::none) {
2505 format_constant( fp, index, dtype );
2506 } else if (ideal_to_sReg_type(_ident) != Form::none) {
2507 // Special format for Stack Slot Register
2508 fprintf(fp," { char reg_str[128];\n");
2509 fprintf(fp," ra->dump_register(node,reg_str);\n");
2510 fprintf(fp," st->print(\"%cs\",reg_str);\n",'%');
2511 fprintf(fp," }\n");
2512 } else {
2513 fprintf(fp," st->print(\"No format defined for %s\n\");\n", _ident);
2514 fflush(fp);
2515 fprintf(stderr,"No format defined for %s\n", _ident);
2516 dump();
2517 assert( false,"Internal error:\n output_internal_operand() attempting to output other than a Register or Constant");
2518 }
2519 }
2520
2521 // Similar to "int_format" but for cases where data is external to operand
2522 // external access to reg# node->in(idx)->_idx,
2523 void OperandForm::ext_format(FILE *fp, FormDict &globals, uint index) {
2524 Form::DataType dtype;
2525 if (_matrule && (_matrule->is_base_register(globals) ||
2526 strcmp(ideal_type(globalAD->globalNames()), "RegFlags") == 0)) {
2527 fprintf(fp," { char reg_str[128];\n");
2528 fprintf(fp," ra->dump_register(node->in(idx");
2529 if ( index != 0 ) fprintf(fp, "+%d",index);
2530 fprintf(fp, "),reg_str);\n");
2531 fprintf(fp," st->print(\"%cs\",reg_str);\n",'%');
2532 fprintf(fp," }\n");
2533 } else if (_matrule && (dtype = _matrule->is_base_constant(globals)) != Form::none) {
2534 format_constant( fp, index, dtype );
2535 } else if (ideal_to_sReg_type(_ident) != Form::none) {
2536 // Special format for Stack Slot Register
2537 fprintf(fp," { char reg_str[128];\n");
2538 fprintf(fp," ra->dump_register(node->in(idx");
2539 if ( index != 0 ) fprintf(fp, "+%d",index);
2540 fprintf(fp, "),reg_str);\n");
2541 fprintf(fp," st->print(\"%cs\",reg_str);\n",'%');
2542 fprintf(fp," }\n");
2543 } else {
2544 fprintf(fp," st->print(\"No format defined for %s\n\");\n", _ident);
2545 assert( false,"Internal error:\n output_external_operand() attempting to output other than a Register or Constant");
2546 }
2547 }
2548
2549 void OperandForm::format_constant(FILE *fp, uint const_index, uint const_type) {
2550 switch(const_type) {
2551 case Form::idealI: fprintf(fp," st->print(\"#%%d\", _c%d);\n", const_index); break;
2552 case Form::idealP: fprintf(fp," if (_c%d) _c%d->dump_on(st);\n", const_index, const_index); break;
2553 case Form::idealNKlass:
2554 case Form::idealN: fprintf(fp," if (_c%d) _c%d->dump_on(st);\n", const_index, const_index); break;
2555 case Form::idealL: fprintf(fp," st->print(\"#\" INT64_FORMAT, (int64_t)_c%d);\n", const_index); break;
2556 case Form::idealF: fprintf(fp," st->print(\"#%%f\", _c%d);\n", const_index); break;
2557 case Form::idealD: fprintf(fp," st->print(\"#%%f\", _c%d);\n", const_index); break;
2558 default:
2559 assert( false, "ShouldNotReachHere()");
2560 }
2561 }
2562
2563 // Return the operand form corresponding to the given index, else NULL.
2564 OperandForm *OperandForm::constant_operand(FormDict &globals,
2565 uint index) {
2566 // !!!!!
2567 // Check behavior on complex operands
2568 uint n_consts = num_consts(globals);
2569 if( n_consts > 0 ) {
2570 uint i = 0;
2571 const char *type;
2572 Component *comp;
2573 _components.reset();
2574 if ((comp = _components.iter()) == NULL) {
2575 assert(n_consts == 1, "Bad component list detected.\n");
2576 // Current operand is THE operand
2577 if ( index == 0 ) {
2578 return this;
2579 }
2580 } // end if NULL
2581 else {
2582 // Skip the first component, it can not be a DEF of a constant
2583 do {
2584 type = comp->base_type(globals);
2585 // Check that "type" is a 'ConI', 'ConP', ...
2586 if ( ideal_to_const_type(type) != Form::none ) {
2587 // When at correct component, get corresponding Operand
2588 if ( index == 0 ) {
2589 return globals[comp->_type]->is_operand();
2590 }
2591 // Decrement number of constants to go
2592 --index;
2593 }
2594 } while((comp = _components.iter()) != NULL);
2595 }
2596 }
2597
2598 // Did not find a constant for this index.
2599 return NULL;
2600 }
2601
2602 // If this operand has a single ideal type, return its type
2603 Form::DataType OperandForm::simple_type(FormDict &globals) const {
2604 const char *type_name = ideal_type(globals);
2605 Form::DataType type = type_name ? ideal_to_const_type( type_name )
2606 : Form::none;
2607 return type;
2608 }
2609
2610 Form::DataType OperandForm::is_base_constant(FormDict &globals) const {
2611 if ( _matrule == NULL ) return Form::none;
2612
2613 return _matrule->is_base_constant(globals);
2614 }
2615
2616 // "true" if this operand is a simple type that is swallowed
2617 bool OperandForm::swallowed(FormDict &globals) const {
2618 Form::DataType type = simple_type(globals);
2619 if( type != Form::none ) {
2620 return true;
2621 }
2622
2623 return false;
2624 }
2625
2626 // Output code to access the value of the index'th constant
2627 void OperandForm::access_constant(FILE *fp, FormDict &globals,
2628 uint const_index) {
2629 OperandForm *oper = constant_operand(globals, const_index);
2630 assert( oper, "Index exceeds number of constants in operand");
2631 Form::DataType dtype = oper->is_base_constant(globals);
2632
2633 switch(dtype) {
2634 case idealI: fprintf(fp,"_c%d", const_index); break;
2635 case idealP: fprintf(fp,"_c%d->get_con()",const_index); break;
2636 case idealL: fprintf(fp,"_c%d", const_index); break;
2637 case idealF: fprintf(fp,"_c%d", const_index); break;
2638 case idealD: fprintf(fp,"_c%d", const_index); break;
2639 default:
2640 assert( false, "ShouldNotReachHere()");
2641 }
2642 }
2643
2644
2645 void OperandForm::dump() {
2646 output(stderr);
2647 }
2648
2649 void OperandForm::output(FILE *fp) {
2650 fprintf(fp,"\nOperand: %s\n", (_ident?_ident:""));
2651 if (_matrule) _matrule->dump();
2652 if (_interface) _interface->dump();
2653 if (_attribs) _attribs->dump();
2654 if (_predicate) _predicate->dump();
2655 if (_constraint) _constraint->dump();
2656 if (_construct) _construct->dump();
2657 if (_format) _format->dump();
2658 }
2659
2660 //------------------------------Constraint-------------------------------------
2661 Constraint::Constraint(const char *func, const char *arg)
2662 : _func(func), _arg(arg) {
2663 }
2664 Constraint::~Constraint() { /* not owner of char* */
2665 }
2666
2667 bool Constraint::stack_slots_only() const {
2668 return strcmp(_func, "ALLOC_IN_RC") == 0
2669 && strcmp(_arg, "stack_slots") == 0;
2670 }
2671
2672 void Constraint::dump() {
2673 output(stderr);
2674 }
2675
2676 void Constraint::output(FILE *fp) { // Write info to output files
2677 assert((_func != NULL && _arg != NULL),"missing constraint function or arg");
2678 fprintf(fp,"Constraint: %s ( %s )\n", _func, _arg);
2679 }
2680
2681 //------------------------------Predicate--------------------------------------
2682 Predicate::Predicate(char *pr)
2683 : _pred(pr) {
2684 }
2685 Predicate::~Predicate() {
2686 }
2687
2688 void Predicate::dump() {
2689 output(stderr);
2690 }
2691
2692 void Predicate::output(FILE *fp) {
2693 fprintf(fp,"Predicate"); // Write to output files
2694 }
2695 //------------------------------Interface--------------------------------------
2696 Interface::Interface(const char *name) : _name(name) {
2697 }
2698 Interface::~Interface() {
2699 }
2700
2701 Form::InterfaceType Interface::interface_type(FormDict &globals) const {
2702 Interface *thsi = (Interface*)this;
2703 if ( thsi->is_RegInterface() ) return Form::register_interface;
2704 if ( thsi->is_MemInterface() ) return Form::memory_interface;
2705 if ( thsi->is_ConstInterface() ) return Form::constant_interface;
2706 if ( thsi->is_CondInterface() ) return Form::conditional_interface;
2707
2708 return Form::no_interface;
2709 }
2710
2711 RegInterface *Interface::is_RegInterface() {
2712 if ( strcmp(_name,"REG_INTER") != 0 )
2713 return NULL;
2714 return (RegInterface*)this;
2715 }
2716 MemInterface *Interface::is_MemInterface() {
2717 if ( strcmp(_name,"MEMORY_INTER") != 0 ) return NULL;
2718 return (MemInterface*)this;
2719 }
2720 ConstInterface *Interface::is_ConstInterface() {
2721 if ( strcmp(_name,"CONST_INTER") != 0 ) return NULL;
2722 return (ConstInterface*)this;
2723 }
2724 CondInterface *Interface::is_CondInterface() {
2725 if ( strcmp(_name,"COND_INTER") != 0 ) return NULL;
2726 return (CondInterface*)this;
2727 }
2728
2729
2730 void Interface::dump() {
2731 output(stderr);
2732 }
2733
2734 // Write info to output files
2735 void Interface::output(FILE *fp) {
2736 fprintf(fp,"Interface: %s\n", (_name ? _name : "") );
2737 }
2738
2739 //------------------------------RegInterface-----------------------------------
2740 RegInterface::RegInterface() : Interface("REG_INTER") {
2741 }
2742 RegInterface::~RegInterface() {
2743 }
2744
2745 void RegInterface::dump() {
2746 output(stderr);
2747 }
2748
2749 // Write info to output files
2750 void RegInterface::output(FILE *fp) {
2751 Interface::output(fp);
2752 }
2753
2754 //------------------------------ConstInterface---------------------------------
2755 ConstInterface::ConstInterface() : Interface("CONST_INTER") {
2756 }
2757 ConstInterface::~ConstInterface() {
2758 }
2759
2760 void ConstInterface::dump() {
2761 output(stderr);
2762 }
2763
2764 // Write info to output files
2765 void ConstInterface::output(FILE *fp) {
2766 Interface::output(fp);
2767 }
2768
2769 //------------------------------MemInterface-----------------------------------
2770 MemInterface::MemInterface(char *base, char *index, char *scale, char *disp)
2771 : Interface("MEMORY_INTER"), _base(base), _index(index), _scale(scale), _disp(disp) {
2772 }
2773 MemInterface::~MemInterface() {
2774 // not owner of any character arrays
2775 }
2776
2777 void MemInterface::dump() {
2778 output(stderr);
2779 }
2780
2781 // Write info to output files
2782 void MemInterface::output(FILE *fp) {
2783 Interface::output(fp);
2784 if ( _base != NULL ) fprintf(fp," base == %s\n", _base);
2785 if ( _index != NULL ) fprintf(fp," index == %s\n", _index);
2786 if ( _scale != NULL ) fprintf(fp," scale == %s\n", _scale);
2787 if ( _disp != NULL ) fprintf(fp," disp == %s\n", _disp);
2788 // fprintf(fp,"\n");
2789 }
2790
2791 //------------------------------CondInterface----------------------------------
2792 CondInterface::CondInterface(const char* equal, const char* equal_format,
2793 const char* not_equal, const char* not_equal_format,
2794 const char* less, const char* less_format,
2795 const char* greater_equal, const char* greater_equal_format,
2796 const char* less_equal, const char* less_equal_format,
2797 const char* greater, const char* greater_format,
2798 const char* overflow, const char* overflow_format,
2799 const char* no_overflow, const char* no_overflow_format)
2800 : Interface("COND_INTER"),
2801 _equal(equal), _equal_format(equal_format),
2802 _not_equal(not_equal), _not_equal_format(not_equal_format),
2803 _less(less), _less_format(less_format),
2804 _greater_equal(greater_equal), _greater_equal_format(greater_equal_format),
2805 _less_equal(less_equal), _less_equal_format(less_equal_format),
2806 _greater(greater), _greater_format(greater_format),
2807 _overflow(overflow), _overflow_format(overflow_format),
2808 _no_overflow(no_overflow), _no_overflow_format(no_overflow_format) {
2809 }
2810 CondInterface::~CondInterface() {
2811 // not owner of any character arrays
2812 }
2813
2814 void CondInterface::dump() {
2815 output(stderr);
2816 }
2817
2818 // Write info to output files
2819 void CondInterface::output(FILE *fp) {
2820 Interface::output(fp);
2821 if ( _equal != NULL ) fprintf(fp," equal == %s\n", _equal);
2822 if ( _not_equal != NULL ) fprintf(fp," not_equal == %s\n", _not_equal);
2823 if ( _less != NULL ) fprintf(fp," less == %s\n", _less);
2824 if ( _greater_equal != NULL ) fprintf(fp," greater_equal == %s\n", _greater_equal);
2825 if ( _less_equal != NULL ) fprintf(fp," less_equal == %s\n", _less_equal);
2826 if ( _greater != NULL ) fprintf(fp," greater == %s\n", _greater);
2827 if ( _overflow != NULL ) fprintf(fp," overflow == %s\n", _overflow);
2828 if ( _no_overflow != NULL ) fprintf(fp," no_overflow == %s\n", _no_overflow);
2829 // fprintf(fp,"\n");
2830 }
2831
2832 //------------------------------ConstructRule----------------------------------
2833 ConstructRule::ConstructRule(char *cnstr)
2834 : _construct(cnstr) {
2835 }
2836 ConstructRule::~ConstructRule() {
2837 }
2838
2839 void ConstructRule::dump() {
2840 output(stderr);
2841 }
2842
2843 void ConstructRule::output(FILE *fp) {
2844 fprintf(fp,"\nConstruct Rule\n"); // Write to output files
2845 }
2846
2847
2848 //==============================Shared Forms===================================
2849 //------------------------------AttributeForm----------------------------------
2850 int AttributeForm::_insId = 0; // start counter at 0
2851 int AttributeForm::_opId = 0; // start counter at 0
2852 const char* AttributeForm::_ins_cost = "ins_cost"; // required name
2853 const char* AttributeForm::_op_cost = "op_cost"; // required name
2854
2855 AttributeForm::AttributeForm(char *attr, int type, char *attrdef)
2856 : Form(Form::ATTR), _attrname(attr), _atype(type), _attrdef(attrdef) {
2857 if (type==OP_ATTR) {
2858 id = ++_opId;
2859 }
2860 else if (type==INS_ATTR) {
2861 id = ++_insId;
2862 }
2863 else assert( false,"");
2864 }
2865 AttributeForm::~AttributeForm() {
2866 }
2867
2868 // Dynamic type check
2869 AttributeForm *AttributeForm::is_attribute() const {
2870 return (AttributeForm*)this;
2871 }
2872
2873
2874 // inlined // int AttributeForm::type() { return id;}
2875
2876 void AttributeForm::dump() {
2877 output(stderr);
2878 }
2879
2880 void AttributeForm::output(FILE *fp) {
2881 if( _attrname && _attrdef ) {
2882 fprintf(fp,"\n// AttributeForm \nstatic const int %s = %s;\n",
2883 _attrname, _attrdef);
2884 }
2885 else {
2886 fprintf(fp,"\n// AttributeForm missing name %s or definition %s\n",
2887 (_attrname?_attrname:""), (_attrdef?_attrdef:"") );
2888 }
2889 }
2890
2891 //------------------------------Component--------------------------------------
2892 Component::Component(const char *name, const char *type, int usedef)
2893 : _name(name), _type(type), _usedef(usedef) {
2894 _ftype = Form::COMP;
2895 }
2896 Component::~Component() {
2897 }
2898
2899 // True if this component is equal to the parameter.
2900 bool Component::is(int use_def_kill_enum) const {
2901 return (_usedef == use_def_kill_enum ? true : false);
2902 }
2903 // True if this component is used/def'd/kill'd as the parameter suggests.
2904 bool Component::isa(int use_def_kill_enum) const {
2905 return (_usedef & use_def_kill_enum) == use_def_kill_enum;
2906 }
2907
2908 // Extend this component with additional use/def/kill behavior
2909 int Component::promote_use_def_info(int new_use_def) {
2910 _usedef |= new_use_def;
2911
2912 return _usedef;
2913 }
2914
2915 // Check the base type of this component, if it has one
2916 const char *Component::base_type(FormDict &globals) {
2917 const Form *frm = globals[_type];
2918 if (frm == NULL) return NULL;
2919 OperandForm *op = frm->is_operand();
2920 if (op == NULL) return NULL;
2921 if (op->ideal_only()) return op->_ident;
2922 return (char *)op->ideal_type(globals);
2923 }
2924
2925 void Component::dump() {
2926 output(stderr);
2927 }
2928
2929 void Component::output(FILE *fp) {
2930 fprintf(fp,"Component:"); // Write to output files
2931 fprintf(fp, " name = %s", _name);
2932 fprintf(fp, ", type = %s", _type);
2933 assert(_usedef != 0, "unknown effect");
2934 fprintf(fp, ", use/def = %s\n", getUsedefName());
2935 }
2936
2937
2938 //------------------------------ComponentList---------------------------------
2939 ComponentList::ComponentList() : NameList(), _matchcnt(0) {
2940 }
2941 ComponentList::~ComponentList() {
2942 // // This list may not own its elements if copied via assignment
2943 // Component *component;
2944 // for (reset(); (component = iter()) != NULL;) {
2945 // delete component;
2946 // }
2947 }
2948
2949 void ComponentList::insert(Component *component, bool mflag) {
2950 NameList::addName((char *)component);
2951 if(mflag) _matchcnt++;
2952 }
2953 void ComponentList::insert(const char *name, const char *opType, int usedef,
2954 bool mflag) {
2955 Component * component = new Component(name, opType, usedef);
2956 insert(component, mflag);
2957 }
2958 Component *ComponentList::current() { return (Component*)NameList::current(); }
2959 Component *ComponentList::iter() { return (Component*)NameList::iter(); }
2960 Component *ComponentList::match_iter() {
2961 if(_iter < _matchcnt) return (Component*)NameList::iter();
2962 return NULL;
2963 }
2964 Component *ComponentList::post_match_iter() {
2965 Component *comp = iter();
2966 // At end of list?
2967 if ( comp == NULL ) {
2968 return comp;
2969 }
2970 // In post-match components?
2971 if (_iter > match_count()-1) {
2972 return comp;
2973 }
2974
2975 return post_match_iter();
2976 }
2977
2978 void ComponentList::reset() { NameList::reset(); }
2979 int ComponentList::count() { return NameList::count(); }
2980
2981 Component *ComponentList::operator[](int position) {
2982 // Shortcut complete iteration if there are not enough entries
2983 if (position >= count()) return NULL;
2984
2985 int index = 0;
2986 Component *component = NULL;
2987 for (reset(); (component = iter()) != NULL;) {
2988 if (index == position) {
2989 return component;
2990 }
2991 ++index;
2992 }
2993
2994 return NULL;
2995 }
2996
2997 const Component *ComponentList::search(const char *name) {
2998 PreserveIter pi(this);
2999 reset();
3000 for( Component *comp = NULL; ((comp = iter()) != NULL); ) {
3001 if( strcmp(comp->_name,name) == 0 ) return comp;
3002 }
3003
3004 return NULL;
3005 }
3006
3007 // Return number of USEs + number of DEFs
3008 // When there are no components, or the first component is a USE,
3009 // then we add '1' to hold a space for the 'result' operand.
3010 int ComponentList::num_operands() {
3011 PreserveIter pi(this);
3012 uint count = 1; // result operand
3013 uint position = 0;
3014
3015 Component *component = NULL;
3016 for( reset(); (component = iter()) != NULL; ++position ) {
3017 if( component->isa(Component::USE) ||
3018 ( position == 0 && (! component->isa(Component::DEF))) ) {
3019 ++count;
3020 }
3021 }
3022
3023 return count;
3024 }
3025
3026 // Return zero-based position of operand 'name' in list; -1 if not in list.
3027 // if parameter 'usedef' is ::USE, it will match USE, USE_DEF, ...
3028 int ComponentList::operand_position(const char *name, int usedef, Form *fm) {
3029 PreserveIter pi(this);
3030 int position = 0;
3031 int num_opnds = num_operands();
3032 Component *component;
3033 Component* preceding_non_use = NULL;
3034 Component* first_def = NULL;
3035 for (reset(); (component = iter()) != NULL; ++position) {
3036 // When the first component is not a DEF,
3037 // leave space for the result operand!
3038 if ( position==0 && (! component->isa(Component::DEF)) ) {
3039 ++position;
3040 ++num_opnds;
3041 }
3042 if (strcmp(name, component->_name)==0 && (component->isa(usedef))) {
3043 // When the first entry in the component list is a DEF and a USE
3044 // Treat them as being separate, a DEF first, then a USE
3045 if( position==0
3046 && usedef==Component::USE && component->isa(Component::DEF) ) {
3047 assert(position+1 < num_opnds, "advertised index in bounds");
3048 return position+1;
3049 } else {
3050 if( preceding_non_use && strcmp(component->_name, preceding_non_use->_name) ) {
3051 fprintf(stderr, "the name '%s(%s)' should not precede the name '%s(%s)'",
3052 preceding_non_use->_name, preceding_non_use->getUsedefName(),
3053 name, component->getUsedefName());
3054 if (fm && fm->is_instruction()) fprintf(stderr, "in form '%s'", fm->is_instruction()->_ident);
3055 if (fm && fm->is_operand()) fprintf(stderr, "in form '%s'", fm->is_operand()->_ident);
3056 fprintf(stderr, "\n");
3057 }
3058 if( position >= num_opnds ) {
3059 fprintf(stderr, "the name '%s' is too late in its name list", name);
3060 if (fm && fm->is_instruction()) fprintf(stderr, "in form '%s'", fm->is_instruction()->_ident);
3061 if (fm && fm->is_operand()) fprintf(stderr, "in form '%s'", fm->is_operand()->_ident);
3062 fprintf(stderr, "\n");
3063 }
3064 assert(position < num_opnds, "advertised index in bounds");
3065 return position;
3066 }
3067 }
3068 if( component->isa(Component::DEF)
3069 && component->isa(Component::USE) ) {
3070 ++position;
3071 if( position != 1 ) --position; // only use two slots for the 1st USE_DEF
3072 }
3073 if( component->isa(Component::DEF) && !first_def ) {
3074 first_def = component;
3075 }
3076 if( !component->isa(Component::USE) && component != first_def ) {
3077 preceding_non_use = component;
3078 } else if( preceding_non_use && !strcmp(component->_name, preceding_non_use->_name) ) {
3079 preceding_non_use = NULL;
3080 }
3081 }
3082 return Not_in_list;
3083 }
3084
3085 // Find position for this name, regardless of use/def information
3086 int ComponentList::operand_position(const char *name) {
3087 PreserveIter pi(this);
3088 int position = 0;
3089 Component *component;
3090 for (reset(); (component = iter()) != NULL; ++position) {
3091 // When the first component is not a DEF,
3092 // leave space for the result operand!
3093 if ( position==0 && (! component->isa(Component::DEF)) ) {
3094 ++position;
3095 }
3096 if (strcmp(name, component->_name)==0) {
3097 return position;
3098 }
3099 if( component->isa(Component::DEF)
3100 && component->isa(Component::USE) ) {
3101 ++position;
3102 if( position != 1 ) --position; // only use two slots for the 1st USE_DEF
3103 }
3104 }
3105 return Not_in_list;
3106 }
3107
3108 int ComponentList::operand_position_format(const char *name, Form *fm) {
3109 PreserveIter pi(this);
3110 int first_position = operand_position(name);
3111 int use_position = operand_position(name, Component::USE, fm);
3112
3113 return ((first_position < use_position) ? use_position : first_position);
3114 }
3115
3116 int ComponentList::label_position() {
3117 PreserveIter pi(this);
3118 int position = 0;
3119 reset();
3120 for( Component *comp; (comp = iter()) != NULL; ++position) {
3121 // When the first component is not a DEF,
3122 // leave space for the result operand!
3123 if ( position==0 && (! comp->isa(Component::DEF)) ) {
3124 ++position;
3125 }
3126 if (strcmp(comp->_type, "label")==0) {
3127 return position;
3128 }
3129 if( comp->isa(Component::DEF)
3130 && comp->isa(Component::USE) ) {
3131 ++position;
3132 if( position != 1 ) --position; // only use two slots for the 1st USE_DEF
3133 }
3134 }
3135
3136 return -1;
3137 }
3138
3139 int ComponentList::method_position() {
3140 PreserveIter pi(this);
3141 int position = 0;
3142 reset();
3143 for( Component *comp; (comp = iter()) != NULL; ++position) {
3144 // When the first component is not a DEF,
3145 // leave space for the result operand!
3146 if ( position==0 && (! comp->isa(Component::DEF)) ) {
3147 ++position;
3148 }
3149 if (strcmp(comp->_type, "method")==0) {
3150 return position;
3151 }
3152 if( comp->isa(Component::DEF)
3153 && comp->isa(Component::USE) ) {
3154 ++position;
3155 if( position != 1 ) --position; // only use two slots for the 1st USE_DEF
3156 }
3157 }
3158
3159 return -1;
3160 }
3161
3162 void ComponentList::dump() { output(stderr); }
3163
3164 void ComponentList::output(FILE *fp) {
3165 PreserveIter pi(this);
3166 fprintf(fp, "\n");
3167 Component *component;
3168 for (reset(); (component = iter()) != NULL;) {
3169 component->output(fp);
3170 }
3171 fprintf(fp, "\n");
3172 }
3173
3174 //------------------------------MatchNode--------------------------------------
3175 MatchNode::MatchNode(ArchDesc &ad, const char *result, const char *mexpr,
3176 const char *opType, MatchNode *lChild, MatchNode *rChild)
3177 : _AD(ad), _result(result), _name(mexpr), _opType(opType),
3178 _lChild(lChild), _rChild(rChild), _internalop(0), _numleaves(0),
3179 _commutative_id(0) {
3180 _numleaves = (lChild ? lChild->_numleaves : 0)
3181 + (rChild ? rChild->_numleaves : 0);
3182 }
3183
3184 MatchNode::MatchNode(ArchDesc &ad, MatchNode& mnode)
3185 : _AD(ad), _result(mnode._result), _name(mnode._name),
3186 _opType(mnode._opType), _lChild(mnode._lChild), _rChild(mnode._rChild),
3187 _internalop(0), _numleaves(mnode._numleaves),
3188 _commutative_id(mnode._commutative_id) {
3189 }
3190
3191 MatchNode::MatchNode(ArchDesc &ad, MatchNode& mnode, int clone)
3192 : _AD(ad), _result(mnode._result), _name(mnode._name),
3193 _opType(mnode._opType),
3194 _internalop(0), _numleaves(mnode._numleaves),
3195 _commutative_id(mnode._commutative_id) {
3196 if (mnode._lChild) {
3197 _lChild = new MatchNode(ad, *mnode._lChild, clone);
3198 } else {
3199 _lChild = NULL;
3200 }
3201 if (mnode._rChild) {
3202 _rChild = new MatchNode(ad, *mnode._rChild, clone);
3203 } else {
3204 _rChild = NULL;
3205 }
3206 }
3207
3208 MatchNode::~MatchNode() {
3209 // // This node may not own its children if copied via assignment
3210 // if( _lChild ) delete _lChild;
3211 // if( _rChild ) delete _rChild;
3212 }
3213
3214 bool MatchNode::find_type(const char *type, int &position) const {
3215 if ( (_lChild != NULL) && (_lChild->find_type(type, position)) ) return true;
3216 if ( (_rChild != NULL) && (_rChild->find_type(type, position)) ) return true;
3217
3218 if (strcmp(type,_opType)==0) {
3219 return true;
3220 } else {
3221 ++position;
3222 }
3223 return false;
3224 }
3225
3226 // Recursive call collecting info on top-level operands, not transitive.
3227 // Implementation does not modify state of internal structures.
3228 void MatchNode::append_components(FormDict& locals, ComponentList& components,
3229 bool def_flag) const {
3230 int usedef = def_flag ? Component::DEF : Component::USE;
3231 FormDict &globals = _AD.globalNames();
3232
3233 assert (_name != NULL, "MatchNode::build_components encountered empty node\n");
3234 // Base case
3235 if (_lChild==NULL && _rChild==NULL) {
3236 // If _opType is not an operation, do not build a component for it #####
3237 const Form *f = globals[_opType];
3238 if( f != NULL ) {
3239 // Add non-ideals that are operands, operand-classes,
3240 if( ! f->ideal_only()
3241 && (f->is_opclass() || f->is_operand()) ) {
3242 components.insert(_name, _opType, usedef, true);
3243 }
3244 }
3245 return;
3246 }
3247 // Promote results of "Set" to DEF
3248 bool tmpdef_flag = (!strcmp(_opType, "Set")) ? true : false;
3249 if (_lChild) _lChild->append_components(locals, components, tmpdef_flag);
3250 tmpdef_flag = false; // only applies to component immediately following 'Set'
3251 if (_rChild) _rChild->append_components(locals, components, tmpdef_flag);
3252 }
3253
3254 // Find the n'th base-operand in the match node,
3255 // recursively investigates match rules of user-defined operands.
3256 //
3257 // Implementation does not modify state of internal structures since they
3258 // can be shared.
3259 bool MatchNode::base_operand(uint &position, FormDict &globals,
3260 const char * &result, const char * &name,
3261 const char * &opType) const {
3262 assert (_name != NULL, "MatchNode::base_operand encountered empty node\n");
3263 // Base case
3264 if (_lChild==NULL && _rChild==NULL) {
3265 // Check for special case: "Universe", "label"
3266 if (strcmp(_opType,"Universe") == 0 || strcmp(_opType,"label")==0 ) {
3267 if (position == 0) {
3268 result = _result;
3269 name = _name;
3270 opType = _opType;
3271 return 1;
3272 } else {
3273 -- position;
3274 return 0;
3275 }
3276 }
3277
3278 const Form *form = globals[_opType];
3279 MatchNode *matchNode = NULL;
3280 // Check for user-defined type
3281 if (form) {
3282 // User operand or instruction?
3283 OperandForm *opForm = form->is_operand();
3284 InstructForm *inForm = form->is_instruction();
3285 if ( opForm ) {
3286 matchNode = (MatchNode*)opForm->_matrule;
3287 } else if ( inForm ) {
3288 matchNode = (MatchNode*)inForm->_matrule;
3289 }
3290 }
3291 // if this is user-defined, recurse on match rule
3292 // User-defined operand and instruction forms have a match-rule.
3293 if (matchNode) {
3294 return (matchNode->base_operand(position,globals,result,name,opType));
3295 } else {
3296 // Either not a form, or a system-defined form (no match rule).
3297 if (position==0) {
3298 result = _result;
3299 name = _name;
3300 opType = _opType;
3301 return 1;
3302 } else {
3303 --position;
3304 return 0;
3305 }
3306 }
3307
3308 } else {
3309 // Examine the left child and right child as well
3310 if (_lChild) {
3311 if (_lChild->base_operand(position, globals, result, name, opType))
3312 return 1;
3313 }
3314
3315 if (_rChild) {
3316 if (_rChild->base_operand(position, globals, result, name, opType))
3317 return 1;
3318 }
3319 }
3320
3321 return 0;
3322 }
3323
3324 // Recursive call on all operands' match rules in my match rule.
3325 uint MatchNode::num_consts(FormDict &globals) const {
3326 uint index = 0;
3327 uint num_consts = 0;
3328 const char *result;
3329 const char *name;
3330 const char *opType;
3331
3332 for (uint position = index;
3333 base_operand(position,globals,result,name,opType); position = index) {
3334 ++index;
3335 if( ideal_to_const_type(opType) ) num_consts++;
3336 }
3337
3338 return num_consts;
3339 }
3340
3341 // Recursive call on all operands' match rules in my match rule.
3342 // Constants in match rule subtree with specified type
3343 uint MatchNode::num_consts(FormDict &globals, Form::DataType type) const {
3344 uint index = 0;
3345 uint num_consts = 0;
3346 const char *result;
3347 const char *name;
3348 const char *opType;
3349
3350 for (uint position = index;
3351 base_operand(position,globals,result,name,opType); position = index) {
3352 ++index;
3353 if( ideal_to_const_type(opType) == type ) num_consts++;
3354 }
3355
3356 return num_consts;
3357 }
3358
3359 // Recursive call on all operands' match rules in my match rule.
3360 uint MatchNode::num_const_ptrs(FormDict &globals) const {
3361 return num_consts( globals, Form::idealP );
3362 }
3363
3364 bool MatchNode::sets_result() const {
3365 return ( (strcmp(_name,"Set") == 0) ? true : false );
3366 }
3367
3368 const char *MatchNode::reduce_right(FormDict &globals) const {
3369 // If there is no right reduction, return NULL.
3370 const char *rightStr = NULL;
3371
3372 // If we are a "Set", start from the right child.
3373 const MatchNode *const mnode = sets_result() ?
3374 (const MatchNode *)this->_rChild :
3375 (const MatchNode *)this;
3376
3377 // If our right child exists, it is the right reduction
3378 if ( mnode->_rChild ) {
3379 rightStr = mnode->_rChild->_internalop ? mnode->_rChild->_internalop
3380 : mnode->_rChild->_opType;
3381 }
3382 // Else, May be simple chain rule: (Set dst operand_form), rightStr=NULL;
3383 return rightStr;
3384 }
3385
3386 const char *MatchNode::reduce_left(FormDict &globals) const {
3387 // If there is no left reduction, return NULL.
3388 const char *leftStr = NULL;
3389
3390 // If we are a "Set", start from the right child.
3391 const MatchNode *const mnode = sets_result() ?
3392 (const MatchNode *)this->_rChild :
3393 (const MatchNode *)this;
3394
3395 // If our left child exists, it is the left reduction
3396 if ( mnode->_lChild ) {
3397 leftStr = mnode->_lChild->_internalop ? mnode->_lChild->_internalop
3398 : mnode->_lChild->_opType;
3399 } else {
3400 // May be simple chain rule: (Set dst operand_form_source)
3401 if ( sets_result() ) {
3402 OperandForm *oper = globals[mnode->_opType]->is_operand();
3403 if( oper ) {
3404 leftStr = mnode->_opType;
3405 }
3406 }
3407 }
3408 return leftStr;
3409 }
3410
3411 //------------------------------count_instr_names------------------------------
3412 // Count occurrences of operands names in the leaves of the instruction
3413 // match rule.
3414 void MatchNode::count_instr_names( Dict &names ) {
3415 if( _lChild ) _lChild->count_instr_names(names);
3416 if( _rChild ) _rChild->count_instr_names(names);
3417 if( !_lChild && !_rChild ) {
3418 uintptr_t cnt = (uintptr_t)names[_name];
3419 cnt++; // One more name found
3420 names.Insert(_name,(void*)cnt);
3421 }
3422 }
3423
3424 //------------------------------build_instr_pred-------------------------------
3425 // Build a path to 'name' in buf. Actually only build if cnt is zero, so we
3426 // can skip some leading instances of 'name'.
3427 int MatchNode::build_instr_pred( char *buf, const char *name, int cnt, int path_bitmask, int level) {
3428 if( _lChild ) {
3429 cnt = _lChild->build_instr_pred(buf, name, cnt, path_bitmask, level+1);
3430 if( cnt < 0 ) {
3431 return cnt; // Found it, all done
3432 }
3433 }
3434 if( _rChild ) {
3435 path_bitmask |= 1 << level;
3436 cnt = _rChild->build_instr_pred( buf, name, cnt, path_bitmask, level+1);
3437 if( cnt < 0 ) {
3438 return cnt; // Found it, all done
3439 }
3440 }
3441 if( !_lChild && !_rChild ) { // Found a leaf
3442 // Wrong name? Give up...
3443 if( strcmp(name,_name) ) return cnt;
3444 if( !cnt ) {
3445 for(int i = 0; i < level; i++) {
3446 int kid = path_bitmask & (1 << i);
3447 if (0 == kid) {
3448 strcpy( buf, "_kids[0]->" );
3449 } else {
3450 strcpy( buf, "_kids[1]->" );
3451 }
3452 buf += 10;
3453 }
3454 strcpy( buf, "_leaf" );
3455 }
3456 return cnt-1;
3457 }
3458 return cnt;
3459 }
3460
3461
3462 //------------------------------build_internalop-------------------------------
3463 // Build string representation of subtree
3464 void MatchNode::build_internalop( ) {
3465 char *iop, *subtree;
3466 const char *lstr, *rstr;
3467 // Build string representation of subtree
3468 // Operation lchildType rchildType
3469 int len = (int)strlen(_opType) + 4;
3470 lstr = (_lChild) ? ((_lChild->_internalop) ?
3471 _lChild->_internalop : _lChild->_opType) : "";
3472 rstr = (_rChild) ? ((_rChild->_internalop) ?
3473 _rChild->_internalop : _rChild->_opType) : "";
3474 len += (int)strlen(lstr) + (int)strlen(rstr);
3475 subtree = (char *)AdlAllocateHeap(len);
3476 sprintf(subtree,"_%s_%s_%s", _opType, lstr, rstr);
3477 // Hash the subtree string in _internalOps; if a name exists, use it
3478 iop = (char *)_AD._internalOps[subtree];
3479 // Else create a unique name, and add it to the hash table
3480 if (iop == NULL) {
3481 iop = subtree;
3482 _AD._internalOps.Insert(subtree, iop);
3483 _AD._internalOpNames.addName(iop);
3484 _AD._internalMatch.Insert(iop, this);
3485 }
3486 // Add the internal operand name to the MatchNode
3487 _internalop = iop;
3488 _result = iop;
3489 }
3490
3491
3492 void MatchNode::dump() {
3493 output(stderr);
3494 }
3495
3496 void MatchNode::output(FILE *fp) {
3497 if (_lChild==0 && _rChild==0) {
3498 fprintf(fp," %s",_name); // operand
3499 }
3500 else {
3501 fprintf(fp," (%s ",_name); // " (opcodeName "
3502 if(_lChild) _lChild->output(fp); // left operand
3503 if(_rChild) _rChild->output(fp); // right operand
3504 fprintf(fp,")"); // ")"
3505 }
3506 }
3507
3508 int MatchNode::needs_ideal_memory_edge(FormDict &globals) const {
3509 static const char *needs_ideal_memory_list[] = {
3510 "StoreI","StoreL","StoreP","StoreN","StoreNKlass","StoreD","StoreF" ,
3511 "StoreB","StoreC","Store" ,"StoreFP",
3512 "LoadI", "LoadL", "LoadP" ,"LoadN", "LoadD" ,"LoadF" ,
3513 "LoadB" , "LoadUB", "LoadUS" ,"LoadS" ,"Load" ,
3514 "StoreVector", "LoadVector", "LoadVectorMasked", "StoreVectorMasked",
3515 "LoadVectorGather", "StoreVectorScatter", "LoadVectorGatherMasked", "StoreVectorScatterMasked",
3516 "LoadRange", "LoadKlass", "LoadNKlass", "LoadL_unaligned", "LoadD_unaligned",
3517 "CompareAndSwapB", "CompareAndSwapS", "CompareAndSwapI", "CompareAndSwapL", "CompareAndSwapP", "CompareAndSwapN",
3518 "WeakCompareAndSwapB", "WeakCompareAndSwapS", "WeakCompareAndSwapI", "WeakCompareAndSwapL", "WeakCompareAndSwapP", "WeakCompareAndSwapN",
3519 "CompareAndExchangeB", "CompareAndExchangeS", "CompareAndExchangeI", "CompareAndExchangeL", "CompareAndExchangeP", "CompareAndExchangeN",
3520 #if INCLUDE_SHENANDOAHGC
3521 "ShenandoahCompareAndSwapN", "ShenandoahCompareAndSwapP", "ShenandoahWeakCompareAndSwapP", "ShenandoahWeakCompareAndSwapN", "ShenandoahCompareAndExchangeP", "ShenandoahCompareAndExchangeN",
3522 #endif
3523 "StoreCM",
3524 "GetAndSetB", "GetAndSetS", "GetAndAddI", "GetAndSetI", "GetAndSetP",
3525 "GetAndAddB", "GetAndAddS", "GetAndAddL", "GetAndSetL", "GetAndSetN",
3526 "ClearArray"
3527 };
3528 int cnt = sizeof(needs_ideal_memory_list)/sizeof(char*);
3529 if( strcmp(_opType,"PrefetchAllocation")==0 )
3530 return 1;
3531 if( strcmp(_opType,"CacheWB")==0 )
3532 return 1;
3533 if( strcmp(_opType,"CacheWBPreSync")==0 )
3534 return 1;
3535 if( strcmp(_opType,"CacheWBPostSync")==0 )
3536 return 1;
3537 if( _lChild ) {
3538 const char *opType = _lChild->_opType;
3539 for( int i=0; i<cnt; i++ )
3540 if( strcmp(opType,needs_ideal_memory_list[i]) == 0 )
3541 return 1;
3542 if( _lChild->needs_ideal_memory_edge(globals) )
3543 return 1;
3544 }
3545 if( _rChild ) {
3546 const char *opType = _rChild->_opType;
3547 for( int i=0; i<cnt; i++ )
3548 if( strcmp(opType,needs_ideal_memory_list[i]) == 0 )
3549 return 1;
3550 if( _rChild->needs_ideal_memory_edge(globals) )
3551 return 1;
3552 }
3553
3554 return 0;
3555 }
3556
3557 // TRUE if defines a derived oop, and so needs a base oop edge present
3558 // post-matching.
3559 int MatchNode::needs_base_oop_edge() const {
3560 if( !strcmp(_opType,"AddP") ) return 1;
3561 if( strcmp(_opType,"Set") ) return 0;
3562 return !strcmp(_rChild->_opType,"AddP");
3563 }
3564
3565 int InstructForm::needs_base_oop_edge(FormDict &globals) const {
3566 if( is_simple_chain_rule(globals) ) {
3567 const char *src = _matrule->_rChild->_opType;
3568 OperandForm *src_op = globals[src]->is_operand();
3569 assert( src_op, "Not operand class of chain rule" );
3570 return src_op->_matrule ? src_op->_matrule->needs_base_oop_edge() : 0;
3571 } // Else check instruction
3572
3573 return _matrule ? _matrule->needs_base_oop_edge() : 0;
3574 }
3575
3576
3577 //-------------------------cisc spilling methods-------------------------------
3578 // helper routines and methods for detecting cisc-spilling instructions
3579 //-------------------------cisc_spill_merge------------------------------------
3580 int MatchNode::cisc_spill_merge(int left_spillable, int right_spillable) {
3581 int cisc_spillable = Maybe_cisc_spillable;
3582
3583 // Combine results of left and right checks
3584 if( (left_spillable == Maybe_cisc_spillable) && (right_spillable == Maybe_cisc_spillable) ) {
3585 // neither side is spillable, nor prevents cisc spilling
3586 cisc_spillable = Maybe_cisc_spillable;
3587 }
3588 else if( (left_spillable == Maybe_cisc_spillable) && (right_spillable > Maybe_cisc_spillable) ) {
3589 // right side is spillable
3590 cisc_spillable = right_spillable;
3591 }
3592 else if( (right_spillable == Maybe_cisc_spillable) && (left_spillable > Maybe_cisc_spillable) ) {
3593 // left side is spillable
3594 cisc_spillable = left_spillable;
3595 }
3596 else if( (left_spillable == Not_cisc_spillable) || (right_spillable == Not_cisc_spillable) ) {
3597 // left or right prevents cisc spilling this instruction
3598 cisc_spillable = Not_cisc_spillable;
3599 }
3600 else {
3601 // Only allow one to spill
3602 cisc_spillable = Not_cisc_spillable;
3603 }
3604
3605 return cisc_spillable;
3606 }
3607
3608 //-------------------------root_ops_match--------------------------------------
3609 bool static root_ops_match(FormDict &globals, const char *op1, const char *op2) {
3610 // Base Case: check that the current operands/operations match
3611 assert( op1, "Must have op's name");
3612 assert( op2, "Must have op's name");
3613 const Form *form1 = globals[op1];
3614 const Form *form2 = globals[op2];
3615
3616 return (form1 == form2);
3617 }
3618
3619 //-------------------------cisc_spill_match_node-------------------------------
3620 // Recursively check two MatchRules for legal conversion via cisc-spilling
3621 int MatchNode::cisc_spill_match(FormDict& globals, RegisterForm* registers, MatchNode* mRule2, const char* &operand, const char* ®_type) {
3622 int cisc_spillable = Maybe_cisc_spillable;
3623 int left_spillable = Maybe_cisc_spillable;
3624 int right_spillable = Maybe_cisc_spillable;
3625
3626 // Check that each has same number of operands at this level
3627 if( (_lChild && !(mRule2->_lChild)) || (_rChild && !(mRule2->_rChild)) )
3628 return Not_cisc_spillable;
3629
3630 // Base Case: check that the current operands/operations match
3631 // or are CISC spillable
3632 assert( _opType, "Must have _opType");
3633 assert( mRule2->_opType, "Must have _opType");
3634 const Form *form = globals[_opType];
3635 const Form *form2 = globals[mRule2->_opType];
3636 if( form == form2 ) {
3637 cisc_spillable = Maybe_cisc_spillable;
3638 } else {
3639 const InstructForm *form2_inst = form2 ? form2->is_instruction() : NULL;
3640 const char *name_left = mRule2->_lChild ? mRule2->_lChild->_opType : NULL;
3641 const char *name_right = mRule2->_rChild ? mRule2->_rChild->_opType : NULL;
3642 DataType data_type = Form::none;
3643 if (form->is_operand()) {
3644 // Make sure the loadX matches the type of the reg
3645 data_type = form->ideal_to_Reg_type(form->is_operand()->ideal_type(globals));
3646 }
3647 // Detect reg vs (loadX memory)
3648 if( form->is_cisc_reg(globals)
3649 && form2_inst
3650 && data_type != Form::none
3651 && (is_load_from_memory(mRule2->_opType) == data_type) // reg vs. (load memory)
3652 && (name_left != NULL) // NOT (load)
3653 && (name_right == NULL) ) { // NOT (load memory foo)
3654 const Form *form2_left = globals[name_left];
3655 if( form2_left && form2_left->is_cisc_mem(globals) ) {
3656 cisc_spillable = Is_cisc_spillable;
3657 operand = _name;
3658 reg_type = _result;
3659 return Is_cisc_spillable;
3660 } else {
3661 cisc_spillable = Not_cisc_spillable;
3662 }
3663 }
3664 // Detect reg vs memory
3665 else if (form->is_cisc_reg(globals) && form2 != NULL && form2->is_cisc_mem(globals)) {
3666 cisc_spillable = Is_cisc_spillable;
3667 operand = _name;
3668 reg_type = _result;
3669 return Is_cisc_spillable;
3670 } else {
3671 cisc_spillable = Not_cisc_spillable;
3672 }
3673 }
3674
3675 // If cisc is still possible, check rest of tree
3676 if( cisc_spillable == Maybe_cisc_spillable ) {
3677 // Check that each has same number of operands at this level
3678 if( (_lChild && !(mRule2->_lChild)) || (_rChild && !(mRule2->_rChild)) ) return Not_cisc_spillable;
3679
3680 // Check left operands
3681 if( (_lChild == NULL) && (mRule2->_lChild == NULL) ) {
3682 left_spillable = Maybe_cisc_spillable;
3683 } else if (_lChild != NULL) {
3684 left_spillable = _lChild->cisc_spill_match(globals, registers, mRule2->_lChild, operand, reg_type);
3685 }
3686
3687 // Check right operands
3688 if( (_rChild == NULL) && (mRule2->_rChild == NULL) ) {
3689 right_spillable = Maybe_cisc_spillable;
3690 } else if (_rChild != NULL) {
3691 right_spillable = _rChild->cisc_spill_match(globals, registers, mRule2->_rChild, operand, reg_type);
3692 }
3693
3694 // Combine results of left and right checks
3695 cisc_spillable = cisc_spill_merge(left_spillable, right_spillable);
3696 }
3697
3698 return cisc_spillable;
3699 }
3700
3701 //---------------------------cisc_spill_match_rule------------------------------
3702 // Recursively check two MatchRules for legal conversion via cisc-spilling
3703 // This method handles the root of Match tree,
3704 // general recursive checks done in MatchNode
3705 int MatchRule::matchrule_cisc_spill_match(FormDict& globals, RegisterForm* registers,
3706 MatchRule* mRule2, const char* &operand,
3707 const char* ®_type) {
3708 int cisc_spillable = Maybe_cisc_spillable;
3709 int left_spillable = Maybe_cisc_spillable;
3710 int right_spillable = Maybe_cisc_spillable;
3711
3712 // Check that each sets a result
3713 if( !(sets_result() && mRule2->sets_result()) ) return Not_cisc_spillable;
3714 // Check that each has same number of operands at this level
3715 if( (_lChild && !(mRule2->_lChild)) || (_rChild && !(mRule2->_rChild)) ) return Not_cisc_spillable;
3716
3717 // Check left operands: at root, must be target of 'Set'
3718 if( (_lChild == NULL) || (mRule2->_lChild == NULL) ) {
3719 left_spillable = Not_cisc_spillable;
3720 } else {
3721 // Do not support cisc-spilling instruction's target location
3722 if( root_ops_match(globals, _lChild->_opType, mRule2->_lChild->_opType) ) {
3723 left_spillable = Maybe_cisc_spillable;
3724 } else {
3725 left_spillable = Not_cisc_spillable;
3726 }
3727 }
3728
3729 // Check right operands: recursive walk to identify reg->mem operand
3730 if (_rChild == NULL) {
3731 if (mRule2->_rChild == NULL) {
3732 right_spillable = Maybe_cisc_spillable;
3733 } else {
3734 assert(0, "_rChild should not be NULL");
3735 }
3736 } else {
3737 right_spillable = _rChild->cisc_spill_match(globals, registers, mRule2->_rChild, operand, reg_type);
3738 }
3739
3740 // Combine results of left and right checks
3741 cisc_spillable = cisc_spill_merge(left_spillable, right_spillable);
3742
3743 return cisc_spillable;
3744 }
3745
3746 //----------------------------- equivalent ------------------------------------
3747 // Recursively check to see if two match rules are equivalent.
3748 // This rule handles the root.
3749 bool MatchRule::equivalent(FormDict &globals, MatchNode *mRule2) {
3750 // Check that each sets a result
3751 if (sets_result() != mRule2->sets_result()) {
3752 return false;
3753 }
3754
3755 // Check that the current operands/operations match
3756 assert( _opType, "Must have _opType");
3757 assert( mRule2->_opType, "Must have _opType");
3758 const Form *form = globals[_opType];
3759 const Form *form2 = globals[mRule2->_opType];
3760 if( form != form2 ) {
3761 return false;
3762 }
3763
3764 if (_lChild ) {
3765 if( !_lChild->equivalent(globals, mRule2->_lChild) )
3766 return false;
3767 } else if (mRule2->_lChild) {
3768 return false; // I have NULL left child, mRule2 has non-NULL left child.
3769 }
3770
3771 if (_rChild ) {
3772 if( !_rChild->equivalent(globals, mRule2->_rChild) )
3773 return false;
3774 } else if (mRule2->_rChild) {
3775 return false; // I have NULL right child, mRule2 has non-NULL right child.
3776 }
3777
3778 // We've made it through the gauntlet.
3779 return true;
3780 }
3781
3782 //----------------------------- equivalent ------------------------------------
3783 // Recursively check to see if two match rules are equivalent.
3784 // This rule handles the operands.
3785 bool MatchNode::equivalent(FormDict &globals, MatchNode *mNode2) {
3786 if( !mNode2 )
3787 return false;
3788
3789 // Check that the current operands/operations match
3790 assert( _opType, "Must have _opType");
3791 assert( mNode2->_opType, "Must have _opType");
3792 const Form *form = globals[_opType];
3793 const Form *form2 = globals[mNode2->_opType];
3794 if( form != form2 ) {
3795 return false;
3796 }
3797
3798 // Check that their children also match
3799 if (_lChild ) {
3800 if( !_lChild->equivalent(globals, mNode2->_lChild) )
3801 return false;
3802 } else if (mNode2->_lChild) {
3803 return false; // I have NULL left child, mNode2 has non-NULL left child.
3804 }
3805
3806 if (_rChild ) {
3807 if( !_rChild->equivalent(globals, mNode2->_rChild) )
3808 return false;
3809 } else if (mNode2->_rChild) {
3810 return false; // I have NULL right child, mNode2 has non-NULL right child.
3811 }
3812
3813 // We've made it through the gauntlet.
3814 return true;
3815 }
3816
3817 //-------------------------- count_commutative_op -------------------------------
3818 // Recursively check for commutative operations with subtree operands
3819 // which could be swapped.
3820 void MatchNode::count_commutative_op(int& count) {
3821 static const char *commut_op_list[] = {
3822 "AddI","AddL","AddF","AddD",
3823 "AndI","AndL",
3824 "MaxI","MinI","MaxF","MinF","MaxD","MinD",
3825 "MulI","MulL","MulF","MulD",
3826 "OrI","OrL",
3827 "XorI","XorL"
3828 };
3829
3830 static const char *commut_vector_op_list[] = {
3831 "AddVB", "AddVS", "AddVI", "AddVL", "AddVF", "AddVD",
3832 "MulVB", "MulVS", "MulVI", "MulVL", "MulVF", "MulVD",
3833 "AndV", "OrV", "XorV",
3834 "MaxV", "MinV"
3835 };
3836
3837 if (_lChild && _rChild && (_lChild->_lChild || _rChild->_lChild)) {
3838 // Don't swap if right operand is an immediate constant.
3839 bool is_const = false;
3840 if (_rChild->_lChild == NULL && _rChild->_rChild == NULL) {
3841 FormDict &globals = _AD.globalNames();
3842 const Form *form = globals[_rChild->_opType];
3843 if (form) {
3844 OperandForm *oper = form->is_operand();
3845 if (oper && oper->interface_type(globals) == Form::constant_interface)
3846 is_const = true;
3847 }
3848 }
3849
3850 if (!is_const) {
3851 int scalar_cnt = sizeof(commut_op_list)/sizeof(char*);
3852 int vector_cnt = sizeof(commut_vector_op_list)/sizeof(char*);
3853 bool matched = false;
3854
3855 // Check the commutative vector op first. It's noncommutative if
3856 // the current node is a masked vector op, since a mask value
3857 // is added to the original vector node's input list and the original
3858 // first two inputs are packed into one BinaryNode. So don't swap
3859 // if one of the operands is a BinaryNode.
3860 for (int i = 0; i < vector_cnt; i++) {
3861 if (strcmp(_opType, commut_vector_op_list[i]) == 0) {
3862 if (strcmp(_lChild->_opType, "Binary") != 0 &&
3863 strcmp(_rChild->_opType, "Binary") != 0) {
3864 count++;
3865 _commutative_id = count; // id should be > 0
3866 }
3867 matched = true;
3868 break;
3869 }
3870 }
3871
3872 // Then check the scalar op if the current op is not in
3873 // the commut_vector_op_list.
3874 if (!matched) {
3875 for (int i = 0; i < scalar_cnt; i++) {
3876 if (strcmp(_opType, commut_op_list[i]) == 0) {
3877 count++;
3878 _commutative_id = count; // id should be > 0
3879 break;
3880 }
3881 }
3882 }
3883 }
3884 }
3885 if (_lChild)
3886 _lChild->count_commutative_op(count);
3887 if (_rChild)
3888 _rChild->count_commutative_op(count);
3889 }
3890
3891 //-------------------------- swap_commutative_op ------------------------------
3892 // Recursively swap specified commutative operation with subtree operands.
3893 void MatchNode::swap_commutative_op(bool atroot, int id) {
3894 if( _commutative_id == id ) { // id should be > 0
3895 assert(_lChild && _rChild && (_lChild->_lChild || _rChild->_lChild ),
3896 "not swappable operation");
3897 MatchNode* tmp = _lChild;
3898 _lChild = _rChild;
3899 _rChild = tmp;
3900 // Don't exit here since we need to build internalop.
3901 }
3902
3903 bool is_set = ( strcmp(_opType, "Set") == 0 );
3904 if( _lChild )
3905 _lChild->swap_commutative_op(is_set, id);
3906 if( _rChild )
3907 _rChild->swap_commutative_op(is_set, id);
3908
3909 // If not the root, reduce this subtree to an internal operand
3910 if( !atroot && (_lChild || _rChild) ) {
3911 build_internalop();
3912 }
3913 }
3914
3915 //-------------------------- swap_commutative_op ------------------------------
3916 // Recursively swap specified commutative operation with subtree operands.
3917 void MatchRule::matchrule_swap_commutative_op(const char* instr_ident, int count, int& match_rules_cnt) {
3918 assert(match_rules_cnt < 100," too many match rule clones");
3919 // Clone
3920 MatchRule* clone = new MatchRule(_AD, this);
3921 // Swap operands of commutative operation
3922 ((MatchNode*)clone)->swap_commutative_op(true, count);
3923 char* buf = (char*) AdlAllocateHeap(strlen(instr_ident) + 4);
3924 sprintf(buf, "%s_%d", instr_ident, match_rules_cnt++);
3925 clone->_result = buf;
3926
3927 clone->_next = this->_next;
3928 this-> _next = clone;
3929 if( (--count) > 0 ) {
3930 this-> matchrule_swap_commutative_op(instr_ident, count, match_rules_cnt);
3931 clone->matchrule_swap_commutative_op(instr_ident, count, match_rules_cnt);
3932 }
3933 }
3934
3935 //------------------------------MatchRule--------------------------------------
3936 MatchRule::MatchRule(ArchDesc &ad)
3937 : MatchNode(ad), _depth(0), _construct(NULL), _numchilds(0) {
3938 _next = NULL;
3939 }
3940
3941 MatchRule::MatchRule(ArchDesc &ad, MatchRule* mRule)
3942 : MatchNode(ad, *mRule, 0), _depth(mRule->_depth),
3943 _construct(mRule->_construct), _numchilds(mRule->_numchilds) {
3944 _next = NULL;
3945 }
3946
3947 MatchRule::MatchRule(ArchDesc &ad, MatchNode* mroot, int depth, char *cnstr,
3948 int numleaves)
3949 : MatchNode(ad,*mroot), _depth(depth), _construct(cnstr),
3950 _numchilds(0) {
3951 _next = NULL;
3952 mroot->_lChild = NULL;
3953 mroot->_rChild = NULL;
3954 delete mroot;
3955 _numleaves = numleaves;
3956 _numchilds = (_lChild ? 1 : 0) + (_rChild ? 1 : 0);
3957 }
3958 MatchRule::~MatchRule() {
3959 }
3960
3961 // Recursive call collecting info on top-level operands, not transitive.
3962 // Implementation does not modify state of internal structures.
3963 void MatchRule::append_components(FormDict& locals, ComponentList& components, bool def_flag) const {
3964 assert (_name != NULL, "MatchNode::build_components encountered empty node\n");
3965
3966 MatchNode::append_components(locals, components,
3967 false /* not necessarily a def */);
3968 }
3969
3970 // Recursive call on all operands' match rules in my match rule.
3971 // Implementation does not modify state of internal structures since they
3972 // can be shared.
3973 // The MatchNode that is called first treats its
3974 bool MatchRule::base_operand(uint &position0, FormDict &globals,
3975 const char *&result, const char * &name,
3976 const char * &opType)const{
3977 uint position = position0;
3978
3979 return (MatchNode::base_operand( position, globals, result, name, opType));
3980 }
3981
3982
3983 bool MatchRule::is_base_register(FormDict &globals) const {
3984 uint position = 1;
3985 const char *result = NULL;
3986 const char *name = NULL;
3987 const char *opType = NULL;
3988 if (!base_operand(position, globals, result, name, opType)) {
3989 position = 0;
3990 if( base_operand(position, globals, result, name, opType) &&
3991 (strcmp(opType,"RegI")==0 ||
3992 strcmp(opType,"RegP")==0 ||
3993 strcmp(opType,"RegN")==0 ||
3994 strcmp(opType,"RegL")==0 ||
3995 strcmp(opType,"RegF")==0 ||
3996 strcmp(opType,"RegD")==0 ||
3997 strcmp(opType,"RegVectMask")==0 ||
3998 strcmp(opType,"VecA")==0 ||
3999 strcmp(opType,"VecS")==0 ||
4000 strcmp(opType,"VecD")==0 ||
4001 strcmp(opType,"VecX")==0 ||
4002 strcmp(opType,"VecY")==0 ||
4003 strcmp(opType,"VecZ")==0 ||
4004 strcmp(opType,"Reg" )==0) ) {
4005 return 1;
4006 }
4007 }
4008 return 0;
4009 }
4010
4011 Form::DataType MatchRule::is_base_constant(FormDict &globals) const {
4012 uint position = 1;
4013 const char *result = NULL;
4014 const char *name = NULL;
4015 const char *opType = NULL;
4016 if (!base_operand(position, globals, result, name, opType)) {
4017 position = 0;
4018 if (base_operand(position, globals, result, name, opType)) {
4019 return ideal_to_const_type(opType);
4020 }
4021 }
4022 return Form::none;
4023 }
4024
4025 bool MatchRule::is_chain_rule(FormDict &globals) const {
4026
4027 // Check for chain rule, and do not generate a match list for it
4028 if ((_lChild == NULL) && (_rChild == NULL) ) {
4029 const Form *form = globals[_opType];
4030 // If this is ideal, then it is a base match, not a chain rule.
4031 if ( form && form->is_operand() && (!form->ideal_only())) {
4032 return true;
4033 }
4034 }
4035 // Check for "Set" form of chain rule, and do not generate a match list
4036 if (_rChild) {
4037 const char *rch = _rChild->_opType;
4038 const Form *form = globals[rch];
4039 if ((!strcmp(_opType,"Set") &&
4040 ((form) && form->is_operand()))) {
4041 return true;
4042 }
4043 }
4044 return false;
4045 }
4046
4047 int MatchRule::is_ideal_copy() const {
4048 if (is_chain_rule(_AD.globalNames()) &&
4049 _lChild && strncmp(_lChild->_opType, "stackSlot", 9) == 0) {
4050 return 1;
4051 }
4052 return 0;
4053 }
4054
4055 int MatchRule::is_expensive() const {
4056 if( _rChild ) {
4057 const char *opType = _rChild->_opType;
4058 if( strcmp(opType,"AtanD")==0 ||
4059 strcmp(opType,"DivD")==0 ||
4060 strcmp(opType,"DivF")==0 ||
4061 strcmp(opType,"DivI")==0 ||
4062 strcmp(opType,"Log10D")==0 ||
4063 strcmp(opType,"ModD")==0 ||
4064 strcmp(opType,"ModF")==0 ||
4065 strcmp(opType,"ModI")==0 ||
4066 strcmp(opType,"SqrtD")==0 ||
4067 strcmp(opType,"SqrtF")==0 ||
4068 strcmp(opType,"TanD")==0 ||
4069 strcmp(opType,"ConvD2F")==0 ||
4070 strcmp(opType,"ConvD2I")==0 ||
4071 strcmp(opType,"ConvD2L")==0 ||
4072 strcmp(opType,"ConvF2D")==0 ||
4073 strcmp(opType,"ConvF2I")==0 ||
4074 strcmp(opType,"ConvF2L")==0 ||
4075 strcmp(opType,"ConvI2D")==0 ||
4076 strcmp(opType,"ConvI2F")==0 ||
4077 strcmp(opType,"ConvI2L")==0 ||
4078 strcmp(opType,"ConvL2D")==0 ||
4079 strcmp(opType,"ConvL2F")==0 ||
4080 strcmp(opType,"ConvL2I")==0 ||
4081 strcmp(opType,"DecodeN")==0 ||
4082 strcmp(opType,"EncodeP")==0 ||
4083 strcmp(opType,"EncodePKlass")==0 ||
4084 strcmp(opType,"DecodeNKlass")==0 ||
4085 strcmp(opType,"FmaD") == 0 ||
4086 strcmp(opType,"FmaF") == 0 ||
4087 strcmp(opType,"RoundDouble")==0 ||
4088 strcmp(opType,"RoundDoubleMode")==0 ||
4089 strcmp(opType,"RoundFloat")==0 ||
4090 strcmp(opType,"ReverseBytesI")==0 ||
4091 strcmp(opType,"ReverseBytesL")==0 ||
4092 strcmp(opType,"ReverseBytesUS")==0 ||
4093 strcmp(opType,"ReverseBytesS")==0 ||
4094 strcmp(opType,"PopulateIndex")==0 ||
4095 strcmp(opType,"AddReductionVI")==0 ||
4096 strcmp(opType,"AddReductionVL")==0 ||
4097 strcmp(opType,"AddReductionVF")==0 ||
4098 strcmp(opType,"AddReductionVD")==0 ||
4099 strcmp(opType,"MulReductionVI")==0 ||
4100 strcmp(opType,"MulReductionVL")==0 ||
4101 strcmp(opType,"MulReductionVF")==0 ||
4102 strcmp(opType,"MulReductionVD")==0 ||
4103 strcmp(opType,"MinReductionV")==0 ||
4104 strcmp(opType,"MaxReductionV")==0 ||
4105 strcmp(opType,"AndReductionV")==0 ||
4106 strcmp(opType,"OrReductionV")==0 ||
4107 strcmp(opType,"XorReductionV")==0 ||
4108 strcmp(opType,"MaskAll")==0 ||
4109 0 /* 0 to line up columns nicely */ ) {
4110 return 1;
4111 }
4112 }
4113 return 0;
4114 }
4115
4116 bool MatchRule::is_ideal_if() const {
4117 if( !_opType ) return false;
4118 return
4119 !strcmp(_opType,"If" ) ||
4120 !strcmp(_opType,"CountedLoopEnd");
4121 }
4122
4123 bool MatchRule::is_ideal_fastlock() const {
4124 if ( _opType && (strcmp(_opType,"Set") == 0) && _rChild ) {
4125 return (strcmp(_rChild->_opType,"FastLock") == 0);
4126 }
4127 return false;
4128 }
4129
4130 bool MatchRule::is_ideal_membar() const {
4131 if( !_opType ) return false;
4132 return
4133 !strcmp(_opType,"MemBarAcquire") ||
4134 !strcmp(_opType,"MemBarRelease") ||
4135 !strcmp(_opType,"MemBarAcquireLock") ||
4136 !strcmp(_opType,"MemBarReleaseLock") ||
4137 !strcmp(_opType,"LoadFence" ) ||
4138 !strcmp(_opType,"StoreFence") ||
4139 !strcmp(_opType,"StoreStoreFence") ||
4140 !strcmp(_opType,"MemBarVolatile") ||
4141 !strcmp(_opType,"MemBarCPUOrder") ||
4142 !strcmp(_opType,"MemBarStoreStore") ||
4143 !strcmp(_opType,"OnSpinWait");
4144 }
4145
4146 bool MatchRule::is_ideal_loadPC() const {
4147 if ( _opType && (strcmp(_opType,"Set") == 0) && _rChild ) {
4148 return (strcmp(_rChild->_opType,"LoadPC") == 0);
4149 }
4150 return false;
4151 }
4152
4153 bool MatchRule::is_ideal_box() const {
4154 if ( _opType && (strcmp(_opType,"Set") == 0) && _rChild ) {
4155 return (strcmp(_rChild->_opType,"Box") == 0);
4156 }
4157 return false;
4158 }
4159
4160 bool MatchRule::is_ideal_goto() const {
4161 bool ideal_goto = false;
4162
4163 if( _opType && (strcmp(_opType,"Goto") == 0) ) {
4164 ideal_goto = true;
4165 }
4166 return ideal_goto;
4167 }
4168
4169 bool MatchRule::is_ideal_jump() const {
4170 if( _opType ) {
4171 if( !strcmp(_opType,"Jump") )
4172 return true;
4173 }
4174 return false;
4175 }
4176
4177 bool MatchRule::is_ideal_bool() const {
4178 if( _opType ) {
4179 if( !strcmp(_opType,"Bool") )
4180 return true;
4181 }
4182 return false;
4183 }
4184
4185
4186 Form::DataType MatchRule::is_ideal_load() const {
4187 Form::DataType ideal_load = Form::none;
4188
4189 if ( _opType && (strcmp(_opType,"Set") == 0) && _rChild ) {
4190 const char *opType = _rChild->_opType;
4191 ideal_load = is_load_from_memory(opType);
4192 }
4193
4194 return ideal_load;
4195 }
4196
4197 bool MatchRule::is_vector() const {
4198 static const char *vector_list[] = {
4199 "AddVB","AddVS","AddVI","AddVL","AddVF","AddVD",
4200 "SubVB","SubVS","SubVI","SubVL","SubVF","SubVD",
4201 "MulVB","MulVS","MulVI","MulVL","MulVF","MulVD",
4202 "CMoveVD", "CMoveVF",
4203 "DivVF","DivVD",
4204 "AbsVB","AbsVS","AbsVI","AbsVL","AbsVF","AbsVD",
4205 "NegVF","NegVD","NegVI","NegVL",
4206 "SqrtVD","SqrtVF",
4207 "AndV" ,"XorV" ,"OrV",
4208 "MaxV", "MinV",
4209 "CompressV", "ExpandV", "CompressM",
4210 "AddReductionVI", "AddReductionVL",
4211 "AddReductionVF", "AddReductionVD",
4212 "MulReductionVI", "MulReductionVL",
4213 "MulReductionVF", "MulReductionVD",
4214 "MaxReductionV", "MinReductionV",
4215 "AndReductionV", "OrReductionV", "XorReductionV",
4216 "MulAddVS2VI", "MacroLogicV",
4217 "LShiftCntV","RShiftCntV",
4218 "LShiftVB","LShiftVS","LShiftVI","LShiftVL",
4219 "RShiftVB","RShiftVS","RShiftVI","RShiftVL",
4220 "URShiftVB","URShiftVS","URShiftVI","URShiftVL",
4221 "ReplicateB","ReplicateS","ReplicateI","ReplicateL","ReplicateF","ReplicateD","ReverseV","ReverseBytesV",
4222 "RoundDoubleModeV","RotateLeftV" , "RotateRightV", "LoadVector","StoreVector",
4223 "LoadVectorGather", "StoreVectorScatter", "LoadVectorGatherMasked", "StoreVectorScatterMasked",
4224 "VectorTest", "VectorLoadMask", "VectorStoreMask", "VectorBlend", "VectorInsert",
4225 "VectorRearrange","VectorLoadShuffle", "VectorLoadConst",
4226 "VectorCastB2X", "VectorCastS2X", "VectorCastI2X",
4227 "VectorCastL2X", "VectorCastF2X", "VectorCastD2X",
4228 "VectorUCastB2X", "VectorUCastS2X", "VectorUCastI2X",
4229 "VectorMaskWrapper","VectorMaskCmp","VectorReinterpret","LoadVectorMasked","StoreVectorMasked",
4230 "FmaVD","FmaVF","PopCountVI","PopCountVL","PopulateIndex","VectorLongToMask",
4231 "CountLeadingZerosV", "CountTrailingZerosV", "SignumVF", "SignumVD",
4232 // Next are vector mask ops.
4233 "MaskAll", "AndVMask", "OrVMask", "XorVMask", "VectorMaskCast",
4234 "RoundVF", "RoundVD",
4235 // Next are not supported currently.
4236 "PackB","PackS","PackI","PackL","PackF","PackD","Pack2L","Pack2D",
4237 "ExtractB","ExtractUB","ExtractC","ExtractS","ExtractI","ExtractL","ExtractF","ExtractD"
4238 };
4239 int cnt = sizeof(vector_list)/sizeof(char*);
4240 if (_rChild) {
4241 const char *opType = _rChild->_opType;
4242 for (int i=0; i<cnt; i++)
4243 if (strcmp(opType,vector_list[i]) == 0)
4244 return true;
4245 }
4246 return false;
4247 }
4248
4249
4250 bool MatchRule::skip_antidep_check() const {
4251 // Some loads operate on what is effectively immutable memory so we
4252 // should skip the anti dep computations. For some of these nodes
4253 // the rewritable field keeps the anti dep logic from triggering but
4254 // for certain kinds of LoadKlass it does not since they are
4255 // actually reading memory which could be rewritten by the runtime,
4256 // though never by generated code. This disables it uniformly for
4257 // the nodes that behave like this: LoadKlass, LoadNKlass and
4258 // LoadRange.
4259 if ( _opType && (strcmp(_opType,"Set") == 0) && _rChild ) {
4260 const char *opType = _rChild->_opType;
4261 if (strcmp("LoadKlass", opType) == 0 ||
4262 strcmp("LoadNKlass", opType) == 0 ||
4263 strcmp("LoadRange", opType) == 0) {
4264 return true;
4265 }
4266 }
4267
4268 return false;
4269 }
4270
4271
4272 Form::DataType MatchRule::is_ideal_store() const {
4273 Form::DataType ideal_store = Form::none;
4274
4275 if ( _opType && (strcmp(_opType,"Set") == 0) && _rChild ) {
4276 const char *opType = _rChild->_opType;
4277 ideal_store = is_store_to_memory(opType);
4278 }
4279
4280 return ideal_store;
4281 }
4282
4283
4284 void MatchRule::dump() {
4285 output(stderr);
4286 }
4287
4288 // Write just one line.
4289 void MatchRule::output_short(FILE *fp) {
4290 fprintf(fp,"MatchRule: ( %s",_name);
4291 if (_lChild) _lChild->output(fp);
4292 if (_rChild) _rChild->output(fp);
4293 fprintf(fp," )");
4294 }
4295
4296 void MatchRule::output(FILE *fp) {
4297 output_short(fp);
4298 fprintf(fp,"\n nesting depth = %d\n", _depth);
4299 if (_result) fprintf(fp," Result Type = %s", _result);
4300 fprintf(fp,"\n");
4301 }
4302
4303 //------------------------------Attribute--------------------------------------
4304 Attribute::Attribute(char *id, char* val, int type)
4305 : _ident(id), _val(val), _atype(type) {
4306 }
4307 Attribute::~Attribute() {
4308 }
4309
4310 int Attribute::int_val(ArchDesc &ad) {
4311 // Make sure it is an integer constant:
4312 int result = 0;
4313 if (!_val || !ADLParser::is_int_token(_val, result)) {
4314 ad.syntax_err(0, "Attribute %s must have an integer value: %s",
4315 _ident, _val ? _val : "");
4316 }
4317 return result;
4318 }
4319
4320 void Attribute::dump() {
4321 output(stderr);
4322 } // Debug printer
4323
4324 // Write to output files
4325 void Attribute::output(FILE *fp) {
4326 fprintf(fp,"Attribute: %s %s\n", (_ident?_ident:""), (_val?_val:""));
4327 }
4328
4329 //------------------------------FormatRule----------------------------------
4330 FormatRule::FormatRule(char *temp)
4331 : _temp(temp) {
4332 }
4333 FormatRule::~FormatRule() {
4334 }
4335
4336 void FormatRule::dump() {
4337 output(stderr);
4338 }
4339
4340 // Write to output files
4341 void FormatRule::output(FILE *fp) {
4342 fprintf(fp,"\nFormat Rule: \n%s", (_temp?_temp:""));
4343 fprintf(fp,"\n");
4344 }