/*

 * 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 *

 */

// Definitions for Error Flags

#define  WARN   0

#define  SYNERR 1

#define  SEMERR 2

#define  INTERNAL_ERR 3

// Minimal declarations for include files

class  OutputMap;

class  ProductionState;

class  Expr;

// STRUCTURE FOR HANDLING INPUT AND OUTPUT FILES

typedef BufferedFile ADLFILE;

//---------------------------ChainList-----------------------------------------

class ChainList {

  NameList _name;

  NameList _cost;

  NameList _rule;

public:

  void insert(const char *name, const char *cost, const char *rule);

  bool search(const char *name);

  void reset();

  bool iter(const char * &name, const char * &cost, const char * &rule);

  void dump();

  void output(FILE *fp);

  ChainList();

  ~ChainList();

};

//---------------------------MatchList-----------------------------------------

class MatchList {

private:

  MatchList  *_next;

  Predicate  *_pred;          // Predicate which applies to this match rule

  const char *_cost;

public:

  const char *_opcode;

  const char *_resultStr;

  const char *_lchild;

  const char *_rchild;

  MatchList(MatchList *nxt, Predicate *prd): _next(nxt), _pred(prd), _cost(NULL){

    _resultStr = _lchild = _rchild = _opcode = NULL; }

  MatchList(MatchList *nxt, Predicate *prd, const char *cost,

            const char *opcode, const char *resultStr, const char *lchild,

            const char *rchild)

    : _next(nxt), _pred(prd), _cost(cost), _opcode(opcode),

      _resultStr(resultStr), _lchild(lchild), _rchild(rchild) { }

  MatchList  *get_next(void)  { return _next; }

  char       *get_pred(void)  { return (_pred?_pred->_pred:NULL); }

  Predicate  *get_pred_obj(void)  { return _pred; }

  const char *get_cost(void) { return _cost == NULL ? "0" :_cost; }

  bool        search(const char *opc, const char *res, const char *lch,

                    const char *rch, Predicate *pr);

  void        dump();

  void        output(FILE *fp);

};

//---------------------------ArchDesc------------------------------------------

class ArchDesc {

private:

  FormDict      _globalNames;        // Global names

  Dict          _idealIndex;         // Map ideal names to index in enumeration

  ExprDict      _globalDefs;         // Global definitions, #defines

  int           _internalOpCounter;  // Internal Operand Counter

  FormList      _header;             // List of Source Code Forms for hpp file

  FormList      _pre_header;         // ditto for the very top of the hpp file

  FormList      _source;             // List of Source Code Forms for output

  FormList      _instructions;       // List of Instruction Forms for output

  FormList      _machnodes;          // List of Node Classes (special for pipelining)

  FormList      _operands;           // List of Operand Forms for output

  FormList      _opclass;            // List of Operand Class Forms for output

  FormList      _attributes;         // List of Attribute Forms for parsing

  RegisterForm *_register;           // Only one Register Form allowed

  FrameForm    *_frame;              // Describe stack-frame layout

  EncodeForm   *_encode;             // Only one Encode Form allowed

  PipelineForm *_pipeline;           // Pipeline Form for output

  bool _has_match_rule[_last_opcode];  // found AD rule for ideal node in <arch>.ad

  MatchList    *_mlistab[_last_opcode]; // Array of MatchLists

  // The Architecture Description identifies which user-defined operand can be used

  // to access [stack_pointer + offset]

  OperandForm  *_cisc_spill_operand;

  // If a Call node uses $constanttablebase, it gets MachConstantBaseNode

  // by the matcher and the matcher will modify the jvms. If so, jvm states

  // always have to be cloned when a node is cloned.  Adlc generates

  // Compile::needs_clone_jvms() accordingly.

  bool _needs_clone_jvms;

  // Methods for outputting the DFA

  void gen_match(FILE *fp, MatchList &mlist, ProductionState &status, Dict &operands_chained_from);

  void chain_rule(FILE *fp, const char *indent, const char *ideal,

                  const Expr *icost, const char *irule,

                  Dict &operands_chained_from, ProductionState &status);

  void expand_opclass(FILE *fp, const char *indent, const Expr *cost,

                      const char *result_type, ProductionState &status);

  Expr *calc_cost(FILE *fp, const char *spaces, MatchList &mList, ProductionState &status);

  void prune_matchlist(Dict &minimize, MatchList &mlist);

