truffle: src/share/vm/adlc/adlparse.cpp comparison

comparison src/share/vm/adlc/adlparse.cpp @ 14456:abec000618bf

Merge

author	kvn
date	Tue, 28 Jan 2014 12:25:34 -0800
parents	de6a9e811145 318d0622a6d7
children	4ca6dc0799b6

comparison

equal deleted inserted replaced

-:2a8891e0a082
+:abec000618bf
 }
 }
 else if (!strcmp(ident, "encode"))  {
 parse_err(SYNERR, "Instructions specify ins_encode, not encode\n");
 }
-else if (!strcmp(ident, "ins_encode"))     ins_encode_parse(*instr);
+else if (!strcmp(ident, "ins_encode"))       ins_encode_parse(*instr);
-else if (!strcmp(ident, "opcode"))         instr->_opcode    = opcode_parse(instr);
+// Parse late expand keyword.
-else if (!strcmp(ident, "size"))           instr->_size      = size_parse(instr);
+else if (!strcmp(ident, "postalloc_expand")) postalloc_expand_parse(*instr);
-else if (!strcmp(ident, "effect"))         effect_parse(instr);
+else if (!strcmp(ident, "opcode"))           instr->_opcode    = opcode_parse(instr);
-else if (!strcmp(ident, "expand"))         instr->_exprule   = expand_parse(instr);
+else if (!strcmp(ident, "size"))             instr->_size      = size_parse(instr);
-else if (!strcmp(ident, "rewrite"))        instr->_rewrule   = rewrite_parse();
+else if (!strcmp(ident, "effect"))           effect_parse(instr);
+else if (!strcmp(ident, "expand"))           instr->_exprule   = expand_parse(instr);
+else if (!strcmp(ident, "rewrite"))          instr->_rewrule   = rewrite_parse();
 else if (!strcmp(ident, "constraint")) {
 parse_err(SYNERR, "Instructions do not specify a constraint\n");
 }
 else if (!strcmp(ident, "construct")) {
 parse_err(SYNERR, "Instructions do not specify a construct\n");
 }
-else if (!strcmp(ident, "format"))         instr->_format    = format_parse();
+else if (!strcmp(ident, "format"))           instr->_format    = format_parse();
 else if (!strcmp(ident, "interface")) {
 parse_err(SYNERR, "Instructions do not specify an interface\n");
 }
 else if (!strcmp(ident, "ins_pipe"))        ins_pipe_parse(*instr);
 else {  // Done with staticly defined parts of instruction definition
 // Check identifier to see if it is the name of an attribute
 const Form    *form = _globalNames[ident];
 AttributeForm *attr = form ? form->is_attribute() : NULL;
-if( attr && (attr->_atype == INS_ATTR) ) {
+if (attr && (attr->_atype == INS_ATTR)) {
 // Insert the new attribute into the linked list.
 Attribute *temp = attr_parse(ident);
 temp->_next = instr->_attribs;
 instr->_attribs = temp;
 } else {
-parse_err(SYNERR, "expected one of:\n predicate, match, encode, or the name of an instruction attribute at %s\n", ident);
+parse_err(SYNERR, "expected one of:\n predicate, match, encode, or the name of"
+" an instruction attribute at %s\n", ident);
 }
 }
 skipws();
 } while(_curchar != '%');
 next_char();
 parse_err(SYNERR, "missing '%%}' in instruction definition\n");
 return;
 }
 // Check for "Set" form of chain rule
 adjust_set_rule(instr);
