Mercurial > hg > graal-compiler

comparison src/share/vm/adlc/output_h.cpp @ 6850:d336b3173277

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
8000592: Improve adlc usability Summary: several changes to adlc to improve its usability Reviewed-by: kvn Contributed-by: goetz.lindenmaier@sap.com
author kvn
date Tue, 09 Oct 2012 16:09:31 -0700
parents 8e47bac5643a
children 705ef39fcaa9
comparison
equal deleted inserted replaced
6849:f6badecb7ea7 6850:d336b3173277
23 */ 23 */
24 24
25 // output_h.cpp - Class HPP file output routines for architecture definition 25 // output_h.cpp - Class HPP file output routines for architecture definition
26 #include "adlc.hpp" 26 #include "adlc.hpp"
27 27
28 // The comment delimiter used in format statements after assembler instructions.
29 #define commentSeperator "!"
28 30
29 // Generate the #define that describes the number of registers. 31 // Generate the #define that describes the number of registers.
30 static void defineRegCount(FILE *fp, RegisterForm *registers) { 32 static void defineRegCount(FILE *fp, RegisterForm *registers) {
31 if (registers) { 33 if (registers) {
32 int regCount = AdlcVMDeps::Physical + registers->_rdefs.count(); 34 int regCount = AdlcVMDeps::Physical + registers->_rdefs.count();
77 79
78 // Output the register number for each register in the allocation classes 80 // Output the register number for each register in the allocation classes
79 _register->reset_RegDefs(); 81 _register->reset_RegDefs();
80 int i = 0; 82 int i = 0;
81 while( (reg_def = _register->iter_RegDefs()) != NULL ) { 83 while( (reg_def = _register->iter_RegDefs()) != NULL ) {
82 fprintf(fp_hpp," %s_num,\t\t// %d\n", reg_def->_regname, i++); 84 fprintf(fp_hpp," %s_num,", reg_def->_regname);
85 for (int j = 0; j < 20-(int)strlen(reg_def->_regname); j++) fprintf(fp_hpp, " ");
86 fprintf(fp_hpp," // enum %3d, regnum %3d, reg encode %3s\n",
87 i++,
88 reg_def->register_num(),
89 reg_def->register_encode());
83 } 90 }
84 // Finish defining enumeration 91 // Finish defining enumeration
85 fprintf(fp_hpp, " _last_Mach_Reg\t// %d\n", i); 92 fprintf(fp_hpp, " _last_Mach_Reg // %d\n", i);
86 fprintf(fp_hpp, "};\n"); 93 fprintf(fp_hpp, "};\n");
87 } 94 }
88 95
89 fprintf(fp_hpp, "\n// Size of register-mask in ints\n"); 96 fprintf(fp_hpp, "\n// Size of register-mask in ints\n");
90 fprintf(fp_hpp, "#define RM_SIZE %d\n",RegisterForm::RegMask_Size()); 97 fprintf(fp_hpp, "#define RM_SIZE %d\n",RegisterForm::RegMask_Size());
119 fprintf(fp_hpp, "\n"); 126 fprintf(fp_hpp, "\n");
120 fprintf(fp_hpp, "// Enumerate machine registers starting after reserved regs.\n"); 127 fprintf(fp_hpp, "// Enumerate machine registers starting after reserved regs.\n");
121 fprintf(fp_hpp, "// in the order of occurrence in the alloc_class(es).\n"); 128 fprintf(fp_hpp, "// in the order of occurrence in the alloc_class(es).\n");
122 fprintf(fp_hpp, "enum MachRegisterEncodes {\n"); 129 fprintf(fp_hpp, "enum MachRegisterEncodes {\n");
123 130
131 // Find max enum string length.
132 size_t maxlen = 0;
133 _register->reset_RegDefs();
134 reg_def = _register->iter_RegDefs();
135 while (reg_def != NULL) {
136 size_t len = strlen(reg_def->_regname);
137 if (len > maxlen) maxlen = len;
138 reg_def = _register->iter_RegDefs();
139 }
140
124 // Output the register encoding for each register in the allocation classes 141 // Output the register encoding for each register in the allocation classes
125 _register->reset_RegDefs(); 142 _register->reset_RegDefs();
126 reg_def_next = _register->iter_RegDefs(); 143 reg_def_next = _register->iter_RegDefs();
127 while( (reg_def = reg_def_next) != NULL ) { 144 while( (reg_def = reg_def_next) != NULL ) {
128 reg_def_next = _register->iter_RegDefs(); 145 reg_def_next = _register->iter_RegDefs();
129 fprintf(fp_hpp," %s_enc = %s%s\n", 146 fprintf(fp_hpp," %s_enc", reg_def->_regname);
130 reg_def->_regname, reg_def->register_encode(), reg_def_next == NULL? "" : "," ); 147 for (size_t i = strlen(reg_def->_regname); i < maxlen; i++) fprintf(fp_hpp, " ");
148 fprintf(fp_hpp," = %3s%s\n", reg_def->register_encode(), reg_def_next == NULL? "" : "," );
131 } 149 }
132 // Finish defining enumeration 150 // Finish defining enumeration
133 fprintf(fp_hpp, "};\n"); 151 fprintf(fp_hpp, "};\n");
134 152
135 } // Done with register form 153 } // Done with register form
173 // --------------------------------------------------------------------------- 191 // ---------------------------------------------------------------------------
174 192
175 //------------------------------Utilities to build Operand Classes------------ 193 //------------------------------Utilities to build Operand Classes------------
176 static void in_RegMask(FILE *fp) { 194 static void in_RegMask(FILE *fp) {
177 fprintf(fp," virtual const RegMask *in_RegMask(int index) const;\n"); 195 fprintf(fp," virtual const RegMask *in_RegMask(int index) const;\n");
178 }
179
180 static void declare_hash(FILE *fp) {
181 fprintf(fp," virtual uint hash() const;\n");
182 }
183
184 static void declare_cmp(FILE *fp) {
185 fprintf(fp," virtual uint cmp( const MachOper &oper ) const;\n");
186 } 196 }
187 197
188 static void declareConstStorage(FILE *fp, FormDict &globals, OperandForm *oper) { 198 static void declareConstStorage(FILE *fp, FormDict &globals, OperandForm *oper) {
189 int i = 0; 199 int i = 0;
190 Component *comp; 200 Component *comp;
370 380
371 // Generate the format rule for condition codes 381 // Generate the format rule for condition codes
372 static void defineCCodeDump(OperandForm* oper, FILE *fp, int i) { 382 static void defineCCodeDump(OperandForm* oper, FILE *fp, int i) {
373 assert(oper != NULL, "what"); 383 assert(oper != NULL, "what");
374 CondInterface* cond = oper->_interface->is_CondInterface(); 384 CondInterface* cond = oper->_interface->is_CondInterface();
375 fprintf(fp, " if( _c%d == BoolTest::eq ) st->print(\"%s\");\n",i,cond->_equal_format); 385 fprintf(fp, " if( _c%d == BoolTest::eq ) st->print(\"%s\");\n",i,cond->_equal_format);
376 fprintf(fp, " else if( _c%d == BoolTest::ne ) st->print(\"%s\");\n",i,cond->_not_equal_format); 386 fprintf(fp, " else if( _c%d == BoolTest::ne ) st->print(\"%s\");\n",i,cond->_not_equal_format);
377 fprintf(fp, " else if( _c%d == BoolTest::le ) st->print(\"%s\");\n",i,cond->_less_equal_format); 387 fprintf(fp, " else if( _c%d == BoolTest::le ) st->print(\"%s\");\n",i,cond->_less_equal_format);
378 fprintf(fp, " else if( _c%d == BoolTest::ge ) st->print(\"%s\");\n",i,cond->_greater_equal_format); 388 fprintf(fp, " else if( _c%d == BoolTest::ge ) st->print(\"%s\");\n",i,cond->_greater_equal_format);
379 fprintf(fp, " else if( _c%d == BoolTest::lt ) st->print(\"%s\");\n",i,cond->_less_format); 389 fprintf(fp, " else if( _c%d == BoolTest::lt ) st->print(\"%s\");\n",i,cond->_less_format);
380 fprintf(fp, " else if( _c%d == BoolTest::gt ) st->print(\"%s\");\n",i,cond->_greater_format); 390 fprintf(fp, " else if( _c%d == BoolTest::gt ) st->print(\"%s\");\n",i,cond->_greater_format);
381 } 391 }
382 392
383 // Output code that dumps constant values, increment "i" if type is constant 393 // Output code that dumps constant values, increment "i" if type is constant
384 static uint dump_spec_constant(FILE *fp, const char *ideal_type, uint i, OperandForm* oper) { 394 static uint dump_spec_constant(FILE *fp, const char *ideal_type, uint i, OperandForm* oper) {
385 if (!strcmp(ideal_type, "ConI")) { 395 if (!strcmp(ideal_type, "ConI")) {
386 fprintf(fp," st->print(\"#%%d\", _c%d);\n", i); 396 fprintf(fp," st->print(\"#%%d\", _c%d);\n", i);
397 fprintf(fp," st->print(\"/0x%%08x\", _c%d);\n", i);
387 ++i; 398 ++i;
388 } 399 }
389 else if (!strcmp(ideal_type, "ConP")) { 400 else if (!strcmp(ideal_type, "ConP")) {
390 fprintf(fp," _c%d->dump_on(st);\n", i); 401 fprintf(fp," _c%d->dump_on(st);\n", i);
391 ++i; 402 ++i;
398 fprintf(fp," _c%d->dump_on(st);\n", i); 409 fprintf(fp," _c%d->dump_on(st);\n", i);
399 ++i; 410 ++i;
400 } 411 }
401 else if (!strcmp(ideal_type, "ConL")) { 412 else if (!strcmp(ideal_type, "ConL")) {
402 fprintf(fp," st->print(\"#\" INT64_FORMAT, _c%d);\n", i); 413 fprintf(fp," st->print(\"#\" INT64_FORMAT, _c%d);\n", i);
414 fprintf(fp," st->print(\"/\" PTR64_FORMAT, _c%d);\n", i);
403 ++i; 415 ++i;
404 } 416 }
405 else if (!strcmp(ideal_type, "ConF")) { 417 else if (!strcmp(ideal_type, "ConF")) {
406 fprintf(fp," st->print(\"#%%f\", _c%d);\n", i); 418 fprintf(fp," st->print(\"#%%f\", _c%d);\n", i);
419 fprintf(fp," jint _c%di = JavaValue(_c%d).get_jint();\n", i, i);
420 fprintf(fp," st->print(\"/0x%%x/\", _c%di);\n", i);
407 ++i; 421 ++i;
408 } 422 }
409 else if (!strcmp(ideal_type, "ConD")) { 423 else if (!strcmp(ideal_type, "ConD")) {
410 fprintf(fp," st->print(\"#%%f\", _c%d);\n", i); 424 fprintf(fp," st->print(\"#%%f\", _c%d);\n", i);
425 fprintf(fp," jlong _c%dl = JavaValue(_c%d).get_jlong();\n", i, i);
426 fprintf(fp," st->print(\"/\" PTR64_FORMAT, _c%dl);\n", i);
411 ++i; 427 ++i;
412 } 428 }
413 else if (!strcmp(ideal_type, "Bool")) { 429 else if (!strcmp(ideal_type, "Bool")) {
414 defineCCodeDump(oper, fp,i); 430 defineCCodeDump(oper, fp,i);
415 ++i; 431 ++i;
427 fprintf(fp," virtual void ext_format(PhaseRegAlloc *ra, const MachNode *node, int idx, outputStream *st) const;\n"); 443 fprintf(fp," virtual void ext_format(PhaseRegAlloc *ra, const MachNode *node, int idx, outputStream *st) const;\n");
428 return; 444 return;
429 } 445 }
430 446
431 // Local pointer indicates remaining part of format rule 447 // Local pointer indicates remaining part of format rule
432 uint idx = 0; // position of operand in match rule 448 int idx = 0; // position of operand in match rule
433 449
434 // Generate internal format function, used when stored locally 450 // Generate internal format function, used when stored locally
435 fprintf(fp, "\n#ifndef PRODUCT\n"); 451 fprintf(fp, "\n#ifndef PRODUCT\n");
436 fprintf(fp,"void %sOper::int_format(PhaseRegAlloc *ra, const MachNode *node, outputStream *st) const {\n", oper._ident); 452 fprintf(fp,"void %sOper::int_format(PhaseRegAlloc *ra, const MachNode *node, outputStream *st) const {\n", oper._ident);
437 // Generate the user-defined portion of the format 453 // Generate the user-defined portion of the format
442 // Build the format from the entries in strings and rep_vars 458 // Build the format from the entries in strings and rep_vars
443 const char *string = NULL; 459 const char *string = NULL;
444 oper._format->_rep_vars.reset(); 460 oper._format->_rep_vars.reset();
445 oper._format->_strings.reset(); 461 oper._format->_strings.reset();
446 while ( (string = oper._format->_strings.iter()) != NULL ) { 462 while ( (string = oper._format->_strings.iter()) != NULL ) {
447 fprintf(fp," ");
448 463
449 // Check if this is a standard string or a replacement variable 464 // Check if this is a standard string or a replacement variable
450 if ( string != NameList::_signal ) { 465 if ( string != NameList::_signal ) {
451 // Normal string 466 // Normal string
452 // Pass through to st->print 467 // Pass through to st->print
453 fprintf(fp,"st->print(\"%s\");\n", string); 468 fprintf(fp," st->print(\"%s\");\n", string);
454 } else { 469 } else {
455 // Replacement variable 470 // Replacement variable
456 const char *rep_var = oper._format->_rep_vars.iter(); 471 const char *rep_var = oper._format->_rep_vars.iter();
457 // Check that it is a local name, and an operand 472 // Check that it is a local name, and an operand
458 const Form* form = oper._localNames[rep_var]; 473 const Form* form = oper._localNames[rep_var];
471 } else { 486 } else {
472 idx = 0; 487 idx = 0;
473 } 488 }
474 489
475 // output invocation of "$..."s format function 490 // output invocation of "$..."s format function
476 if ( op != NULL ) op->int_format(fp, globals, idx); 491 if ( op != NULL ) op->int_format(fp, globals, idx);
477 492
478 if ( idx == -1 ) { 493 if ( idx == -1 ) {
479 fprintf(stderr, 494 fprintf(stderr,
480 "Using a name, %s, that isn't in match rule\n", rep_var); 495 "Using a name, %s, that isn't in match rule\n", rep_var);
481 assert( strcmp(op->_ident,"label")==0, "Unimplemented"); 496 assert( strcmp(op->_ident,"label")==0, "Unimplemented");
514 // Build the format from the entries in strings and rep_vars 529 // Build the format from the entries in strings and rep_vars
515 const char *string = NULL; 530 const char *string = NULL;
516 oper._format->_rep_vars.reset(); 531 oper._format->_rep_vars.reset();
517 oper._format->_strings.reset(); 532 oper._format->_strings.reset();
518 while ( (string = oper._format->_strings.iter()) != NULL ) { 533 while ( (string = oper._format->_strings.iter()) != NULL ) {
519 fprintf(fp," ");
520 534
521 // Check if this is a standard string or a replacement variable 535 // Check if this is a standard string or a replacement variable
522 if ( string != NameList::_signal ) { 536 if ( string != NameList::_signal ) {
523 // Normal string 537 // Normal string
524 // Pass through to st->print 538 // Pass through to st->print
525 fprintf(fp,"st->print(\"%s\");\n", string); 539 fprintf(fp," st->print(\"%s\");\n", string);
526 } else { 540 } else {
527 // Replacement variable 541 // Replacement variable
528 const char *rep_var = oper._format->_rep_vars.iter(); 542 const char *rep_var = oper._format->_rep_vars.iter();
529 // Check that it is a local name, and an operand 543 // Check that it is a local name, and an operand
530 const Form* form = oper._localNames[rep_var]; 544 const Form* form = oper._localNames[rep_var];
545 } 559 }
546 // output invocation of "$..."s format function 560 // output invocation of "$..."s format function
547 if ( op != NULL ) op->ext_format(fp, globals, idx); 561 if ( op != NULL ) op->ext_format(fp, globals, idx);
548 562
549 // Lookup the index position of the replacement variable 563 // Lookup the index position of the replacement variable
550 idx = oper._components.operand_position_format(rep_var); 564 idx = oper._components.operand_position_format(rep_var, &oper);
551 if ( idx == -1 ) { 565 if ( idx == -1 ) {
552 fprintf(stderr, 566 fprintf(stderr,
553 "Using a name, %s, that isn't in match rule\n", rep_var); 567 "Using a name, %s, that isn't in match rule\n", rep_var);
554 assert( strcmp(op->_ident,"label")==0, "Unimplemented"); 568 assert( strcmp(op->_ident,"label")==0, "Unimplemented");
555 } 569 }
599 // Build the format from the entries in strings and rep_vars 613 // Build the format from the entries in strings and rep_vars
600 const char *string = NULL; 614 const char *string = NULL;
601 inst._format->_rep_vars.reset(); 615 inst._format->_rep_vars.reset();
602 inst._format->_strings.reset(); 616 inst._format->_strings.reset();
603 while( (string = inst._format->_strings.iter()) != NULL ) { 617 while( (string = inst._format->_strings.iter()) != NULL ) {
604 fprintf(fp," "); 618 fprintf(fp," ");
605 // Check if this is a standard string or a replacement variable 619 // Check if this is a standard string or a replacement variable
606 if( string == NameList::_signal ) { // Replacement variable 620 if( string == NameList::_signal ) { // Replacement variable
607 const char* rep_var = inst._format->_rep_vars.iter(); 621 const char* rep_var = inst._format->_rep_vars.iter();
608 inst.rep_var_format( fp, rep_var); 622 inst.rep_var_format( fp, rep_var);
609 } else if( string == NameList::_signal3 ) { // Replacement variable in raw text 623 } else if( string == NameList::_signal3 ) { // Replacement variable in raw text
656 // Add call debug info automatically 670 // Add call debug info automatically
657 Form::CallType call_type = inst.is_ideal_call(); 671 Form::CallType call_type = inst.is_ideal_call();
658 if( call_type != Form::invalid_type ) { 672 if( call_type != Form::invalid_type ) {
659 switch( call_type ) { 673 switch( call_type ) {
660 case Form::JAVA_DYNAMIC: 674 case Form::JAVA_DYNAMIC:
661 fprintf(fp," _method->print_short_name();\n"); 675 fprintf(fp," _method->print_short_name(st);\n");
662 break; 676 break;
663 case Form::JAVA_STATIC: 677 case Form::JAVA_STATIC:
664 fprintf(fp," if( _method ) _method->print_short_name(st); else st->print(\" wrapper for: %%s\", _name);\n"); 678 fprintf(fp," if( _method ) _method->print_short_name(st);\n");
665 fprintf(fp," if( !_method ) dump_trap_args(st);\n"); 679 fprintf(fp," else st->print(\" wrapper for: %%s\", _name);\n");
680 fprintf(fp," if( !_method ) dump_trap_args(st);\n");
666 break; 681 break;
667 case Form::JAVA_COMPILED: 682 case Form::JAVA_COMPILED:
668 case Form::JAVA_INTERP: 683 case Form::JAVA_INTERP:
669 break; 684 break;
670 case Form::JAVA_RUNTIME: 685 case Form::JAVA_RUNTIME:
671 case Form::JAVA_LEAF: 686 case Form::JAVA_LEAF:
672 case Form::JAVA_NATIVE: 687 case Form::JAVA_NATIVE:
673 fprintf(fp," st->print(\" %%s\", _name);"); 688 fprintf(fp," st->print(\" %%s\", _name);");
674 break; 689 break;
675 default: 690 default:
676 assert(0,"ShouldNotReacHere"); 691 assert(0,"ShouldNotReachHere");
677 } 692 }
678 fprintf(fp, " st->print_cr(\"\");\n" ); 693 fprintf(fp, " st->print_cr(\"\");\n" );
679 fprintf(fp, " if (_jvms) _jvms->format(ra, this, st); else st->print_cr(\" No JVM State Info\");\n" ); 694 fprintf(fp, " if (_jvms) _jvms->format(ra, this, st); else st->print_cr(\" No JVM State Info\");\n" );
680 fprintf(fp, " st->print(\" # \");\n" ); 695 fprintf(fp, " st->print(\" # \");\n" );
681 fprintf(fp, " if( _jvms ) _oop_map->print_on(st);\n"); 696 fprintf(fp, " if( _jvms && _oop_map ) _oop_map->print_on(st);\n");
682 } 697 }
683 else if(inst.is_ideal_safepoint()) { 698 else if(inst.is_ideal_safepoint()) {
684 fprintf(fp, " st->print(\"\");\n" ); 699 fprintf(fp, " st->print(\"\");\n" );
685 fprintf(fp, " if (_jvms) _jvms->format(ra, this, st); else st->print_cr(\" No JVM State Info\");\n" ); 700 fprintf(fp, " if (_jvms) _jvms->format(ra, this, st); else st->print_cr(\" No JVM State Info\");\n" );
686 fprintf(fp, " st->print(\" # \");\n" ); 701 fprintf(fp, " st->print(\" # \");\n" );
687 fprintf(fp, " if( _jvms ) _oop_map->print_on(st);\n"); 702 fprintf(fp, " if( _jvms && _oop_map ) _oop_map->print_on(st);\n");
688 } 703 }
689 else if( inst.is_ideal_if() ) { 704 else if( inst.is_ideal_if() ) {
690 fprintf(fp, " st->print(\" P=%%f C=%%f\",_prob,_fcnt);\n" ); 705 fprintf(fp, " st->print(\" P=%%f C=%%f\",_prob,_fcnt);\n" );
691 } 706 }
692 else if( inst.is_ideal_mem() ) { 707 else if( inst.is_ideal_mem() ) {
693 // Print out the field name if available to improve readability 708 // Print out the field name if available to improve readability
694 fprintf(fp, " if (ra->C->alias_type(adr_type())->field() != NULL) {\n"); 709 fprintf(fp, " if (ra->C->alias_type(adr_type())->field() != NULL) {\n");
695 fprintf(fp, " ciField* f = ra->C->alias_type(adr_type())->field();\n"); 710 fprintf(fp, " ciField* f = ra->C->alias_type(adr_type())->field();\n");
696 fprintf(fp, " st->print(\" ! Field: \");\n"); 711 fprintf(fp, " st->print(\" %s Field: \");\n", commentSeperator);
697 fprintf(fp, " if (f->is_volatile())\n"); 712 fprintf(fp, " if (f->is_volatile())\n");
698 fprintf(fp, " st->print(\"volatile \");\n"); 713 fprintf(fp, " st->print(\"volatile \");\n");
699 fprintf(fp, " f->holder()->name()->print_symbol_on(st);\n"); 714 fprintf(fp, " f->holder()->name()->print_symbol_on(st);\n");
700 fprintf(fp, " st->print(\".\");\n"); 715 fprintf(fp, " st->print(\".\");\n");
701 fprintf(fp, " f->name()->print_symbol_on(st);\n"); 716 fprintf(fp, " f->name()->print_symbol_on(st);\n");
702 fprintf(fp, " if (f->is_constant())\n"); 717 fprintf(fp, " if (f->is_constant())\n");
703 fprintf(fp, " st->print(\" (constant)\");\n"); 718 fprintf(fp, " st->print(\" (constant)\");\n");
704 fprintf(fp, " } else\n"); 719 fprintf(fp, " } else {\n");
705 // Make sure 'Volatile' gets printed out 720 // Make sure 'Volatile' gets printed out
706 fprintf(fp, " if (ra->C->alias_type(adr_type())->is_volatile())\n"); 721 fprintf(fp, " if (ra->C->alias_type(adr_type())->is_volatile())\n");
707 fprintf(fp, " st->print(\" volatile!\");\n"); 722 fprintf(fp, " st->print(\" volatile!\");\n");
723 fprintf(fp, " }\n");
708 } 724 }
709 725
710 // Complete the definition of the format function 726 // Complete the definition of the format function
711 fprintf(fp, " }\n#endif\n"); 727 fprintf(fp, "}\n#endif\n");
712 }
713
714 static bool is_non_constant(char* x) {
715 // Tells whether the string (part of an operator interface) is non-constant.
716 // Simply detect whether there is an occurrence of a formal parameter,
717 // which will always begin with '$'.
718 return strchr(x, '$') == 0;
719 } 728 }
720 729
721 void ArchDesc::declare_pipe_classes(FILE *fp_hpp) { 730 void ArchDesc::declare_pipe_classes(FILE *fp_hpp) {
722 if (!_pipeline) 731 if (!_pipeline)
723 return; 732 return;
1105 _pipeline->_nopcnt); 1114 _pipeline->_nopcnt);
1106 fprintf(fp_hpp, " };\n\n"); 1115 fprintf(fp_hpp, " };\n\n");
1107 fprintf(fp_hpp, " static void initialize_nops(MachNode *nop_list[%d], Compile* C);\n\n", 1116 fprintf(fp_hpp, " static void initialize_nops(MachNode *nop_list[%d], Compile* C);\n\n",
1108 _pipeline->_nopcnt); 1117 _pipeline->_nopcnt);
1109 fprintf(fp_hpp, "#ifndef PRODUCT\n"); 1118 fprintf(fp_hpp, "#ifndef PRODUCT\n");
1110 fprintf(fp_hpp, " void dump() const;\n"); 1119 fprintf(fp_hpp, " void dump(outputStream *st = tty) const;\n");
1111 fprintf(fp_hpp, "#endif\n"); 1120 fprintf(fp_hpp, "#endif\n");
1112 fprintf(fp_hpp, "};\n\n"); 1121 fprintf(fp_hpp, "};\n\n");
1113 1122
1114 // const char *classname; 1123 // const char *classname;
1115 // for (_pipeline->_classlist.reset(); (classname = _pipeline->_classlist.iter()) != NULL; ) { 1124 // for (_pipeline->_classlist.reset(); (classname = _pipeline->_classlist.iter()) != NULL; ) {
1250 if ((oper->_matrule) && (oper->_matrule->_lChild == NULL) && 1259 if ((oper->_matrule) && (oper->_matrule->_lChild == NULL) &&
1251 (oper->_matrule->_rChild == NULL)) { 1260 (oper->_matrule->_rChild == NULL)) {
1252 unsigned int position = 0; 1261 unsigned int position = 0;
1253 const char *opret, *opname, *optype; 1262 const char *opret, *opname, *optype;
1254 oper->_matrule->base_operand(position,_globalNames,opret,opname,optype); 1263 oper->_matrule->base_operand(position,_globalNames,opret,opname,optype);
1255 fprintf(fp," virtual const Type *type() const {"); 1264 fprintf(fp," virtual const Type *type() const {");
1256 const char *type = getIdealType(optype); 1265 const char *type = getIdealType(optype);
1257 if( type != NULL ) { 1266 if( type != NULL ) {
1258 Form::DataType data_type = oper->is_base_constant(_globalNames); 1267 Form::DataType data_type = oper->is_base_constant(_globalNames);
1259 // Check if we are an ideal pointer type 1268 // Check if we are an ideal pointer type
1260 if( data_type == Form::idealP || data_type == Form::idealN || data_type == Form::idealNKlass ) { 1269 if( data_type == Form::idealP || data_type == Form::idealN || data_type == Form::idealNKlass ) {
1529 fprintf(fp," MachOper *_opnd_array[%d];\n", instr->num_opnds() ); 1538 fprintf(fp," MachOper *_opnd_array[%d];\n", instr->num_opnds() );
1530 if ( instr->is_ideal_jump() ) { 1539 if ( instr->is_ideal_jump() ) {
1531 fprintf(fp, " GrowableArray<Label*> _index2label;\n"); 1540 fprintf(fp, " GrowableArray<Label*> _index2label;\n");
1532 } 1541 }
1533 fprintf(fp,"public:\n"); 1542 fprintf(fp,"public:\n");
1534 fprintf(fp," MachOper *opnd_array(uint operand_index) const { assert(operand_index < _num_opnds, \"invalid _opnd_array index\"); return _opnd_array[operand_index]; }\n"); 1543 fprintf(fp," MachOper *opnd_array(uint operand_index) const {\n");
1535 fprintf(fp," void set_opnd_array(uint operand_index, MachOper *operand) { assert(operand_index < _num_opnds, \"invalid _opnd_array index\"); _opnd_array[operand_index] = operand; }\n"); 1544 fprintf(fp," assert(operand_index < _num_opnds, \"invalid _opnd_array index\");\n");
1545 fprintf(fp," return _opnd_array[operand_index];\n");
1546 fprintf(fp," }\n");
1547 fprintf(fp," void set_opnd_array(uint operand_index, MachOper *operand) {\n");
1548 fprintf(fp," assert(operand_index < _num_opnds, \"invalid _opnd_array index\");\n");
1549 fprintf(fp," _opnd_array[operand_index] = operand;\n");
1550 fprintf(fp," }\n");
1536 fprintf(fp,"private:\n"); 1551 fprintf(fp,"private:\n");
1537 if ( instr->is_ideal_jump() ) { 1552 if ( instr->is_ideal_jump() ) {
1538 fprintf(fp," virtual void add_case_label(int index_num, Label* blockLabel) {\n"); 1553 fprintf(fp," virtual void add_case_label(int index_num, Label* blockLabel) {\n");
1539 fprintf(fp," _index2label.at_put_grow(index_num, blockLabel);}\n"); 1554 fprintf(fp," _index2label.at_put_grow(index_num, blockLabel);\n");
1555 fprintf(fp," }\n");
1540 } 1556 }
1541 if( can_cisc_spill() && (instr->cisc_spill_alternate() != NULL) ) { 1557 if( can_cisc_spill() && (instr->cisc_spill_alternate() != NULL) ) {
1542 fprintf(fp," const RegMask *_cisc_RegMask;\n"); 1558 fprintf(fp," const RegMask *_cisc_RegMask;\n");
1543 } 1559 }
1544 1560
1570 Attribute *attr = instr->_attribs; 1586 Attribute *attr = instr->_attribs;
1571 bool avoid_back_to_back = false; 1587 bool avoid_back_to_back = false;
1572 while (attr != NULL) { 1588 while (attr != NULL) {
1573 if (strcmp(attr->_ident,"ins_cost") && 1589 if (strcmp(attr->_ident,"ins_cost") &&
1574 strcmp(attr->_ident,"ins_short_branch")) { 1590 strcmp(attr->_ident,"ins_short_branch")) {
1575 fprintf(fp," int %s() const { return %s; }\n", 1591 fprintf(fp," int %s() const { return %s; }\n",
1576 attr->_ident, attr->_val); 1592 attr->_ident, attr->_val);
1577 } 1593 }
1578 // Check value for ins_avoid_back_to_back, and if it is true (1), set the flag 1594 // Check value for ins_avoid_back_to_back, and if it is true (1), set the flag
1579 if (!strcmp(attr->_ident,"ins_avoid_back_to_back") && attr->int_val(*this) != 0) 1595 if (!strcmp(attr->_ident,"ins_avoid_back_to_back") && attr->int_val(*this) != 0)
1580 avoid_back_to_back = true; 1596 avoid_back_to_back = true;
1654 fprintf(fp," virtual MachNode *peephole(Block *block, int block_index, PhaseRegAlloc *ra_, int &deleted, Compile *C);\n"); 1670 fprintf(fp," virtual MachNode *peephole(Block *block, int block_index, PhaseRegAlloc *ra_, int &deleted, Compile *C);\n");
1655 } 1671 }
1656 1672
1657 // Output the declaration for number of relocation entries 1673 // Output the declaration for number of relocation entries
1658 if ( instr->reloc(_globalNames) != 0 ) { 1674 if ( instr->reloc(_globalNames) != 0 ) {
1659 fprintf(fp," virtual int reloc() const;\n"); 1675 fprintf(fp," virtual int reloc() const;\n");
1660 } 1676 }
1661 1677
1662 if (instr->alignment() != 1) { 1678 if (instr->alignment() != 1) {
1663 fprintf(fp," virtual int alignment_required() const { return %d; }\n", instr->alignment()); 1679 fprintf(fp," virtual int alignment_required() const { return %d; }\n", instr->alignment());
1664 fprintf(fp," virtual int compute_padding(int current_offset) const;\n"); 1680 fprintf(fp," virtual int compute_padding(int current_offset) const;\n");
1665 } 1681 }
1666 1682
1667 // Starting point for inputs matcher wants. 1683 // Starting point for inputs matcher wants.
1668 // Use MachNode::oper_input_base() for nodes based on MachNode class 1684 // Use MachNode::oper_input_base() for nodes based on MachNode class
1669 // if the base == 1. 1685 // if the base == 1.
1829 // !!!!! 1845 // !!!!!
1830 // Convert all ints, floats, ... to machine-independent TypeXs 1846 // Convert all ints, floats, ... to machine-independent TypeXs
1831 // as is done for pointers 1847 // as is done for pointers
1832 // 1848 //
1833 // Construct appropriate constant type containing the constant value. 1849 // Construct appropriate constant type containing the constant value.
1834 fprintf(fp," virtual const class Type *bottom_type() const{\n"); 1850 fprintf(fp," virtual const class Type *bottom_type() const {\n");
1835 switch( data_type ) { 1851 switch( data_type ) {
1836 case Form::idealI: 1852 case Form::idealI:
1837 fprintf(fp," return TypeInt::make(opnd_array(1)->constant());\n"); 1853 fprintf(fp," return TypeInt::make(opnd_array(1)->constant());\n");
1838 break; 1854 break;
1839 case Form::idealP: 1855 case Form::idealP:
1860 ( strcmp("ConvF2I",instr->_matrule->_rChild->_opType)==0 1876 ( strcmp("ConvF2I",instr->_matrule->_rChild->_opType)==0
1861 || strcmp("ConvD2I",instr->_matrule->_rChild->_opType)==0 ) ) { 1877 || strcmp("ConvD2I",instr->_matrule->_rChild->_opType)==0 ) ) {
1862 // !!!!! !!!!! 1878 // !!!!! !!!!!
1863 // Provide explicit bottom type for conversions to int 1879 // Provide explicit bottom type for conversions to int
1864 // On Intel the result operand is a stackSlot, untyped. 1880 // On Intel the result operand is a stackSlot, untyped.
1865 fprintf(fp," virtual const class Type *bottom_type() const{"); 1881 fprintf(fp," virtual const class Type *bottom_type() const {");
1866 fprintf(fp, " return TypeInt::INT;"); 1882 fprintf(fp, " return TypeInt::INT;");
1867 fprintf(fp, " };\n"); 1883 fprintf(fp, " };\n");
1868 }*/ 1884 }*/
1869 else if( instr->is_ideal_copy() && 1885 else if( instr->is_ideal_copy() &&
1870 !strcmp(instr->_matrule->_lChild->_opType,"stackSlotP") ) { 1886 !strcmp(instr->_matrule->_lChild->_opType,"stackSlotP") ) {
1881 } 1897 }
1882 else if( instr->is_ideal_box() ) { 1898 else if( instr->is_ideal_box() ) {
1883 // BoxNode provides the address of a stack slot. 1899 // BoxNode provides the address of a stack slot.
1884 // Define its bottom type to be TypeRawPtr::BOTTOM instead of TypePtr::BOTTOM 1900 // Define its bottom type to be TypeRawPtr::BOTTOM instead of TypePtr::BOTTOM
1885 // This prevent s insert_anti_dependencies from complaining. It will 1901 // This prevent s insert_anti_dependencies from complaining. It will
1886 // complain if it see that the pointer base is TypePtr::BOTTOM since 1902 // complain if it sees that the pointer base is TypePtr::BOTTOM since
1887 // it doesn't understand what that might alias. 1903 // it doesn't understand what that might alias.
1888 fprintf(fp," const Type *bottom_type() const { return TypeRawPtr::BOTTOM; } // Box?\n"); 1904 fprintf(fp," const Type *bottom_type() const { return TypeRawPtr::BOTTOM; } // Box?\n");
1889 } 1905 }
1890 else if( instr->_matrule && instr->_matrule->_rChild && !strcmp(instr->_matrule->_rChild->_opType,"CMoveP") ) { 1906 else if( instr->_matrule && instr->_matrule->_rChild && !strcmp(instr->_matrule->_rChild->_opType,"CMoveP") ) {
1891 int offset = 1; 1907 int offset = 1;
2044 2060
2045 // Information needed to generate the ReduceOp mapping for the DFA 2061 // Information needed to generate the ReduceOp mapping for the DFA
2046 class OutputMachOperands : public OutputMap { 2062 class OutputMachOperands : public OutputMap {
2047 public: 2063 public:
2048 OutputMachOperands(FILE *hpp, FILE *cpp, FormDict &globals, ArchDesc &AD) 2064 OutputMachOperands(FILE *hpp, FILE *cpp, FormDict &globals, ArchDesc &AD)
2049 : OutputMap(hpp, cpp, globals, AD) {}; 2065 : OutputMap(hpp, cpp, globals, AD, "MachOperands") {};
2050 2066
2051 void declaration() { } 2067 void declaration() { }
2052 void definition() { fprintf(_cpp, "enum MachOperands {\n"); } 2068 void definition() { fprintf(_cpp, "enum MachOperands {\n"); }
2053 void closing() { fprintf(_cpp, " _LAST_MACH_OPER\n"); 2069 void closing() { fprintf(_cpp, " _LAST_MACH_OPER\n");
2054 OutputMap::closing(); 2070 OutputMap::closing();
2079 int begin_rematerialize; 2095 int begin_rematerialize;
2080 int end_rematerialize; 2096 int end_rematerialize;
2081 int end_instructions; 2097 int end_instructions;
2082 public: 2098 public:
2083 OutputMachOpcodes(FILE *hpp, FILE *cpp, FormDict &globals, ArchDesc &AD) 2099 OutputMachOpcodes(FILE *hpp, FILE *cpp, FormDict &globals, ArchDesc &AD)
2084 : OutputMap(hpp, cpp, globals, AD), 2100 : OutputMap(hpp, cpp, globals, AD, "MachOpcodes"),
2085 begin_inst_chain_rule(-1), end_inst_chain_rule(-1), end_instructions(-1) 2101 begin_inst_chain_rule(-1), end_inst_chain_rule(-1), end_instructions(-1)
2086 {}; 2102 {};
2087 2103
2088 void declaration() { } 2104 void declaration() { }
2089 void definition() { fprintf(_cpp, "enum MachOpcodes {\n"); } 2105 void definition() { fprintf(_cpp, "enum MachOpcodes {\n"); }