Mercurial > hg > truffle
comparison src/share/vm/adlc/output_c.cpp @ 18058:54bc75c144b0
Merge
author | asaha |
---|---|
date | Thu, 29 May 2014 13:14:25 -0700 |
parents | 62c54fcc0a35 |
children | 52b4284cb496 |
comparison
equal
deleted
inserted
replaced
18055:1fa005fb28f5 | 18058:54bc75c144b0 |
---|---|
1568 for(expand->reset_instructions(); | 1568 for(expand->reset_instructions(); |
1569 (expand_instr = expand->iter_instructions()) != NULL; cnt++) { | 1569 (expand_instr = expand->iter_instructions()) != NULL; cnt++) { |
1570 new_id = expand_instr->name(); | 1570 new_id = expand_instr->name(); |
1571 | 1571 |
1572 InstructForm* expand_instruction = (InstructForm*)globalAD->globalNames()[new_id]; | 1572 InstructForm* expand_instruction = (InstructForm*)globalAD->globalNames()[new_id]; |
1573 | |
1574 if (!expand_instruction) { | |
1575 globalAD->syntax_err(node->_linenum, "In %s: instruction %s used in expand not declared\n", | |
1576 node->_ident, new_id); | |
1577 continue; | |
1578 } | |
1579 | |
1573 if (expand_instruction->has_temps()) { | 1580 if (expand_instruction->has_temps()) { |
1574 globalAD->syntax_err(node->_linenum, "In %s: expand rules using instructs with TEMPs aren't supported: %s", | 1581 globalAD->syntax_err(node->_linenum, "In %s: expand rules using instructs with TEMPs aren't supported: %s", |
1575 node->_ident, new_id); | 1582 node->_ident, new_id); |
1576 } | 1583 } |
1577 | 1584 |
1590 fprintf(fp, " ((MachIfNode*)n%d)->_fcnt = _fcnt;\n",cnt); | 1597 fprintf(fp, " ((MachIfNode*)n%d)->_fcnt = _fcnt;\n",cnt); |
1591 } | 1598 } |
1592 | 1599 |
1593 if( node->is_ideal_fastlock() && new_inst->is_ideal_fastlock() ) { | 1600 if( node->is_ideal_fastlock() && new_inst->is_ideal_fastlock() ) { |
1594 fprintf(fp, " ((MachFastLockNode*)n%d)->_counters = _counters;\n",cnt); | 1601 fprintf(fp, " ((MachFastLockNode*)n%d)->_counters = _counters;\n",cnt); |
1602 fprintf(fp, " ((MachFastLockNode*)n%d)->_rtm_counters = _rtm_counters;\n",cnt); | |
1603 fprintf(fp, " ((MachFastLockNode*)n%d)->_stack_rtm_counters = _stack_rtm_counters;\n",cnt); | |
1595 } | 1604 } |
1596 | 1605 |
1597 // Fill in the bottom_type where requested | 1606 // Fill in the bottom_type where requested |
1598 if (node->captures_bottom_type(_globalNames) && | 1607 if (node->captures_bottom_type(_globalNames) && |
1599 new_inst->captures_bottom_type(_globalNames)) { | 1608 new_inst->captures_bottom_type(_globalNames)) { |
1626 int prev_pos = -1; | 1635 int prev_pos = -1; |
1627 for( expand_instr->reset(); (opid = expand_instr->iter()) != NULL; ) { | 1636 for( expand_instr->reset(); (opid = expand_instr->iter()) != NULL; ) { |
1628 // Use 'parameter' at current position in list of new instruction's formals | 1637 // Use 'parameter' at current position in list of new instruction's formals |
1629 // instead of 'opid' when looking up info internal to new_inst | 1638 // instead of 'opid' when looking up info internal to new_inst |
1630 const char *parameter = formal_lst->iter(); | 1639 const char *parameter = formal_lst->iter(); |
1640 if (!parameter) { | |
1641 globalAD->syntax_err(node->_linenum, "Operand %s of expand instruction %s has" | |
1642 " no equivalent in new instruction %s.", | |
1643 opid, node->_ident, new_inst->_ident); | |
1644 assert(0, "Wrong expand"); | |
1645 } | |
1646 | |
1631 // Check for an operand which is created in the expand rule | 1647 // Check for an operand which is created in the expand rule |
1632 if ((exp_pos = node->_exprule->_newopers.index(opid)) != -1) { | 1648 if ((exp_pos = node->_exprule->_newopers.index(opid)) != -1) { |
1633 new_pos = new_inst->operand_position(parameter,Component::USE); | 1649 new_pos = new_inst->operand_position(parameter,Component::USE); |
1634 exp_pos += node->num_opnds(); | 1650 exp_pos += node->num_opnds(); |
1635 // If there is no use of the created operand, just skip it | 1651 // If there is no use of the created operand, just skip it |
1823 } | 1839 } |
1824 } | 1840 } |
1825 | 1841 |
1826 // If the node is a MachConstantNode, insert the MachConstantBaseNode edge. | 1842 // If the node is a MachConstantNode, insert the MachConstantBaseNode edge. |
1827 // NOTE: this edge must be the last input (see MachConstantNode::mach_constant_base_node_input). | 1843 // NOTE: this edge must be the last input (see MachConstantNode::mach_constant_base_node_input). |
1828 if (node->is_mach_constant()) { | 1844 // There are nodes that don't use $constantablebase, but still require that it |
1829 fprintf(fp," add_req(C->mach_constant_base_node());\n"); | 1845 // is an input to the node. Example: divF_reg_immN, Repl32B_imm on x86_64. |
1830 } | 1846 if (node->is_mach_constant() || node->needs_constant_base()) { |
1831 | 1847 if (node->is_ideal_call() != Form::invalid_type && |
1832 fprintf(fp,"\n"); | 1848 node->is_ideal_call() != Form::JAVA_LEAF) { |
1833 if( node->expands() ) { | 1849 fprintf(fp, " // MachConstantBaseNode added in matcher.\n"); |
1834 fprintf(fp," return result;\n"); | 1850 _needs_clone_jvms = true; |
1851 } else { | |
1852 fprintf(fp, " add_req(C->mach_constant_base_node());\n"); | |
1853 } | |
1854 } | |
1855 | |
1856 fprintf(fp, "\n"); | |
1857 if (node->expands()) { | |
1858 fprintf(fp, " return result;\n"); | |
1835 } else { | 1859 } else { |
1836 fprintf(fp," return this;\n"); | 1860 fprintf(fp, " return this;\n"); |
1837 } | 1861 } |
1838 fprintf(fp,"}\n"); | 1862 fprintf(fp, "}\n"); |
1839 fprintf(fp,"\n"); | 1863 fprintf(fp, "\n"); |
1840 } | 1864 } |
1841 | 1865 |
1842 | 1866 |
1843 //------------------------------Emit Routines---------------------------------- | 1867 //------------------------------Emit Routines---------------------------------- |
1844 // Special classes and routines for defining node emit routines which output | 1868 // Special classes and routines for defining node emit routines which output |
1936 "'primary', 'secondary' and 'tertiary' don't follow operand."); | 1960 "'primary', 'secondary' and 'tertiary' don't follow operand."); |
1937 } | 1961 } |
1938 else if ((strcmp(rep_var, "constanttablebase") == 0) || | 1962 else if ((strcmp(rep_var, "constanttablebase") == 0) || |
1939 (strcmp(rep_var, "constantoffset") == 0) || | 1963 (strcmp(rep_var, "constantoffset") == 0) || |
1940 (strcmp(rep_var, "constantaddress") == 0)) { | 1964 (strcmp(rep_var, "constantaddress") == 0)) { |
1941 if (!_inst.is_mach_constant()) { | 1965 if (!(_inst.is_mach_constant() || _inst.needs_constant_base())) { |
1942 _AD.syntax_err(_encoding._linenum, | 1966 _AD.syntax_err(_encoding._linenum, |
1943 "Replacement variable %s not allowed in instruct %s (only in MachConstantNode).\n", | 1967 "Replacement variable %s not allowed in instruct %s (only in MachConstantNode or MachCall).\n", |
1944 rep_var, _encoding._name); | 1968 rep_var, _encoding._name); |
1945 } | 1969 } |
1946 } | 1970 } |
1947 else { | 1971 else { |
1948 // Lookup its position in (formal) parameter list of encoding | 1972 // Lookup its position in (formal) parameter list of encoding |
2101 if ( _reg_status != LITERAL_NOT_SEEN ) { | 2125 if ( _reg_status != LITERAL_NOT_SEEN ) { |
2102 assert( _reg_status == LITERAL_SEEN, "Must have seen register literal before now"); | 2126 assert( _reg_status == LITERAL_SEEN, "Must have seen register literal before now"); |
2103 if (strcmp(rep_var,"$reg") == 0 || reg_conversion(rep_var) != NULL) { | 2127 if (strcmp(rep_var,"$reg") == 0 || reg_conversion(rep_var) != NULL) { |
2104 _reg_status = LITERAL_ACCESSED; | 2128 _reg_status = LITERAL_ACCESSED; |
2105 } else { | 2129 } else { |
2130 _AD.syntax_err(_encoding._linenum, | |
2131 "Invalid access to literal register parameter '%s' in %s.\n", | |
2132 rep_var, _encoding._name); | |
2106 assert( false, "invalid access to literal register parameter"); | 2133 assert( false, "invalid access to literal register parameter"); |
2107 } | 2134 } |
2108 } | 2135 } |
2109 // literal constant parameters must be accessed as a 'constant' field | 2136 // literal constant parameters must be accessed as a 'constant' field |
2110 if ( _constant_status != LITERAL_NOT_SEEN ) { | 2137 if (_constant_status != LITERAL_NOT_SEEN) { |
2111 assert( _constant_status == LITERAL_SEEN, "Must have seen constant literal before now"); | 2138 assert(_constant_status == LITERAL_SEEN, "Must have seen constant literal before now"); |
2112 if( strcmp(rep_var,"$constant") == 0 ) { | 2139 if (strcmp(rep_var,"$constant") == 0) { |
2113 _constant_status = LITERAL_ACCESSED; | 2140 _constant_status = LITERAL_ACCESSED; |
2114 } else { | 2141 } else { |
2115 assert( false, "invalid access to literal constant parameter"); | 2142 _AD.syntax_err(_encoding._linenum, |
2143 "Invalid access to literal constant parameter '%s' in %s.\n", | |
2144 rep_var, _encoding._name); | |
2116 } | 2145 } |
2117 } | 2146 } |
2118 } // end replacement and/or subfield | 2147 } // end replacement and/or subfield |
2119 | 2148 |
2120 } | 2149 } |
2292 if (strcmp(rep_var,"$Register") == 0) return "as_Register"; | 2321 if (strcmp(rep_var,"$Register") == 0) return "as_Register"; |
2293 if (strcmp(rep_var,"$FloatRegister") == 0) return "as_FloatRegister"; | 2322 if (strcmp(rep_var,"$FloatRegister") == 0) return "as_FloatRegister"; |
2294 #if defined(IA32) || defined(AMD64) | 2323 #if defined(IA32) || defined(AMD64) |
2295 if (strcmp(rep_var,"$XMMRegister") == 0) return "as_XMMRegister"; | 2324 if (strcmp(rep_var,"$XMMRegister") == 0) return "as_XMMRegister"; |
2296 #endif | 2325 #endif |
2326 if (strcmp(rep_var,"$CondRegister") == 0) return "as_ConditionRegister"; | |
2297 return NULL; | 2327 return NULL; |
2298 } | 2328 } |
2299 | 2329 |
2300 void emit_field(const char *rep_var) { | 2330 void emit_field(const char *rep_var) { |
2301 const char* reg_convert = reg_conversion(rep_var); | 2331 const char* reg_convert = reg_conversion(rep_var); |
2486 //(2) | 2516 //(2) |
2487 // Print the size | 2517 // Print the size |
2488 fprintf(fp, " return (VerifyOops ? MachNode::size(ra_) : %s);\n", inst._size); | 2518 fprintf(fp, " return (VerifyOops ? MachNode::size(ra_) : %s);\n", inst._size); |
2489 | 2519 |
2490 // (3) and (4) | 2520 // (3) and (4) |
2491 fprintf(fp,"}\n"); | 2521 fprintf(fp,"}\n\n"); |
2522 } | |
2523 | |
2524 // Emit postalloc expand function. | |
2525 void ArchDesc::define_postalloc_expand(FILE *fp, InstructForm &inst) { | |
2526 InsEncode *ins_encode = inst._insencode; | |
2527 | |
2528 // Output instruction's postalloc_expand prototype. | |
2529 fprintf(fp, "void %sNode::postalloc_expand(GrowableArray <Node *> *nodes, PhaseRegAlloc *ra_) {\n", | |
2530 inst._ident); | |
2531 | |
2532 assert((_encode != NULL) && (ins_encode != NULL), "You must define an encode section."); | |
2533 | |
2534 // Output each operand's offset into the array of registers. | |
2535 inst.index_temps(fp, _globalNames); | |
2536 | |
2537 // Output variables "unsigned idx_<par_name>", Node *n_<par_name> and "MachOpnd *op_<par_name>" | |
2538 // for each parameter <par_name> specified in the encoding. | |
2539 ins_encode->reset(); | |
2540 const char *ec_name = ins_encode->encode_class_iter(); | |
2541 assert(ec_name != NULL, "Postalloc expand must specify an encoding."); | |
2542 | |
2543 EncClass *encoding = _encode->encClass(ec_name); | |
2544 if (encoding == NULL) { | |
2545 fprintf(stderr, "User did not define contents of this encode_class: %s\n", ec_name); | |
2546 abort(); | |
2547 } | |
2548 if (ins_encode->current_encoding_num_args() != encoding->num_args()) { | |
2549 globalAD->syntax_err(ins_encode->_linenum, "In %s: passing %d arguments to %s but expecting %d", | |
2550 inst._ident, ins_encode->current_encoding_num_args(), | |
2551 ec_name, encoding->num_args()); | |
2552 } | |
2553 | |
2554 fprintf(fp, " // Access to ins and operands for postalloc expand.\n"); | |
2555 const int buflen = 2000; | |
2556 char idxbuf[buflen]; char *ib = idxbuf; idxbuf[0] = '\0'; | |
2557 char nbuf [buflen]; char *nb = nbuf; nbuf[0] = '\0'; | |
2558 char opbuf [buflen]; char *ob = opbuf; opbuf[0] = '\0'; | |
2559 | |
2560 encoding->_parameter_type.reset(); | |
2561 encoding->_parameter_name.reset(); | |
2562 const char *type = encoding->_parameter_type.iter(); | |
2563 const char *name = encoding->_parameter_name.iter(); | |
2564 int param_no = 0; | |
2565 for (; (type != NULL) && (name != NULL); | |
2566 (type = encoding->_parameter_type.iter()), (name = encoding->_parameter_name.iter())) { | |
2567 const char* arg_name = ins_encode->rep_var_name(inst, param_no); | |
2568 int idx = inst.operand_position_format(arg_name); | |
2569 if (strcmp(arg_name, "constanttablebase") == 0) { | |
2570 ib += sprintf(ib, " unsigned idx_%-5s = mach_constant_base_node_input(); \t// %s, \t%s\n", | |
2571 name, type, arg_name); | |
2572 nb += sprintf(nb, " Node *n_%-7s = lookup(idx_%s);\n", name, name); | |
2573 // There is no operand for the constanttablebase. | |
2574 } else if (inst.is_noninput_operand(idx)) { | |
2575 globalAD->syntax_err(inst._linenum, | |
2576 "In %s: you can not pass the non-input %s to a postalloc expand encoding.\n", | |
2577 inst._ident, arg_name); | |
2578 } else { | |
2579 ib += sprintf(ib, " unsigned idx_%-5s = idx%d; \t// %s, \t%s\n", | |
2580 name, idx, type, arg_name); | |
2581 nb += sprintf(nb, " Node *n_%-7s = lookup(idx_%s);\n", name, name); | |
2582 ob += sprintf(ob, " %sOper *op_%s = (%sOper *)opnd_array(%d);\n", type, name, type, idx); | |
2583 } | |
2584 param_no++; | |
2585 } | |
2586 assert(ib < &idxbuf[buflen-1] && nb < &nbuf[buflen-1] && ob < &opbuf[buflen-1], "buffer overflow"); | |
2587 | |
2588 fprintf(fp, "%s", idxbuf); | |
2589 fprintf(fp, " Node *n_region = lookup(0);\n"); | |
2590 fprintf(fp, "%s%s", nbuf, opbuf); | |
2591 fprintf(fp, " Compile *C = ra_->C;\n"); | |
2592 | |
2593 // Output this instruction's encodings. | |
2594 fprintf(fp, " {"); | |
2595 const char *ec_code = NULL; | |
2596 const char *ec_rep_var = NULL; | |
2597 assert(encoding == _encode->encClass(ec_name), ""); | |
2598 | |
2599 DefineEmitState pending(fp, *this, *encoding, *ins_encode, inst); | |
2600 encoding->_code.reset(); | |
2601 encoding->_rep_vars.reset(); | |
2602 // Process list of user-defined strings, | |
2603 // and occurrences of replacement variables. | |
2604 // Replacement Vars are pushed into a list and then output. | |
2605 while ((ec_code = encoding->_code.iter()) != NULL) { | |
2606 if (! encoding->_code.is_signal(ec_code)) { | |
2607 // Emit pending code. | |
2608 pending.emit(); | |
2609 pending.clear(); | |
2610 // Emit this code section. | |
2611 fprintf(fp, "%s", ec_code); | |
2612 } else { | |
2613 // A replacement variable or one of its subfields. | |
2614 // Obtain replacement variable from list. | |
2615 ec_rep_var = encoding->_rep_vars.iter(); | |
2616 pending.add_rep_var(ec_rep_var); | |
2617 } | |
2618 } | |
2619 // Emit pending code. | |
2620 pending.emit(); | |
2621 pending.clear(); | |
2622 fprintf(fp, " }\n"); | |
2623 | |
2624 fprintf(fp, "}\n\n"); | |
2625 | |
2626 ec_name = ins_encode->encode_class_iter(); | |
2627 assert(ec_name == NULL, "Postalloc expand may only have one encoding."); | |
2492 } | 2628 } |
2493 | 2629 |
2494 // defineEmit ----------------------------------------------------------------- | 2630 // defineEmit ----------------------------------------------------------------- |
2495 void ArchDesc::defineEmit(FILE* fp, InstructForm& inst) { | 2631 void ArchDesc::defineEmit(FILE* fp, InstructForm& inst) { |
2496 InsEncode* encode = inst._insencode; | 2632 InsEncode* encode = inst._insencode; |
2839 fprintf(fp,"(PhaseRegAlloc *ra_, const Node *node, int idx) const { \n"); | 2975 fprintf(fp,"(PhaseRegAlloc *ra_, const Node *node, int idx) const { \n"); |
2840 emit_position = true; | 2976 emit_position = true; |
2841 } else if ( (strcmp(name,"disp") == 0) ) { | 2977 } else if ( (strcmp(name,"disp") == 0) ) { |
2842 fprintf(fp,"(PhaseRegAlloc *ra_, const Node *node, int idx) const { \n"); | 2978 fprintf(fp,"(PhaseRegAlloc *ra_, const Node *node, int idx) const { \n"); |
2843 } else { | 2979 } else { |
2844 fprintf(fp,"() const { \n"); | 2980 fprintf(fp, "() const {\n"); |
2845 } | 2981 } |
2846 | 2982 |
2847 // Check for hexadecimal value OR replacement variable | 2983 // Check for hexadecimal value OR replacement variable |
2848 if( *encoding == '$' ) { | 2984 if( *encoding == '$' ) { |
2849 // Replacement variable | 2985 // Replacement variable |
2889 } | 3025 } |
2890 else if( *encoding == '0' && *(encoding+1) == 'x' ) { | 3026 else if( *encoding == '0' && *(encoding+1) == 'x' ) { |
2891 // Hex value | 3027 // Hex value |
2892 fprintf(fp," return %s;\n", encoding); | 3028 fprintf(fp," return %s;\n", encoding); |
2893 } else { | 3029 } else { |
3030 globalAD->syntax_err(oper._linenum, "In operand %s: Do not support this encode constant: '%s' for %s.", | |
3031 oper._ident, encoding, name); | |
2894 assert( false, "Do not support octal or decimal encode constants"); | 3032 assert( false, "Do not support octal or decimal encode constants"); |
2895 } | 3033 } |
2896 fprintf(fp," }\n"); | 3034 fprintf(fp," }\n"); |
2897 | 3035 |
2898 if( emit_position && (position != -1) && (oper.num_edges(globals) > 0) ) { | 3036 if( emit_position && (position != -1) && (oper.num_edges(globals) > 0) ) { |
3053 if ( instr->ideal_only() ) continue; | 3191 if ( instr->ideal_only() ) continue; |
3054 // If there are multiple defs/kills, or an explicit expand rule, build rule | 3192 // If there are multiple defs/kills, or an explicit expand rule, build rule |
3055 if( instr->expands() || instr->needs_projections() || | 3193 if( instr->expands() || instr->needs_projections() || |
3056 instr->has_temps() || | 3194 instr->has_temps() || |
3057 instr->is_mach_constant() || | 3195 instr->is_mach_constant() || |
3196 instr->needs_constant_base() || | |
3058 instr->_matrule != NULL && | 3197 instr->_matrule != NULL && |
3059 instr->num_opnds() != instr->num_unique_opnds() ) | 3198 instr->num_opnds() != instr->num_unique_opnds() ) |
3060 defineExpand(_CPP_EXPAND_file._fp, instr); | 3199 defineExpand(_CPP_EXPAND_file._fp, instr); |
3061 // If there is an explicit peephole rule, build it | 3200 // If there is an explicit peephole rule, build it |
3062 if ( instr->peepholes() ) | 3201 if ( instr->peepholes() ) |
3140 _instructions.reset(); | 3279 _instructions.reset(); |
3141 for( ; (instr = (InstructForm*)_instructions.iter()) != NULL; ) { | 3280 for( ; (instr = (InstructForm*)_instructions.iter()) != NULL; ) { |
3142 // Ensure this is a machine-world instruction | 3281 // Ensure this is a machine-world instruction |
3143 if ( instr->ideal_only() ) continue; | 3282 if ( instr->ideal_only() ) continue; |
3144 | 3283 |
3145 if (instr->_insencode) defineEmit (fp, *instr); | 3284 if (instr->_insencode) { |
3285 if (instr->postalloc_expands()) { | |
3286 // Don't write this to _CPP_EXPAND_file, as the code generated calls C-code | |
3287 // from code sections in ad file that is dumped to fp. | |
3288 define_postalloc_expand(fp, *instr); | |
3289 } else { | |
3290 defineEmit(fp, *instr); | |
3291 } | |
3292 } | |
3146 if (instr->is_mach_constant()) defineEvalConstant(fp, *instr); | 3293 if (instr->is_mach_constant()) defineEvalConstant(fp, *instr); |
3147 if (instr->_size) defineSize (fp, *instr); | 3294 if (instr->_size) defineSize (fp, *instr); |
3148 | 3295 |
3149 // side-call to generate output that used to be in the header file: | 3296 // side-call to generate output that used to be in the header file: |
3150 extern void gen_inst_format(FILE *fp, FormDict &globals, InstructForm &oper, bool for_c_file); | 3297 extern void gen_inst_format(FILE *fp, FormDict &globals, InstructForm &oper, bool for_c_file); |
3499 else if (!strcmp(calling_convention, "SOC")) callconv = 'C'; | 3646 else if (!strcmp(calling_convention, "SOC")) callconv = 'C'; |
3500 else if (!strcmp(calling_convention, "AS")) callconv = 'A'; | 3647 else if (!strcmp(calling_convention, "AS")) callconv = 'A'; |
3501 else callconv = 'Z'; | 3648 else callconv = 'Z'; |
3502 | 3649 |
3503 return callconv; | 3650 return callconv; |
3651 } | |
3652 | |
3653 void ArchDesc::generate_needs_clone_jvms(FILE *fp_cpp) { | |
3654 fprintf(fp_cpp, "bool Compile::needs_clone_jvms() { return %s; }\n\n", | |
3655 _needs_clone_jvms ? "true" : "false"); | |
3504 } | 3656 } |
3505 | 3657 |
3506 //---------------------------generate_assertion_checks------------------- | 3658 //---------------------------generate_assertion_checks------------------- |
3507 void ArchDesc::generate_adlc_verification(FILE *fp_cpp) { | 3659 void ArchDesc::generate_adlc_verification(FILE *fp_cpp) { |
3508 fprintf(fp_cpp, "\n"); | 3660 fprintf(fp_cpp, "\n"); |
3817 fprintf(fp_cpp, " );\n"); | 3969 fprintf(fp_cpp, " );\n"); |
3818 // ##### | 3970 // ##### |
3819 } | 3971 } |
3820 | 3972 |
3821 // Fill in the bottom_type where requested | 3973 // Fill in the bottom_type where requested |
3822 if ( inst->captures_bottom_type(_globalNames) ) { | 3974 if (inst->captures_bottom_type(_globalNames)) { |
3823 fprintf(fp_cpp, "%s node->_bottom_type = _leaf->bottom_type();\n", indent); | 3975 if (strncmp("MachCall", inst->mach_base_class(_globalNames), strlen("MachCall"))) { |
3976 fprintf(fp_cpp, "%s node->_bottom_type = _leaf->bottom_type();\n", indent); | |
3977 } | |
3824 } | 3978 } |
3825 if( inst->is_ideal_if() ) { | 3979 if( inst->is_ideal_if() ) { |
3826 fprintf(fp_cpp, "%s node->_prob = _leaf->as_If()->_prob;\n", indent); | 3980 fprintf(fp_cpp, "%s node->_prob = _leaf->as_If()->_prob;\n", indent); |
3827 fprintf(fp_cpp, "%s node->_fcnt = _leaf->as_If()->_fcnt;\n", indent); | 3981 fprintf(fp_cpp, "%s node->_fcnt = _leaf->as_If()->_fcnt;\n", indent); |
3828 } | 3982 } |
3829 if( inst->is_ideal_fastlock() ) { | 3983 if( inst->is_ideal_fastlock() ) { |
3830 fprintf(fp_cpp, "%s node->_counters = _leaf->as_FastLock()->counters();\n", indent); | 3984 fprintf(fp_cpp, "%s node->_counters = _leaf->as_FastLock()->counters();\n", indent); |
3985 fprintf(fp_cpp, "%s node->_rtm_counters = _leaf->as_FastLock()->rtm_counters();\n", indent); | |
3986 fprintf(fp_cpp, "%s node->_stack_rtm_counters = _leaf->as_FastLock()->stack_rtm_counters();\n", indent); | |
3831 } | 3987 } |
3832 | 3988 |
3833 } | 3989 } |
3834 | 3990 |
3835 //---------------------------declare_cisc_version------------------------------ | 3991 //---------------------------declare_cisc_version------------------------------ |