  // Helper function that outputs code to generate an instruction in MachNodeGenerator

  void buildMachNode(FILE *fp_cpp, InstructForm *inst, const char *indent);

public:

  ArchDesc();

  ~ArchDesc();

  // Option flags which control miscellaneous behaviors throughout the code

  int   _TotalLines;                    // Line Counter

  int   _no_output;                     // Flag to disable output of DFA, etc.

  int   _quiet_mode;                    // Do not output banner messages, etc.

  int   _disable_warnings;              // Do not output warning messages

  int   _dfa_debug;                     // Debug Flag for generated DFA

  int   _dfa_small;                     // Debug Flag for generated DFA

  int   _adl_debug;                     // Debug Flag for ADLC

  int   _adlocation_debug;              // Debug Flag to use ad file locations

  bool  _cisc_spill_debug;              // Debug Flag to see cisc-spill-instructions

  bool  _short_branch_debug;            // Debug Flag to see short branch instructions

  // Error/Warning Counts

  int _syntax_errs;                  // Count of syntax errors

  int _semantic_errs;                // Count of semantic errors

  int _warnings;                     // Count warnings

  int _internal_errs;                // Count of internal errors

  // Accessor for private data.

  void has_match_rule(int opc, const bool b) { _has_match_rule[opc] = b; }

  // I/O Files

  ADLFILE  _ADL_file;          // Input Architecture Description File

  // Machine dependent files, built from architecture definition

  ADLFILE  _DFA_file;          // File for definition of Matcher::DFA

  ADLFILE  _HPP_file;          // File for ArchNode class declarations

  ADLFILE  _CPP_file;          // File for ArchNode class defintions

  ADLFILE  _CPP_CLONE_file;    // File for MachNode/Oper clone defintions

  ADLFILE  _CPP_EXPAND_file;   // File for MachNode expand methods

  ADLFILE  _CPP_FORMAT_file;   // File for MachNode/Oper format defintions

  ADLFILE  _CPP_GEN_file;      // File for MachNode/Oper generator methods

  ADLFILE  _CPP_MISC_file;     // File for miscellaneous MachNode/Oper tables & methods

  ADLFILE  _CPP_PEEPHOLE_file; // File for MachNode peephole methods

  ADLFILE  _CPP_PIPELINE_file; // File for MachNode pipeline defintions

  ADLFILE  _VM_file;           // File for constants needed in VM code

  ADLFILE  _bug_file;          // DFA debugging file

  // I/O helper methods

  int  open_file(bool required, ADLFILE & adf, const char *action);

  void close_file(int delete_out, ADLFILE & adf);

  int  open_files(void);

  void close_files(int delete_out);

  Dict _chainRules;            // Maps user operand names to ChainRules

  Dict _internalOps;           // Maps match strings to internal operand names

  NameList _internalOpNames;   // List internal operand names

  Dict _internalMatch;         // Map internal name to its MatchNode

  NameList      _preproc_list; // Preprocessor flag names

  FormDict      _preproc_table;// Preprocessor flag bindings

  char* get_preproc_def(const char* flag);

  void  set_preproc_def(const char* flag, const char* def);

  FormDict& globalNames() {return _globalNames;} // map global names to forms

  void initKeywords(FormDict& globals);  // Add keywords to global name table

  ExprDict& globalDefs()  {return _globalDefs;}  // map global names to expressions

  OperandForm *constructOperand(const char *ident, bool ideal_only);

  void initBaseOpTypes();            // Import predefined base types.

  void addForm(PreHeaderForm *ptr);  // Add objects to pre-header list

  void addForm(HeaderForm *ptr);     // Add objects to header list

  void addForm(SourceForm *ptr);     // Add objects to source list

  void addForm(EncodeForm *ptr);     // Add objects to encode list

  void addForm(InstructForm *ptr);   // Add objects to the instruct list

  void addForm(OperandForm *ptr);    // Add objects to the operand list

  void addForm(OpClassForm *ptr);    // Add objects to the opclasss list

  void addForm(AttributeForm *ptr);  // Add objects to the attributes list

  void addForm(RegisterForm *ptr);   // Add objects to the register list

  void addForm(FrameForm    *ptr);   // Add objects to the frame list

  void addForm(PipelineForm *ptr);   // Add objects to the pipeline list

  void addForm(MachNodeForm *ptr);   // Add objects to the machnode list

