8234541: C1 emits an empty message when it inlines successfully
Summary: Use "inline" as the message when successfull
Reviewed-by: thartmann, mdoerr
Contributed-by: navy.xliu@gmail.com
/*
* Copyright (c) 1997, 2019, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*
*/
#ifndef SHARE_ADLC_ARCHDESC_HPP
#define SHARE_ADLC_ARCHDESC_HPP
// 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) {}
};
#endif // SHARE_ADLC_ARCHDESC_HPP