45 _rdefs.addName(name); |
45 _rdefs.addName(name); |
46 _regDef.Insert(name,regDef); |
46 _regDef.Insert(name,regDef); |
47 } |
47 } |
48 |
48 |
49 // record a new register class |
49 // record a new register class |
50 RegClass *RegisterForm::addRegClass(const char *className) { |
50 template <typename T> |
51 RegClass *regClass = new RegClass(className); |
51 T* RegisterForm::addRegClass(const char* className) { |
|
52 T* regClass = new T(className); |
52 _rclasses.addName(className); |
53 _rclasses.addName(className); |
53 _regClass.Insert(className,regClass); |
54 _regClass.Insert(className, regClass); |
54 return regClass; |
55 return regClass; |
55 } |
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); |
56 |
62 |
57 // record a new register class |
63 // record a new register class |
58 AllocClass *RegisterForm::addAllocClass(char *className) { |
64 AllocClass *RegisterForm::addAllocClass(char *className) { |
59 AllocClass *allocClass = new AllocClass(className); |
65 AllocClass *allocClass = new AllocClass(className); |
60 _aclasses.addName(className); |
66 _aclasses.addName(className); |
65 // Called after parsing the Register block. Record the register class |
71 // Called after parsing the Register block. Record the register class |
66 // for spill-slots/regs. |
72 // for spill-slots/regs. |
67 void RegisterForm::addSpillRegClass() { |
73 void RegisterForm::addSpillRegClass() { |
68 // Stack slots start at the next available even register number. |
74 // Stack slots start at the next available even register number. |
69 _reg_ctr = (_reg_ctr+7) & ~7; |
75 _reg_ctr = (_reg_ctr+7) & ~7; |
70 const char *rc_name = "stack_slots"; |
76 const char *rc_name = "stack_slots"; |
71 RegClass *reg_class = new RegClass(rc_name); |
77 RegClass* reg_class = new RegClass(rc_name); |
72 reg_class->_stack_or_reg = true; |
78 reg_class->set_stack_version(true); |
73 _rclasses.addName(rc_name); |
79 _rclasses.addName(rc_name); |
74 _regClass.Insert(rc_name,reg_class); |
80 _regClass.Insert(rc_name,reg_class); |
75 } |
81 } |
76 |
82 |
77 |
83 |
303 ((RegDef*)_regDef[name])->output(fp); |
311 ((RegDef*)_regDef[name])->output(fp); |
304 } |
312 } |
305 fprintf(fp,"--- done with entries for reg_class %s\n\n",_classid); |
313 fprintf(fp,"--- done with entries for reg_class %s\n\n",_classid); |
306 } |
314 } |
307 |
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 } |
308 |
401 |
309 //------------------------------AllocClass------------------------------------- |
402 //------------------------------AllocClass------------------------------------- |
310 AllocClass::AllocClass(char *classid) : _classid(classid), _regDef(cmpstr,hashstr, Form::arena) { |
403 AllocClass::AllocClass(char *classid) : _classid(classid), _regDef(cmpstr,hashstr, Form::arena) { |
311 } |
404 } |
312 |
405 |