c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith#include "adlc.hpp"

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmithstatic FILE *errfile = stderr;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmithinline char toUpper(char lower) {

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith return (('a' <= lower && lower <= 'z') ? (lower + ('A'-'a')) : lower);

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith}

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmithchar *toUpper(const char *str) {

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith char *upper = new char[strlen(str)+1];

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith char *result = upper;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith const char *end = str + strlen(str);

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith for (; str < end; ++str, ++upper) {

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith *upper = toUpper(*str);

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith }

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith *upper = '\0';

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith return result;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith}

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmithstatic bool is_def(int usedef) {

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith switch(usedef) {

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith case Component::DEF:

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith case Component::USE_DEF: return true; break;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith }

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith return false;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith}

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmithstatic bool is_use(int usedef) {

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith switch(usedef) {

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith case Component::USE:

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith case Component::USE_DEF:

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith case Component::USE_KILL: return true; break;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith }

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith return false;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith}

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmithstatic bool is_kill(int usedef) {

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith switch(usedef) {

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith case Component::KILL:

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith case Component::USE_KILL: return true; break;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith }

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith return false;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith}

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David GoldsmithChainList::ChainList() {

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith}

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmithvoid ChainList::insert(const char *name, const char *cost, const char *rule) {

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _name.addName(name);

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _cost.addName(cost);

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _rule.addName(rule);

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith}

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmithbool ChainList::search(const char *name) {

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith return _name.search(name);

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith}

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmithvoid ChainList::reset() {

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _name.reset();

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _cost.reset();

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _rule.reset();

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith}

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmithbool ChainList::iter(const char * &name, const char * &cost, const char * &rule) {

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith bool notDone = false;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith const char *n = _name.iter();

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith const char *c = _cost.iter();

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith const char *r = _rule.iter();

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith if (n && c && r) {

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith notDone = true;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith name = n;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith cost = c;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith rule = r;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith }

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith return notDone;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith}

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmithvoid ChainList::dump() {

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith output(stderr);

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith}

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmithvoid ChainList::output(FILE *fp) {

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith fprintf(fp, "\nChain Rules: output resets iterator\n");

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith const char *cost = NULL;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith const char *name = NULL;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith const char *rule = NULL;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith bool chains_exist = false;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith for(reset(); (iter(name,cost,rule)) == true; ) {

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith fprintf(fp, "Chain to <%s> at cost #%s using %s_rule\n",name, cost ? cost : "0", rule);

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith // // Check for transitive chain rules

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith // Form *form = (Form *)_globalNames[rule];

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith // if (form->is_instruction()) {

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith // // chain_rule(fp, indent, name, cost, rule);

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith // chain_rule(fp, indent, name, cost, rule);

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith // }

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith }

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith reset();

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith if( ! chains_exist ) {

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith fprintf(fp, "No entries in this ChainList\n");

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith }

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith}

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmithbool MatchList::search(const char *opc, const char *res, const char *lch,

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith const char *rch, Predicate *pr) {

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith bool tmp = false;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith if ((res == _resultStr) || (res && _resultStr && !strcmp(res, _resultStr))) {

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith if ((lch == _lchild) || (lch && _lchild && !strcmp(lch, _lchild))) {

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith if ((rch == _rchild) || (rch && _rchild && !strcmp(rch, _rchild))) {

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith char * predStr = get_pred();

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith char * prStr = pr?pr->_pred:NULL;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith if (ADLParser::equivalent_expressions(prStr, predStr)) {

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith return true;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith }

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith }

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith }

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith }

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith if (_next) {

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith tmp = _next->search(opc, res, lch, rch, pr);

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith }

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith return tmp;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith}

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmithvoid MatchList::dump() {

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith output(stderr);

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith}

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmithvoid MatchList::output(FILE *fp) {

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith fprintf(fp, "\nMatchList output is Unimplemented();\n");

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith}

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David GoldsmithArchDesc::ArchDesc()

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith : _globalNames(cmpstr,hashstr, Form::arena),

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _globalDefs(cmpstr,hashstr, Form::arena),

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _preproc_table(cmpstr,hashstr, Form::arena),

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _idealIndex(cmpstr,hashstr, Form::arena),

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _internalOps(cmpstr,hashstr, Form::arena),

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _internalMatch(cmpstr,hashstr, Form::arena),

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _chainRules(cmpstr,hashstr, Form::arena),

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _cisc_spill_operand(NULL) {

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith // Initialize the opcode to MatchList table with NULLs

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith for( int i=0; i<_last_opcode; ++i ) {

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _mlistab[i] = NULL;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith }

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith // Set-up the global tables

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith initKeywords(_globalNames); // Initialize the Name Table with keywords

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith // Prime user-defined types with predefined types: Set, RegI, RegF, ...

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith initBaseOpTypes();

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith // Initialize flags & counters

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _TotalLines = 0;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _no_output = 0;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _quiet_mode = 0;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _disable_warnings = 0;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _dfa_debug = 0;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _dfa_small = 0;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _adl_debug = 0;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _adlocation_debug = 0;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _internalOpCounter = 0;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _cisc_spill_debug = false;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _short_branch_debug = false;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith // Initialize match rule flags

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith for (int i = 0; i < _last_opcode; i++) {

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _has_match_rule[i] = false;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith }

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith // Error/Warning Counts

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _syntax_errs = 0;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _semantic_errs = 0;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _warnings = 0;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _internal_errs = 0;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith // Initialize I/O Files

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _ADL_file._name = NULL; _ADL_file._fp = NULL;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith // Machine dependent output files

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _DFA_file._name = NULL; _DFA_file._fp = NULL;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _HPP_file._name = NULL; _HPP_file._fp = NULL;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _CPP_file._name = NULL; _CPP_file._fp = NULL;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _bug_file._name = "bugs.out"; _bug_file._fp = NULL;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith // Initialize Register & Pipeline Form Pointers

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _register = NULL;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _encode = NULL;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _pipeline = NULL;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith _frame = NULL;

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith}

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David GoldsmithArchDesc::~ArchDesc() {

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith // Clean-up and quit

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith}

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmithvoid ArchDesc::addForm(PreHeaderForm *ptr) { _pre_header.addForm(ptr); };

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmithvoid ArchDesc::addForm(HeaderForm *ptr) { _header.addForm(ptr); };

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmithvoid ArchDesc::addForm(SourceForm *ptr) { _source.addForm(ptr); };

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmithvoid ArchDesc::addForm(EncodeForm *ptr) { _encode = ptr; };

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmithvoid ArchDesc::addForm(InstructForm *ptr) { _instructions.addForm(ptr); };

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmithvoid ArchDesc::addForm(MachNodeForm *ptr) { _machnodes.addForm(ptr); };

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmithvoid ArchDesc::addForm(OperandForm *ptr) { _operands.addForm(ptr); };

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmithvoid ArchDesc::addForm(OpClassForm *ptr) { _opclass.addForm(ptr); };

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmithvoid ArchDesc::addForm(AttributeForm *ptr) { _attributes.addForm(ptr); };

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmithvoid ArchDesc::addForm(RegisterForm *ptr) { _register = ptr; };

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmithvoid ArchDesc::addForm(FrameForm *ptr) { _frame = ptr; };

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmithvoid ArchDesc::addForm(PipelineForm *ptr) { _pipeline = ptr; };

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmith

c1bef59b02d89a84c23d29663cc4e6d46148ebd2David Goldsmithvoid ArchDesc::generateMatchLists() {

// Call inspection routines to populate array

inspectOperands();

inspectInstructions();

}

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);

}

}

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();

if ( instr->is_ideal_branch() && instr->label_position() == -1 ||

!instr->is_ideal_branch() && instr->label_position() != -1) {

syntax_err(instr->_linenum, "%s: Only branches to a label are supported\n", rootOp);

}

Attribute *attr = instr->_attribs;

while (attr != NULL) {

if (strcmp(attr->_ident,"ins_short_branch") == 0 &&

attr->int_val(*this) != 0) {

if (!instr->is_ideal_branch() || instr->label_position() == -1) {

syntax_err(instr->_linenum, "%s: Only short branch to a label is supported\n", rootOp);

}

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;

}

}

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;

}

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;

}

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;

// }

}

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);

}

}

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);

}

}

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;

}

}

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;

}

}

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;

}

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;

}

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;

}

char* ArchDesc::get_preproc_def(const char* flag) {

// In case of syntax errors, flag may take the value NULL.

SourceForm* deff = NULL;

if (flag != NULL)

deff = (SourceForm*) _preproc_table[flag];

return (deff == NULL) ? NULL : deff->_code;

}

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();

}

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);

}

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;

}

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;

}

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");

