1 /*
2 * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #ifndef SHARE_VM_ADLC_ARCHDESC_HPP
26 #define SHARE_VM_ADLC_ARCHDESC_HPP
27
28 // Definitions for Error Flags
29 #define WARN 0
30 #define SYNERR 1
31 #define SEMERR 2
32 #define INTERNAL_ERR 3
33
34 // Minimal declarations for include files
35 class OutputMap;
36 class ProductionState;
37 class Expr;
38
39 // STRUCTURE FOR HANDLING INPUT AND OUTPUT FILES
40 typedef BufferedFile ADLFILE;
41
42 //---------------------------ChainList-----------------------------------------
43 class ChainList {
44 NameList _name;
45 NameList _cost;
46 NameList _rule;
47
48 public:
49 void insert(const char *name, const char *cost, const char *rule);
50 bool search(const char *name);
51
52 void reset();
53 bool iter(const char * &name, const char * &cost, const char * &rule);
54
55 void dump();
56 void output(FILE *fp);
57
58 ChainList();
59 ~ChainList();
60 };
61
62 //---------------------------MatchList-----------------------------------------
63 class MatchList {
64 private:
65 MatchList *_next;
66 Predicate *_pred; // Predicate which applies to this match rule
67 const char *_cost;
68
69 public:
70 const char *_opcode;
71 const char *_resultStr;
72 const char *_lchild;
73 const char *_rchild;
74
75 MatchList(MatchList *nxt, Predicate *prd): _next(nxt), _pred(prd), _cost(NULL){
76 _resultStr = _lchild = _rchild = _opcode = NULL; }
77
78 MatchList(MatchList *nxt, Predicate *prd, const char *cost,
79 const char *opcode, const char *resultStr, const char *lchild,
80 const char *rchild)
81 : _next(nxt), _pred(prd), _cost(cost), _opcode(opcode),
82 _resultStr(resultStr), _lchild(lchild), _rchild(rchild) { }
83
84 MatchList *get_next(void) { return _next; }
85 char *get_pred(void) { return (_pred?_pred->_pred:NULL); }
86 Predicate *get_pred_obj(void) { return _pred; }
87 const char *get_cost(void) { return _cost == NULL ? "0" :_cost; }
88 bool search(const char *opc, const char *res, const char *lch,
89 const char *rch, Predicate *pr);
90
91 void dump();
92 void output(FILE *fp);
93 };
94
95 //---------------------------ArchDesc------------------------------------------
96 class ArchDesc {
97 private:
98 FormDict _globalNames; // Global names
99 Dict _idealIndex; // Map ideal names to index in enumeration
100 ExprDict _globalDefs; // Global definitions, #defines
101 int _internalOpCounter; // Internal Operand Counter
102
103 FormList _header; // List of Source Code Forms for hpp file
104 FormList _pre_header; // ditto for the very top of the hpp file
105 FormList _source; // List of Source Code Forms for output
106 FormList _instructions; // List of Instruction Forms for output
107 FormList _machnodes; // List of Node Classes (special for pipelining)
108 FormList _operands; // List of Operand Forms for output
109 FormList _opclass; // List of Operand Class Forms for output
110 FormList _attributes; // List of Attribute Forms for parsing
111 RegisterForm *_register; // Only one Register Form allowed
112 FrameForm *_frame; // Describe stack-frame layout
113 EncodeForm *_encode; // Only one Encode Form allowed
114 PipelineForm *_pipeline; // Pipeline Form for output
115
116 bool _has_match_rule[_last_opcode]; // found AD rule for ideal node in <arch>.ad
117
118 MatchList *_mlistab[_last_opcode]; // Array of MatchLists
119
120 // The Architecture Description identifies which user-defined operand can be used
121 // to access [stack_pointer + offset]
122 OperandForm *_cisc_spill_operand;
123
124 // Methods for outputting the DFA
125 void gen_match(FILE *fp, MatchList &mlist, ProductionState &status, Dict &operands_chained_from);
126 void chain_rule(FILE *fp, const char *indent, const char *ideal,
127 const Expr *icost, const char *irule,
128 Dict &operands_chained_from, ProductionState &status);
129 void expand_opclass(FILE *fp, const char *indent, const Expr *cost,
130 const char *result_type, ProductionState &status);
131 Expr *calc_cost(FILE *fp, const char *spaces, MatchList &mList, ProductionState &status);
132 void prune_matchlist(Dict &minimize, MatchList &mlist);
133
134 // Helper function that outputs code to generate an instruction in MachNodeGenerator
135 void buildMachNode(FILE *fp_cpp, InstructForm *inst, const char *indent);
136
137 public:
138 ArchDesc();
139 ~ArchDesc();
140
141 // Option flags which control miscellaneous behaviors throughout the code
142 int _TotalLines; // Line Counter
143 int _no_output; // Flag to disable output of DFA, etc.
144 int _quiet_mode; // Do not output banner messages, etc.
145 int _disable_warnings; // Do not output warning messages
146 int _dfa_debug; // Debug Flag for generated DFA
147 int _dfa_small; // Debug Flag for generated DFA
148 int _adl_debug; // Debug Flag for ADLC
149 int _adlocation_debug; // Debug Flag to use ad file locations
150 bool _cisc_spill_debug; // Debug Flag to see cisc-spill-instructions
151 bool _short_branch_debug; // Debug Flag to see short branch instructions
152
153 // Error/Warning Counts
154 int _syntax_errs; // Count of syntax errors
155 int _semantic_errs; // Count of semantic errors
156 int _warnings; // Count warnings
157 int _internal_errs; // Count of internal errors
158
159 // Accessor for private data.
160 void has_match_rule(int opc, const bool b) { _has_match_rule[opc] = b; }
161
162 // I/O Files
163 ADLFILE _ADL_file; // Input Architecture Description File
164 // Machine dependent files, built from architecture definition
165 ADLFILE _DFA_file; // File for definition of Matcher::DFA
166 ADLFILE _HPP_file; // File for ArchNode class declarations
167 ADLFILE _CPP_file; // File for ArchNode class defintions
168 ADLFILE _CPP_CLONE_file; // File for MachNode/Oper clone defintions
169 ADLFILE _CPP_EXPAND_file; // File for MachNode expand methods
170 ADLFILE _CPP_FORMAT_file; // File for MachNode/Oper format defintions
171 ADLFILE _CPP_GEN_file; // File for MachNode/Oper generator methods
172 ADLFILE _CPP_MISC_file; // File for miscellaneous MachNode/Oper tables & methods
173 ADLFILE _CPP_PEEPHOLE_file; // File for MachNode peephole methods
174 ADLFILE _CPP_PIPELINE_file; // File for MachNode pipeline defintions
175 ADLFILE _VM_file; // File for constants needed in VM code
176 ADLFILE _bug_file; // DFA debugging file
177
178 // I/O helper methods
179 int open_file(bool required, ADLFILE & adf, const char *action);
180 void close_file(int delete_out, ADLFILE & adf);
181 int open_files(void);
182 void close_files(int delete_out);
183
184 Dict _chainRules; // Maps user operand names to ChainRules
185 Dict _internalOps; // Maps match strings to internal operand names
186 NameList _internalOpNames; // List internal operand names
187 Dict _internalMatch; // Map internal name to its MatchNode
188
189 NameList _preproc_list; // Preprocessor flag names
190 FormDict _preproc_table;// Preprocessor flag bindings
191 char* get_preproc_def(const char* flag);
192 void set_preproc_def(const char* flag, const char* def);
193
194 FormDict& globalNames() {return _globalNames;} // map global names to forms
195 void initKeywords(FormDict& globals); // Add keywords to global name table
196
197 ExprDict& globalDefs() {return _globalDefs;} // map global names to expressions
198
199 OperandForm *constructOperand(const char *ident, bool ideal_only);
200 void initBaseOpTypes(); // Import predefined base types.
201
202 void addForm(PreHeaderForm *ptr); // Add objects to pre-header list
203 void addForm(HeaderForm *ptr); // Add objects to header list
204 void addForm(SourceForm *ptr); // Add objects to source list
205 void addForm(EncodeForm *ptr); // Add objects to encode list
206 void addForm(InstructForm *ptr); // Add objects to the instruct list
207 void addForm(OperandForm *ptr); // Add objects to the operand list
208 void addForm(OpClassForm *ptr); // Add objects to the opclasss list
209 void addForm(AttributeForm *ptr); // Add objects to the attributes list
210 void addForm(RegisterForm *ptr); // Add objects to the register list
211 void addForm(FrameForm *ptr); // Add objects to the frame list
212 void addForm(PipelineForm *ptr); // Add objects to the pipeline list
213 void addForm(MachNodeForm *ptr); // Add objects to the machnode list
214
215 int operandFormCount(); // Count number of OperandForms defined
216 int opclassFormCount(); // Count number of OpClassForms defined
217 int instructFormCount(); // Count number of InstructForms defined
218
219 inline void getForm(EncodeForm **ptr) { *ptr = _encode; }
220
221 bool verify();
222 void dump();
223
224 // Helper utility that gets MatchList components from inside MatchRule
225 void check_optype(MatchRule *mrule);
226 void build_chain_rule(OperandForm *oper);
227 void add_chain_rule_entry(const char *src, const char *cost,
228 const char *result);
229 const char *getMatchListIndex(MatchRule &mrule);
230 void generateMatchLists(); // Build MatchList array and populate it
231 void inspectOperands(); // Build MatchLists for all operands
232 void inspectOpClasses(); // Build MatchLists for all operands
233 void inspectInstructions(); // Build MatchLists for all operands
234 void buildDFA(FILE *fp); // Driver for constructing the DFA
235 void gen_dfa_state_body(FILE *fp, Dict &minmize, ProductionState &status, Dict &chained, int i); // Driver for constructing the DFA state bodies
236
237 // Helper utilities to generate reduction maps for internal operands
238 const char *reduceLeft (char *internalName);
239 const char *reduceRight(char *internalName);
240
241 // Build enumerations, (1) dense operand index, (2) operands and opcodes
242 const char *machOperEnum(const char *opName); // create dense index names using static function
243 static const char *getMachOperEnum(const char *opName);// create dense index name
244 void buildMachOperEnum(FILE *fp_hpp);// dense enumeration for operands
245 void buildMachOpcodesEnum(FILE *fp_hpp);// enumeration for MachOpers & MachNodes
246
247 // Helper utilities to generate Register Masks
248 RegisterForm *get_registers() { return _register; }
249 const char *reg_mask(OperandForm &opForm);
250 const char *reg_mask(InstructForm &instForm);
251 const char *reg_class_to_reg_mask(const char *reg_class);
252 char *stack_or_reg_mask(OperandForm &opForm); // name of cisc_spillable version
253 // This register class should also generate a stack_or_reg_mask
254 void set_stack_or_reg(const char *reg_class_name); // for cisc-spillable reg classes
255 // Generate an enumeration of register mask names and the RegMask objects.
256 void declare_register_masks(FILE *fp_cpp);
257 void build_register_masks(FILE *fp_cpp);
258 // Generate enumeration of machine register numbers
259 void buildMachRegisterNumbers(FILE *fp_hpp);
260 // Generate enumeration of machine register encodings
261 void buildMachRegisterEncodes(FILE *fp_hpp);
262 // Generate Regsiter Size Array
263 void declareRegSizes(FILE *fp_hpp);
264 // Generate Pipeline Class information
265 void declare_pipe_classes(FILE *fp_hpp);
266 // Generate Pipeline definitions
267 void build_pipeline_enums(FILE *fp_cpp);
268 // Generate Pipeline Class information
269 void build_pipe_classes(FILE *fp_cpp);
270
271 // Declare and define mappings from rules to result and input types
272 void build_map(OutputMap &map);
273 void buildReduceMaps(FILE *fp_hpp, FILE *fp_cpp);
274 // build flags for signaling that our machine needs this instruction cloned
275 void buildMustCloneMap(FILE *fp_hpp, FILE *fp_cpp);
276
277 // output SUN copyright info
278 void addSunCopyright(char* legal, int size, FILE *fp);
279 // output the start of an include guard.
280 void addIncludeGuardStart(ADLFILE &adlfile, const char* guardString);
281 // output the end of an include guard.
282 void addIncludeGuardEnd(ADLFILE &adlfile, const char* guardString);
283 // output the #include line for this file.
284 void addInclude(ADLFILE &adlfile, const char* fileName);
285 void addInclude(ADLFILE &adlfile, const char* includeDir, const char* fileName);
286 // Output C preprocessor code to verify the backend compilation environment.
287 void addPreprocessorChecks(FILE *fp);
288 // Output C source and header (source_hpp) blocks.
289 void addPreHeaderBlocks(FILE *fp_hpp);
290 void addHeaderBlocks(FILE *fp_hpp);
291 void addSourceBlocks(FILE *fp_cpp);
292 void generate_adlc_verification(FILE *fp_cpp);
293
294 // output declaration of class State
295 void defineStateClass(FILE *fp);
296
297 // Generator for MachOper objects given integer type
298 void buildMachOperGenerator(FILE *fp_cpp);
299 // Generator for MachNode objects given integer type
300 void buildMachNodeGenerator(FILE *fp_cpp);
301
302 // Generator for Expand methods for instructions with expand rules
303 void defineExpand (FILE *fp, InstructForm *node);
304 // Generator for Peephole methods for instructions with peephole rules
305 void definePeephole (FILE *fp, InstructForm *node);
306 // Generator for Size methods for instructions
307 void defineSize (FILE *fp, InstructForm &node);
308
309 public:
310 // Generator for EvalConstantValue methods for instructions
311 void defineEvalConstant(FILE *fp, InstructForm &node);
312 // Generator for Emit methods for instructions
313 void defineEmit (FILE *fp, InstructForm &node);
314 // Generator for postalloc_expand methods for instructions.
315 void define_postalloc_expand(FILE *fp, InstructForm &node);
316
317 // Define a MachOper encode method
318 void define_oper_interface(FILE *fp, OperandForm &oper, FormDict &globals,
319 const char *name, const char *encoding);
320
321 // Methods to construct the MachNode class hierarchy
322 // Return the type signature for the ideal operation
323 const char *getIdealType(const char *idealOp);
324 // Declare and define the classes derived from MachOper and MachNode
325 void declareClasses(FILE *fp_hpp);
326 void defineClasses(FILE *fp_cpp);
327
328 // Emit an ADLC message
329 void internal_err( const char *fmt, ...);
330 void syntax_err ( int lineno, const char *fmt, ...);
331 int emit_msg(int quiet, int flag, int linenum, const char *fmt,
332 va_list args);
333
334 // Generator for has_match_rule methods
335 void buildInstructMatchCheck(FILE *fp_cpp) const;
336
337 // Generator for Frame Methods
338 void buildFrameMethods(FILE *fp_cpp);
339
340 // Generate CISC_spilling oracle and MachNode::cisc_spill() methods
341 void build_cisc_spill_instructions(FILE *fp_hpp, FILE *fp_cpp);
342 void identify_cisc_spill_instructions();
343 void identify_short_branches();
344 void identify_unique_operands();
345 void set_cisc_spill_operand(OperandForm *opForm) { _cisc_spill_operand = opForm; }
346 OperandForm *cisc_spill_operand() { return _cisc_spill_operand; }
347 bool can_cisc_spill() { return _cisc_spill_operand != NULL; }
348
349
350 protected:
351 // build MatchList from MatchRule
352 void buildMatchList(MatchRule *mrule, const char *resultStr,
353 const char *rootOp, Predicate *pred, const char *cost);
354
355 void buildMList(MatchNode *node, const char *rootOp, const char *resultOp,
356 Predicate *pred, const char *cost);
357
358 friend class ADLParser;
359
360 };
361
362
363 // -------------------------------- maps ------------------------------------
364
365 // Base class for generating a mapping from rule number to value.
366 // Used with ArchDesc::build_map() for all maps except "enum MachOperands"
367 // A derived class defines the appropriate output for a specific mapping.
368 class OutputMap {
369 protected:
370 FILE *_hpp;
371 FILE *_cpp;
372 FormDict &_globals;
373 ArchDesc &_AD;
374 const char *_name;
375 public:
376 OutputMap (FILE *decl_file, FILE *def_file, FormDict &globals, ArchDesc &AD, const char *name)
377 : _hpp(decl_file), _cpp(def_file), _globals(globals), _AD(AD), _name(name) {};
378 // Access files used by this routine
379 FILE *decl_file() { return _hpp; }
380 FILE *def_file() { return _cpp; }
381 // Positions in iteration that derived class will be told about
382 enum position { BEGIN_OPERANDS,
383 BEGIN_OPCLASSES,
384 BEGIN_INTERNALS,
385 BEGIN_INSTRUCTIONS,
386 BEGIN_INST_CHAIN_RULES,
387 END_INST_CHAIN_RULES,
388 BEGIN_REMATERIALIZE,
389 END_REMATERIALIZE,
390 END_INSTRUCTIONS
391 };
392 // Output routines specific to the derived class
393 virtual void declaration() {}
394 virtual void definition() {}
395 virtual void closing() { fprintf(_cpp, "};\n"); }
396 virtual void map(OperandForm &oper) { }
397 virtual void map(OpClassForm &opc) { }
398 virtual void map(char *internal_name) { }
399 // Allow enum-MachOperands to turn-off instructions
400 virtual bool do_instructions() { return true; }
401 virtual void map(InstructForm &inst) { }
402 // Allow derived class to output name and position specific info
403 virtual void record_position(OutputMap::position place, int index) {}
404 };
405
406 #endif // SHARE_VM_ADLC_ARCHDESC_HPP