author | rbackman |
Tue, 06 Mar 2012 12:36:59 +0100 | |
changeset 12377 | ae6def2813e0 |
parent 7433 | b418028612ad |
child 13971 | 3c568f3dacca |
permissions | -rw-r--r-- |
1 | 1 |
/* |
7397 | 2 |
* Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. |
1 | 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 |
* |
|
5547
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1
diff
changeset
|
21 |
* questions. |
1 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
#ifndef SHARE_VM_ADLC_ARCHDESC_HPP |
26 |
#define SHARE_VM_ADLC_ARCHDESC_HPP |
|
27 |
||
1 | 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); |
|
7397 | 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); |
|
1 | 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 |
|
7433 | 303 |
void defineExpand (FILE *fp, InstructForm *node); |
1 | 304 |
// Generator for Peephole methods for instructions with peephole rules |
7433 | 305 |
void definePeephole (FILE *fp, InstructForm *node); |
1 | 306 |
// Generator for Size methods for instructions |
7433 | 307 |
void defineSize (FILE *fp, InstructForm &node); |
308 |
||
309 |
public: |
|
310 |
// Generator for EvalConstantValue methods for instructions |
|
311 |
void defineEvalConstant(FILE *fp, InstructForm &node); |
|
1 | 312 |
// Generator for Emit methods for instructions |
7433 | 313 |
void defineEmit (FILE *fp, InstructForm &node); |
314 |
||
1 | 315 |
// Define a MachOper encode method |
316 |
void define_oper_interface(FILE *fp, OperandForm &oper, FormDict &globals, |
|
317 |
const char *name, const char *encoding); |
|
318 |
||
319 |
// Methods to construct the MachNode class hierarchy |
|
320 |
// Return the type signature for the ideal operation |
|
321 |
const char *getIdealType(const char *idealOp); |
|
322 |
// Declare and define the classes derived from MachOper and MachNode |
|
323 |
void declareClasses(FILE *fp_hpp); |
|
324 |
void defineClasses(FILE *fp_cpp); |
|
325 |
||
326 |
// Emit an ADLC message |
|
327 |
void internal_err( const char *fmt, ...); |
|
328 |
void syntax_err ( int lineno, const char *fmt, ...); |
|
329 |
int emit_msg(int quiet, int flag, int linenum, const char *fmt, |
|
330 |
va_list args); |
|
331 |
||
332 |
// Generator for has_match_rule methods |
|
333 |
void buildInstructMatchCheck(FILE *fp_cpp) const; |
|
334 |
||
335 |
// Generator for Frame Methods |
|
336 |
void buildFrameMethods(FILE *fp_cpp); |
|
337 |
||
338 |
// Generate CISC_spilling oracle and MachNode::cisc_spill() methods |
|
339 |
void build_cisc_spill_instructions(FILE *fp_hpp, FILE *fp_cpp); |
|
340 |
void identify_cisc_spill_instructions(); |
|
341 |
void identify_short_branches(); |
|
342 |
void identify_unique_operands(); |
|
343 |
void set_cisc_spill_operand(OperandForm *opForm) { _cisc_spill_operand = opForm; } |
|
344 |
OperandForm *cisc_spill_operand() { return _cisc_spill_operand; } |
|
345 |
bool can_cisc_spill() { return _cisc_spill_operand != NULL; } |
|
346 |
||
347 |
||
348 |
protected: |
|
349 |
// build MatchList from MatchRule |
|
350 |
void buildMatchList(MatchRule *mrule, const char *resultStr, |
|
351 |
const char *rootOp, Predicate *pred, const char *cost); |
|
352 |
||
353 |
void buildMList(MatchNode *node, const char *rootOp, const char *resultOp, |
|
354 |
Predicate *pred, const char *cost); |
|
355 |
||
356 |
friend class ADLParser; |
|
357 |
||
358 |
}; |
|
359 |
||
360 |
||
361 |
// -------------------------------- maps ------------------------------------ |
|
362 |
||
363 |
// Base class for generating a mapping from rule number to value. |
|
364 |
// Used with ArchDesc::build_map() for all maps except "enum MachOperands" |
|
365 |
// A derived class defines the appropriate output for a specific mapping. |
|
366 |
class OutputMap { |
|
367 |
protected: |
|
368 |
FILE *_hpp; |
|
369 |
FILE *_cpp; |
|
370 |
FormDict &_globals; |
|
371 |
ArchDesc &_AD; |
|
372 |
public: |
|
373 |
OutputMap (FILE *decl_file, FILE *def_file, FormDict &globals, ArchDesc &AD) |
|
374 |
: _hpp(decl_file), _cpp(def_file), _globals(globals), _AD(AD) {}; |
|
375 |
// Access files used by this routine |
|
376 |
FILE *decl_file() { return _hpp; } |
|
377 |
FILE *def_file() { return _cpp; } |
|
378 |
// Positions in iteration that derived class will be told about |
|
379 |
enum position { BEGIN_OPERANDS, |
|
380 |
BEGIN_OPCLASSES, |
|
381 |
BEGIN_INTERNALS, |
|
382 |
BEGIN_INSTRUCTIONS, |
|
383 |
BEGIN_INST_CHAIN_RULES, |
|
384 |
END_INST_CHAIN_RULES, |
|
385 |
BEGIN_REMATERIALIZE, |
|
386 |
END_REMATERIALIZE, |
|
387 |
END_INSTRUCTIONS |
|
388 |
}; |
|
389 |
// Output routines specific to the derived class |
|
390 |
virtual void declaration() {} |
|
391 |
virtual void definition() {} |
|
392 |
virtual void closing() { fprintf(_cpp, "};\n"); } |
|
393 |
virtual void map(OperandForm &oper) { } |
|
394 |
virtual void map(OpClassForm &opc) { } |
|
395 |
virtual void map(char *internal_name) { } |
|
396 |
// Allow enum-MachOperands to turn-off instructions |
|
397 |
virtual bool do_instructions() { return true; } |
|
398 |
virtual void map(InstructForm &inst) { } |
|
399 |
// Allow derived class to output name and position specific info |
|
400 |
virtual void record_position(OutputMap::position place, int index) {} |
|
401 |
}; |
|
7397 | 402 |
|
403 |
#endif // SHARE_VM_ADLC_ARCHDESC_HPP |