30
31 //------------------------------RegisterForm-----------------------------------
32 // Constructor
33 RegisterForm::RegisterForm()
34 : _regDef(cmpstr,hashstr, Form::arena),
35 _regClass(cmpstr,hashstr, Form::arena),
36 _allocClass(cmpstr,hashstr, Form::arena) {
37 }
38 RegisterForm::~RegisterForm() {
39 }
40
41 // record a new register definition
42 void RegisterForm::addRegDef(char *name, char *callingConv, char *c_conv,
43 char *idealtype, char *encoding, char* concrete) {
44 RegDef *regDef = new RegDef(name, callingConv, c_conv, idealtype, encoding, concrete);
45 _rdefs.addName(name);
46 _regDef.Insert(name,regDef);
47 }
48
49 // record a new register class
50 RegClass *RegisterForm::addRegClass(const char *className) {
51 RegClass *regClass = new RegClass(className);
52 _rclasses.addName(className);
53 _regClass.Insert(className,regClass);
54 return regClass;
55 }
56
57 // record a new register class
58 AllocClass *RegisterForm::addAllocClass(char *className) {
59 AllocClass *allocClass = new AllocClass(className);
60 _aclasses.addName(className);
61 _allocClass.Insert(className,allocClass);
62 return allocClass;
63 }
64
65 // Called after parsing the Register block. Record the register class
66 // for spill-slots/regs.
67 void RegisterForm::addSpillRegClass() {
68 // Stack slots start at the next available even register number.
69 _reg_ctr = (_reg_ctr+7) & ~7;
70 const char *rc_name = "stack_slots";
71 RegClass *reg_class = new RegClass(rc_name);
72 reg_class->_stack_or_reg = true;
73 _rclasses.addName(rc_name);
74 _regClass.Insert(rc_name,reg_class);
75 }
76
77
78 // Provide iteration over all register definitions
79 // in the order used by the register allocator
80 void RegisterForm::reset_RegDefs() {
81 _current_ac = NULL;
82 _aclasses.reset();
83 }
84
85 RegDef *RegisterForm::iter_RegDefs() {
86 // Check if we need to get the next AllocClass
87 if ( _current_ac == NULL ) {
88 const char *ac_name = _aclasses.iter();
89 if( ac_name == NULL ) return NULL; // No more allocation classes
90 _current_ac = (AllocClass*)_allocClass[ac_name];
91 _current_ac->_regDefs.reset();
92 assert( _current_ac != NULL, "Name must match an allocation class");
207 }
208
209 // Register number used in machine-independent code
210 uint32 RegDef::register_num() const {
211 return _register_num;
212 }
213
214 void RegDef::dump() {
215 output(stderr);
216 }
217
218 void RegDef::output(FILE *fp) { // Write info to output files
219 fprintf(fp,"RegDef: %s (%s) encode as %s using number %d\n",
220 _regname, (_callconv?_callconv:""), _register_encode, _register_num);
221 fprintf(fp,"\n");
222 }
223
224
225 //------------------------------RegClass---------------------------------------
226 // Construct a register class into which registers will be inserted
227 RegClass::RegClass(const char *classid) : _stack_or_reg(false), _classid(classid), _regDef(cmpstr,hashstr, Form::arena),
228 _user_defined(NULL)
229 {
230 }
231
232 // record a register in this class
233 void RegClass::addReg(RegDef *regDef) {
234 _regDefs.addName(regDef->_regname);
235 _regDef.Insert((void*)regDef->_regname, regDef);
236 }
237
238 // Number of registers in class
239 uint RegClass::size() const {
240 return _regDef.Size();
241 }
242
243 const RegDef *RegClass::get_RegDef(const char *rd_name) const {
244 return (const RegDef*)_regDef[rd_name];
245 }
246
247 void RegClass::reset() {
248 _regDefs.reset();
249 }
288 if( wordnum*32+i >= RegisterForm::_reg_ctr )
289 word |= (1 << i);
290 }
291
292 return word;
293 }
294
295 void RegClass::dump() {
296 output(stderr);
297 }
298
299 void RegClass::output(FILE *fp) { // Write info to output files
300 fprintf(fp,"RegClass: %s\n",_classid);
301 const char *name;
302 for(_regDefs.reset(); (name = _regDefs.iter()) != NULL;) {
303 ((RegDef*)_regDef[name])->output(fp);
304 }
305 fprintf(fp,"--- done with entries for reg_class %s\n\n",_classid);
306 }
307
308
309 //------------------------------AllocClass-------------------------------------
310 AllocClass::AllocClass(char *classid) : _classid(classid), _regDef(cmpstr,hashstr, Form::arena) {
311 }
312
313 // record a register in this class
314 void AllocClass::addReg(RegDef *regDef) {
315 assert( regDef != NULL, "Can not add a NULL to an allocation class");
316 regDef->set_register_num( RegisterForm::_reg_ctr++ );
317 // Add regDef to this allocation class
318 _regDefs.addName(regDef->_regname);
319 _regDef.Insert((void*)regDef->_regname, regDef);
320 }
321
322 void AllocClass::dump() {
323 output(stderr);
324 }
325
326 void AllocClass::output(FILE *fp) { // Write info to output files
327 fprintf(fp,"AllocClass: %s \n",_classid);
|
30
31 //------------------------------RegisterForm-----------------------------------
32 // Constructor
33 RegisterForm::RegisterForm()
34 : _regDef(cmpstr,hashstr, Form::arena),
35 _regClass(cmpstr,hashstr, Form::arena),
36 _allocClass(cmpstr,hashstr, Form::arena) {
37 }
38 RegisterForm::~RegisterForm() {
39 }
40
41 // record a new register definition
42 void RegisterForm::addRegDef(char *name, char *callingConv, char *c_conv,
43 char *idealtype, char *encoding, char* concrete) {
44 RegDef *regDef = new RegDef(name, callingConv, c_conv, idealtype, encoding, concrete);
45 _rdefs.addName(name);
46 _regDef.Insert(name,regDef);
47 }
48
49 // record a new register class
50 template <typename T>
51 T* RegisterForm::addRegClass(const char* className) {
52 T* regClass = new T(className);
53 _rclasses.addName(className);
54 _regClass.Insert(className, regClass);
55 return regClass;
56 }
57
58 // Explicit instantiation for all supported register classes.
59 template RegClass* RegisterForm::addRegClass<RegClass>(const char* className);
60 template CodeSnippetRegClass* RegisterForm::addRegClass<CodeSnippetRegClass>(const char* className);
61 template ConditionalRegClass* RegisterForm::addRegClass<ConditionalRegClass>(const char* className);
62
63 // record a new register class
64 AllocClass *RegisterForm::addAllocClass(char *className) {
65 AllocClass *allocClass = new AllocClass(className);
66 _aclasses.addName(className);
67 _allocClass.Insert(className,allocClass);
68 return allocClass;
69 }
70
71 // Called after parsing the Register block. Record the register class
72 // for spill-slots/regs.
73 void RegisterForm::addSpillRegClass() {
74 // Stack slots start at the next available even register number.
75 _reg_ctr = (_reg_ctr+7) & ~7;
76 const char *rc_name = "stack_slots";
77 RegClass* reg_class = new RegClass(rc_name);
78 reg_class->set_stack_version(true);
79 _rclasses.addName(rc_name);
80 _regClass.Insert(rc_name,reg_class);
81 }
82
83
84 // Provide iteration over all register definitions
85 // in the order used by the register allocator
86 void RegisterForm::reset_RegDefs() {
87 _current_ac = NULL;
88 _aclasses.reset();
89 }
90
91 RegDef *RegisterForm::iter_RegDefs() {
92 // Check if we need to get the next AllocClass
93 if ( _current_ac == NULL ) {
94 const char *ac_name = _aclasses.iter();
95 if( ac_name == NULL ) return NULL; // No more allocation classes
96 _current_ac = (AllocClass*)_allocClass[ac_name];
97 _current_ac->_regDefs.reset();
98 assert( _current_ac != NULL, "Name must match an allocation class");
213 }
214
215 // Register number used in machine-independent code
216 uint32 RegDef::register_num() const {
217 return _register_num;
218 }
219
220 void RegDef::dump() {
221 output(stderr);
222 }
223
224 void RegDef::output(FILE *fp) { // Write info to output files
225 fprintf(fp,"RegDef: %s (%s) encode as %s using number %d\n",
226 _regname, (_callconv?_callconv:""), _register_encode, _register_num);
227 fprintf(fp,"\n");
228 }
229
230
231 //------------------------------RegClass---------------------------------------
232 // Construct a register class into which registers will be inserted
233 RegClass::RegClass(const char* classid) : _stack_or_reg(false), _classid(classid), _regDef(cmpstr, hashstr, Form::arena) {
234 }
235
236 RegClass::~RegClass() {
237 delete _classid;
238 }
239
240 // record a register in this class
241 void RegClass::addReg(RegDef *regDef) {
242 _regDefs.addName(regDef->_regname);
243 _regDef.Insert((void*)regDef->_regname, regDef);
244 }
245
246 // Number of registers in class
247 uint RegClass::size() const {
248 return _regDef.Size();
249 }
250
251 const RegDef *RegClass::get_RegDef(const char *rd_name) const {
252 return (const RegDef*)_regDef[rd_name];
253 }
254
255 void RegClass::reset() {
256 _regDefs.reset();
257 }
296 if( wordnum*32+i >= RegisterForm::_reg_ctr )
297 word |= (1 << i);
298 }
299
300 return word;
301 }
302
303 void RegClass::dump() {
304 output(stderr);
305 }
306
307 void RegClass::output(FILE *fp) { // Write info to output files
308 fprintf(fp,"RegClass: %s\n",_classid);
309 const char *name;
310 for(_regDefs.reset(); (name = _regDefs.iter()) != NULL;) {
311 ((RegDef*)_regDef[name])->output(fp);
312 }
313 fprintf(fp,"--- done with entries for reg_class %s\n\n",_classid);
314 }
315
316 void RegClass::declare_register_masks(FILE* fp) {
317 const char* prefix = "";
318 const char* rc_name_to_upper = toUpper(_classid);
319 fprintf(fp, "extern const RegMask _%s%s_mask;\n", prefix, rc_name_to_upper);
320 fprintf(fp, "inline const RegMask &%s%s_mask() { return _%s%s_mask; }\n", prefix, rc_name_to_upper, prefix, rc_name_to_upper);
321 if (_stack_or_reg) {
322 fprintf(fp, "extern const RegMask _%sSTACK_OR_%s_mask;\n", prefix, rc_name_to_upper);
323 fprintf(fp, "inline const RegMask &%sSTACK_OR_%s_mask() { return _%sSTACK_OR_%s_mask; }\n", prefix, rc_name_to_upper, prefix, rc_name_to_upper);
324 }
325 delete[] rc_name_to_upper;
326 }
327
328 void RegClass::build_register_masks(FILE* fp) {
329 int len = RegisterForm::RegMask_Size();
330 const char *prefix = "";
331 const char* rc_name_to_upper = toUpper(_classid);
332 fprintf(fp, "const RegMask _%s%s_mask(", prefix, rc_name_to_upper);
333
334 int i;
335 for(i = 0; i < len - 1; i++) {
336 fprintf(fp," 0x%x,", regs_in_word(i, false));
337 }
338 fprintf(fp," 0x%x );\n", regs_in_word(i, false));
339
340 if (_stack_or_reg) {
341 fprintf(fp, "const RegMask _%sSTACK_OR_%s_mask(", prefix, rc_name_to_upper);
342 for(i = 0; i < len - 1; i++) {
343 fprintf(fp," 0x%x,", regs_in_word(i, true));
344 }
345 fprintf(fp," 0x%x );\n", regs_in_word(i, true));
346 }
347 delete[] rc_name_to_upper;
348 }
349
350 //------------------------------CodeSnippetRegClass---------------------------
351 CodeSnippetRegClass::CodeSnippetRegClass(const char* classid) : RegClass(classid), _code_snippet(NULL) {
352 }
353
354 CodeSnippetRegClass::~CodeSnippetRegClass() {
355 delete _code_snippet;
356 }
357
358 void CodeSnippetRegClass::declare_register_masks(FILE* fp) {
359 const char* prefix = "";
360 const char* rc_name_to_upper = toUpper(_classid);
361 fprintf(fp, "inline const RegMask &%s%s_mask() { %s }\n", prefix, rc_name_to_upper, _code_snippet);
362 delete[] rc_name_to_upper;
363 }
364
365 //------------------------------ConditionalRegClass---------------------------
366 ConditionalRegClass::ConditionalRegClass(const char *classid) : RegClass(classid), _condition_code(NULL) {
367 }
368
369 ConditionalRegClass::~ConditionalRegClass() {
370 delete _condition_code;
371 }
372
373 void ConditionalRegClass::declare_register_masks(FILE* fp) {
374 const char* prefix = "";
375 const char* rc_name_to_upper = toUpper(_classid);
376 const char* rclass_0_to_upper = toUpper(_rclasses[0]->_classid);
377 const char* rclass_1_to_upper = toUpper(_rclasses[1]->_classid);
378 fprintf(fp, "inline const RegMask &%s%s_mask() {"
379 " return (%s) ?"
380 " %s%s_mask() :"
381 " %s%s_mask(); }\n",
382 prefix, rc_name_to_upper,
383 _condition_code,
384 prefix, rclass_0_to_upper,
385 prefix, rclass_1_to_upper);
386 if (_stack_or_reg) {
387 fprintf(fp, "inline const RegMask &%sSTACK_OR_%s_mask() {"
388 " return (%s) ?"
389 " %sSTACK_OR_%s_mask() :"
390 " %sSTACK_OR_%s_mask(); }\n",
391 prefix, rc_name_to_upper,
392 _condition_code,
393 prefix, rclass_0_to_upper,
394 prefix, rclass_1_to_upper);
395 }
396 delete[] rc_name_to_upper;
397 delete[] rclass_0_to_upper;
398 delete[] rclass_1_to_upper;
399 return;
400 }
401
402 //------------------------------AllocClass-------------------------------------
403 AllocClass::AllocClass(char *classid) : _classid(classid), _regDef(cmpstr,hashstr, Form::arena) {
404 }
405
406 // record a register in this class
407 void AllocClass::addReg(RegDef *regDef) {
408 assert( regDef != NULL, "Can not add a NULL to an allocation class");
409 regDef->set_register_num( RegisterForm::_reg_ctr++ );
410 // Add regDef to this allocation class
411 _regDefs.addName(regDef->_regname);
412 _regDef.Insert((void*)regDef->_regname, regDef);
413 }
414
415 void AllocClass::dump() {
416 output(stderr);
417 }
418
419 void AllocClass::output(FILE *fp) { // Write info to output files
420 fprintf(fp,"AllocClass: %s \n",_classid);
|