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