src/share/vm/adlc/formsopt.hpp
Index
Unified diffs
Context diffs
Sdiffs
Patch
New
Old
Previous File
Next File
*** old/src/share/vm/adlc/formsopt.hpp Fri May 29 13:57:37 2015
--- new/src/share/vm/adlc/formsopt.hpp Fri May 29 13:57:37 2015
*** 58,67 ****
--- 58,69 ----
class CondInterface;
class Opcode;
class InsEncode;
class RegDef;
class RegClass;
+ class CodeSnippetRegClass;
+ class ConditionalRegClass;
class AllocClass;
class ResourceForm;
class PipeClassForm;
class PipeClassOperandForm;
class PipeClassResourceForm;
*** 96,106 ****
--- 98,109 ----
RegisterForm();
~RegisterForm();
void addRegDef(char *regName, char *callingConv, char *c_conv,
char * idealtype, char *encoding, char* concreteName);
! RegClass *addRegClass(const char *className);
! template<typename T> T* addRegClass(const char* className);
+
AllocClass *addAllocClass(char *allocName);
void addSpillRegClass();
// Provide iteration over all register definitions
// in the order used by the register allocator
*** 152,172 ****
--- 155,186 ----
void dump(); // Debug printer
void output(FILE *fp); // Write info to output files
};
//------------------------------RegClass---------------------------------------
+ // Generic register class. This register class is the internal representation
+ // for the following .ad file format:
+ //
+ // reg_class ptr(RAX, RBX, ...);
+ //
+ // where ptr is the name of the register class, RAX and RBX are registers.
+ //
+ // This register class allows registers to be spilled onto the stack. Spilling
+ // is allowed is field _stack_or_reg is true.
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
+ protected:
bool _stack_or_reg; // Allowed on any stack slot
char* _user_defined;
+ public:
// Public Methods
RegClass(const char *classid);// Constructor
+ virtual ~RegClass();
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 );
*** 181,190 ****
--- 195,313 ----
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
+
+ virtual bool has_stack_version() {
+ return _stack_or_reg;
+ }
+ virtual void set_stack_version(bool flag) {
+ _stack_or_reg = flag;
+ }
+
+ virtual void declare_register_masks(FILE* fp);
+ virtual void build_register_masks(FILE* fp);
+ };
+
+ //------------------------------CodeSnippetRegClass----------------------------
+ // Register class that has an user-defined C++ code snippet attached to it
+ // to determine at runtime which register class to use. This register class is
+ // the internal representation for the following .ad file format:
+ //
+ // reg_class actual_dflt_reg %{
+ // if (VM_Version::has_vfp3_32()) {
+ // return DFLT_REG_mask();
+ // } else {
+ // return DFLT_LOW_REG_mask();
+ // }
+ // %}
+ //
+ // where DFLT_REG_mask() and DFLT_LOW_REG_mask() are the internal names of the
+ // masks of register classes dflt_reg and dflt_low_reg.
+ //
+ // The attached code snippet can select also between more than two register classes.
+ // This register class can be, however, used only if the register class is not
+ // cisc-spillable (i.e., the registers of this class are not allowed on the stack,
+ // which is equivalent with _stack_or_reg being false).
+ class CodeSnippetRegClass : public RegClass {
+ protected:
+ char* _code_snippet;
+ public:
+ CodeSnippetRegClass(const char* classid);// Constructor
+ ~CodeSnippetRegClass();
+
+ void set_code_snippet(char* code) {
+ _code_snippet = code;
+ }
+ char* code_snippet() {
+ return _code_snippet;
+ }
+ void set_stack_version(bool flag) {
+ assert(false, "User defined register classes are not allowed to spill to the stack.");
+ }
+ void declare_register_masks(FILE* fp);
+ void build_register_masks(FILE* fp) {
+ // We do not need to generate register masks because we select at runtime
+ // between register masks generated for other register classes.
+ return;
+ }
+ };
+
+ //------------------------------ConditionalRegClass----------------------------
+ // Register class that has two register classes and a runtime condition attached
+ // to it. The condition is evaluated at runtime and either one of the register
+ // attached register classes is selected. This register class is the internal
+ // representation for the following .ad format:
+ //
+ // reg_class_dynamic actual_dflt_reg(dflt_reg, low_reg,
+ // %{ VM_Version::has_vfp3_32() }%
+ // );
+ //
+ // This example is equivalent to the example used with the CodeSnippetRegClass
+ // register class. A ConditionalRegClass works also if a register class is cisc-spillable
+ // (i.e., _stack_or_reg is true), but if can select only between two register classes.
+ class ConditionalRegClass : public RegClass {
+ protected:
+ // reference to condition code
+ char* _condition_code; // C++ condition code to dynamically determine which register class to use.
+
+ // Example syntax (equivalent to previous example):
+ //
+ // reg_class actual_dflt_reg(dflt_reg, low_reg,
+ // %{ VM_Version::has_vfp3_32() }%
+ // );
+ // reference to conditional register classes
+ RegClass* _rclasses[2]; // 0 is the register class selected if the condition code returns true
+ // 1 is the register class selected if the condition code returns false
+ public:
+ ConditionalRegClass(const char* classid);// Constructor
+ ~ConditionalRegClass();
+
+ virtual void set_stack_version(bool flag) {
+ RegClass::set_stack_version(flag);
+ assert((_rclasses[0] != NULL), "Register class NULL for condition code == true");
+ assert((_rclasses[1] != NULL), "Register class NULL for condition code == false");
+ _rclasses[0]->set_stack_version(flag);
+ _rclasses[1]->set_stack_version(flag);
+ }
+ void declare_register_masks(FILE* fp);
+ void build_register_masks(FILE* fp) {
+ // We do not need to generate register masks because we select at runtime
+ // between register masks generated for other register classes.
+ return;
+ }
+ void set_rclass_at_index(int index, RegClass* rclass) {
+ assert((0 <= index && index < 2), "Condition code can select only between two register classes");
+ _rclasses[index] = rclass;
+ }
+ void set_condition_code(char* code) {
+ _condition_code = code;
+ }
+ char* condition_code() {
+ return _condition_code;
+ }
};
//------------------------------AllocClass-------------------------------------
class AllocClass : public Form {
private:
src/share/vm/adlc/formsopt.hpp
Index
Unified diffs
Context diffs
Sdiffs
Patch
New
Old
Previous File
Next File