  int  operandFormCount();           // Count number of OperandForms defined

  int  opclassFormCount();           // Count number of OpClassForms defined

  int  instructFormCount();          // Count number of InstructForms defined

  inline void getForm(EncodeForm **ptr)     { *ptr = _encode; }

  bool verify();

  void dump();

  // Helper utility that gets MatchList components from inside MatchRule

  void check_optype(MatchRule *mrule);

  void build_chain_rule(OperandForm *oper);

  void add_chain_rule_entry(const char *src, const char *cost,

                            const char *result);

  const char *getMatchListIndex(MatchRule &mrule);

  void generateMatchLists();         // Build MatchList array and populate it

  void inspectOperands();            // Build MatchLists for all operands

  void inspectOpClasses();           // Build MatchLists for all operands

  void inspectInstructions();        // Build MatchLists for all operands

  void buildDFA(FILE *fp);           // Driver for constructing the DFA

  void gen_dfa_state_body(FILE *fp, Dict &minmize, ProductionState &status, Dict &chained, int i);    // Driver for constructing the DFA state bodies

  // Helper utilities to generate reduction maps for internal operands

  const char *reduceLeft (char *internalName);

  const char *reduceRight(char *internalName);

  // Build enumerations, (1) dense operand index, (2) operands and opcodes

  const char *machOperEnum(const char *opName);       // create dense index names using static function

  static const char *getMachOperEnum(const char *opName);// create dense index name

  void buildMachOperEnum(FILE *fp_hpp);// dense enumeration for operands

  void buildMachOpcodesEnum(FILE *fp_hpp);// enumeration for MachOpers & MachNodes

  // Helper utilities to generate Register Masks

  RegisterForm *get_registers() { return _register; }

  const char *reg_mask(OperandForm  &opForm);

  const char *reg_mask(InstructForm &instForm);

  const char *reg_class_to_reg_mask(const char *reg_class);

  char *stack_or_reg_mask(OperandForm  &opForm);  // name of cisc_spillable version

  // This register class should also generate a stack_or_reg_mask

  void  set_stack_or_reg(const char *reg_class_name); // for cisc-spillable reg classes

  // Generate an enumeration of register mask names and the RegMask objects.

  void  declare_register_masks(FILE *fp_cpp);

  void  build_register_masks(FILE *fp_cpp);

  // Generate enumeration of machine register numbers

  void  buildMachRegisterNumbers(FILE *fp_hpp);

  // Generate enumeration of machine register encodings

  void  buildMachRegisterEncodes(FILE *fp_hpp);

  // Generate Regsiter Size Array

  void  declareRegSizes(FILE *fp_hpp);

  // Generate Pipeline Class information

  void declare_pipe_classes(FILE *fp_hpp);

  // Generate Pipeline definitions

  void build_pipeline_enums(FILE *fp_cpp);

  // Generate Pipeline Class information

  void build_pipe_classes(FILE *fp_cpp);

  // Declare and define mappings from rules to result and input types

  void build_map(OutputMap &map);

  void buildReduceMaps(FILE *fp_hpp, FILE *fp_cpp);

  // build flags for signaling that our machine needs this instruction cloned

  void buildMustCloneMap(FILE *fp_hpp, FILE *fp_cpp);

  // output SUN copyright info

  void addSunCopyright(char* legal, int size, FILE *fp);

  // output the start of an include guard.

  void addIncludeGuardStart(ADLFILE &adlfile, const char* guardString);

  // output the end of an include guard.

  void addIncludeGuardEnd(ADLFILE &adlfile, const char* guardString);

  // output the #include line for this file.

  void addInclude(ADLFILE &adlfile, const char* fileName);

  void addInclude(ADLFILE &adlfile, const char* includeDir, const char* fileName);

  // Output C preprocessor code to verify the backend compilation environment.

  void addPreprocessorChecks(FILE *fp);

  // Output C source and header (source_hpp) blocks.

  void addPreHeaderBlocks(FILE *fp_hpp);

  void addHeaderBlocks(FILE *fp_hpp);

  void addSourceBlocks(FILE *fp_cpp);

  void generate_needs_clone_jvms(FILE *fp_cpp);

  void generate_adlc_verification(FILE *fp_cpp);

  // output declaration of class State

  void defineStateClass(FILE *fp);

  // Generator for MachOper objects given integer type

  void buildMachOperGenerator(FILE *fp_cpp);

