jdk8-mips64-public/hotspot: comparison src/share/vm/adlc/formsopt.hpp

--1:000000000000
+:a61af66fc99e
+/*
+* Copyright 1998-2006 Sun Microsystems, Inc.  All Rights Reserved.
+* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+*
+* This code is free software; you can redistribute it and/or modify it
+* under the terms of the GNU General Public License version 2 only, as
+* published by the Free Software Foundation.
+*
+* This code is distributed in the hope that it will be useful, but WITHOUT
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+* version 2 for more details (a copy is included in the LICENSE file that
+* accompanied this code).
+*
+* You should have received a copy of the GNU General Public License version
+* 2 along with this work; if not, write to the Free Software Foundation,
+* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+*
+* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+* CA 95054 USA or visit www.sun.com if you need additional information or
+* have any questions.
+*
+*/
+// FORMSOPT.HPP - ADL Parser Target Specific Optimization Forms Classes
+// Class List
+class Form;
+class InstructForm;
+class OperandForm;
+class OpClassForm;
+class AttributeForm;
+class RegisterForm;
+class PipelineForm;
+class SourceForm;
+class EncodeForm;
+class Component;
+class Constraint;
+class Predicate;
+class MatchRule;
+class Attribute;
+class Effect;
+class ExpandRule;
+class RewriteRule;
+class ConstructRule;
+class FormatRule;
+class Peephole;
+class PeepMatch;
+class PeepConstraint;
+class EncClass;
+class Interface;
+class RegInterface;
+class ConstInterface;
+class MemInterface;
+class CondInterface;
+class Opcode;
+class InsEncode;
+class RegDef;
+class RegClass;
+class AllocClass;
+class ResourceForm;
+class PipeClassForm;
+class PipeClassOperandForm;
+class PipeClassResourceForm;
+class PeepMatch;
+class PeepConstraint;
+class PeepReplace;
+class MatchList;
+class ArchDesc;
+//==============================Register Allocation============================
+//------------------------------RegisterForm-----------------------------------
+class RegisterForm : public Form {
+private:
+AllocClass *_current_ac;         // State used by iter_RegDefs()
+public:
+// Public Data
+NameList    _rdefs;              // List of register definition names
+Dict        _regDef;             // map register name to RegDef*
+NameList    _rclasses;           // List of register class names
+Dict        _regClass;           // map register class name to RegClass*
+NameList    _aclasses;           // List of allocation class names
+Dict        _allocClass;         // Dictionary of allocation classes
+static int  _reg_ctr;         // Register counter
+static int  RegMask_Size();   // Compute RegMask size
+// Public Methods
+RegisterForm();
+~RegisterForm();
+void        addRegDef(char *regName, char *callingConv, char *c_conv,
+char * idealtype, char *encoding, char* concreteName);
+RegClass   *addRegClass(const char *className);
+AllocClass *addAllocClass(char *allocName);
+void        addSpillRegClass();
+// Provide iteration over all register definitions
+// in the order used by the register allocator
+void        reset_RegDefs();
+RegDef     *iter_RegDefs();
+RegDef     *getRegDef  (const char *regName);
+RegClass   *getRegClass(const char *className);
+// Return register mask, compressed chunk and register #
+uint       reg_mask(char *register_class);
+// Check that register classes are compatible with chunks
+bool       verify();
+void dump();                     // Debug printer
+void output(FILE *fp);           // Write info to output files
+};
+//------------------------------RegDef-----------------------------------------
+class RegDef : public Form {
+public:
+// Public Data
+const char *_regname;            // ADLC (Opto) Register name
+const char *_callconv;           // Calling convention
+const char *_c_conv;             // Native calling convention, 'C'
+const char *_idealtype;          // Ideal Type for register save/restore
+const char *_concrete;           // concrete register name
+private:
+const char *_register_encode;   // The register encoding
+// The chunk and register mask bits define info for register allocation
+uint32      _register_num;      // Which register am I
+public:
+// Public Methods
+RegDef(char  *regname, char *callconv, char *c_conv,
+char *idealtype, char *encoding, char *concrete);
+~RegDef();                       // Destructor
+// Interface to define/redefine the register number
+void     set_register_num(uint32 new_register_num);
+// Bit pattern used for generating machine code
+const char *register_encode()   const;
+// Register number used in machine-independent code
+uint32   register_num()      const;
+void dump();                     // Debug printer
+void output(FILE *fp);           // Write info to output files
+};
+//------------------------------RegClass---------------------------------------
+class RegClass : public Form {
+public:
+// Public Data
+const char *_classid;         // Name of class
+NameList    _regDefs;         // List of registers in class
+Dict        _regDef;          // Dictionary of registers in class
+bool        _stack_or_reg;    // Allowed on any stack slot
+// Public Methods
+RegClass(const char *classid);// Constructor
+void addReg(RegDef *regDef);  // Add a register to this class
+uint size() const;            // Number of registers in class
+int regs_in_word( int wordnum, bool stack_also );
+const RegDef *get_RegDef(const char *regDef_name) const;
+// Returns the lowest numbered register in the mask.
+const RegDef* find_first_elem();
+// Iteration support
+void          reset();        // Reset the following two iterators
+RegDef       *RegDef_iter();  // which move jointly,
+const char   *rd_name_iter(); // invoking either advances both.
+void dump();                  // Debug printer
+void output(FILE *fp);        // Write info to output files
+};
+//------------------------------AllocClass-------------------------------------
+class AllocClass : public Form {
+private:
+public:
+// Public Data
+char    *_classid;            // Name of class
+NameList _regDefs;            // List of registers in class
+Dict     _regDef;             // Dictionary of registers in class
+// Public Methods
+AllocClass(char *classid);    // Constructor
+void addReg(RegDef *regDef);  // Add a register to this class
+uint size() {return _regDef.Size();} // Number of registers in class
+void dump();                  // Debug printer
+void output(FILE *fp);        // Write info to output files
+};
+//==============================Frame Handling================================
+//------------------------------FrameForm-------------------------------------
+class FrameForm : public Form {
+private:
+public:
+// Public Data
+bool  _direction;                // Direction of stack growth
+char *_sync_stack_slots;
+char *_inline_cache_reg;
+char *_interpreter_method_oop_reg;
+char *_interpreter_frame_pointer_reg;
+char *_cisc_spilling_operand_name;
+char *_frame_pointer;
+char *_c_frame_pointer;
+char *_alignment;
+bool  _return_addr_loc;
+bool  _c_return_addr_loc;
+char *_return_addr;
+char *_c_return_addr;
+char *_in_preserve_slots;
+char *_varargs_C_out_slots_killed;
+char *_calling_convention;
+char *_c_calling_convention;
+char *_return_value;
+char *_c_return_value;
+// Public Methods
+FrameForm();
+~FrameForm();
+void dump();                     // Debug printer
+void output(FILE *fp);           // Write info to output files
+};
+//==============================Scheduling=====================================
+//------------------------------PipelineForm-----------------------------------
+class PipelineForm : public Form {
+private:
+public:
+// Public Data
+NameList   _reslist;            // List of pipeline resources
+FormDict   _resdict;            // Resource Name -> ResourceForm mapping
+int        _rescount;           // Number of resources (ignores OR cases)
+int        _maxcycleused;       // Largest cycle used relative to beginning of instruction
+NameList   _stages;             // List of pipeline stages on architecture
+int        _stagecnt;           // Number of stages listed
+NameList   _classlist;          // List of pipeline classes
+FormDict   _classdict;          // Class Name -> PipeClassForm mapping
+int        _classcnt;           // Number of classes
+NameList   _noplist;            // List of NOP instructions
+int        _nopcnt;             // Number of nop instructions
+bool       _variableSizeInstrs; // Indicates if this architecture has variable sized instructions
+bool       _branchHasDelaySlot; // Indicates that branches have delay slot instructions
+int        _maxInstrsPerBundle; // Indicates the maximum number of instructions for ILP
+int        _maxBundlesPerCycle; // Indicates the maximum number of bundles for ILP
+int        _instrUnitSize;      // The minimum instruction unit size, in bytes
+int        _bundleUnitSize;     // The bundle unit size, in bytes
+int        _instrFetchUnitSize; // The size of the I-fetch unit, in bytes [must be power of 2]
+int        _instrFetchUnits;    // The number of I-fetch units processed per cycle
+// Public Methods
+PipelineForm();
+~PipelineForm();
+void dump();                    // Debug printer
+void output(FILE *fp);          // Write info to output files
+};
+//------------------------------ResourceForm-----------------------------------
+class ResourceForm : public Form {
+public:
+unsigned mask() const { return _resmask; };
+private:
+// Public Data
+unsigned _resmask;         // Resource Mask (OR of resource specifier bits)
+public:
+// Virtual Methods
+virtual ResourceForm  *is_resource()    const;
+// Public Methods
+ResourceForm(unsigned resmask); // Constructor
+~ResourceForm();                // Destructor
+void dump();                    // Debug printer
+void output(FILE *fp);          // Write info to output files
+};
+//------------------------------PipeClassOperandForm-----------------------------
+class PipeClassOperandForm : public Form {
+private:
+public:
+// Public Data
+const char *_stage;             // Name of Stage
+unsigned _iswrite;              // Read or Write
+unsigned _more_instrs;          // Additional Instructions
+// Public Methods
+PipeClassOperandForm(const char *stage, unsigned iswrite, unsigned more_instrs)
+: _stage(stage)
+, _iswrite(iswrite)
+, _more_instrs(more_instrs)
+{};
+~PipeClassOperandForm() {};     // Destructor
+bool isWrite() const { return _iswrite != 0; }
+void dump();                    // Debug printer
+void output(FILE *fp);          // Write info to output files
+};
+//------------------------------PipeClassResourceForm--------------------------
+class PipeClassResourceForm : public Form {
+private:
+public:
+// Public Data
+const char *_resource;          // Resource
+const char *_stage;             // Stage the resource is used in
+int         _cycles;            // Number of cycles the resource is used
+// Public Methods
+PipeClassResourceForm(const char *resource, const char *stage, int cycles)
+// Constructor
+: _resource(resource)
+, _stage(stage)
+, _cycles(cycles)
+{};
+~PipeClassResourceForm() {};    // Destructor
+void dump();                    // Debug printer
+void output(FILE *fp);          // Write info to output files
+};
+//------------------------------PipeClassForm----------------------------------
+class PipeClassForm : public Form {
+private:
+public:
+// Public Data
+const char       *_ident;             // Name of class
+int               _num;               // Used in name of MachNode subclass
+NameList          _parameters;        // Locally defined names
+FormDict          _localNames;        // Table of operands & their types
+FormDict          _localUsage;        // Table of operand usage
+FormList          _resUsage;          // List of resource usage
+NameList          _instructs;         // List of instructions and machine nodes that use this pipeline class
+bool              _has_fixed_latency; // Always takes this number of cycles
+int               _fixed_latency;     // Always takes this number of cycles
+int               _instruction_count; // Number of instructions in first bundle
+bool              _has_multiple_bundles;  // Indicates if 1 or multiple bundles
+bool              _has_branch_delay_slot; // Has branch delay slot as last instruction
+bool              _force_serialization;   // This node serializes relative to surrounding nodes
+bool              _may_have_no_code;      // This node may generate no code based on register allocation
+// Virtual Methods
+virtual PipeClassForm  *is_pipeclass()    const;
+// Public Methods
+PipeClassForm(const char *id, int num);
+// Constructor
+~PipeClassForm();               // Destructor
+bool hasFixedLatency() { return _has_fixed_latency; }
+int fixedLatency() { return _fixed_latency; }
+void setFixedLatency(int fixed_latency) { _has_fixed_latency = 1; _fixed_latency = fixed_latency; }
+void setInstructionCount(int i)    { _instruction_count = i; }
+void setMultipleBundles(bool b)    { _has_multiple_bundles = b; }
+void setBranchDelay(bool s)        { _has_branch_delay_slot = s; }
+void setForceSerialization(bool s) { _force_serialization = s; }
+void setMayHaveNoCode(bool s)      { _may_have_no_code = s; }
+int  InstructionCount()   const { return _instruction_count; }
+bool hasMultipleBundles() const { return _has_multiple_bundles; }
+bool hasBranchDelay()     const { return _has_branch_delay_slot; }
+bool forceSerialization() const { return _force_serialization; }
+bool mayHaveNoCode()      const { return _may_have_no_code; }
+void dump();                    // Debug printer
+void output(FILE *fp);          // Write info to output files
+};
+//==============================Peephole Optimization==========================
+//------------------------------Peephole---------------------------------------
+class Peephole : public Form {
+private:
+static int      _peephole_counter;// Incremented by each peephole rule parsed
+int             _peephole_number;// Remember my order in architecture description
+PeepMatch      *_match;          // Instruction pattern to match
+PeepConstraint *_constraint;     // List of additional constraints
+PeepReplace    *_replace;        // Instruction pattern to substitute in
+Peephole *_next;
+public:
+// Public Methods
+Peephole();
+~Peephole();
+// Append a peephole rule with the same root instruction
+void append_peephole(Peephole *next_peephole);
+// Store the components of this peephole rule
+void add_match(PeepMatch *only_one_match);
+void append_constraint(PeepConstraint *next_constraint);
+void add_replace(PeepReplace *only_one_replacement);
+// Access the components of this peephole rule
+int             peephole_number() { return _peephole_number; }
+PeepMatch      *match()       { return _match; }
+PeepConstraint *constraints() { return _constraint; }
+PeepReplace    *replacement() { return _replace; }
+Peephole       *next()        { return _next; }
+void dump();                     // Debug printer
+void output(FILE *fp);           // Write info to output files
+};
+class PeepMatch : public Form {
+private:
+char *_rule;
+// NameList  _depth;                // Depth of this instruction
+NameList  _parent;
+NameList  _position;
+NameList  _instrs;               // List of instructions in match rule
+NameList  _input;                // input position in parent's instruction
+int       _max_position;
+public:
+// Public Methods
+PeepMatch(char *rule);
+~PeepMatch();
+// Insert info into the match-rule
+void  add_instruction(int parent, int position, const char *name, int input);
+// Access info about instructions in the peep-match rule
+int   max_position();
+const char *instruction_name(intptr_t position);
+// Iterate through all info on matched instructions
+void  reset();
+void  next_instruction( intptr_t &parent, intptr_t &position, const char * &name, intptr_t &input );
+// 'true' if current position in iteration is a placeholder, not matched.
+bool  is_placeholder();
+void dump();
+void output(FILE *fp);
+};
+class PeepConstraint : public Form {
+private:
+PeepConstraint *_next;           // Additional constraints ANDed together
+public:
+const intptr_t  _left_inst;
+const char      *_left_op;
+const char      *_relation;
+const intptr_t  _right_inst;
+const char      *_right_op;
+public:
+// Public Methods
+PeepConstraint(intptr_t  left_inst,  char *left_op, char *relation,
+intptr_t  right_inst, char *right_op);
+~PeepConstraint();
+// Check if constraints use instruction at position
+bool constrains_instruction(intptr_t position);
+// Add another constraint
+void append(PeepConstraint *next_peep_constraint);
+// Access the next constraint in the list
+PeepConstraint *next();
+void dump();
+void output(FILE *fp);
+};
+class PeepReplace : public Form {
+private:
+char *_rule;
+NameList _instruction;
+NameList _operand_inst_num;
+NameList _operand_op_name;
+public:
+// Public Methods
+PeepReplace(char *rule);
+~PeepReplace();
+// Add contents of peepreplace
+void  add_instruction(char *root);
+void  add_operand( int inst_num, char *inst_operand );
+// Access contents of peepreplace
+void  reset();
+void  next_instruction(const char * &root);
+void  next_operand( intptr_t &inst_num, const char * &inst_operand );
+// Utilities
+void dump();
+void output(FILE *fp);
+};
+class PeepChild : public Form {
+public:
+const int   _inst_num;         // Number of instruction (-1 if only named)
+const char *_inst_op;          // Instruction's operand, NULL if number == -1
+const char *_inst_name;        // Name of the instruction
+public:
+PeepChild(char *inst_name)
+: _inst_num(-1), _inst_op(NULL), _inst_name(inst_name) {};
+PeepChild(int inst_num, char *inst_op, char *inst_name)
+: _inst_num(inst_num), _inst_op(inst_op), _inst_name(inst_name) {};
+~PeepChild();
+bool  use_leaf_operand()        { return _inst_num != -1; };
+bool  generate_an_instruction() { return _inst_num == -1; }
+void dump();
+void output(FILE *fp);
+};

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/adlc/formsopt.hpp

src/share/vm/adlc/formsopt.hpp