--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/src/share/vm/adlc/archDesc.cpp Sat Dec 01 00:00:00 2007 +0000
@@ -0,0 +1,1131 @@
+//
+// Copyright 1997-2007 Sun Microsystems, Inc. All Rights Reserved.
+// DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+//
+// This code is free software; you can redistribute it and/or modify it
+// under the terms of the GNU General Public License version 2 only, as
+// published by the Free Software Foundation.
+//
+// This code is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+// version 2 for more details (a copy is included in the LICENSE file that
+// accompanied this code).
+//
+// You should have received a copy of the GNU General Public License version
+// 2 along with this work; if not, write to the Free Software Foundation,
+// Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+// CA 95054 USA or visit www.sun.com if you need additional information or
+// have any questions.
+//
+//
+
+
+// archDesc.cpp - Internal format for architecture definition
+#include "adlc.hpp"
+
+static FILE *errfile = stderr;
+
+//--------------------------- utility functions -----------------------------
+inline char toUpper(char lower) {
+ return (('a' <= lower && lower <= 'z') ? (lower + ('A'-'a')) : lower);
+}
+char *toUpper(const char *str) {
+ char *upper = new char[strlen(str)+1];
+ char *result = upper;
+ const char *end = str + strlen(str);
+ for (; str < end; ++str, ++upper) {
+ *upper = toUpper(*str);
+ }
+ *upper = '\0';
+ return result;
+}
+
+// Utilities to characterize effect statements
+static bool is_def(int usedef) {
+ switch(usedef) {
+ case Component::DEF:
+ case Component::USE_DEF: return true; break;
+ }
+ return false;
+}
+
+static bool is_use(int usedef) {
+ switch(usedef) {
+ case Component::USE:
+ case Component::USE_DEF:
+ case Component::USE_KILL: return true; break;
+ }
+ return false;
+}
+
+static bool is_kill(int usedef) {
+ switch(usedef) {
+ case Component::KILL:
+ case Component::USE_KILL: return true; break;
+ }
+ return false;
+}
+
+//---------------------------ChainList Methods-------------------------------
+ChainList::ChainList() {
+}
+
+void ChainList::insert(const char *name, const char *cost, const char *rule) {
+ _name.addName(name);
+ _cost.addName(cost);
+ _rule.addName(rule);
+}
+
+bool ChainList::search(const char *name) {
+ return _name.search(name);
+}
+
+void ChainList::reset() {
+ _name.reset();
+ _cost.reset();
+ _rule.reset();
+}
+
+bool ChainList::iter(const char * &name, const char * &cost, const char * &rule) {
+ bool notDone = false;
+ const char *n = _name.iter();
+ const char *c = _cost.iter();
+ const char *r = _rule.iter();
+
+ if (n && c && r) {
+ notDone = true;
+ name = n;
+ cost = c;
+ rule = r;
+ }
+
+ return notDone;
+}
+
+void ChainList::dump() {
+ output(stderr);
+}
+
+void ChainList::output(FILE *fp) {
+ fprintf(fp, "\nChain Rules: output resets iterator\n");
+ const char *cost = NULL;
+ const char *name = NULL;
+ const char *rule = NULL;
+ bool chains_exist = false;
+ for(reset(); (iter(name,cost,rule)) == true; ) {
+ fprintf(fp, "Chain to <%s> at cost #%s using %s_rule\n",name, cost ? cost : "0", rule);
+ // // Check for transitive chain rules
+ // Form *form = (Form *)_globalNames[rule];
+ // if (form->is_instruction()) {
+ // // chain_rule(fp, indent, name, cost, rule);
+ // chain_rule(fp, indent, name, cost, rule);
+ // }
+ }
+ reset();
+ if( ! chains_exist ) {
+ fprintf(fp, "No entries in this ChainList\n");
+ }
+}
+
+
+//---------------------------MatchList Methods-------------------------------
+bool MatchList::search(const char *opc, const char *res, const char *lch,
+ const char *rch, Predicate *pr) {
+ bool tmp = false;
+ if ((res == _resultStr) || (res && _resultStr && !strcmp(res, _resultStr))) {
+ if ((lch == _lchild) || (lch && _lchild && !strcmp(lch, _lchild))) {
+ if ((rch == _rchild) || (rch && _rchild && !strcmp(rch, _rchild))) {
+ char * predStr = get_pred();
+ char * prStr = pr?pr->_pred:NULL;
+ if ((prStr == predStr) || (prStr && predStr && !strcmp(prStr, predStr))) {
+ return true;
+ }
+ }
+ }
+ }
+ if (_next) {
+ tmp = _next->search(opc, res, lch, rch, pr);
+ }
+ return tmp;
+}
+
+
+void MatchList::dump() {
+ output(stderr);
+}
+
+void MatchList::output(FILE *fp) {
+ fprintf(fp, "\nMatchList output is Unimplemented();\n");
+}
+
+
+//---------------------------ArchDesc Constructor and Destructor-------------
+
+ArchDesc::ArchDesc()
+ : _globalNames(cmpstr,hashstr, Form::arena),
+ _globalDefs(cmpstr,hashstr, Form::arena),
+ _preproc_table(cmpstr,hashstr, Form::arena),
+ _idealIndex(cmpstr,hashstr, Form::arena),
+ _internalOps(cmpstr,hashstr, Form::arena),
+ _internalMatch(cmpstr,hashstr, Form::arena),
+ _chainRules(cmpstr,hashstr, Form::arena),
+ _cisc_spill_operand(NULL) {
+
+ // Initialize the opcode to MatchList table with NULLs
+ for( int i=0; i<_last_opcode; ++i ) {
+ _mlistab[i] = NULL;
+ }
+
+ // Set-up the global tables
+ initKeywords(_globalNames); // Initialize the Name Table with keywords
+
+ // Prime user-defined types with predefined types: Set, RegI, RegF, ...
+ initBaseOpTypes();
+
+ // Initialize flags & counters
+ _TotalLines = 0;
+ _no_output = 0;
+ _quiet_mode = 0;
+ _disable_warnings = 0;
+ _dfa_debug = 0;
+ _dfa_small = 0;
+ _adl_debug = 0;
+ _adlocation_debug = 0;
+ _internalOpCounter = 0;
+ _cisc_spill_debug = false;
+ _short_branch_debug = false;
+
+ // Initialize match rule flags
+ for (int i = 0; i < _last_opcode; i++) {
+ _has_match_rule[i] = false;
+ }
+
+ // Error/Warning Counts
+ _syntax_errs = 0;
+ _semantic_errs = 0;
+ _warnings = 0;
+ _internal_errs = 0;
+
+ // Initialize I/O Files
+ _ADL_file._name = NULL; _ADL_file._fp = NULL;
+ // Machine dependent output files
+ _DFA_file._name = "dfa_i486.cpp"; _DFA_file._fp = NULL;
+ _HPP_file._name = "ad_i486.hpp"; _HPP_file._fp = NULL;
+ _CPP_file._name = "ad_i486.cpp"; _CPP_file._fp = NULL;
+ _bug_file._name = "bugs.out"; _bug_file._fp = NULL;
+
+ // Initialize Register & Pipeline Form Pointers
+ _register = NULL;
+ _encode = NULL;
+ _pipeline = NULL;
+}
+
+ArchDesc::~ArchDesc() {
+ // Clean-up and quit
+
+}
+
+//---------------------------ArchDesc methods: Public ----------------------
+// Store forms according to type
+void ArchDesc::addForm(PreHeaderForm *ptr) { _pre_header.addForm(ptr); };
+void ArchDesc::addForm(HeaderForm *ptr) { _header.addForm(ptr); };
+void ArchDesc::addForm(SourceForm *ptr) { _source.addForm(ptr); };
+void ArchDesc::addForm(EncodeForm *ptr) { _encode = ptr; };
+void ArchDesc::addForm(InstructForm *ptr) { _instructions.addForm(ptr); };
+void ArchDesc::addForm(MachNodeForm *ptr) { _machnodes.addForm(ptr); };
+void ArchDesc::addForm(OperandForm *ptr) { _operands.addForm(ptr); };
+void ArchDesc::addForm(OpClassForm *ptr) { _opclass.addForm(ptr); };
+void ArchDesc::addForm(AttributeForm *ptr) { _attributes.addForm(ptr); };
+void ArchDesc::addForm(RegisterForm *ptr) { _register = ptr; };
+void ArchDesc::addForm(FrameForm *ptr) { _frame = ptr; };
+void ArchDesc::addForm(PipelineForm *ptr) { _pipeline = ptr; };
+
+// Build MatchList array and construct MatchLists
+void ArchDesc::generateMatchLists() {
+ // Call inspection routines to populate array
+ inspectOperands();
+ inspectInstructions();
+}
+
+// Build MatchList structures for operands
+void ArchDesc::inspectOperands() {
+
+ // Iterate through all operands
+ _operands.reset();
+ OperandForm *op;
+ for( ; (op = (OperandForm*)_operands.iter()) != NULL;) {
+ // Construct list of top-level operands (components)
+ op->build_components();
+
+ // Ensure that match field is defined.
+ if ( op->_matrule == NULL ) continue;
+
+ // Type check match rules
+ check_optype(op->_matrule);
+
+ // Construct chain rules
+ build_chain_rule(op);
+
+ MatchRule &mrule = *op->_matrule;
+ Predicate *pred = op->_predicate;
+
+ // Grab the machine type of the operand
+ const char *rootOp = op->_ident;
+ mrule._machType = rootOp;
+
+ // Check for special cases
+ if (strcmp(rootOp,"Universe")==0) continue;
+ if (strcmp(rootOp,"label")==0) continue;
+ // !!!!! !!!!!
+ assert( strcmp(rootOp,"sReg") != 0, "Disable untyped 'sReg'");
+ if (strcmp(rootOp,"sRegI")==0) continue;
+ if (strcmp(rootOp,"sRegP")==0) continue;
+ if (strcmp(rootOp,"sRegF")==0) continue;
+ if (strcmp(rootOp,"sRegD")==0) continue;
+ if (strcmp(rootOp,"sRegL")==0) continue;
+
+ // Cost for this match
+ const char *costStr = op->cost();
+ const char *defaultCost =
+ ((AttributeForm*)_globalNames[AttributeForm::_op_cost])->_attrdef;
+ const char *cost = costStr? costStr : defaultCost;
+
+ // Find result type for match.
+ const char *result = op->reduce_result();
+ bool has_root = false;
+
+ // Construct a MatchList for this entry
+ buildMatchList(op->_matrule, result, rootOp, pred, cost);
+ }
+}
+
+// Build MatchList structures for instructions
+void ArchDesc::inspectInstructions() {
+
+ // Iterate through all instructions
+ _instructions.reset();
+ InstructForm *instr;
+ for( ; (instr = (InstructForm*)_instructions.iter()) != NULL; ) {
+ // Construct list of top-level operands (components)
+ instr->build_components();
+
+ // Ensure that match field is defined.
+ if ( instr->_matrule == NULL ) continue;
+
+ MatchRule &mrule = *instr->_matrule;
+ Predicate *pred = instr->build_predicate();
+
+ // Grab the machine type of the operand
+ const char *rootOp = instr->_ident;
+ mrule._machType = rootOp;
+
+ // Cost for this match
+ const char *costStr = instr->cost();
+ const char *defaultCost =
+ ((AttributeForm*)_globalNames[AttributeForm::_ins_cost])->_attrdef;
+ const char *cost = costStr? costStr : defaultCost;
+
+ // Find result type for match
+ const char *result = instr->reduce_result();
+
+ Attribute *attr = instr->_attribs;
+ while (attr != NULL) {
+ if (strcmp(attr->_ident,"ins_short_branch") == 0 &&
+ attr->int_val(*this) != 0) {
+ instr->set_short_branch(true);
+ } else if (strcmp(attr->_ident,"ins_alignment") == 0 &&
+ attr->int_val(*this) != 0) {
+ instr->set_alignment(attr->int_val(*this));
+ }
+ attr = (Attribute *)attr->_next;
+ }
+
+ if (!instr->is_short_branch()) {
+ buildMatchList(instr->_matrule, result, mrule._machType, pred, cost);
+ }
+ }
+}
+
+static int setsResult(MatchRule &mrule) {
+ if (strcmp(mrule._name,"Set") == 0) return 1;
+ return 0;
+}
+
+const char *ArchDesc::getMatchListIndex(MatchRule &mrule) {
+ if (setsResult(mrule)) {
+ // right child
+ return mrule._rChild->_opType;
+ } else {
+ // first entry
+ return mrule._opType;
+ }
+}
+
+
+//------------------------------result of reduction----------------------------
+
+
+//------------------------------left reduction---------------------------------
+// Return the left reduction associated with an internal name
+const char *ArchDesc::reduceLeft(char *internalName) {
+ const char *left = NULL;
+ MatchNode *mnode = (MatchNode*)_internalMatch[internalName];
+ if (mnode->_lChild) {
+ mnode = mnode->_lChild;
+ left = mnode->_internalop ? mnode->_internalop : mnode->_opType;
+ }
+ return left;
+}
+
+
+//------------------------------right reduction--------------------------------
+const char *ArchDesc::reduceRight(char *internalName) {
+ const char *right = NULL;
+ MatchNode *mnode = (MatchNode*)_internalMatch[internalName];
+ if (mnode->_rChild) {
+ mnode = mnode->_rChild;
+ right = mnode->_internalop ? mnode->_internalop : mnode->_opType;
+ }
+ return right;
+}
+
+
+//------------------------------check_optype-----------------------------------
+void ArchDesc::check_optype(MatchRule *mrule) {
+ MatchRule *rule = mrule;
+
+ // !!!!!
+ // // Cycle through the list of match rules
+ // while(mrule) {
+ // // Check for a filled in type field
+ // if (mrule->_opType == NULL) {
+ // const Form *form = operands[_result];
+ // OpClassForm *opcForm = form ? form->is_opclass() : NULL;
+ // assert(opcForm != NULL, "Match Rule contains invalid operand name.");
+ // }
+ // char *opType = opcForm->_ident;
+ // }
+}
+
+//------------------------------add_chain_rule_entry--------------------------
+void ArchDesc::add_chain_rule_entry(const char *src, const char *cost,
+ const char *result) {
+ // Look-up the operation in chain rule table
+ ChainList *lst = (ChainList *)_chainRules[src];
+ if (lst == NULL) {
+ lst = new ChainList();
+ _chainRules.Insert(src, lst);
+ }
+ if (!lst->search(result)) {
+ if (cost == NULL) {
+ cost = ((AttributeForm*)_globalNames[AttributeForm::_op_cost])->_attrdef;
+ }
+ lst->insert(result, cost, result);
+ }
+}
+
+//------------------------------build_chain_rule-------------------------------
+void ArchDesc::build_chain_rule(OperandForm *oper) {
+ MatchRule *rule;
+
+ // Check for chain rules here
+ // If this is only a chain rule
+ if ((oper->_matrule) && (oper->_matrule->_lChild == NULL) &&
+ (oper->_matrule->_rChild == NULL)) {
+
+ const Form *form = _globalNames[oper->_matrule->_opType];
+ if ((form) && form->is_operand() &&
+ (form->ideal_only() == false)) {
+ add_chain_rule_entry(oper->_matrule->_opType, oper->cost(), oper->_ident);
+ }
+ // Check for additional chain rules
+ if (oper->_matrule->_next) {
+ rule = oper->_matrule;
+ do {
+ rule = rule->_next;
+ // Any extra match rules after the first must be chain rules
+ const Form *form = _globalNames[rule->_opType];
+ if ((form) && form->is_operand() &&
+ (form->ideal_only() == false)) {
+ add_chain_rule_entry(rule->_opType, oper->cost(), oper->_ident);
+ }
+ } while(rule->_next != NULL);
+ }
+ }
+ else if ((oper->_matrule) && (oper->_matrule->_next)) {
+ // Regardles of whether the first matchrule is a chain rule, check the list
+ rule = oper->_matrule;
+ do {
+ rule = rule->_next;
+ // Any extra match rules after the first must be chain rules
+ const Form *form = _globalNames[rule->_opType];
+ if ((form) && form->is_operand() &&
+ (form->ideal_only() == false)) {
+ assert( oper->cost(), "This case expects NULL cost, not default cost");
+ add_chain_rule_entry(rule->_opType, oper->cost(), oper->_ident);
+ }
+ } while(rule->_next != NULL);
+ }
+
+}
+
+//------------------------------buildMatchList---------------------------------
+// operands and instructions provide the result
+void ArchDesc::buildMatchList(MatchRule *mrule, const char *resultStr,
+ const char *rootOp, Predicate *pred,
+ const char *cost) {
+ const char *leftstr, *rightstr;
+ MatchNode *mnode;
+
+ leftstr = rightstr = NULL;
+ // Check for chain rule, and do not generate a match list for it
+ if ( mrule->is_chain_rule(_globalNames) ) {
+ return;
+ }
+
+ // Identify index position among ideal operands
+ intptr_t index = _last_opcode;
+ const char *indexStr = getMatchListIndex(*mrule);
+ index = (intptr_t)_idealIndex[indexStr];
+ if (index == 0) {
+ fprintf(stderr, "Ideal node missing: %s\n", indexStr);
+ assert(index != 0, "Failed lookup of ideal node\n");
+ }
+
+ // Check that this will be placed appropriately in the DFA
+ if (index >= _last_opcode) {
+ fprintf(stderr, "Invalid match rule %s <-- ( %s )\n",
+ resultStr ? resultStr : " ",
+ rootOp ? rootOp : " ");
+ assert(index < _last_opcode, "Matching item not in ideal graph\n");
+ return;
+ }
+
+
+ // Walk the MatchRule, generating MatchList entries for each level
+ // of the rule (each nesting of parentheses)
+ // Check for "Set"
+ if (!strcmp(mrule->_opType, "Set")) {
+ mnode = mrule->_rChild;
+ buildMList(mnode, rootOp, resultStr, pred, cost);
+ return;
+ }
+ // Build MatchLists for children
+ // Check each child for an internal operand name, and use that name
+ // for the parent's matchlist entry if it exists
+ mnode = mrule->_lChild;
+ if (mnode) {
+ buildMList(mnode, NULL, NULL, NULL, NULL);
+ leftstr = mnode->_internalop ? mnode->_internalop : mnode->_opType;
+ }
+ mnode = mrule->_rChild;
+ if (mnode) {
+ buildMList(mnode, NULL, NULL, NULL, NULL);
+ rightstr = mnode->_internalop ? mnode->_internalop : mnode->_opType;
+ }
+ // Search for an identical matchlist entry already on the list
+ if ((_mlistab[index] == NULL) ||
+ (_mlistab[index] &&
+ !_mlistab[index]->search(rootOp, resultStr, leftstr, rightstr, pred))) {
+ // Place this match rule at front of list
+ MatchList *mList =
+ new MatchList(_mlistab[index], pred, cost,
+ rootOp, resultStr, leftstr, rightstr);
+ _mlistab[index] = mList;
+ }
+}
+
+// Recursive call for construction of match lists
+void ArchDesc::buildMList(MatchNode *node, const char *rootOp,
+ const char *resultOp, Predicate *pred,
+ const char *cost) {
+ const char *leftstr, *rightstr;
+ const char *resultop;
+ const char *opcode;
+ MatchNode *mnode;
+ Form *form;
+
+ leftstr = rightstr = NULL;
+ // Do not process leaves of the Match Tree if they are not ideal
+ if ((node) && (node->_lChild == NULL) && (node->_rChild == NULL) &&
+ ((form = (Form *)_globalNames[node->_opType]) != NULL) &&
+ (!form->ideal_only())) {
+ return;
+ }
+
+ // Identify index position among ideal operands
+ intptr_t index = _last_opcode;
+ const char *indexStr = node ? node->_opType : (char *) " ";
+ index = (intptr_t)_idealIndex[indexStr];
+ if (index == 0) {
+ fprintf(stderr, "error: operand \"%s\" not found\n", indexStr);
+ assert(0, "fatal error");
+ }
+
+ // Build MatchLists for children
+ // Check each child for an internal operand name, and use that name
+ // for the parent's matchlist entry if it exists
+ mnode = node->_lChild;
+ if (mnode) {
+ buildMList(mnode, NULL, NULL, NULL, NULL);
+ leftstr = mnode->_internalop ? mnode->_internalop : mnode->_opType;
+ }
+ mnode = node->_rChild;
+ if (mnode) {
+ buildMList(mnode, NULL, NULL, NULL, NULL);
+ rightstr = mnode->_internalop ? mnode->_internalop : mnode->_opType;
+ }
+ // Grab the string for the opcode of this list entry
+ if (rootOp == NULL) {
+ opcode = (node->_internalop) ? node->_internalop : node->_opType;
+ } else {
+ opcode = rootOp;
+ }
+ // Grab the string for the result of this list entry
+ if (resultOp == NULL) {
+ resultop = (node->_internalop) ? node->_internalop : node->_opType;
+ }
+ else resultop = resultOp;
+ // Search for an identical matchlist entry already on the list
+ if ((_mlistab[index] == NULL) || (_mlistab[index] &&
+ !_mlistab[index]->search(opcode, resultop, leftstr, rightstr, pred))) {
+ // Place this match rule at front of list
+ MatchList *mList =
+ new MatchList(_mlistab[index],pred,cost,
+ opcode, resultop, leftstr, rightstr);
+ _mlistab[index] = mList;
+ }
+}
+
+// Count number of OperandForms defined
+int ArchDesc::operandFormCount() {
+ // Only interested in ones with non-NULL match rule
+ int count = 0; _operands.reset();
+ OperandForm *cur;
+ for( ; (cur = (OperandForm*)_operands.iter()) != NULL; ) {
+ if (cur->_matrule != NULL) ++count;
+ };
+ return count;
+}
+
+// Count number of OpClassForms defined
+int ArchDesc::opclassFormCount() {
+ // Only interested in ones with non-NULL match rule
+ int count = 0; _operands.reset();
+ OpClassForm *cur;
+ for( ; (cur = (OpClassForm*)_opclass.iter()) != NULL; ) {
+ ++count;
+ };
+ return count;
+}
+
+// Count number of InstructForms defined
+int ArchDesc::instructFormCount() {
+ // Only interested in ones with non-NULL match rule
+ int count = 0; _instructions.reset();
+ InstructForm *cur;
+ for( ; (cur = (InstructForm*)_instructions.iter()) != NULL; ) {
+ if (cur->_matrule != NULL) ++count;
+ };
+ return count;
+}
+
+
+//------------------------------get_preproc_def--------------------------------
+// Return the textual binding for a given CPP flag name.
+// Return NULL if there is no binding, or it has been #undef-ed.
+char* ArchDesc::get_preproc_def(const char* flag) {
+ SourceForm* deff = (SourceForm*) _preproc_table[flag];
+ return (deff == NULL) ? NULL : deff->_code;
+}
+
+
+//------------------------------set_preproc_def--------------------------------
+// Change or create a textual binding for a given CPP flag name.
+// Giving NULL means the flag name is to be #undef-ed.
+// In any case, _preproc_list collects all names either #defined or #undef-ed.
+void ArchDesc::set_preproc_def(const char* flag, const char* def) {
+ SourceForm* deff = (SourceForm*) _preproc_table[flag];
+ if (deff == NULL) {
+ deff = new SourceForm(NULL);
+ _preproc_table.Insert(flag, deff);
+ _preproc_list.addName(flag); // this supports iteration
+ }
+ deff->_code = (char*) def;
+}
+
+
+bool ArchDesc::verify() {
+
+ if (_register)
+ assert( _register->verify(), "Register declarations failed verification");
+ if (!_quiet_mode)
+ fprintf(stderr,"\n");
+ // fprintf(stderr,"---------------------------- Verify Operands ---------------\n");
+ // _operands.verify();
+ // fprintf(stderr,"\n");
+ // fprintf(stderr,"---------------------------- Verify Operand Classes --------\n");
+ // _opclass.verify();
+ // fprintf(stderr,"\n");
+ // fprintf(stderr,"---------------------------- Verify Attributes ------------\n");
+ // _attributes.verify();
+ // fprintf(stderr,"\n");
+ if (!_quiet_mode)
+ fprintf(stderr,"---------------------------- Verify Instructions ----------------------------\n");
+ _instructions.verify();
+ if (!_quiet_mode)
+ fprintf(stderr,"\n");
+ // if ( _encode ) {
+ // fprintf(stderr,"---------------------------- Verify Encodings --------------\n");
+ // _encode->verify();
+ // }
+
+ //if (_pipeline) _pipeline->verify();
+
+ return true;
+}
+
+
+void ArchDesc::dump() {
+ _pre_header.dump();
+ _header.dump();
+ _source.dump();
+ if (_register) _register->dump();
+ fprintf(stderr,"\n");
+ fprintf(stderr,"------------------ Dump Operands ---------------------\n");
+ _operands.dump();
+ fprintf(stderr,"\n");
+ fprintf(stderr,"------------------ Dump Operand Classes --------------\n");
+ _opclass.dump();
+ fprintf(stderr,"\n");
+ fprintf(stderr,"------------------ Dump Attributes ------------------\n");
+ _attributes.dump();
+ fprintf(stderr,"\n");
+ fprintf(stderr,"------------------ Dump Instructions -----------------\n");
+ _instructions.dump();
+ if ( _encode ) {
+ fprintf(stderr,"------------------ Dump Encodings --------------------\n");
+ _encode->dump();
+ }
+ if (_pipeline) _pipeline->dump();
+}
+
+
+//------------------------------init_keywords----------------------------------
+// Load the kewords into the global name table
+void ArchDesc::initKeywords(FormDict& names) {
+ // Insert keyword strings into Global Name Table. Keywords have a NULL value
+ // field for quick easy identification when checking identifiers.
+ names.Insert("instruct", NULL);
+ names.Insert("operand", NULL);
+ names.Insert("attribute", NULL);
+ names.Insert("source", NULL);
+ names.Insert("register", NULL);
+ names.Insert("pipeline", NULL);
+ names.Insert("constraint", NULL);
+ names.Insert("predicate", NULL);
+ names.Insert("encode", NULL);
+ names.Insert("enc_class", NULL);
+ names.Insert("interface", NULL);
+ names.Insert("opcode", NULL);
+ names.Insert("ins_encode", NULL);
+ names.Insert("match", NULL);
+ names.Insert("effect", NULL);
+ names.Insert("expand", NULL);
+ names.Insert("rewrite", NULL);
+ names.Insert("reg_def", NULL);
+ names.Insert("reg_class", NULL);
+ names.Insert("alloc_class", NULL);
+ names.Insert("resource", NULL);
+ names.Insert("pipe_class", NULL);
+ names.Insert("pipe_desc", NULL);
+}
+
+
+//------------------------------internal_err----------------------------------
+// Issue a parser error message, and skip to the end of the current line
+void ArchDesc::internal_err(const char *fmt, ...) {
+ va_list args;
+
+ va_start(args, fmt);
+ _internal_errs += emit_msg(0, INTERNAL_ERR, 0, fmt, args);
+ va_end(args);
+
+ _no_output = 1;
+}
+
+//------------------------------syntax_err----------------------------------
+// Issue a parser error message, and skip to the end of the current line
+void ArchDesc::syntax_err(int lineno, const char *fmt, ...) {
+ va_list args;
+
+ va_start(args, fmt);
+ _internal_errs += emit_msg(0, SYNERR, lineno, fmt, args);
+ va_end(args);
+
+ _no_output = 1;
+}
+
+//------------------------------emit_msg---------------------------------------
+// Emit a user message, typically a warning or error
+int ArchDesc::emit_msg(int quiet, int flag, int line, const char *fmt,
+ va_list args) {
+ static int last_lineno = -1;
+ int i;
+ const char *pref;
+
+ switch(flag) {
+ case 0: pref = "Warning: "; break;
+ case 1: pref = "Syntax Error: "; break;
+ case 2: pref = "Semantic Error: "; break;
+ case 3: pref = "Internal Error: "; break;
+ default: assert(0, ""); break;
+ }
+
+ if (line == last_lineno) return 0;
+ last_lineno = line;
+
+ if (!quiet) { /* no output if in quiet mode */
+ i = fprintf(errfile, "%s(%d) ", _ADL_file._name, line);
+ while (i++ <= 15) fputc(' ', errfile);
+ fprintf(errfile, "%-8s:", pref);
+ vfprintf(errfile, fmt, args);
+ fprintf(errfile, "\n"); }
+ return 1;
+}
+
+
+// ---------------------------------------------------------------------------
+//--------Utilities to build mappings for machine registers ------------------
+// ---------------------------------------------------------------------------
+
+// Construct the name of the register mask.
+static const char *getRegMask(const char *reg_class_name) {
+ if( reg_class_name == NULL ) return "RegMask::Empty";
+
+ if (strcmp(reg_class_name,"Universe")==0) {
+ return "RegMask::Empty";
+ } else if (strcmp(reg_class_name,"stack_slots")==0) {
+ return "(Compile::current()->FIRST_STACK_mask())";
+ } else {
+ char *rc_name = toUpper(reg_class_name);
+ const char *mask = "_mask";
+ int length = (int)strlen(rc_name) + (int)strlen(mask) + 3;
+ char *regMask = new char[length];
+ sprintf(regMask,"%s%s", rc_name, mask);
+ return regMask;
+ }
+}
+
+// Convert a register class name to its register mask.
+const char *ArchDesc::reg_class_to_reg_mask(const char *rc_name) {
+ const char *reg_mask = "RegMask::Empty";
+
+ if( _register ) {
+ RegClass *reg_class = _register->getRegClass(rc_name);
+ if (reg_class == NULL) {
+ syntax_err(0, "Use of an undefined register class %s", rc_name);
+ return reg_mask;
+ }
+
+ // Construct the name of the register mask.
+ reg_mask = getRegMask(rc_name);
+ }
+
+ return reg_mask;
+}
+
+
+// Obtain the name of the RegMask for an OperandForm
+const char *ArchDesc::reg_mask(OperandForm &opForm) {
+ const char *regMask = "RegMask::Empty";
+
+ // Check constraints on result's register class
+ const char *result_class = opForm.constrained_reg_class();
+ if (!result_class) opForm.dump();
+ assert( result_class, "Resulting register class was not defined for operand");
+ regMask = reg_class_to_reg_mask( result_class );
+
+ return regMask;
+}
+
+// Obtain the name of the RegMask for an InstructForm
+const char *ArchDesc::reg_mask(InstructForm &inForm) {
+ const char *result = inForm.reduce_result();
+ assert( result,
+ "Did not find result operand or RegMask for this instruction");
+
+ // Instructions producing 'Universe' use RegMask::Empty
+ if( strcmp(result,"Universe")==0 ) {
+ return "RegMask::Empty";
+ }
+
+ // Lookup this result operand and get its register class
+ Form *form = (Form*)_globalNames[result];
+ assert( form, "Result operand must be defined");
+ OperandForm *oper = form->is_operand();
+ assert( oper, "Result must be an OperandForm");
+ return reg_mask( *oper );
+}
+
+
+// Obtain the STACK_OR_reg_mask name for an OperandForm
+char *ArchDesc::stack_or_reg_mask(OperandForm &opForm) {
+ // name of cisc_spillable version
+ const char *reg_mask_name = reg_mask(opForm);
+ assert( reg_mask_name != NULL, "called with incorrect opForm");
+
+ const char *stack_or = "STACK_OR_";
+ int length = (int)strlen(stack_or) + (int)strlen(reg_mask_name) + 1;
+ char *result = new char[length];
+ sprintf(result,"%s%s", stack_or, reg_mask_name);
+
+ return result;
+}
+
+// Record that the register class must generate a stack_or_reg_mask
+void ArchDesc::set_stack_or_reg(const char *reg_class_name) {
+ if( _register ) {
+ RegClass *reg_class = _register->getRegClass(reg_class_name);
+ reg_class->_stack_or_reg = true;
+ }
+}
+
+
+// Return the type signature for the ideal operation
+const char *ArchDesc::getIdealType(const char *idealOp) {
+ // Find last character in idealOp, it specifies the type
+ char last_char = 0;
+ const char *ptr = idealOp;
+ for( ; *ptr != '\0'; ++ptr) {
+ last_char = *ptr;
+ }
+
+ // !!!!!
+ switch( last_char ) {
+ case 'I': return "TypeInt::INT";
+ case 'P': return "TypePtr::BOTTOM";
+ case 'F': return "Type::FLOAT";
+ case 'D': return "Type::DOUBLE";
+ case 'L': return "TypeLong::LONG";
+ case 's': return "TypeInt::CC /*flags*/";
+ default:
+ return NULL;
+ // !!!!!
+ // internal_err("Ideal type %s with unrecognized type\n",idealOp);
+ break;
+ }
+
+ return NULL;
+}
+
+
+
+OperandForm *ArchDesc::constructOperand(const char *ident,
+ bool ideal_only) {
+ OperandForm *opForm = new OperandForm(ident, ideal_only);
+ _globalNames.Insert(ident, opForm);
+ addForm(opForm);
+
+ return opForm;
+}
+
+
+// Import predefined base types: Set = 1, RegI, RegP, ...
+void ArchDesc::initBaseOpTypes() {
+ // Create OperandForm and assign type for each opcode.
+ for (int i = 1; i < _last_machine_leaf; ++i) {
+ char *ident = (char *)NodeClassNames[i];
+ constructOperand(ident, true);
+ }
+ // Create InstructForm and assign type for each ideal instruction.
+ for ( int j = _last_machine_leaf+1; j < _last_opcode; ++j) {
+ char *ident = (char *)NodeClassNames[j];
+ if(!strcmp(ident, "ConI") || !strcmp(ident, "ConP") ||
+ !strcmp(ident, "ConF") || !strcmp(ident, "ConD") ||
+ !strcmp(ident, "ConL") || !strcmp(ident, "Con" ) ||
+ !strcmp(ident, "Bool") ) {
+ constructOperand(ident, true);
+ }
+ else {
+ InstructForm *insForm = new InstructForm(ident, true);
+ // insForm->_opcode = nextUserOpType(ident);
+ _globalNames.Insert(ident,insForm);
+ addForm(insForm);
+ }
+ }
+
+ { OperandForm *opForm;
+ // Create operand type "Universe" for return instructions.
+ const char *ident = "Universe";
+ opForm = constructOperand(ident, false);
+
+ // Create operand type "label" for branch targets
+ ident = "label";
+ opForm = constructOperand(ident, false);
+
+ // !!!!! Update - when adding a new sReg/stackSlot type
+ // Create operand types "sReg[IPFDL]" for stack slot registers
+ opForm = constructOperand("sRegI", false);
+ opForm->_constraint = new Constraint("ALLOC_IN_RC", "stack_slots");
+ opForm = constructOperand("sRegP", false);
+ opForm->_constraint = new Constraint("ALLOC_IN_RC", "stack_slots");
+ opForm = constructOperand("sRegF", false);
+ opForm->_constraint = new Constraint("ALLOC_IN_RC", "stack_slots");
+ opForm = constructOperand("sRegD", false);
+ opForm->_constraint = new Constraint("ALLOC_IN_RC", "stack_slots");
+ opForm = constructOperand("sRegL", false);
+ opForm->_constraint = new Constraint("ALLOC_IN_RC", "stack_slots");
+
+ // Create operand type "method" for call targets
+ ident = "method";
+ opForm = constructOperand(ident, false);
+ }
+
+ // Create Effect Forms for each of the legal effects
+ // USE, DEF, USE_DEF, KILL, USE_KILL
+ {
+ const char *ident = "USE";
+ Effect *eForm = new Effect(ident);
+ _globalNames.Insert(ident, eForm);
+ ident = "DEF";
+ eForm = new Effect(ident);
+ _globalNames.Insert(ident, eForm);
+ ident = "USE_DEF";
+ eForm = new Effect(ident);
+ _globalNames.Insert(ident, eForm);
+ ident = "KILL";
+ eForm = new Effect(ident);
+ _globalNames.Insert(ident, eForm);
+ ident = "USE_KILL";
+ eForm = new Effect(ident);
+ _globalNames.Insert(ident, eForm);
+ ident = "TEMP";
+ eForm = new Effect(ident);
+ _globalNames.Insert(ident, eForm);
+ }
+
+ //
+ // Build mapping from ideal names to ideal indices
+ int idealIndex = 0;
+ for (idealIndex = 1; idealIndex < _last_machine_leaf; ++idealIndex) {
+ const char *idealName = NodeClassNames[idealIndex];
+ _idealIndex.Insert((void*)idealName, (void*)idealIndex);
+ }
+ for ( idealIndex = _last_machine_leaf+1;
+ idealIndex < _last_opcode; ++idealIndex) {
+ const char *idealName = NodeClassNames[idealIndex];
+ _idealIndex.Insert((void*)idealName, (void*)idealIndex);
+ }
+
+}
+
+
+//---------------------------addSUNcopyright-------------------------------
+// output SUN copyright info
+void ArchDesc::addSunCopyright(char* legal, int size, FILE *fp) {
+ fwrite(legal, size, 1, fp);
+ fprintf(fp,"\n");
+ fprintf(fp,"// Machine Generated File. Do Not Edit!\n");
+ fprintf(fp,"\n");
+}
+
+//---------------------------machineDependentIncludes--------------------------
+// output #include declarations for machine specific files
+void ArchDesc::machineDependentIncludes(ADLFILE &adlfile) {
+ const char *basename = adlfile._name;
+ const char *cp;
+ for (cp = basename; *cp; cp++)
+ if (*cp == '/') basename = cp+1;
+
+ // Build #include lines
+ fprintf(adlfile._fp, "\n");
+ fprintf(adlfile._fp, "#include \"incls/_precompiled.incl\"\n");
+ fprintf(adlfile._fp, "#include \"incls/_%s.incl\"\n",basename);
+ fprintf(adlfile._fp, "\n");
+
+}
+
+
+//---------------------------addPreprocessorChecks-----------------------------
+// Output C preprocessor code to verify the backend compilation environment.
+// The idea is to force code produced by "adlc -DHS64" to be compiled by a
+// command of the form "CC ... -DHS64 ...", so that any #ifdefs in the source
+// blocks select C code that is consistent with adlc's selections of AD code.
+void ArchDesc::addPreprocessorChecks(FILE *fp) {
+ const char* flag;
+ _preproc_list.reset();
+ if (_preproc_list.count() > 0 && !_preproc_list.current_is_signal()) {
+ fprintf(fp, "// Check consistency of C++ compilation with ADLC options:\n");
+ }
+ for (_preproc_list.reset(); (flag = _preproc_list.iter()) != NULL; ) {
+ if (_preproc_list.current_is_signal()) break;
+ char* def = get_preproc_def(flag);
+ fprintf(fp, "// Check adlc ");
+ if (def)
+ fprintf(fp, "-D%s=%s\n", flag, def);
+ else fprintf(fp, "-U%s\n", flag);
+ fprintf(fp, "#%s %s\n",
+ def ? "ifndef" : "ifdef", flag);
+ fprintf(fp, "# error \"%s %s be defined\"\n",
+ flag, def ? "must" : "must not");
+ fprintf(fp, "#endif // %s\n", flag);
+ }
+}
+
+
+// Convert operand name into enum name
+const char *ArchDesc::machOperEnum(const char *opName) {
+ return ArchDesc::getMachOperEnum(opName);
+}
+
+// Convert operand name into enum name
+const char *ArchDesc::getMachOperEnum(const char *opName) {
+ return (opName ? toUpper(opName) : opName);
+}
+
+//---------------------------buildMustCloneMap-----------------------------
+// Flag cases when machine needs cloned values or instructions
+void ArchDesc::buildMustCloneMap(FILE *fp_hpp, FILE *fp_cpp) {
+ // Build external declarations for mappings
+ fprintf(fp_hpp, "// Mapping from machine-independent opcode to boolean\n");
+ fprintf(fp_hpp, "// Flag cases where machine needs cloned values or instructions\n");
+ fprintf(fp_hpp, "extern const char must_clone[];\n");
+ fprintf(fp_hpp, "\n");
+
+ // Build mapping from ideal names to ideal indices
+ fprintf(fp_cpp, "\n");
+ fprintf(fp_cpp, "// Mapping from machine-independent opcode to boolean\n");
+ fprintf(fp_cpp, "const char must_clone[] = {\n");
+ for (int idealIndex = 0; idealIndex < _last_opcode; ++idealIndex) {
+ int must_clone = 0;
+ const char *idealName = NodeClassNames[idealIndex];
+ // Previously selected constants for cloning
+ // !!!!!
+ // These are the current machine-dependent clones
+ if ( strcmp(idealName,"CmpI") == 0
+ || strcmp(idealName,"CmpU") == 0
+ || strcmp(idealName,"CmpP") == 0
+ || strcmp(idealName,"CmpL") == 0
+ || strcmp(idealName,"CmpD") == 0
+ || strcmp(idealName,"CmpF") == 0
+ || strcmp(idealName,"FastLock") == 0
+ || strcmp(idealName,"FastUnlock") == 0
+ || strcmp(idealName,"Bool") == 0
+ || strcmp(idealName,"Binary") == 0 ) {
+ // Removed ConI from the must_clone list. CPUs that cannot use
+ // large constants as immediates manifest the constant as an
+ // instruction. The must_clone flag prevents the constant from
+ // floating up out of loops.
+ must_clone = 1;
+ }
+ fprintf(fp_cpp, " %d%s // %s: %d\n", must_clone,
+ (idealIndex != (_last_opcode - 1)) ? "," : " // no trailing comma",
+ idealName, idealIndex);
+ }
+ // Finish defining table
+ fprintf(fp_cpp, "};\n");
+}