90 //---------------------------------------------------
91
92
93 LIR_Address::Scale LIR_Address::scale(BasicType type) {
94 int elem_size = type2aelembytes(type);
95 switch (elem_size) {
96 case 1: return LIR_Address::times_1;
97 case 2: return LIR_Address::times_2;
98 case 4: return LIR_Address::times_4;
99 case 8: return LIR_Address::times_8;
100 }
101 ShouldNotReachHere();
102 return LIR_Address::times_1;
103 }
104
105 //---------------------------------------------------
106
107 char LIR_OprDesc::type_char(BasicType t) {
108 switch (t) {
109 case T_ARRAY:
110 t = T_OBJECT;
111 case T_BOOLEAN:
112 case T_CHAR:
113 case T_FLOAT:
114 case T_DOUBLE:
115 case T_BYTE:
116 case T_SHORT:
117 case T_INT:
118 case T_LONG:
119 case T_OBJECT:
120 case T_ADDRESS:
121 case T_VOID:
122 return ::type2char(t);
123 case T_METADATA:
124 return 'M';
125 case T_ILLEGAL:
126 return '?';
127
128 default:
129 ShouldNotReachHere();
148 ARM_ONLY(|| kindfield == cpu_register)
149 PPC32_ONLY(|| kindfield == cpu_register) ) &&
150 size_field() == single_size, "must match");
151 break;
152 case T_DOUBLE:
153 // FP return values can be also in CPU registers on ARM and PPC32 (softfp ABI)
154 assert((kindfield == fpu_register || kindfield == stack_value
155 ARM_ONLY(|| kindfield == cpu_register)
156 PPC32_ONLY(|| kindfield == cpu_register) ) &&
157 size_field() == double_size, "must match");
158 break;
159 case T_BOOLEAN:
160 case T_CHAR:
161 case T_BYTE:
162 case T_SHORT:
163 case T_INT:
164 case T_ADDRESS:
165 case T_OBJECT:
166 case T_METADATA:
167 case T_ARRAY:
168 assert((kindfield == cpu_register || kindfield == stack_value) &&
169 size_field() == single_size, "must match");
170 break;
171
172 case T_ILLEGAL:
173 // XXX TKR also means unknown right now
174 // assert(is_illegal(), "must match");
175 break;
176
177 default:
178 ShouldNotReachHere();
179 }
180 }
181 #endif
182
183 }
184 #endif // PRODUCT
185
186
187 bool LIR_OprDesc::is_oop() const {
|
90 //---------------------------------------------------
91
92
93 LIR_Address::Scale LIR_Address::scale(BasicType type) {
94 int elem_size = type2aelembytes(type);
95 switch (elem_size) {
96 case 1: return LIR_Address::times_1;
97 case 2: return LIR_Address::times_2;
98 case 4: return LIR_Address::times_4;
99 case 8: return LIR_Address::times_8;
100 }
101 ShouldNotReachHere();
102 return LIR_Address::times_1;
103 }
104
105 //---------------------------------------------------
106
107 char LIR_OprDesc::type_char(BasicType t) {
108 switch (t) {
109 case T_ARRAY:
110 case T_VALUETYPE:
111 t = T_OBJECT;
112 case T_BOOLEAN:
113 case T_CHAR:
114 case T_FLOAT:
115 case T_DOUBLE:
116 case T_BYTE:
117 case T_SHORT:
118 case T_INT:
119 case T_LONG:
120 case T_OBJECT:
121 case T_ADDRESS:
122 case T_VOID:
123 return ::type2char(t);
124 case T_METADATA:
125 return 'M';
126 case T_ILLEGAL:
127 return '?';
128
129 default:
130 ShouldNotReachHere();
149 ARM_ONLY(|| kindfield == cpu_register)
150 PPC32_ONLY(|| kindfield == cpu_register) ) &&
151 size_field() == single_size, "must match");
152 break;
153 case T_DOUBLE:
154 // FP return values can be also in CPU registers on ARM and PPC32 (softfp ABI)
155 assert((kindfield == fpu_register || kindfield == stack_value
156 ARM_ONLY(|| kindfield == cpu_register)
157 PPC32_ONLY(|| kindfield == cpu_register) ) &&
158 size_field() == double_size, "must match");
159 break;
160 case T_BOOLEAN:
161 case T_CHAR:
162 case T_BYTE:
163 case T_SHORT:
164 case T_INT:
165 case T_ADDRESS:
166 case T_OBJECT:
167 case T_METADATA:
168 case T_ARRAY:
169 case T_VALUETYPE:
170 assert((kindfield == cpu_register || kindfield == stack_value) &&
171 size_field() == single_size, "must match");
172 break;
173
174 case T_ILLEGAL:
175 // XXX TKR also means unknown right now
176 // assert(is_illegal(), "must match");
177 break;
178
179 default:
180 ShouldNotReachHere();
181 }
182 }
183 #endif
184
185 }
186 #endif // PRODUCT
187
188
189 bool LIR_OprDesc::is_oop() const {
|