SymEval: Use MachRegister interface
[dyninst.git] / symEval / src / SymEvalPolicy.C
1 #include "SymEvalPolicy.h"
2
3 using namespace Dyninst;
4 using namespace Dyninst::SymbolicEvaluation;
5 using namespace Dyninst::InstructionAPI;
6
7 SymEvalPolicy::SymEvalPolicy(SymEval::Result &r) :
8   res(r) {
9   // We also need to build aaMap FTW!!!
10   for (SymEval::Result::iterator iter = r.begin();
11        iter != r.end(); ++iter) {
12     Assignment::Ptr a = iter->first;
13     AbsRegion &o = a->out();
14
15     if (o.containsOfType(Absloc::Register)) {
16       // We're assuming this is a single register...
17       for (std::set<Absloc>::const_iterator a_iter = o.abslocs().begin();
18            a_iter != o.abslocs().end(); ++a_iter) {
19         aaMap[*a_iter] = a;
20       }
21     }
22     else {
23       // Use sufficiently-unique (Heap,0) Absloc
24       // to represent a definition to a memory absloc
25       aaMap[Absloc(0)] = a;
26     }
27   }
28 }
29   
30
31 void SymEvalPolicy::startInstruction(SgAsmx86Instruction *) {
32 }
33
34 void SymEvalPolicy::finishInstruction(SgAsmx86Instruction *) {
35 }
36
37 Absloc SymEvalPolicy::convert(X86GeneralPurposeRegister r)
38 {
39   MachRegister mreg;
40   switch (r) {
41     case x86_gpr_ax:
42       mreg = x86::eax;
43       break;
44     case x86_gpr_cx:
45       mreg = x86::ecx;
46       break;
47     case x86_gpr_dx:
48       mreg = x86::edx;
49       break;
50     case x86_gpr_bx:
51       mreg = x86::ebx;
52       break;
53     case x86_gpr_sp:
54       mreg = x86::esp;
55       break;
56     case x86_gpr_bp:
57       mreg = x86::ebp;
58       break;
59     case x86_gpr_si:
60       mreg = x86::esi;
61       break;
62     case x86_gpr_di:
63       mreg = x86::edi;
64       break;
65     default:
66       break;
67   }
68
69   return Absloc(mreg);;
70 }
71
72 Absloc SymEvalPolicy::convert(X86SegmentRegister r)
73 {
74   MachRegister mreg;
75   switch (r) {
76     case x86_segreg_es:
77       mreg = x86::es;
78       break;
79     case x86_segreg_cs:
80       mreg = x86::cs;
81       break;
82     case x86_segreg_ss:
83       mreg = x86::ss;
84       break;
85     case x86_segreg_ds:
86       mreg = x86::ds;
87       break;
88     case x86_segreg_fs:
89       mreg = x86::fs;
90       break;
91     case x86_segreg_gs:
92       mreg = x86::gs;
93       break;
94     default:
95       break;
96   }
97
98   return Absloc(mreg);
99 }
100
101 Absloc SymEvalPolicy::convert(X86Flag f)
102 {
103   return Absloc(x86::flags);
104   
105   switch (f) {
106     case x86_flag_cf:
107       break;
108     case x86_flag_pf:
109       break;
110     case x86_flag_af:
111       break;
112     case x86_flag_zf:
113       break;
114     case x86_flag_sf:
115       break;
116     case x86_flag_tf:
117       break;
118     case x86_flag_if:
119       break;
120     case x86_flag_df:
121       break;
122     case x86_flag_of:
123       break;
124     case x86_flag_nt:
125       break;
126     case x86_flag_rf:
127       break;
128     default:
129       std::cerr << "Failed to find flag " << f << std::endl;
130       assert(0);
131   }
132
133   
134 }
135