fflush(errfile);

}

return 1;

}

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) + 5;

char *regMask = new char[length];

sprintf(regMask,"%s%s()", rc_name, mask);

delete[] rc_name;

return regMask;

}

}

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;

}

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 == NULL) {

opForm.dump();

syntax_err(opForm._linenum,

"Use of an undefined result class for operand: %s",

opForm._ident);

abort();

}

regMask = reg_class_to_reg_mask( result_class );

return regMask;

}

const char *ArchDesc::reg_mask(InstructForm &inForm) {

const char *result = inForm.reduce_result();

if (result == NULL) {

syntax_err(inForm._linenum,

"Did not find result operand or RegMask"

" for this instruction: %s",

inForm._ident);

abort();

}

// 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];

if (form == NULL) {

syntax_err(inForm._linenum,

"Did not find result operand for result: %s", result);

abort();

}

OperandForm *oper = form->is_operand();

if (oper == NULL) {

syntax_err(inForm._linenum, "Form is not an OperandForm:");

form->dump();

abort();

}

return reg_mask( *oper );

}

char *ArchDesc::stack_or_reg_mask(OperandForm &opForm) {

// name of cisc_spillable version

const char *reg_mask_name = reg_mask(opForm);

if (reg_mask_name == NULL) {

syntax_err(opForm._linenum,

"Did not find reg_mask for opForm: %s",

opForm._ident);

abort();

}

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;

}

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;

}

}

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;

}

// Match Vector types.

if (strncmp(idealOp, "Vec",3)==0) {

switch(last_char) {

case 'S': return "TypeVect::VECTS";

case 'D': return "TypeVect::VECTD";

case 'X': return "TypeVect::VECTX";

case 'Y': return "TypeVect::VECTY";

default:

internal_err("Vector type %s with unrecognized type\n",idealOp);

}

}

// !!!!!

switch(last_char) {

case 'I': return "TypeInt::INT";

case 'P': return "TypePtr::BOTTOM";

case 'N': return "TypeNarrowOop::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;

}

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, "ConN") ||

!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);

ident = "CALL";

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*) (intptr_t) idealIndex);

}

for ( idealIndex = _last_machine_leaf+1;

idealIndex < _last_opcode; ++idealIndex) {

const char *idealName = NodeClassNames[idealIndex];

_idealIndex.Insert((void*) idealName, (void*) (intptr_t) idealIndex);

}

}

void ArchDesc::addSunCopyright(char* legal, int size, FILE *fp) {

size_t count = fwrite(legal, 1, size, fp);

assert(count == (size_t) size, "copyright info truncated");

fprintf(fp,"\n");

fprintf(fp,"// Machine Generated File. Do Not Edit!\n");

fprintf(fp,"\n");

}

void ArchDesc::addIncludeGuardStart(ADLFILE &adlfile, const char* guardString) {

// Build #include lines

fprintf(adlfile._fp, "\n");

fprintf(adlfile._fp, "#ifndef %s\n", guardString);

fprintf(adlfile._fp, "#define %s\n", guardString);

fprintf(adlfile._fp, "\n");

}

void ArchDesc::addIncludeGuardEnd(ADLFILE &adlfile, const char* guardString) {

// Build #include lines

fprintf(adlfile._fp, "\n");

fprintf(adlfile._fp, "#endif // %s\n", guardString);

}

void ArchDesc::addInclude(ADLFILE &adlfile, const char* fileName) {

fprintf(adlfile._fp, "#include \"%s\"\n", fileName);

}

void ArchDesc::addInclude(ADLFILE &adlfile, const char* includeDir, const char* fileName) {

fprintf(adlfile._fp, "#include \"%s/%s\"\n", includeDir, fileName);

}

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);

}

}

const char *ArchDesc::machOperEnum(const char *opName) {

return ArchDesc::getMachOperEnum(opName);

}

const char *ArchDesc::getMachOperEnum(const char *opName) {

return (opName ? toUpper(opName) : opName);

}

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,"CmpN") == 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");

}