  // Generator for MachNode objects given integer type

  void buildMachNodeGenerator(FILE *fp_cpp);

  // Generator for Expand methods for instructions with expand rules

  void defineExpand      (FILE *fp, InstructForm *node);

  // Generator for Peephole methods for instructions with peephole rules

  void definePeephole    (FILE *fp, InstructForm *node);

  // Generator for Size methods for instructions

  void defineSize        (FILE *fp, InstructForm &node);

public:

  // Generator for EvalConstantValue methods for instructions

  void defineEvalConstant(FILE *fp, InstructForm &node);

  // Generator for Emit methods for instructions

  void defineEmit        (FILE *fp, InstructForm &node);

  // Generator for postalloc_expand methods for instructions.

  void define_postalloc_expand(FILE *fp, InstructForm &node);

  // Define a MachOper encode method

  void define_oper_interface(FILE *fp, OperandForm &oper, FormDict &globals,

                             const char *name, const char *encoding);

  // Methods to construct the MachNode class hierarchy

  // Return the type signature for the ideal operation

  const char *getIdealType(const char *idealOp);

  // Declare and define the classes derived from MachOper and MachNode

  void declareClasses(FILE *fp_hpp);

  void defineClasses(FILE *fp_cpp);

  // Emit an ADLC message

  void internal_err( const char *fmt, ...);

  void syntax_err  ( int lineno, const char *fmt, ...);

  int  emit_msg(int quiet, int flag, int linenum, const char *fmt,

       va_list args);

  // Generator for has_match_rule methods

  void buildInstructMatchCheck(FILE *fp_cpp) const;

  // Generator for Frame Methods

  void buildFrameMethods(FILE *fp_cpp);

  // Generate CISC_spilling oracle and MachNode::cisc_spill() methods

  void          build_cisc_spill_instructions(FILE *fp_hpp, FILE *fp_cpp);

  void          identify_cisc_spill_instructions();

  void          identify_short_branches();

  void          identify_unique_operands();

  void          set_cisc_spill_operand(OperandForm *opForm) { _cisc_spill_operand = opForm; }

  OperandForm  *cisc_spill_operand() { return _cisc_spill_operand; }

  bool          can_cisc_spill() { return _cisc_spill_operand != NULL; }

protected:

  // build MatchList from MatchRule

  void buildMatchList(MatchRule *mrule, const char *resultStr,

                      const char *rootOp, Predicate *pred, const char *cost);

  void buildMList(MatchNode *node, const char *rootOp, const char *resultOp,

                  Predicate *pred, const char *cost);

  friend class ADLParser;

};

// -------------------------------- maps ------------------------------------

// Base class for generating a mapping from rule number to value.

// Used with ArchDesc::build_map() for all maps except "enum MachOperands"

// A derived class defines the appropriate output for a specific mapping.

class OutputMap {

protected:

  FILE       *_hpp;

  FILE       *_cpp;

  FormDict   &_globals;

  ArchDesc   &_AD;

  const char *_name;

public:

  OutputMap (FILE *decl_file, FILE *def_file, FormDict &globals, ArchDesc &AD, const char *name)

    : _hpp(decl_file), _cpp(def_file), _globals(globals), _AD(AD), _name(name) {};

  // Access files used by this routine

  FILE        *decl_file() { return _hpp; }

  FILE        *def_file()  { return _cpp; }

  // Positions in iteration that derived class will be told about

  enum position { BEGIN_OPERANDS,

                  BEGIN_OPCLASSES,

                  BEGIN_INTERNALS,

                  BEGIN_INSTRUCTIONS,

                  BEGIN_INST_CHAIN_RULES,

                  END_INST_CHAIN_RULES,

                  BEGIN_REMATERIALIZE,

                  END_REMATERIALIZE,

                  END_INSTRUCTIONS

  };

  // Output routines specific to the derived class

  virtual void declaration() {}

  virtual void definition()  {}

  virtual void closing()     {  fprintf(_cpp, "};\n"); }

  virtual void map(OperandForm  &oper) { }

  virtual void map(OpClassForm  &opc)  { }

  virtual void map(char         *internal_name) { }

  // Allow enum-MachOperands to turn-off instructions

  virtual bool do_instructions()       { return true; }

  virtual void map(InstructForm &inst) { }

  // Allow derived class to output name and position specific info

  virtual void record_position(OutputMap::position place, int index) {}

};