Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
[mc] Move mc_dwarf_location_list_init() into namespace
[simgrid.git] / src / mc / DwarfExpression.cpp
1 /* Copyright (c) 2014-2015. The SimGrid Team.
2  * All rights reserved.                                                     */
3
4 /* This program is free software; you can redistribute it and/or modify it
5  * under the terms of the license (GNU LGPL) which comes with this package. */
6
7 #include <cstdint>
8 #include <cstdarg>
9
10 #include <dwarf.h>
11 #include <elfutils/libdw.h>
12
13 #include "mc_object_info.h"
14 #include "mc_private.h"
15 #include "mc/LocationList.hpp"
16 #include "mc/AddressSpace.hpp"
17 #include "mc/Frame.hpp"
18 #include "mc/ObjectInformation.hpp"
19 #include "mc/DwarfExpression.hpp"
20 #include "mc_dwarf.hpp"
21
22 using simgrid::mc::remote;
23
24 namespace simgrid {
25 namespace dwarf {
26
27 evaluation_error::~evaluation_error() {}
28
29 }
30 }
31
32 namespace simgrid {
33 namespace dwarf {
34
35 void execute(
36   const Dwarf_Op* ops, std::size_t n,
37   const ExpressionContext& context, ExpressionStack& stack)
38 {
39   for (size_t i = 0; i != n; ++i) {
40     const Dwarf_Op *op = ops + i;
41     std::uint8_t atom = op->atom;
42
43     switch (atom) {
44
45       // Registers:
46
47     case DW_OP_breg0:
48     case DW_OP_breg1:
49     case DW_OP_breg2:
50     case DW_OP_breg3:
51     case DW_OP_breg4:
52     case DW_OP_breg5:
53     case DW_OP_breg6:
54     case DW_OP_breg7:
55     case DW_OP_breg8:
56     case DW_OP_breg9:
57     case DW_OP_breg10:
58     case DW_OP_breg11:
59     case DW_OP_breg12:
60     case DW_OP_breg13:
61     case DW_OP_breg14:
62     case DW_OP_breg15:
63     case DW_OP_breg16:
64     case DW_OP_breg17:
65     case DW_OP_breg18:
66     case DW_OP_breg19:
67     case DW_OP_breg20:
68     case DW_OP_breg21:
69     case DW_OP_breg22:
70     case DW_OP_breg23:
71     case DW_OP_breg24:
72     case DW_OP_breg25:
73     case DW_OP_breg26:
74     case DW_OP_breg27:
75     case DW_OP_breg28:
76     case DW_OP_breg29:
77     case DW_OP_breg30:
78     case DW_OP_breg31:{
79         int register_id = simgrid::dwarf::dwarf_register_to_libunwind(
80           op->atom - DW_OP_breg0);
81         unw_word_t res;
82         if (!context.cursor)
83           throw evaluation_error("Missin stack context");
84         unw_get_reg(context.cursor, register_id, &res);
85         stack.push(res + op->number);
86         break;
87       }
88
89       // Push the CFA (Canonical Frame Addresse):
90     case DW_OP_call_frame_cfa:
91       {
92         // UNW_X86_64_CFA does not return the CFA DWARF expects
93         // (it is a synonym for UNW_X86_64_RSP) so copy the cursor,
94         // unwind it once in order to find the parent SP:
95
96         if (!context.cursor)
97           throw evaluation_error("Missint cursor");
98
99         // Get frame:
100         unw_cursor_t cursor = *(context.cursor);
101         unw_step(&cursor);
102
103         unw_word_t res;
104         unw_get_reg(&cursor, UNW_REG_SP, &res);
105         stack.push(res);
106         break;
107       }
108
109       // Frame base:
110
111     case DW_OP_fbreg:
112       stack.push((std::uintptr_t) context.frame_base + op->number);
113       break;
114
115       // ***** Constants:
116
117       // Short constant literals:
118       // DW_OP_lit15 pushed the 15 on the stack.
119     case DW_OP_lit0:
120     case DW_OP_lit1:
121     case DW_OP_lit2:
122     case DW_OP_lit3:
123     case DW_OP_lit4:
124     case DW_OP_lit5:
125     case DW_OP_lit6:
126     case DW_OP_lit7:
127     case DW_OP_lit8:
128     case DW_OP_lit9:
129     case DW_OP_lit10:
130     case DW_OP_lit11:
131     case DW_OP_lit12:
132     case DW_OP_lit13:
133     case DW_OP_lit14:
134     case DW_OP_lit15:
135     case DW_OP_lit16:
136     case DW_OP_lit17:
137     case DW_OP_lit18:
138     case DW_OP_lit19:
139     case DW_OP_lit20:
140     case DW_OP_lit21:
141     case DW_OP_lit22:
142     case DW_OP_lit23:
143     case DW_OP_lit24:
144     case DW_OP_lit25:
145     case DW_OP_lit26:
146     case DW_OP_lit27:
147     case DW_OP_lit28:
148     case DW_OP_lit29:
149     case DW_OP_lit30:
150     case DW_OP_lit31:
151       stack.push(atom - DW_OP_lit0);
152       break;
153
154       // Address from the base address of this ELF object.
155       // Push the address on the stack (base_address + argument).
156     case DW_OP_addr: {
157       if (!context.object_info)
158         throw evaluation_error("No base address");
159       Dwarf_Off addr = (Dwarf_Off) (std::uintptr_t)
160         context.object_info->base_address() + op->number;
161       stack.push(addr);
162       break;
163     }
164
165       // General constants:
166       // Push the constant argument on the stack.
167     case DW_OP_const1u:
168     case DW_OP_const2u:
169     case DW_OP_const4u:
170     case DW_OP_const8u:
171     case DW_OP_const1s:
172     case DW_OP_const2s:
173     case DW_OP_const4s:
174     case DW_OP_const8s:
175     case DW_OP_constu:
176     case DW_OP_consts:
177       stack.push(op->number);
178       break;
179
180       // ***** Stack manipulation:
181
182       // Push another copy/duplicate the value at the top of the stack:
183     case DW_OP_dup:
184       stack.dup();
185       break;
186
187       // Pop/drop the top of the stack:
188     case DW_OP_drop:
189       stack.pop();
190       break;
191
192       // Swap the two top-most value of the stack:
193     case DW_OP_swap:
194       std::swap(stack.top(), stack.top(1));
195       break;
196
197       // Duplicate the value under the top of the stack:
198     case DW_OP_over:
199       stack.push(stack.top(1));
200       break;
201
202       // ***** Operations:
203       // Those usually take the top of the stack and the next value as argument
204       // and replace the top of the stack with the computed value
205       // (stack.top() += stack.before_top()).
206
207     case DW_OP_plus:
208       stack.push(stack.pop() + stack.pop());
209       break;
210
211     case DW_OP_mul:
212       stack.push(stack.pop() * stack.pop());
213       break;
214
215     case DW_OP_plus_uconst:
216       stack.top() += op->number;
217       break;
218
219     case DW_OP_not:
220       stack.top() = ~stack.top();
221       break;
222
223     case DW_OP_neg:
224       stack.top() = - (intptr_t) stack.top();
225       break;
226
227     case DW_OP_minus:
228       stack.push(stack.pop() - stack.pop());
229       break;
230
231     case DW_OP_and:
232       stack.push(stack.pop() & stack.pop());
233       break;
234
235     case DW_OP_or:
236       stack.push(stack.pop() | stack.pop());
237       break;
238
239     case DW_OP_xor:
240       stack.push(stack.pop() ^ stack.pop());
241       break;
242
243     case DW_OP_nop:
244       break;
245
246       // ***** Deference (memory fetch)
247
248     case DW_OP_deref_size:
249       throw evaluation_error("Unsupported operation");
250
251     case DW_OP_deref:
252       // Computed address:
253       if (!context.address_space)
254         throw evaluation_error("Missing address space");
255       context.address_space->read_bytes(
256         &stack.top(), sizeof(uintptr_t), remote(stack.top()),
257         context.process_index);
258       break;
259
260       // Not handled:
261     default:
262       throw evaluation_error("Unsupported operation");
263     }
264
265   }
266 }
267
268 }
269 }