annotate src/share/vm/adlc/formsopt.hpp @ 5663:1dcea64e9f00

8024830: SEGV in org.apache.lucene.codecs.compressing.CompressingTermVectorsReader.get Summary: Exclude last input argument's stack slots from vector's spilling masks. Reviewed-by: iveresov
author kvn
date Mon, 11 Nov 2013 11:53:33 -0800
parents f95d63e2154a
children
rev   line source
duke@0 1 /*
stefank@1879 2 * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved.
duke@0 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@0 4 *
duke@0 5 * This code is free software; you can redistribute it and/or modify it
duke@0 6 * under the terms of the GNU General Public License version 2 only, as
duke@0 7 * published by the Free Software Foundation.
duke@0 8 *
duke@0 9 * This code is distributed in the hope that it will be useful, but WITHOUT
duke@0 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@0 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
duke@0 12 * version 2 for more details (a copy is included in the LICENSE file that
duke@0 13 * accompanied this code).
duke@0 14 *
duke@0 15 * You should have received a copy of the GNU General Public License version
duke@0 16 * 2 along with this work; if not, write to the Free Software Foundation,
duke@0 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@0 18 *
trims@1472 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
trims@1472 20 * or visit www.oracle.com if you need additional information or have any
trims@1472 21 * questions.
duke@0 22 *
duke@0 23 */
duke@0 24
stefank@1879 25 #ifndef SHARE_VM_ADLC_FORMSOPT_HPP
stefank@1879 26 #define SHARE_VM_ADLC_FORMSOPT_HPP
stefank@1879 27
duke@0 28 // FORMSOPT.HPP - ADL Parser Target Specific Optimization Forms Classes
duke@0 29
duke@0 30 // Class List
duke@0 31 class Form;
duke@0 32 class InstructForm;
duke@0 33 class OperandForm;
duke@0 34 class OpClassForm;
duke@0 35 class AttributeForm;
duke@0 36 class RegisterForm;
duke@0 37 class PipelineForm;
duke@0 38 class SourceForm;
duke@0 39 class EncodeForm;
duke@0 40 class Component;
duke@0 41 class Constraint;
duke@0 42 class Predicate;
duke@0 43 class MatchRule;
duke@0 44 class Attribute;
duke@0 45 class Effect;
duke@0 46 class ExpandRule;
duke@0 47 class RewriteRule;
duke@0 48 class ConstructRule;
duke@0 49 class FormatRule;
duke@0 50 class Peephole;
duke@0 51 class PeepMatch;
duke@0 52 class PeepConstraint;
duke@0 53 class EncClass;
duke@0 54 class Interface;
duke@0 55 class RegInterface;
duke@0 56 class ConstInterface;
duke@0 57 class MemInterface;
duke@0 58 class CondInterface;
duke@0 59 class Opcode;
duke@0 60 class InsEncode;
duke@0 61 class RegDef;
duke@0 62 class RegClass;
duke@0 63 class AllocClass;
duke@0 64 class ResourceForm;
duke@0 65 class PipeClassForm;
duke@0 66 class PipeClassOperandForm;
duke@0 67 class PipeClassResourceForm;
duke@0 68 class PeepMatch;
duke@0 69 class PeepConstraint;
duke@0 70 class PeepReplace;
duke@0 71 class MatchList;
duke@0 72
duke@0 73 class ArchDesc;
duke@0 74
duke@0 75 //==============================Register Allocation============================
duke@0 76 //------------------------------RegisterForm-----------------------------------
duke@0 77 class RegisterForm : public Form {
duke@0 78 private:
duke@0 79 AllocClass *_current_ac; // State used by iter_RegDefs()
duke@0 80
duke@0 81 public:
duke@0 82 // Public Data
duke@0 83 NameList _rdefs; // List of register definition names
duke@0 84 Dict _regDef; // map register name to RegDef*
duke@0 85
duke@0 86 NameList _rclasses; // List of register class names
duke@0 87 Dict _regClass; // map register class name to RegClass*
duke@0 88
duke@0 89 NameList _aclasses; // List of allocation class names
duke@0 90 Dict _allocClass; // Dictionary of allocation classes
duke@0 91
duke@0 92 static int _reg_ctr; // Register counter
duke@0 93 static int RegMask_Size(); // Compute RegMask size
duke@0 94
duke@0 95 // Public Methods
duke@0 96 RegisterForm();
duke@0 97 ~RegisterForm();
duke@0 98
duke@0 99 void addRegDef(char *regName, char *callingConv, char *c_conv,
duke@0 100 char * idealtype, char *encoding, char* concreteName);
duke@0 101 RegClass *addRegClass(const char *className);
duke@0 102 AllocClass *addAllocClass(char *allocName);
duke@0 103 void addSpillRegClass();
duke@0 104
duke@0 105 // Provide iteration over all register definitions
duke@0 106 // in the order used by the register allocator
duke@0 107 void reset_RegDefs();
duke@0 108 RegDef *iter_RegDefs();
duke@0 109 RegDef *getRegDef (const char *regName);
duke@0 110
duke@0 111 RegClass *getRegClass(const char *className);
duke@0 112
duke@0 113 // Return register mask, compressed chunk and register #
duke@0 114 uint reg_mask(char *register_class);
duke@0 115
duke@0 116 // Check that register classes are compatible with chunks
duke@0 117 bool verify();
duke@0 118
duke@0 119 void dump(); // Debug printer
duke@0 120 void output(FILE *fp); // Write info to output files
duke@0 121 };
duke@0 122
duke@0 123 //------------------------------RegDef-----------------------------------------
duke@0 124 class RegDef : public Form {
duke@0 125 public:
duke@0 126 // Public Data
duke@0 127 const char *_regname; // ADLC (Opto) Register name
duke@0 128 const char *_callconv; // Calling convention
duke@0 129 const char *_c_conv; // Native calling convention, 'C'
duke@0 130 const char *_idealtype; // Ideal Type for register save/restore
duke@0 131 const char *_concrete; // concrete register name
duke@0 132
duke@0 133 private:
duke@0 134 const char *_register_encode; // The register encoding
duke@0 135 // The chunk and register mask bits define info for register allocation
duke@0 136 uint32 _register_num; // Which register am I
duke@0 137
duke@0 138 public:
duke@0 139 // Public Methods
duke@0 140 RegDef(char *regname, char *callconv, char *c_conv,
duke@0 141 char *idealtype, char *encoding, char *concrete);
duke@0 142 ~RegDef(); // Destructor
duke@0 143
duke@0 144 // Interface to define/redefine the register number
duke@0 145 void set_register_num(uint32 new_register_num);
duke@0 146
duke@0 147 // Bit pattern used for generating machine code
duke@0 148 const char *register_encode() const;
duke@0 149 // Register number used in machine-independent code
duke@0 150 uint32 register_num() const;
duke@0 151
duke@0 152 void dump(); // Debug printer
duke@0 153 void output(FILE *fp); // Write info to output files
duke@0 154 };
duke@0 155
duke@0 156 //------------------------------RegClass---------------------------------------
duke@0 157 class RegClass : public Form {
duke@0 158 public:
duke@0 159 // Public Data
duke@0 160 const char *_classid; // Name of class
duke@0 161 NameList _regDefs; // List of registers in class
duke@0 162 Dict _regDef; // Dictionary of registers in class
duke@0 163 bool _stack_or_reg; // Allowed on any stack slot
roland@2882 164 char* _user_defined;
duke@0 165
duke@0 166 // Public Methods
duke@0 167 RegClass(const char *classid);// Constructor
duke@0 168
duke@0 169 void addReg(RegDef *regDef); // Add a register to this class
duke@0 170
duke@0 171 uint size() const; // Number of registers in class
duke@0 172 int regs_in_word( int wordnum, bool stack_also );
duke@0 173
duke@0 174 const RegDef *get_RegDef(const char *regDef_name) const;
duke@0 175
duke@0 176 // Returns the lowest numbered register in the mask.
duke@0 177 const RegDef* find_first_elem();
duke@0 178
duke@0 179 // Iteration support
duke@0 180 void reset(); // Reset the following two iterators
duke@0 181 RegDef *RegDef_iter(); // which move jointly,
duke@0 182 const char *rd_name_iter(); // invoking either advances both.
duke@0 183
duke@0 184 void dump(); // Debug printer
duke@0 185 void output(FILE *fp); // Write info to output files
duke@0 186 };
duke@0 187
duke@0 188 //------------------------------AllocClass-------------------------------------
duke@0 189 class AllocClass : public Form {
duke@0 190 private:
duke@0 191
duke@0 192 public:
duke@0 193 // Public Data
duke@0 194 char *_classid; // Name of class
duke@0 195 NameList _regDefs; // List of registers in class
duke@0 196 Dict _regDef; // Dictionary of registers in class
duke@0 197
duke@0 198 // Public Methods
duke@0 199 AllocClass(char *classid); // Constructor
duke@0 200
duke@0 201 void addReg(RegDef *regDef); // Add a register to this class
duke@0 202 uint size() {return _regDef.Size();} // Number of registers in class
duke@0 203
duke@0 204 void dump(); // Debug printer
duke@0 205 void output(FILE *fp); // Write info to output files
duke@0 206 };
duke@0 207
duke@0 208
duke@0 209 //==============================Frame Handling================================
duke@0 210 //------------------------------FrameForm-------------------------------------
duke@0 211 class FrameForm : public Form {
duke@0 212 private:
duke@0 213
duke@0 214 public:
duke@0 215 // Public Data
duke@0 216 bool _direction; // Direction of stack growth
duke@0 217 char *_sync_stack_slots;
duke@0 218 char *_inline_cache_reg;
duke@0 219 char *_interpreter_method_oop_reg;
duke@0 220 char *_interpreter_frame_pointer_reg;
duke@0 221 char *_cisc_spilling_operand_name;
duke@0 222 char *_frame_pointer;
duke@0 223 char *_c_frame_pointer;
duke@0 224 char *_alignment;
duke@0 225 bool _return_addr_loc;
duke@0 226 bool _c_return_addr_loc;
duke@0 227 char *_return_addr;
duke@0 228 char *_c_return_addr;
duke@0 229 char *_in_preserve_slots;
duke@0 230 char *_varargs_C_out_slots_killed;
duke@0 231 char *_calling_convention;
duke@0 232 char *_c_calling_convention;
duke@0 233 char *_return_value;
duke@0 234 char *_c_return_value;
duke@0 235
duke@0 236 // Public Methods
duke@0 237 FrameForm();
duke@0 238 ~FrameForm();
duke@0 239
duke@0 240 void dump(); // Debug printer
duke@0 241 void output(FILE *fp); // Write info to output files
duke@0 242 };
duke@0 243
duke@0 244
duke@0 245 //==============================Scheduling=====================================
duke@0 246 //------------------------------PipelineForm-----------------------------------
duke@0 247 class PipelineForm : public Form {
duke@0 248 private:
duke@0 249
duke@0 250 public:
duke@0 251 // Public Data
duke@0 252 NameList _reslist; // List of pipeline resources
duke@0 253 FormDict _resdict; // Resource Name -> ResourceForm mapping
duke@0 254 int _rescount; // Number of resources (ignores OR cases)
duke@0 255 int _maxcycleused; // Largest cycle used relative to beginning of instruction
duke@0 256
duke@0 257 NameList _stages; // List of pipeline stages on architecture
duke@0 258 int _stagecnt; // Number of stages listed
duke@0 259
duke@0 260 NameList _classlist; // List of pipeline classes
duke@0 261 FormDict _classdict; // Class Name -> PipeClassForm mapping
duke@0 262 int _classcnt; // Number of classes
duke@0 263
duke@0 264 NameList _noplist; // List of NOP instructions
duke@0 265 int _nopcnt; // Number of nop instructions
duke@0 266
duke@0 267 bool _variableSizeInstrs; // Indicates if this architecture has variable sized instructions
duke@0 268 bool _branchHasDelaySlot; // Indicates that branches have delay slot instructions
duke@0 269 int _maxInstrsPerBundle; // Indicates the maximum number of instructions for ILP
duke@0 270 int _maxBundlesPerCycle; // Indicates the maximum number of bundles for ILP
duke@0 271 int _instrUnitSize; // The minimum instruction unit size, in bytes
duke@0 272 int _bundleUnitSize; // The bundle unit size, in bytes
duke@0 273 int _instrFetchUnitSize; // The size of the I-fetch unit, in bytes [must be power of 2]
duke@0 274 int _instrFetchUnits; // The number of I-fetch units processed per cycle
duke@0 275
duke@0 276 // Public Methods
duke@0 277 PipelineForm();
duke@0 278 ~PipelineForm();
duke@0 279
duke@0 280 void dump(); // Debug printer
duke@0 281 void output(FILE *fp); // Write info to output files
duke@0 282 };
duke@0 283
duke@0 284 //------------------------------ResourceForm-----------------------------------
duke@0 285 class ResourceForm : public Form {
duke@0 286 public:
duke@0 287 unsigned mask() const { return _resmask; };
duke@0 288
duke@0 289 private:
duke@0 290 // Public Data
duke@0 291 unsigned _resmask; // Resource Mask (OR of resource specifier bits)
duke@0 292
duke@0 293 public:
duke@0 294
duke@0 295 // Virtual Methods
duke@0 296 virtual ResourceForm *is_resource() const;
duke@0 297
duke@0 298 // Public Methods
duke@0 299 ResourceForm(unsigned resmask); // Constructor
duke@0 300 ~ResourceForm(); // Destructor
duke@0 301
duke@0 302 void dump(); // Debug printer
duke@0 303 void output(FILE *fp); // Write info to output files
duke@0 304 };
duke@0 305
duke@0 306 //------------------------------PipeClassOperandForm-----------------------------
duke@0 307 class PipeClassOperandForm : public Form {
duke@0 308 private:
duke@0 309
duke@0 310 public:
duke@0 311 // Public Data
duke@0 312 const char *_stage; // Name of Stage
duke@0 313 unsigned _iswrite; // Read or Write
duke@0 314 unsigned _more_instrs; // Additional Instructions
duke@0 315
duke@0 316 // Public Methods
duke@0 317 PipeClassOperandForm(const char *stage, unsigned iswrite, unsigned more_instrs)
duke@0 318 : _stage(stage)
duke@0 319 , _iswrite(iswrite)
duke@0 320 , _more_instrs(more_instrs)
duke@0 321 {};
duke@0 322
duke@0 323 ~PipeClassOperandForm() {}; // Destructor
duke@0 324
duke@0 325 bool isWrite() const { return _iswrite != 0; }
duke@0 326
duke@0 327 void dump(); // Debug printer
duke@0 328 void output(FILE *fp); // Write info to output files
duke@0 329 };
duke@0 330
duke@0 331 //------------------------------PipeClassResourceForm--------------------------
duke@0 332 class PipeClassResourceForm : public Form {
duke@0 333 private:
duke@0 334
duke@0 335 public:
duke@0 336 // Public Data
duke@0 337 const char *_resource; // Resource
duke@0 338 const char *_stage; // Stage the resource is used in
duke@0 339 int _cycles; // Number of cycles the resource is used
duke@0 340
duke@0 341 // Public Methods
duke@0 342 PipeClassResourceForm(const char *resource, const char *stage, int cycles)
duke@0 343 // Constructor
duke@0 344 : _resource(resource)
duke@0 345 , _stage(stage)
duke@0 346 , _cycles(cycles)
duke@0 347 {};
duke@0 348
duke@0 349 ~PipeClassResourceForm() {}; // Destructor
duke@0 350
duke@0 351 void dump(); // Debug printer
duke@0 352 void output(FILE *fp); // Write info to output files
duke@0 353 };
duke@0 354
duke@0 355 //------------------------------PipeClassForm----------------------------------
duke@0 356 class PipeClassForm : public Form {
duke@0 357 private:
duke@0 358
duke@0 359 public:
duke@0 360
duke@0 361 // Public Data
duke@0 362 const char *_ident; // Name of class
duke@0 363 int _num; // Used in name of MachNode subclass
duke@0 364 NameList _parameters; // Locally defined names
duke@0 365 FormDict _localNames; // Table of operands & their types
duke@0 366 FormDict _localUsage; // Table of operand usage
duke@0 367 FormList _resUsage; // List of resource usage
duke@0 368 NameList _instructs; // List of instructions and machine nodes that use this pipeline class
duke@0 369 bool _has_fixed_latency; // Always takes this number of cycles
duke@0 370 int _fixed_latency; // Always takes this number of cycles
duke@0 371 int _instruction_count; // Number of instructions in first bundle
duke@0 372 bool _has_multiple_bundles; // Indicates if 1 or multiple bundles
duke@0 373 bool _has_branch_delay_slot; // Has branch delay slot as last instruction
duke@0 374 bool _force_serialization; // This node serializes relative to surrounding nodes
duke@0 375 bool _may_have_no_code; // This node may generate no code based on register allocation
duke@0 376
duke@0 377 // Virtual Methods
duke@0 378 virtual PipeClassForm *is_pipeclass() const;
duke@0 379
duke@0 380 // Public Methods
duke@0 381 PipeClassForm(const char *id, int num);
duke@0 382 // Constructor
duke@0 383 ~PipeClassForm(); // Destructor
duke@0 384
duke@0 385 bool hasFixedLatency() { return _has_fixed_latency; }
duke@0 386 int fixedLatency() { return _fixed_latency; }
duke@0 387
duke@0 388 void setFixedLatency(int fixed_latency) { _has_fixed_latency = 1; _fixed_latency = fixed_latency; }
duke@0 389
duke@0 390 void setInstructionCount(int i) { _instruction_count = i; }
duke@0 391 void setMultipleBundles(bool b) { _has_multiple_bundles = b; }
duke@0 392 void setBranchDelay(bool s) { _has_branch_delay_slot = s; }
duke@0 393 void setForceSerialization(bool s) { _force_serialization = s; }
duke@0 394 void setMayHaveNoCode(bool s) { _may_have_no_code = s; }
duke@0 395
duke@0 396 int InstructionCount() const { return _instruction_count; }
duke@0 397 bool hasMultipleBundles() const { return _has_multiple_bundles; }
duke@0 398 bool hasBranchDelay() const { return _has_branch_delay_slot; }
duke@0 399 bool forceSerialization() const { return _force_serialization; }
duke@0 400 bool mayHaveNoCode() const { return _may_have_no_code; }
duke@0 401
duke@0 402 void dump(); // Debug printer
duke@0 403 void output(FILE *fp); // Write info to output files
duke@0 404 };
duke@0 405
duke@0 406
duke@0 407 //==============================Peephole Optimization==========================
duke@0 408 //------------------------------Peephole---------------------------------------
duke@0 409 class Peephole : public Form {
duke@0 410 private:
duke@0 411 static int _peephole_counter;// Incremented by each peephole rule parsed
duke@0 412 int _peephole_number;// Remember my order in architecture description
duke@0 413 PeepMatch *_match; // Instruction pattern to match
duke@0 414 PeepConstraint *_constraint; // List of additional constraints
duke@0 415 PeepReplace *_replace; // Instruction pattern to substitute in
duke@0 416
duke@0 417 Peephole *_next;
duke@0 418
duke@0 419 public:
duke@0 420 // Public Methods
duke@0 421 Peephole();
duke@0 422 ~Peephole();
duke@0 423
duke@0 424 // Append a peephole rule with the same root instruction
duke@0 425 void append_peephole(Peephole *next_peephole);
duke@0 426
duke@0 427 // Store the components of this peephole rule
duke@0 428 void add_match(PeepMatch *only_one_match);
duke@0 429 void append_constraint(PeepConstraint *next_constraint);
duke@0 430 void add_replace(PeepReplace *only_one_replacement);
duke@0 431
duke@0 432 // Access the components of this peephole rule
duke@0 433 int peephole_number() { return _peephole_number; }
duke@0 434 PeepMatch *match() { return _match; }
duke@0 435 PeepConstraint *constraints() { return _constraint; }
duke@0 436 PeepReplace *replacement() { return _replace; }
duke@0 437 Peephole *next() { return _next; }
duke@0 438
duke@0 439 void dump(); // Debug printer
duke@0 440 void output(FILE *fp); // Write info to output files
duke@0 441 };
duke@0 442
duke@0 443
duke@0 444 class PeepMatch : public Form {
duke@0 445 private:
duke@0 446 char *_rule;
duke@0 447 // NameList _depth; // Depth of this instruction
duke@0 448 NameList _parent;
duke@0 449 NameList _position;
duke@0 450 NameList _instrs; // List of instructions in match rule
duke@0 451 NameList _input; // input position in parent's instruction
duke@0 452 int _max_position;
duke@0 453
duke@0 454 public:
duke@0 455 // Public Methods
duke@0 456 PeepMatch(char *rule);
duke@0 457 ~PeepMatch();
duke@0 458
duke@0 459 // Insert info into the match-rule
duke@0 460 void add_instruction(int parent, int position, const char *name, int input);
duke@0 461
duke@0 462 // Access info about instructions in the peep-match rule
duke@0 463 int max_position();
twisti@603 464 const char *instruction_name(int position);
duke@0 465 // Iterate through all info on matched instructions
duke@0 466 void reset();
twisti@603 467 void next_instruction(int &parent, int &position, const char* &name, int &input);
duke@0 468 // 'true' if current position in iteration is a placeholder, not matched.
duke@0 469 bool is_placeholder();
duke@0 470
duke@0 471 void dump();
duke@0 472 void output(FILE *fp);
duke@0 473 };
duke@0 474
duke@0 475
duke@0 476 class PeepConstraint : public Form {
duke@0 477 private:
duke@0 478 PeepConstraint *_next; // Additional constraints ANDed together
duke@0 479
duke@0 480 public:
twisti@603 481 const int _left_inst;
twisti@603 482 const char* _left_op;
twisti@603 483 const char* _relation;
twisti@603 484 const int _right_inst;
twisti@603 485 const char* _right_op;
duke@0 486
duke@0 487 public:
duke@0 488 // Public Methods
twisti@603 489 PeepConstraint(int left_inst, char* left_op, char* relation,
twisti@603 490 int right_inst, char* right_op);
duke@0 491 ~PeepConstraint();
duke@0 492
duke@0 493 // Check if constraints use instruction at position
twisti@603 494 bool constrains_instruction(int position);
duke@0 495
duke@0 496 // Add another constraint
duke@0 497 void append(PeepConstraint *next_peep_constraint);
duke@0 498 // Access the next constraint in the list
duke@0 499 PeepConstraint *next();
duke@0 500
duke@0 501 void dump();
duke@0 502 void output(FILE *fp);
duke@0 503 };
duke@0 504
duke@0 505
duke@0 506 class PeepReplace : public Form {
duke@0 507 private:
duke@0 508 char *_rule;
duke@0 509 NameList _instruction;
duke@0 510 NameList _operand_inst_num;
duke@0 511 NameList _operand_op_name;
duke@0 512
duke@0 513 public:
duke@0 514
duke@0 515 // Public Methods
duke@0 516 PeepReplace(char *rule);
duke@0 517 ~PeepReplace();
duke@0 518
duke@0 519 // Add contents of peepreplace
duke@0 520 void add_instruction(char *root);
duke@0 521 void add_operand( int inst_num, char *inst_operand );
duke@0 522
duke@0 523 // Access contents of peepreplace
duke@0 524 void reset();
duke@0 525 void next_instruction(const char * &root);
twisti@603 526 void next_operand(int &inst_num, const char * &inst_operand );
duke@0 527
duke@0 528 // Utilities
duke@0 529 void dump();
duke@0 530 void output(FILE *fp);
duke@0 531 };
duke@0 532
duke@0 533
duke@0 534 class PeepChild : public Form {
duke@0 535 public:
duke@0 536 const int _inst_num; // Number of instruction (-1 if only named)
duke@0 537 const char *_inst_op; // Instruction's operand, NULL if number == -1
duke@0 538 const char *_inst_name; // Name of the instruction
duke@0 539
duke@0 540 public:
duke@0 541 PeepChild(char *inst_name)
duke@0 542 : _inst_num(-1), _inst_op(NULL), _inst_name(inst_name) {};
duke@0 543 PeepChild(int inst_num, char *inst_op, char *inst_name)
duke@0 544 : _inst_num(inst_num), _inst_op(inst_op), _inst_name(inst_name) {};
duke@0 545 ~PeepChild();
duke@0 546
duke@0 547 bool use_leaf_operand() { return _inst_num != -1; };
duke@0 548 bool generate_an_instruction() { return _inst_num == -1; }
duke@0 549
duke@0 550 void dump();
duke@0 551 void output(FILE *fp);
duke@0 552 };
stefank@1879 553
stefank@1879 554 #endif // SHARE_VM_ADLC_FORMSOPT_HPP