-if (_AD._pipeline ) {
+if (_AD._pipeline) {
-if( instr->expands() ) {
+// No pipe required for late expand.
-if( instr->_ins_pipe )
+if (instr->expands() || instr->postalloc_expands()) {
-parse_err(WARN, "ins_pipe and expand rule both specified for instruction \"%s\"; ins_pipe will be unused\n", instr->_ident);
+if (instr->_ins_pipe) {
+parse_err(WARN, "ins_pipe and expand rule both specified for instruction \"%s\";"
+" ins_pipe will be unused\n", instr->_ident);
+}
 } else {
-if( !instr->_ins_pipe )
+if (!instr->_ins_pipe) {
 parse_err(WARN, "No ins_pipe specified for instruction \"%s\"\n", instr->_ident);
+}
 }
 }
 // Add instruction to tail of instruction list
 _AD.addForm(instr);
 while ((param = inst._parameters.iter()) != NULL) {
 OperandForm* opForm = (OperandForm*) inst._localNames[param];
 encoding->add_parameter(opForm->_ident, param);
 }
-// Define a MacroAssembler instance for use by the encoding.  The
+if (!inst._is_postalloc_expand) {
-// name is chosen to match the __ idiom used for assembly in other
+// Define a MacroAssembler instance for use by the encoding.  The
-// parts of hotspot and assumes the existence of the standard
+// name is chosen to match the __ idiom used for assembly in other
-// #define __ _masm.
+// parts of hotspot and assumes the existence of the standard
-encoding->add_code("    MacroAssembler _masm(&cbuf);\n");
+// #define __ _masm.
+encoding->add_code("    MacroAssembler _masm(&cbuf);\n");
+}
 // Parse the following %{ }% block
 ins_encode_parse_block_impl(inst, encoding, ec_name);
 // Build an encoding rule which invokes the encoding rule we just
 skipws();
 // Check if this instruct is a MachConstantNode.
 if (strcmp(rep_var, "constanttablebase") == 0) {
 // This instruct is a MachConstantNode.
-inst.set_is_mach_constant(true);
+inst.set_needs_constant_base(true);
+if (strncmp("MachCall", inst.mach_base_class(_globalNames), strlen("MachCall")) != 0 ) {
+inst.set_is_mach_constant(true);
+}
 if (_curchar == '(')  {
-parse_err(SYNERR, "constanttablebase in instruct %s cannot have an argument (only constantaddress and constantoffset)", ec_name);
+parse_err(SYNERR, "constanttablebase in instruct %s cannot have an argument "
+"(only constantaddress and constantoffset)", ec_name);
 return;
 }
 }
 else if ((strcmp(rep_var, "constantaddress")   == 0) ||
 (strcmp(rep_var, "constantoffset")    == 0)) {
 // Parse the encode method's parameters
 while (_curchar != ')') {
 char *param = get_ident_or_literal_constant("encoding operand");
 if ( param != NULL ) {
-// Found a parameter:
-// Check it is a local name, add it to the list, then check for more
+// Check if this instruct is a MachConstantNode.
-// New: allow hex constants as parameters to an encode method.
+if (strcmp(param, "constanttablebase") == 0) {
-// New: allow parenthesized expressions as parameters.
+// This instruct is a MachConstantNode.
-// New: allow "primary", "secondary", "tertiary" as parameters.
+inst.set_needs_constant_base(true);
-// New: allow user-defined register name as parameter
+if (strncmp("MachCall", inst.mach_base_class(_globalNames), strlen("MachCall")) != 0 ) {
-if ( (inst._localNames[param] == NULL) &&
+inst.set_is_mach_constant(true);
-!ADLParser::is_literal_constant(param) &&
+}
-(Opcode::as_opcode_type(param) == Opcode::NOT_AN_OPCODE) &&
-((_AD._register == NULL ) || (_AD._register->getRegDef(param) == NULL)) ) {
+if (_curchar == '(')  {
-parse_err(SYNERR, "Using non-locally defined parameter %s for encoding %s.\n", param, ec_name);
+parse_err(SYNERR, "constanttablebase in instruct %s cannot have an argument "
-return;
+"(only constantaddress and constantoffset)", ec_name);
+return;
+}
+} else {
+// Found a parameter:
+// Check it is a local name, add it to the list, then check for more
+// New: allow hex constants as parameters to an encode method.
+// New: allow parenthesized expressions as parameters.
+// New: allow "primary", "secondary", "tertiary" as parameters.
+// New: allow user-defined register name as parameter
+if ( (inst._localNames[param] == NULL) &&
+!ADLParser::is_literal_constant(param) &&
+(Opcode::as_opcode_type(param) == Opcode::NOT_AN_OPCODE) &&
+((_AD._register == NULL ) || (_AD._register->getRegDef(param) == NULL)) ) {
+parse_err(SYNERR, "Using non-locally defined parameter %s for encoding %s.\n", param, ec_name);
+return;
+}
 }
 params->add_entry(param);
 skipws();
 if (_curchar == ',' ) {
 return;
 }
 // Debug Stuff
 if (_AD._adl_debug > 1) fprintf(stderr,"Instruction Encode: %s\n", ec_name);
+// Set encode class of this instruction.
+inst._insencode = encrule;
+}
+//------------------------------postalloc_expand_parse---------------------------
+// Encode rules have the form
+//   postalloc_expand( encode_class_name(parameter_list) );
+//
+// The "encode_class_name" must be defined in the encode section.
+// The parameter list contains $names that are locals.
+//
+// This is just a copy of ins_encode_parse without the loop.
+void ADLParser::postalloc_expand_parse(InstructForm& inst) {
+inst._is_postalloc_expand = true;
+// Parse encode class name.
+skipws();                        // Skip whitespace.
+if (_curchar != '(') {
+// Check for postalloc_expand %{ form
+if ((_curchar == '%') && (*(_ptr+1) == '{')) {
+next_char();                      // Skip '%'
+next_char();                      // Skip '{'
+// Parse the block form of postalloc_expand
+ins_encode_parse_block(inst);
+return;
+}
+parse_err(SYNERR, "missing '(' in postalloc_expand definition\n");
+return;
+}
+next_char();                     // Move past '('.
+skipws();
+InsEncode *encrule = new InsEncode(); // Encode class for instruction.
+encrule->_linenum = linenum();
+char      *ec_name = NULL;       // String representation of encode rule.
+// identifier is optional.
+if (_curchar != ')') {
+ec_name = get_ident();
+if (ec_name == NULL) {
+parse_err(SYNERR, "Invalid postalloc_expand class name after 'postalloc_expand('.\n");
+return;
+}
+// Check that encoding is defined in the encode section.
+EncClass *encode_class = _AD._encode->encClass(ec_name);
+// Get list for encode method's parameters
+NameAndList *params = encrule->add_encode(ec_name);
+// Parse the parameters to this encode method.
+skipws();
+if (_curchar == '(') {
+next_char();                 // Move past '(' for parameters.
+// Parse the encode method's parameters.
+while (_curchar != ')') {
+char *param = get_ident_or_literal_constant("encoding operand");
+if (param != NULL) {
+// Found a parameter:
+// First check for constant table support.
+// Check if this instruct is a MachConstantNode.
+if (strcmp(param, "constanttablebase") == 0) {
+// This instruct is a MachConstantNode.
+inst.set_needs_constant_base(true);
+if (strncmp("MachCall", inst.mach_base_class(_globalNames), strlen("MachCall")) != 0 ) {
+inst.set_is_mach_constant(true);
+}
+if (_curchar == '(') {
+parse_err(SYNERR, "constanttablebase in instruct %s cannot have an argument "
+"(only constantaddress and constantoffset)", ec_name);
+return;
+}
+}
+else if ((strcmp(param, "constantaddress") == 0) ||
+(strcmp(param, "constantoffset")  == 0))  {
+// This instruct is a MachConstantNode.
+inst.set_is_mach_constant(true);
+// If the constant keyword has an argument, parse it.
+if (_curchar == '(') constant_parse(inst);
+}
+// Else check it is a local name, add it to the list, then check for more.
+// New: allow hex constants as parameters to an encode method.
+// New: allow parenthesized expressions as parameters.
+// New: allow "primary", "secondary", "tertiary" as parameters.
+// New: allow user-defined register name as parameter.
+else if ((inst._localNames[param] == NULL) &&
+!ADLParser::is_literal_constant(param) &&
+(Opcode::as_opcode_type(param) == Opcode::NOT_AN_OPCODE) &&
+((_AD._register == NULL) || (_AD._register->getRegDef(param) == NULL))) {
+parse_err(SYNERR, "Using non-locally defined parameter %s for encoding %s.\n", param, ec_name);
+return;
+}
+params->add_entry(param);
+skipws();
+if (_curchar == ',') {
+// More parameters to come.
+next_char();           // Move past ',' between parameters.
+skipws();              // Skip to next parameter.
+} else if (_curchar == ')') {
+// Done with parameter list
+} else {
+// Only ',' or ')' are valid after a parameter name.
+parse_err(SYNERR, "expected ',' or ')' after parameter %s.\n", ec_name);
+return;
+}
+} else {
+skipws();
+// Did not find a parameter.
+if (_curchar == ',') {
+parse_err(SYNERR, "Expected encode parameter before ',' in postalloc_expand %s.\n", ec_name);
+return;
+}
+if (_curchar != ')') {
+parse_err(SYNERR, "Expected ')' after postalloc_expand parameters.\n");
+return;
+}
+}
+} // WHILE loop collecting parameters.
+next_char();                 // Move past ')' at end of parameters.
+} // Done with parameter list for encoding.
+// Check for ',' or ')' after encoding.
+skipws();                      // Move to character after parameters.
+if (_curchar != ')') {
+// Only a ')' is allowed.
+parse_err(SYNERR, "Expected ')' after postalloc_expand %s.\n", ec_name);
+return;
+}
+} // Done parsing postalloc_expand method and their parameters.
+if (_curchar != ')') {
+parse_err(SYNERR, "Missing ')' at end of postalloc_expand description.\n");
+return;
+}
+next_char();                     // Move past ')'.
+skipws();                        // Skip leading whitespace.
+if (_curchar != ';') {
+parse_err(SYNERR, "Missing ';' at end of postalloc_expand.\n");
+return;
+}
+next_char();                     // Move past ';'.
+skipws();                        // Be friendly to oper_parse().
+// Debug Stuff.
+if (_AD._adl_debug > 1) fprintf(stderr, "Instruction postalloc_expand: %s\n", ec_name);
 // Set encode class of this instruction.
 inst._insencode = encrule;
 }
 }
 //------------------------------expand_parse-----------------------------------
 ExpandRule* ADLParser::expand_parse(InstructForm *instr) {
 char         *ident, *ident2;
-OperandForm  *oper;
-InstructForm *ins;
 NameAndList  *instr_and_operands = NULL;
 ExpandRule   *exp = new ExpandRule();
-// Expand is a block containing an ordered list of instructions, each of
+// Expand is a block containing an ordered list of operands with initializers,
-// which has an ordered list of operands.
+// or instructions, each of which has an ordered list of operands.
 // Check for block delimiter
 skipws();                        // Skip leading whitespace
 if ((_curchar != '%')
 || (next_char(), (_curchar != '{')) ) { // If not open block
 parse_err(SYNERR, "missing '%%{' in expand definition\n");
 do {
 ident = get_ident();           // Grab next identifier
 if (ident == NULL) {
 parse_err(SYNERR, "identifier expected at %c\n", _curchar);
 continue;
-}                              // Check that you have a valid instruction
+}
+// Check whether we should parse an instruction or operand.
 const Form *form = _globalNames[ident];
-ins = form ? form->is_instruction() : NULL;
+bool parse_oper = false;
-if (ins == NULL) {
+bool parse_ins  = false;
+if (form == NULL) {
+skipws();
+// Check whether this looks like an instruction specification.  If so,
+// just parse the instruction.  The declaration of the instruction is
+// not needed here.
+if (_curchar == '(') parse_ins = true;
+} else if (form->is_instruction()) {
+parse_ins = true;
+} else if (form->is_operand()) {
+parse_oper = true;
+} else {
+parse_err(SYNERR, "instruction/operand name expected at %s\n", ident);
+continue;
+}
+if (parse_oper) {
 // This is a new operand
-oper = form ? form->is_operand() : NULL;
+OperandForm *oper = form->is_operand();
 if (oper == NULL) {
 parse_err(SYNERR, "instruction/operand name expected at %s\n", ident);
 continue;
 }
 // Throw the operand on the _newopers list
 }
 else next_char(); // Skip the ;
 skipws();
 }
 else {
+assert(parse_ins, "sanity");
 // Add instruction to list
 instr_and_operands = new NameAndList(ident);
 // Grab operands, build nameList of them, and then put into dictionary
 skipws();
 if (_curchar != '(') {         // Check for parenthesized operand list
 const Form *form2 = instr->_localNames[ident2];
 if (!form2) {
 parse_err(SYNERR, "operand name expected at %s\n", ident2);
 continue;
 }
-oper = form2->is_operand();
+OperandForm *oper = form2->is_operand();
 if (oper == NULL && !form2->is_opclass()) {
 parse_err(SYNERR, "operand name expected at %s\n", ident2);
 continue;
 }                            // Add operand to list
 instr_and_operands->add_entry(ident2);

Mercurial > hg > truffle

comparison src/share/vm/adlc/adlparse.cpp @ 14456:abec000618bf