Mercurial > hg > truffle
annotate src/share/vm/adlc/archDesc.hpp @ 17716:cdb71841f4bc
6498581: ThreadInterruptTest3 produces wrong output on Windows
Summary: There is race condition between os::interrupt and os::is_interrupted on Windows. In JVM_Sleep(Thread.sleep), check if thread gets interrupted, it may see interrupted but not really interrupted so cause spurious waking up (early return from sleep). Fix by checking if interrupt event really gets set thus prevent false return. For intrinsic of _isInterrupted, on Windows, go fastpath only on bit not set.
Reviewed-by: acorn, kvn
Contributed-by: david.holmes@oracle.com, yumin.qi@oracle.com
| author | minqi |
|---|---|
| date | Wed, 26 Feb 2014 15:20:41 -0800 |
| parents | d336b3173277 |
| children | 044b28168e20 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 1972 | 2 * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. |
| 0 | 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_ADLC_ARCHDESC_HPP |
| 26 #define SHARE_VM_ADLC_ARCHDESC_HPP | |
| 27 | |
| 0 | 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); | |
| 1972 | 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); | |
| 0 | 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 | |
| 2008 | 303 void defineExpand (FILE *fp, InstructForm *node); |
| 0 | 304 // Generator for Peephole methods for instructions with peephole rules |
| 2008 | 305 void definePeephole (FILE *fp, InstructForm *node); |
| 0 | 306 // Generator for Size methods for instructions |
| 2008 | 307 void defineSize (FILE *fp, InstructForm &node); |
| 308 | |
| 309 public: | |
| 310 // Generator for EvalConstantValue methods for instructions | |
| 311 void defineEvalConstant(FILE *fp, InstructForm &node); | |
| 0 | 312 // Generator for Emit methods for instructions |
| 2008 | 313 void defineEmit (FILE *fp, InstructForm &node); |
| 314 | |
| 0 | 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: | |
| 6850 | 368 FILE *_hpp; |
| 369 FILE *_cpp; | |
| 370 FormDict &_globals; | |
| 371 ArchDesc &_AD; | |
| 372 const char *_name; | |
| 0 | 373 public: |
| 6850 | 374 OutputMap (FILE *decl_file, FILE *def_file, FormDict &globals, ArchDesc &AD, const char *name) |
| 375 : _hpp(decl_file), _cpp(def_file), _globals(globals), _AD(AD), _name(name) {}; | |
| 0 | 376 // Access files used by this routine |
| 377 FILE *decl_file() { return _hpp; } | |
| 378 FILE *def_file() { return _cpp; } | |
| 379 // Positions in iteration that derived class will be told about | |
| 380 enum position { BEGIN_OPERANDS, | |
| 381 BEGIN_OPCLASSES, | |
| 382 BEGIN_INTERNALS, | |
| 383 BEGIN_INSTRUCTIONS, | |
| 384 BEGIN_INST_CHAIN_RULES, | |
| 385 END_INST_CHAIN_RULES, | |
| 386 BEGIN_REMATERIALIZE, | |
| 387 END_REMATERIALIZE, | |
| 388 END_INSTRUCTIONS | |
| 389 }; | |
| 390 // Output routines specific to the derived class | |
| 391 virtual void declaration() {} | |
| 392 virtual void definition() {} | |
| 393 virtual void closing() { fprintf(_cpp, "};\n"); } | |
| 394 virtual void map(OperandForm &oper) { } | |
| 395 virtual void map(OpClassForm &opc) { } | |
| 396 virtual void map(char *internal_name) { } | |
| 397 // Allow enum-MachOperands to turn-off instructions | |
| 398 virtual bool do_instructions() { return true; } | |
| 399 virtual void map(InstructForm &inst) { } | |
| 400 // Allow derived class to output name and position specific info | |
| 401 virtual void record_position(OutputMap::position place, int index) {} | |
| 402 }; | |
| 1972 | 403 |
| 404 #endif // SHARE_VM_ADLC_ARCHDESC_HPP |