SymEval: Use MachRegister interface
[dyninst.git] / symEval / src / RoseImpl.C
1 /*
2  * Copyright (c) 1996-2007 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as "Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * By your use of Paradyn, you understand and agree that we (or any
12  * other person or entity with proprietary rights in Paradyn) are
13  * under no obligation to provide either maintenance services,
14  * update services, notices of latent defects, or correction of
15  * defects for Paradyn.
16  * 
17  * This library is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  * 
22  * This library is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * Lesser General Public License for more details.
26  * 
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
30  */
31
32 #include <string>
33 #include <map>
34 #include <iostream>
35
36 #include "../rose/SgAsmx86Instruction.h"
37 #include "external/rose/rose-compat.h"
38 #include "../rose/x86InstructionSemantics.h"
39
40 // SgAsmType.h
41
42 SgAsmType::SgAsmType()
43 {
44
45 }
46
47 std::string SgAsmType::class_name() const
48 {
49   return "SgAsmType";
50 }
51
52 VariantT SgAsmType::variantT() const
53 {
54   return static_variant;
55 }
56
57 SgAsmType::~SgAsmType()
58 {
59
60 }
61
62 SgAsmTypeByte::SgAsmTypeByte()
63 {
64
65 }
66
67 std::string SgAsmTypeByte::class_name() const
68 {
69   return "SgAsmTypeByte";
70 }
71
72 VariantT SgAsmTypeByte::variantT() const
73 {
74   return static_variant;
75 }
76
77 SgAsmTypeByte::~SgAsmTypeByte()
78 {
79
80 }
81
82 SgAsmTypeWord::SgAsmTypeWord()
83 {
84
85 }
86
87 std::string SgAsmTypeWord::class_name() const
88 {
89   return "SgAsmTypeWord";
90 }
91
92 VariantT SgAsmTypeWord::variantT() const
93 {
94   return static_variant;
95 }
96
97 SgAsmTypeWord::~SgAsmTypeWord()
98 {
99
100 }
101
102 SgAsmTypeDoubleWord::SgAsmTypeDoubleWord()
103 {
104
105 }
106
107 std::string SgAsmTypeDoubleWord::class_name() const
108 {
109   return "SgAsmTypeDoubleWord";
110 }
111
112 VariantT SgAsmTypeDoubleWord::variantT() const
113 {
114   return static_variant;
115 }
116
117 SgAsmTypeDoubleWord::~SgAsmTypeDoubleWord()
118 {
119
120 }
121
122 SgAsmTypeQuadWord::SgAsmTypeQuadWord()
123 {
124
125 }
126
127 std::string SgAsmTypeQuadWord::class_name() const
128 {
129   return "SgAsmTypeQuadWord";
130 }
131
132 VariantT SgAsmTypeQuadWord::variantT() const
133 {
134   return static_variant;
135 }
136
137 SgAsmTypeQuadWord::~SgAsmTypeQuadWord()
138 {
139
140 }
141
142 SgAsmTypeSingleFloat::SgAsmTypeSingleFloat()
143 {
144
145 }
146
147 std::string SgAsmTypeSingleFloat::class_name() const
148 {
149   return "SgAsmTypeSingleFloat";
150 }
151
152 VariantT SgAsmTypeSingleFloat::variantT() const
153 {
154   return static_variant;
155 }
156
157 SgAsmTypeSingleFloat::~SgAsmTypeSingleFloat()
158 {
159
160 }
161
162 SgAsmTypeDoubleFloat::SgAsmTypeDoubleFloat()
163 {
164
165 }
166
167 std::string SgAsmTypeDoubleFloat::class_name() const
168 {
169   return "SgAsmTypeDoubleFloat";
170 }
171
172 VariantT SgAsmTypeDoubleFloat::variantT() const
173 {
174   return static_variant;
175 }
176
177 SgAsmTypeDoubleFloat::~SgAsmTypeDoubleFloat()
178 {
179
180 }
181
182 // SgAsmExpression.h
183
184 SgAsmExpression::SgAsmExpression()
185 {
186
187 }
188
189 SgAsmType* SgAsmExpression::get_type()
190 {
191   return new SgAsmType();
192 }
193
194 std::string SgAsmExpression::class_name() const
195 {
196   return "SgAsmExpression";
197 }
198
199 VariantT SgAsmExpression::variantT() const
200 {
201   return static_variant;
202 }
203
204 SgAsmExpression::~SgAsmExpression()
205 {
206
207 }
208
209 SgAsmValueExpression::SgAsmValueExpression()
210 {
211
212 }
213
214 SgAsmType* SgAsmValueExpression::get_type()
215 {
216   return new SgAsmType();
217 }
218
219 std::string SgAsmValueExpression::class_name() const
220 {
221   return "SgAsmValueExpression";
222 }
223
224 VariantT SgAsmValueExpression::variantT() const
225 {
226   return static_variant;
227 }
228
229 SgAsmValueExpression::~SgAsmValueExpression()
230 {
231
232 }
233
234 SgAsmByteValueExpression::SgAsmByteValueExpression(unsigned char value)
235 {
236   p_value = value;
237 }
238
239 SgAsmType* SgAsmByteValueExpression::get_type()
240 {
241   return new SgAsmTypeByte();
242 }
243
244 std::string SgAsmByteValueExpression::class_name() const
245 {
246   return "SgAsmByteValueExpression";
247 }
248
249 VariantT SgAsmByteValueExpression::variantT() const
250 {
251   return static_variant;
252 }
253
254 uint8_t SgAsmByteValueExpression::get_value() const
255 {
256   return p_value;
257 }
258
259 SgAsmByteValueExpression::~SgAsmByteValueExpression()
260 {
261
262 }
263
264 SgAsmWordValueExpression::SgAsmWordValueExpression(unsigned short value)
265 {
266   p_value = value;
267 }
268
269 SgAsmType* SgAsmWordValueExpression::get_type()
270 {
271   return new SgAsmTypeWord();
272 }
273
274 std::string SgAsmWordValueExpression::class_name() const
275 {
276   return "SgAsmWordValueExpression";
277 }
278
279 VariantT SgAsmWordValueExpression::variantT() const
280 {
281   return static_variant;
282 }
283
284 uint16_t SgAsmWordValueExpression::get_value() const
285 {
286   return p_value;
287 }
288
289 SgAsmWordValueExpression::~SgAsmWordValueExpression()
290 {
291
292 }
293
294 SgAsmDoubleWordValueExpression::SgAsmDoubleWordValueExpression(unsigned int value)
295 {
296   p_value = value;
297 }
298
299 SgAsmType* SgAsmDoubleWordValueExpression::get_type()
300 {
301   return new SgAsmTypeDoubleWord();
302 }
303
304 std::string SgAsmDoubleWordValueExpression::class_name() const
305 {
306   return "SgAsmDoubleWordValueExpression";
307 }
308
309 VariantT SgAsmDoubleWordValueExpression::variantT() const
310 {
311   return static_variant;
312 }
313
314 uint32_t SgAsmDoubleWordValueExpression::get_value() const
315 {
316   return p_value;
317 }
318
319 SgAsmDoubleWordValueExpression::~SgAsmDoubleWordValueExpression()
320 {
321
322 }
323
324 SgAsmQuadWordValueExpression::SgAsmQuadWordValueExpression(unsigned long value)
325 {
326   p_value = value;
327 }
328
329 SgAsmType* SgAsmQuadWordValueExpression::get_type()
330 {
331   return new SgAsmTypeQuadWord();
332 }
333
334 std::string SgAsmQuadWordValueExpression::class_name() const
335 {
336   return "SgAsmQuadWordValueExpression";
337 }
338
339 VariantT SgAsmQuadWordValueExpression::variantT() const
340 {
341   return static_variant;
342 }
343
344 uint64_t SgAsmQuadWordValueExpression::get_value() const
345 {
346   return p_value;
347 }
348
349 SgAsmQuadWordValueExpression::~SgAsmQuadWordValueExpression()
350 {
351
352 }
353
354 SgAsmSingleFloatValueExpression::SgAsmSingleFloatValueExpression(float value)
355 {
356   p_value = value;
357 }
358
359 SgAsmType* SgAsmSingleFloatValueExpression::get_type()
360 {
361   return new SgAsmTypeSingleFloat();
362 }
363
364 std::string SgAsmSingleFloatValueExpression::class_name() const
365 {
366   return "SgAsmSingleFloatValueExpression";
367 }
368
369 VariantT SgAsmSingleFloatValueExpression::variantT() const
370 {
371   return static_variant;
372 }
373
374 SgAsmSingleFloatValueExpression::~SgAsmSingleFloatValueExpression()
375 {
376
377 }
378
379 SgAsmDoubleFloatValueExpression::SgAsmDoubleFloatValueExpression(double value)
380 {
381   p_value = value;
382 }
383
384 SgAsmType* SgAsmDoubleFloatValueExpression::get_type()
385 {
386   return new SgAsmTypeDoubleFloat();
387 }
388
389 std::string SgAsmDoubleFloatValueExpression::class_name() const
390 {
391   return "SgAsmDoubleFloatValueExpression";
392 }
393
394 VariantT SgAsmDoubleFloatValueExpression::variantT() const
395 {
396   return static_variant;
397 }
398
399 SgAsmDoubleFloatValueExpression::~SgAsmDoubleFloatValueExpression()
400 {
401
402 }
403
404 SgAsmBinaryExpression::SgAsmBinaryExpression(SgAsmExpression* lhs, SgAsmExpression* rhs)
405 {
406   p_lhs = lhs;
407   p_rhs = rhs;
408 }
409
410 SgAsmType* SgAsmBinaryExpression::get_type()
411 {
412   // TODO this might not be safe
413   return p_lhs->get_type();
414 }
415
416 std::string SgAsmBinaryExpression::class_name() const
417 {
418   return "SgAsmBinaryExpression";
419 }
420
421 VariantT SgAsmBinaryExpression::variantT() const
422 {
423   return static_variant;
424 }
425
426 SgAsmExpression* SgAsmBinaryExpression::get_lhs() const
427 {
428   return p_lhs;
429 }
430
431 SgAsmExpression* SgAsmBinaryExpression::get_rhs() const
432 {
433   return p_rhs;
434 }
435
436 SgAsmBinaryExpression::~SgAsmBinaryExpression()
437 {
438
439 }
440
441 SgAsmBinaryAdd::SgAsmBinaryAdd(SgAsmExpression* lhs, SgAsmExpression* rhs)
442  : SgAsmBinaryExpression(lhs, rhs)
443 {
444
445 }
446
447 SgAsmType* SgAsmBinaryAdd::get_type()
448 {
449   return ((SgAsmBinaryExpression*)this)->get_type();
450 }
451
452 std::string SgAsmBinaryAdd::class_name() const
453 {
454   return "SgAsmBinaryAdd";
455 }
456
457 VariantT SgAsmBinaryAdd::variantT() const
458 {
459   return static_variant;
460 }
461
462 SgAsmBinaryAdd::~SgAsmBinaryAdd()
463 {
464
465 }
466
467 SgAsmBinaryMultiply::SgAsmBinaryMultiply(SgAsmExpression* lhs, SgAsmExpression* rhs)
468  : SgAsmBinaryExpression(lhs, rhs)
469 {
470
471 }
472
473 SgAsmType* SgAsmBinaryMultiply::get_type()
474 {
475   return ((SgAsmBinaryExpression*)this)->get_type();
476 }
477
478 std::string SgAsmBinaryMultiply::class_name() const
479 {
480   return "SgAsmBinaryMultiply";
481 }
482
483 VariantT SgAsmBinaryMultiply::variantT() const
484 {
485   return static_variant;
486 }
487
488 SgAsmBinaryMultiply::~SgAsmBinaryMultiply()
489 {
490
491 }
492
493 SgAsmRegisterReferenceExpression::SgAsmRegisterReferenceExpression()
494 {
495
496 }
497
498 SgAsmType* SgAsmRegisterReferenceExpression::get_type()
499 {
500   return p_type;
501 }
502
503 std::string SgAsmRegisterReferenceExpression::class_name() const
504 {
505   return "SgAsmRegisterReferenceExpression";
506 }
507
508 VariantT SgAsmRegisterReferenceExpression::variantT() const
509 {
510   return static_variant;
511 }
512
513 SgAsmRegisterReferenceExpression::~SgAsmRegisterReferenceExpression()
514 {
515
516 }
517
518 SgAsmx86RegisterReferenceExpression::SgAsmx86RegisterReferenceExpression(X86RegisterClass register_class, int register_number, X86PositionInRegister position_in_register)
519 {
520   p_register_class = register_class;
521   p_register_number = register_number;
522   p_position_in_register = position_in_register;
523
524   // Need to fix for 64-bit
525   // Right now semantics only accepts byte, word, doubleword
526
527   switch (position_in_register)
528   {
529     case x86_regpos_low_byte:
530     case x86_regpos_high_byte:
531       p_type = new SgAsmTypeByte();
532       break;
533     case x86_regpos_word:
534       p_type = new SgAsmTypeWord();
535       break;
536     case x86_regpos_all:
537     case x86_regpos_dword:
538       p_type = new SgAsmTypeDoubleWord();
539       break;
540     case x86_regpos_qword:
541     default:
542       p_type = 0;
543   }
544 }
545
546 SgAsmType* SgAsmx86RegisterReferenceExpression::get_type()
547 {
548   return p_type;
549 }
550
551 std::string SgAsmx86RegisterReferenceExpression::class_name() const
552 {
553   return "SgAsmx86RegisterReferenceExpression";
554 }
555
556 VariantT SgAsmx86RegisterReferenceExpression::variantT() const
557 {
558   return static_variant;
559 }
560
561 int SgAsmx86RegisterReferenceExpression::get_register_number() const
562 {
563   return p_register_number;
564 }
565
566 X86RegisterClass SgAsmx86RegisterReferenceExpression::get_register_class() const
567 {
568   return p_register_class;
569 }
570
571 X86PositionInRegister SgAsmx86RegisterReferenceExpression::get_position_in_register() const
572 {
573   return p_position_in_register;
574 }
575
576 SgAsmx86RegisterReferenceExpression::~SgAsmx86RegisterReferenceExpression()
577 {
578
579 }
580
581 SgAsmMemoryReferenceExpression::SgAsmMemoryReferenceExpression(SgAsmExpression* address, SgAsmExpression* segment)
582 {
583   p_address = address;
584   p_segment = segment;
585 }
586
587 SgAsmType* SgAsmMemoryReferenceExpression::get_type()
588 {
589   return p_type;
590 }
591
592 std::string SgAsmMemoryReferenceExpression::class_name() const
593 {
594   return "SgAsmMemoryReferenceExpression";
595 }
596
597 VariantT SgAsmMemoryReferenceExpression::variantT() const
598 {
599   return static_variant;
600 }
601
602 SgAsmExpression * SgAsmMemoryReferenceExpression::get_address() const
603 {
604   return p_address;
605 }
606
607 SgAsmExpression* SgAsmMemoryReferenceExpression::get_segment() const
608 {
609   return p_segment;
610 }
611
612 void SgAsmMemoryReferenceExpression::set_type(SgAsmType* type)
613 {
614   p_type = type;
615 }
616
617 SgAsmMemoryReferenceExpression::~SgAsmMemoryReferenceExpression()
618 {
619
620 }
621
622 uint64_t getAsmSignedConstant(SgAsmValueExpression* valexp)
623 {
624   switch(valexp->variantT())
625   {
626     case V_SgAsmByteValueExpression:
627       return dynamic_cast<SgAsmByteValueExpression*>(valexp)->get_value();
628       break;
629     case V_SgAsmWordValueExpression:
630       return dynamic_cast<SgAsmWordValueExpression*>(valexp)->get_value();
631       break;
632     case V_SgAsmDoubleWordValueExpression:
633       return dynamic_cast<SgAsmDoubleWordValueExpression*>(valexp)->get_value();
634       break;
635     case V_SgAsmQuadWordValueExpression:
636       return dynamic_cast<SgAsmQuadWordValueExpression*>(valexp)->get_value();
637       break;
638     default:
639       return 0; // error
640   }
641 }
642
643 // conversions.h
644
645 uint64_t SageInterface::getAsmSignedConstant(SgAsmValueExpression *valexp)
646 {
647   return ::getAsmSignedConstant(valexp);
648 }
649
650 SgAsmValueExpression* isSgAsmValueExpression(SgNode* s)
651 {
652   return dynamic_cast<SgAsmValueExpression*>(s);
653 }
654
655 SgAsmBinaryAdd* isSgAsmBinaryAdd(SgNode* s)
656 {
657   return dynamic_cast<SgAsmBinaryAdd*>(s);
658 }
659
660 SgAsmBinaryMultiply* isSgAsmBinaryMultiply(SgNode* s)
661 {
662   return dynamic_cast<SgAsmBinaryMultiply*>(s);
663 }
664
665 SgAsmx86RegisterReferenceExpression* isSgAsmx86RegisterReferenceExpression( SgNode *n)
666 {
667   return dynamic_cast<SgAsmx86RegisterReferenceExpression*>(n);
668 }
669
670 SgAsmByteValueExpression* isSgAsmByteValueExpression(SgNode* s)
671 {
672   return dynamic_cast<SgAsmByteValueExpression*>(s);
673 }
674
675 SgAsmMemoryReferenceExpression* isSgAsmMemoryReferenceExpression(SgNode* s)
676 {
677   return dynamic_cast<SgAsmMemoryReferenceExpression*>(s);
678 }
679
680 const char * regclassToString(X86RegisterClass)
681 {
682   return "NOT IMPLEMENTED";
683 }
684
685 // SgAsmx86Instruction.h
686
687 SgAsmx86Instruction::SgAsmx86Instruction(rose_addr_t address,
688                         std::string mnemonic,
689                         X86InstructionKind kind,
690                         X86InstructionSize baseSize,
691                         X86InstructionSize operandSize,
692                         X86InstructionSize addressSize)
693 {
694   p_address = address;
695   p_mnemonic = mnemonic;
696   p_kind = kind;
697   p_baseSize = baseSize;
698   p_operandSize = operandSize;
699   p_addressSize = addressSize;
700 }
701
702 std::string SgAsmx86Instruction::class_name() const
703 {
704   return "SgAsmx86Instruction";
705 }
706
707 VariantT SgAsmx86Instruction::variantT() const
708 {
709   return static_variant;
710 }
711
712 SgAsmx86Instruction::~SgAsmx86Instruction()
713 {
714
715 }
716
717 rose_addr_t SgAsmx86Instruction::get_address() const
718 {
719   return p_address;
720 }
721
722 X86InstructionKind SgAsmx86Instruction::get_kind() const
723 {
724   return p_kind;
725 }
726
727 X86InstructionSize SgAsmx86Instruction::get_addressSize() const
728 {
729   return p_addressSize;
730 }
731
732 X86InstructionSize SgAsmx86Instruction::get_operandSize() const
733 {
734   return p_operandSize;
735 }
736
737 X86SegmentRegister SgAsmx86Instruction::get_segmentOverride() const
738 {
739   return p_segmentOverride;
740 }
741
742 SgAsmOperandList* SgAsmx86Instruction::get_operandList() const
743 {
744   return p_operandList;
745 }
746
747 std::string SgAsmx86Instruction::get_mnemonic() const
748 {
749   return p_mnemonic;
750 }
751
752 SgUnsignedCharList SgAsmx86Instruction::get_raw_bytes() const
753 {
754   return p_raw_bytes;
755 }
756
757 void SgAsmx86Instruction::set_address(unsigned long address)
758 {
759   p_address = address;
760 }
761
762 void SgAsmx86Instruction::set_kind(X86InstructionKind kind)
763 {
764   p_kind = kind;
765 }
766
767 void SgAsmx86Instruction::set_addressSize(X86InstructionSize size)
768 {
769   p_addressSize = size;
770 }
771
772 void SgAsmx86Instruction::set_operandSize(X86InstructionSize size)
773 {
774   p_operandSize = size;
775 }
776
777 void SgAsmx86Instruction::set_operandList(SgAsmOperandList* operandList)
778 {
779   p_operandList = operandList;
780 }
781
782 void SgAsmx86Instruction::set_mnemonic(std::string mnemonic)
783 {
784   p_mnemonic = mnemonic;
785 }
786
787 void SgAsmx86Instruction::set_raw_bytes(std::vector<unsigned char> raw_bytes)
788 {
789   p_raw_bytes = raw_bytes;
790 }
791
792 // SgAsmOperandList.h
793
794 SgAsmOperandList::SgAsmOperandList()
795 {
796
797 }
798
799 std::string SgAsmOperandList::class_name() const
800 {
801   return "SgAsmOperandList";
802 }
803
804 VariantT SgAsmOperandList::variantT() const
805 {
806   return static_variant;
807 }
808
809 SgAsmExpressionPtrList& SgAsmOperandList::get_operands()
810 {
811   return p_operands;
812 }
813
814 void SgAsmOperandList::append_operand(SgAsmExpression* operand)
815 {
816   p_operands.push_back(operand);
817 }
818
819 SgAsmOperandList::~SgAsmOperandList()
820 {
821
822 }
823