Conservative fix for the stack pointer passing problem.
[dyninst.git] / dataflowAPI / src / ABI.C
1 /*
2  * See the dyninst/COPYRIGHT file for copyright information.
3  *
4  * We provide the Paradyn Tools (below described as "Paradyn")
5  * on an AS IS basis, and do not warrant its validity or performance.
6  * We reserve the right to update, modify, or discontinue this
7  * software at any time.  We shall have no obligation to supply such
8  * updates or modifications or any other form of support to you.
9  *
10  * By your use of Paradyn, you understand and agree that we (or any
11  * other person or entity with proprietary rights in Paradyn) are
12  * under no obligation to provide either maintenance services,
13  * update services, notices of latent defects, or correction of
14  * defects for Paradyn.
15  *
16  * This library is free software; you can redistribute it and/or
17  * modify it under the terms of the GNU Lesser General Public
18  * License as published by the Free Software Foundation; either
19  * version 2.1 of the License, or (at your option) any later version.
20  *
21  * This library is distributed in the hope that it will be useful,
22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
24  * Lesser General Public License for more details.
25  *
26  * You should have received a copy of the GNU Lesser General Public
27  * License along with this library; if not, write to the Free Software
28  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
29  */
30
31 #include "dataflowAPI/h/ABI.h"
32 #include "dataflowAPI/src/RegisterMap.h"
33 #include <stdio.h>
34
35 using namespace Dyninst;
36 using namespace DataflowAPI;
37
38 bitArray ABI::callRead_;
39 bitArray ABI::callWritten_;
40 bitArray ABI::returnRead_;
41 bitArray ABI::returnRegs_;
42 bitArray ABI::callParam_;
43 bitArray ABI::syscallRead_;
44 bitArray ABI::syscallWritten_;
45
46 bitArray ABI::callRead64_;
47 bitArray ABI::callWritten64_;
48 bitArray ABI::returnRead64_;
49 bitArray ABI::returnRegs64_;
50 bitArray ABI::callParam64_;
51 bitArray ABI::syscallRead64_;
52 bitArray ABI::syscallWritten64_;
53 bitArray ABI::allRegs_;
54 bitArray ABI::allRegs64_;
55 ABI* ABI::globalABI_ = NULL;
56 ABI* ABI::globalABI64_ = NULL;
57
58 int ABI::getIndex(MachRegister machReg){
59         if (index->find(machReg) == index->end()){
60             return -1;
61         }
62         return (*index)[machReg];
63 }
64 std::map<MachRegister,int>* ABI::getIndexMap(){
65         return index;
66 }
67
68 ABI* ABI::getABI(int addr_width){
69     if (globalABI_ == NULL){
70         globalABI_ = new ABI();
71         globalABI_->addr_width = 4;
72         globalABI64_ = new ABI();
73
74 #if defined(arch_x86) || defined(arch_x86_64)
75         globalABI64_->addr_width = 8;
76         globalABI_->index = &machRegIndex_x86();
77         globalABI64_->index = &machRegIndex_x86_64();
78 #endif
79
80 #if defined(arch_power)
81         globalABI64_->addr_width = 4;
82         globalABI_->index = &machRegIndex_ppc();
83         globalABI64_->index = &machRegIndex_ppc();
84
85 #endif
86
87 //#warning "This is not verified yet!"
88 #if defined(arch_aarch64)
89         globalABI64_->addr_width = 8;
90         globalABI_->index = &machRegIndex_ppc();
91         globalABI64_->index = &machRegIndex_ppc();
92 #endif
93
94         initialize32();
95 #if defined(cap_32_64)
96         initialize64();
97 #endif
98     }
99     return (addr_width == 4) ? globalABI_ : globalABI64_;
100 }
101
102
103 const bitArray &ABI::getCallReadRegisters() const {
104     if (addr_width == 4)
105         return callRead_;
106     else if (addr_width == 8)
107         return callRead64_;
108     else {
109         assert(0);
110         return callRead_;
111     }
112 }
113 const bitArray &ABI::getCallWrittenRegisters() const {
114     if (addr_width == 4)
115         return callWritten_;
116     else if (addr_width == 8)
117         return callWritten64_;
118     else {
119         assert(0);
120         return callWritten_;
121     }
122 }
123
124 const bitArray &ABI::getReturnReadRegisters() const {
125     if (addr_width == 4)
126         return returnRead_;
127     else if (addr_width == 8)
128         return returnRead64_;
129     else {
130         assert(0);
131         return returnRead_;
132     }
133 }
134
135 const bitArray &ABI::getReturnRegisters() const {
136     if (addr_width == 4)
137         return returnRegs_;
138     else if (addr_width == 8)
139         return returnRegs64_;
140     else {
141         assert(0);
142         return returnRegs_;
143     }
144 }
145
146 const bitArray &ABI::getParameterRegisters() const {
147     if (addr_width == 4)
148         return callParam_;
149     else if (addr_width == 8)
150         return callParam64_;
151     else {
152         assert(0);
153         return callParam_;
154     }
155 }
156
157 const bitArray &ABI::getSyscallReadRegisters() const {
158     if (addr_width == 4)
159         return syscallRead_;
160     else if (addr_width == 8)
161         return syscallRead64_;
162     else {
163         assert(0);
164         return syscallRead_;
165     }
166 }
167 const bitArray &ABI::getSyscallWrittenRegisters() const {
168     if (addr_width == 4)
169         return syscallWritten_;
170     else if (addr_width == 8)
171         return syscallWritten64_;
172     else {
173         assert(0);
174         return syscallWritten_;
175     }
176 }
177
178 const bitArray &ABI::getAllRegs() const
179 {
180    if (addr_width == 4)
181       return allRegs_;
182    else if (addr_width == 8)
183       return allRegs64_;
184    else {
185       assert(0);
186       return allRegs_;
187    }
188 }
189
190 bitArray ABI::getBitArray()  {
191   return bitArray(index->size());
192 }
193 #if defined(arch_x86) || defined(arch_x86_64)
194 void ABI::initialize32(){
195
196    returnRegs_ = getBitArray(machRegIndex_x86().size());
197    returnRegs_[machRegIndex_x86()[x86::eax]] = true;
198
199    callParam_ = getBitArray(machRegIndex_x86().size());
200
201    returnRead_ = getBitArray(machRegIndex_x86().size());
202    // Callee-save registers...
203    returnRead_[machRegIndex_x86()[x86::ebx]] = true;
204    returnRead_[machRegIndex_x86()[x86::esi]] = true;
205    returnRead_[machRegIndex_x86()[x86::edi]] = true;
206    // And return value
207    returnRead_[machRegIndex_x86()[x86::eax]] = true;
208    // Return reads no registers
209
210    callRead_ = getBitArray(machRegIndex_x86().size());
211    // CallRead reads no registers
212    // We wish...
213    callRead_[machRegIndex_x86()[x86::ecx]] = true;
214    callRead_[machRegIndex_x86()[x86::edx]] = true;
215
216    // PLT entries use ebx
217    callRead_[machRegIndex_x86()[x86::ebx]] = true;
218
219    // TODO: Fix this for platform-specific calling conventions
220
221    // Assume calls write flags
222    callWritten_ = callRead_;
223
224    callWritten_[machRegIndex_x86()[x86::of]] = true;
225    callWritten_[machRegIndex_x86()[x86::sf]] = true;
226    callWritten_[machRegIndex_x86()[x86::zf]] = true;
227    callWritten_[machRegIndex_x86()[x86::af]] = true;
228    callWritten_[machRegIndex_x86()[x86::pf]] = true;
229    callWritten_[machRegIndex_x86()[x86::cf]] = true;
230    callWritten_[machRegIndex_x86()[x86::tf]] = true;
231    callWritten_[machRegIndex_x86()[x86::if_]] = true;
232    callWritten_[machRegIndex_x86()[x86::df]] = true;
233    callWritten_[machRegIndex_x86()[x86::nt_]] = true;
234    callWritten_[machRegIndex_x86()[x86::rf]] = true;
235
236
237
238     // And eax...
239     callWritten_[machRegIndex_x86()[x86::eax]] = true;
240
241
242     // And assume a syscall reads or writes _everything_
243     syscallRead_ = getBitArray(machRegIndex_x86().size()).set();
244     syscallWritten_ = syscallRead_;
245
246 #if defined(os_windows)
247     // VERY conservative, but it's safe wrt the ABI.
248     // Let's set everything and unset flags
249     callRead_ = syscallRead_;
250     callRead_[machRegIndex_x86()[x86::of]] = false;
251     callRead_[machRegIndex_x86()[x86::sf]] = false;
252     callRead_[machRegIndex_x86()[x86::zf]] = false;
253     callRead_[machRegIndex_x86()[x86::af]] = false;
254     callRead_[machRegIndex_x86()[x86::pf]] = false;
255     callRead_[machRegIndex_x86()[x86::cf]] = false;
256     callRead_[machRegIndex_x86()[x86::tf]] = false;
257     callRead_[machRegIndex_x86()[x86::if_]] = false;
258     callRead_[machRegIndex_x86()[x86::df]] = false;
259     callRead_[machRegIndex_x86()[x86::nt_]] = false;
260     callRead_[machRegIndex_x86()[x86::rf]] = false;
261
262
263     callWritten_ = syscallWritten_;
264
265 // IF DEFINED KEVIN FUNKY MODE
266         returnRead_ = callRead_;
267         // Doesn't exist, but should
268         //returnWritten_ = callWritten_;
269 // ENDIF DEFINED KEVIN FUNKY MODE
270
271
272 #endif
273
274         allRegs_ = getBitArray(machRegIndex_x86().size()).set();
275
276 }
277
278 void ABI::initialize64(){
279
280     returnRegs64_ = getBitArray(machRegIndex_x86_64().size());
281     returnRegs64_[machRegIndex_x86_64()[x86_64::rax]] = true;
282     returnRegs64_[machRegIndex_x86_64()[x86_64::rdx]] = true;
283
284     callParam64_ = getBitArray(machRegIndex_x86_64().size());
285     callParam64_[machRegIndex_x86_64()[x86_64::rdi]] = true;
286     callParam64_[machRegIndex_x86_64()[x86_64::rsi]] = true;
287     callParam64_[machRegIndex_x86_64()[x86_64::rdx]] = true;
288     callParam64_[machRegIndex_x86_64()[x86_64::rcx]] = true;
289     callParam64_[machRegIndex_x86_64()[x86_64::r8]] = true;
290     callParam64_[machRegIndex_x86_64()[x86_64::r9]] = true;
291
292     returnRead64_ = getBitArray(machRegIndex_x86_64().size());
293     returnRead64_[machRegIndex_x86_64()[x86_64::rax]] = true;
294     returnRead64_[machRegIndex_x86_64()[x86_64::rcx]] = true; //Not correct, temporary
295     // Returns also "read" any callee-saved registers
296     returnRead64_[machRegIndex_x86_64()[x86_64::rbx]] = true;
297     returnRead64_[machRegIndex_x86_64()[x86_64::rdx]] = true;
298     returnRead64_[machRegIndex_x86_64()[x86_64::r12]] = true;
299     returnRead64_[machRegIndex_x86_64()[x86_64::r13]] = true;
300     returnRead64_[machRegIndex_x86_64()[x86_64::r14]] = true;
301     returnRead64_[machRegIndex_x86_64()[x86_64::r15]] = true;
302
303     returnRead64_[machRegIndex_x86_64()[x86_64::xmm0]] = true;
304     returnRead64_[machRegIndex_x86_64()[x86_64::xmm1]] = true;
305
306
307     callRead64_ = getBitArray(machRegIndex_x86_64().size());
308     callRead64_[machRegIndex_x86_64()[x86_64::rax]] = true;
309     callRead64_[machRegIndex_x86_64()[x86_64::rcx]] = true;
310     callRead64_[machRegIndex_x86_64()[x86_64::rdx]] = true;
311     callRead64_[machRegIndex_x86_64()[x86_64::r8]] = true;
312     callRead64_[machRegIndex_x86_64()[x86_64::r9]] = true;
313     callRead64_[machRegIndex_x86_64()[x86_64::rdi]] = true;
314     callRead64_[machRegIndex_x86_64()[x86_64::rsi]] = true;
315
316     callRead64_[machRegIndex_x86_64()[x86_64::xmm0]] = true;
317     callRead64_[machRegIndex_x86_64()[x86_64::xmm1]] = true;
318     callRead64_[machRegIndex_x86_64()[x86_64::xmm2]] = true;
319     callRead64_[machRegIndex_x86_64()[x86_64::xmm3]] = true;
320     callRead64_[machRegIndex_x86_64()[x86_64::xmm4]] = true;
321     callRead64_[machRegIndex_x86_64()[x86_64::xmm5]] = true;
322     callRead64_[machRegIndex_x86_64()[x86_64::xmm6]] = true;
323     callRead64_[machRegIndex_x86_64()[x86_64::xmm7]] = true;
324
325     // Anything in those four is not preserved across a call...
326     // So we copy this as a shorthand then augment it
327     callWritten64_ = callRead64_;
328
329     // As well as RAX, R10, R11
330     callWritten64_[machRegIndex_x86_64()[x86_64::rax]] = true;
331     callWritten64_[machRegIndex_x86_64()[x86_64::r10]] = true;
332     callWritten64_[machRegIndex_x86_64()[x86_64::r11]] = true;
333     // And flags
334
335     callWritten64_[machRegIndex_x86_64()[x86_64::of]] = true;
336     callWritten64_[machRegIndex_x86_64()[x86_64::sf]] = true;
337     callWritten64_[machRegIndex_x86_64()[x86_64::zf]] = true;
338     callWritten64_[machRegIndex_x86_64()[x86_64::af]] = true;
339     callWritten64_[machRegIndex_x86_64()[x86_64::pf]] = true;
340     callWritten64_[machRegIndex_x86_64()[x86_64::cf]] = true;
341     callWritten64_[machRegIndex_x86_64()[x86_64::tf]] = true;
342     callWritten64_[machRegIndex_x86_64()[x86_64::if_]] = true;
343     callWritten64_[machRegIndex_x86_64()[x86_64::df]] = true;
344     callWritten64_[machRegIndex_x86_64()[x86_64::nt_]] = true;
345     callWritten64_[machRegIndex_x86_64()[x86_64::rf]] = true;
346
347
348     // And assume a syscall reads or writes _everything_
349     syscallRead64_ = getBitArray(machRegIndex_x86_64().size()).set();
350     syscallWritten64_ = syscallRead64_;
351
352     allRegs64_ = getBitArray(machRegIndex_x86_64().size()).set();
353 }
354
355 #endif
356
357 #if defined(arch_power)
358 void ABI::initialize32(){
359     returnRegs_ = getBitArray(machRegIndex_ppc().size());
360     returnRegs_[machRegIndex_ppc()[ppc32::r3]] = true;
361
362     callParam_ = getBitArray(machRegIndex_ppc().size());
363     callParam_[machRegIndex_ppc()[ppc32::r3]] = true;
364     callParam_[machRegIndex_ppc()[ppc32::r4]] = true;
365     callParam_[machRegIndex_ppc()[ppc32::r5]] = true;
366     callParam_[machRegIndex_ppc()[ppc32::r6]] = true;
367     callParam_[machRegIndex_ppc()[ppc32::r7]] = true;
368     callParam_[machRegIndex_ppc()[ppc32::r8]] = true;
369     callParam_[machRegIndex_ppc()[ppc32::r9]] = true;
370     callParam_[machRegIndex_ppc()[ppc32::r10]] = true;
371
372
373     returnRead_ = getBitArray(machRegIndex_ppc().size());
374     // Return reads r3, r4, fpr1, fpr2
375     returnRead_[machRegIndex_ppc()[ppc32::r3]] = true;
376     returnRead_[machRegIndex_ppc()[ppc32::r4]] = true;
377     returnRead_[machRegIndex_ppc()[ppc32::fpr1]] = true;
378     returnRead_[machRegIndex_ppc()[ppc32::fpr2]] = true;
379
380     // Calls
381     callRead_ = getBitArray(machRegIndex_ppc().size());
382     // Calls read r3 -> r10 (parameters), fpr1 -> fpr13 (volatile FPRs)
383 /*    for (unsigned i = r3; i <= r10; i++)
384         callRead_[i] = true;
385     for (unsigned i = fpr1; i <= fpr13; i++)
386         callRead_[i] = true;*/
387
388     callRead_[machRegIndex_ppc()[ppc32::r3]] = true;
389     callRead_[machRegIndex_ppc()[ppc32::r4]] = true;
390     callRead_[machRegIndex_ppc()[ppc32::r5]] = true;
391     callRead_[machRegIndex_ppc()[ppc32::r6]] = true;
392     callRead_[machRegIndex_ppc()[ppc32::r7]] = true;
393     callRead_[machRegIndex_ppc()[ppc32::r8]] = true;
394     callRead_[machRegIndex_ppc()[ppc32::r9]] = true;
395     callRead_[machRegIndex_ppc()[ppc32::r10]] = true;
396
397     callRead_[machRegIndex_ppc()[ppc32::fpr1]] = true;
398     callRead_[machRegIndex_ppc()[ppc32::fpr2]] = true;
399     callRead_[machRegIndex_ppc()[ppc32::fpr3]] = true;
400     callRead_[machRegIndex_ppc()[ppc32::fpr4]] = true;
401     callRead_[machRegIndex_ppc()[ppc32::fpr5]] = true;
402     callRead_[machRegIndex_ppc()[ppc32::fpr6]] = true;
403     callRead_[machRegIndex_ppc()[ppc32::fpr7]] = true;
404     callRead_[machRegIndex_ppc()[ppc32::fpr8]] = true;
405     callRead_[machRegIndex_ppc()[ppc32::fpr9]] = true;
406     callRead_[machRegIndex_ppc()[ppc32::fpr10]] = true;
407     callRead_[machRegIndex_ppc()[ppc32::fpr11]] = true;
408     callRead_[machRegIndex_ppc()[ppc32::fpr12]] = true;
409     callRead_[machRegIndex_ppc()[ppc32::fpr13]] = true;
410
411     callWritten_ = getBitArray(machRegIndex_ppc().size());
412     // Calls write to pretty much every register we use for code generation
413     callWritten_[machRegIndex_ppc()[ppc32::r0]] = true;
414 /*    for (unsigned i = r3; i <= r12; i++)
415         callWritten_[i] = true;
416     // FPRs 0->13 are volatile
417     for (unsigned i = fpr0; i <= fpr13; i++)
418         callWritten_[i] = true;*/
419
420     callWritten_[machRegIndex_ppc()[ppc32::r3]] = true;
421     callWritten_[machRegIndex_ppc()[ppc32::r4]] = true;
422     callWritten_[machRegIndex_ppc()[ppc32::r5]] = true;
423     callWritten_[machRegIndex_ppc()[ppc32::r6]] = true;
424     callWritten_[machRegIndex_ppc()[ppc32::r7]] = true;
425     callWritten_[machRegIndex_ppc()[ppc32::r8]] = true;
426     callWritten_[machRegIndex_ppc()[ppc32::r9]] = true;
427     callWritten_[machRegIndex_ppc()[ppc32::r10]] = true;
428     callWritten_[machRegIndex_ppc()[ppc32::r11]] = true;
429     callWritten_[machRegIndex_ppc()[ppc32::r12]] = true;
430
431     callWritten_[machRegIndex_ppc()[ppc32::fpr0]] = true;
432     callWritten_[machRegIndex_ppc()[ppc32::fpr1]] = true;
433     callWritten_[machRegIndex_ppc()[ppc32::fpr2]] = true;
434     callWritten_[machRegIndex_ppc()[ppc32::fpr3]] = true;
435     callWritten_[machRegIndex_ppc()[ppc32::fpr4]] = true;
436     callWritten_[machRegIndex_ppc()[ppc32::fpr5]] = true;
437     callWritten_[machRegIndex_ppc()[ppc32::fpr6]] = true;
438     callWritten_[machRegIndex_ppc()[ppc32::fpr7]] = true;
439     callWritten_[machRegIndex_ppc()[ppc32::fpr8]] = true;
440     callWritten_[machRegIndex_ppc()[ppc32::fpr9]] = true;
441     callWritten_[machRegIndex_ppc()[ppc32::fpr10]] = true;
442     callWritten_[machRegIndex_ppc()[ppc32::fpr11]] = true;
443     callWritten_[machRegIndex_ppc()[ppc32::fpr12]] = true;
444     callWritten_[machRegIndex_ppc()[ppc32::fpr13]] = true;
445
446     // Syscall - assume the same as call
447     //syscallRead_ = getBitArray().set();
448     //syscallWritten_ = getBitArray().set();
449     syscallRead_ = callRead_;
450     syscallRead_[machRegIndex_ppc()[ppc32::r0]] = true;
451     syscallWritten_ = callWritten_;
452
453     allRegs_ = getBitArray(machRegIndex_ppc().size()).set();
454 }
455
456 void ABI::initialize64(){
457     returnRegs64_ = getBitArray(machRegIndex_ppc_64().size());
458     returnRegs64_[machRegIndex_ppc_64()[ppc64::r3]] = true;
459
460     callParam64_ = getBitArray(machRegIndex_ppc_64().size());
461     callParam64_[machRegIndex_ppc_64()[ppc64::r3]] = true;
462     callParam64_[machRegIndex_ppc_64()[ppc64::r4]] = true;
463     callParam64_[machRegIndex_ppc_64()[ppc64::r5]] = true;
464     callParam64_[machRegIndex_ppc_64()[ppc64::r6]] = true;
465     callParam64_[machRegIndex_ppc_64()[ppc64::r7]] = true;
466     callParam64_[machRegIndex_ppc_64()[ppc64::r8]] = true;
467     callParam64_[machRegIndex_ppc_64()[ppc64::r9]] = true;
468     callParam64_[machRegIndex_ppc_64()[ppc64::r10]] = true;
469
470     returnRead64_ = getBitArray(machRegIndex_ppc_64().size());
471     // Return reads r3, r4, fpr1, fpr2
472     returnRead64_[machRegIndex_ppc_64()[ppc64::r3]] = true;
473     returnRead64_[machRegIndex_ppc_64()[ppc64::r4]] = true;
474     returnRead64_[machRegIndex_ppc_64()[ppc64::fpr3]] = true;
475     returnRead64_[machRegIndex_ppc_64()[ppc64::fpr2]] = true;
476
477     // Calls
478     callRead64_ = getBitArray(machRegIndex_ppc_64().size());
479     // Calls read r3 -> r10 (parameters), fpr1 -> fpr13 (volatile FPRs)
480
481     callRead64_[machRegIndex_ppc_64()[ppc64::r3]] = true;
482     callRead64_[machRegIndex_ppc_64()[ppc64::r4]] = true;
483     callRead64_[machRegIndex_ppc_64()[ppc64::r5]] = true;
484     callRead64_[machRegIndex_ppc_64()[ppc64::r6]] = true;
485     callRead64_[machRegIndex_ppc_64()[ppc64::r7]] = true;
486     callRead64_[machRegIndex_ppc_64()[ppc64::r8]] = true;
487     callRead64_[machRegIndex_ppc_64()[ppc64::r9]] = true;
488     callRead64_[machRegIndex_ppc_64()[ppc64::r10]] = true;
489
490     callRead64_[machRegIndex_ppc_64()[ppc64::fpr1]] = true;
491     callRead64_[machRegIndex_ppc_64()[ppc64::fpr2]] = true;
492     callRead64_[machRegIndex_ppc_64()[ppc64::fpr3]] = true;
493     callRead64_[machRegIndex_ppc_64()[ppc64::fpr4]] = true;
494     callRead64_[machRegIndex_ppc_64()[ppc64::fpr5]] = true;
495     callRead64_[machRegIndex_ppc_64()[ppc64::fpr6]] = true;
496     callRead64_[machRegIndex_ppc_64()[ppc64::fpr7]] = true;
497     callRead64_[machRegIndex_ppc_64()[ppc64::fpr8]] = true;
498     callRead64_[machRegIndex_ppc_64()[ppc64::fpr9]] = true;
499     callRead64_[machRegIndex_ppc_64()[ppc64::fpr10]] = true;
500     callRead64_[machRegIndex_ppc_64()[ppc64::fpr11]] = true;
501     callRead64_[machRegIndex_ppc_64()[ppc64::fpr12]] = true;
502     callRead64_[machRegIndex_ppc_64()[ppc64::fpr13]] = true;
503
504
505     callWritten64_ = getBitArray(machRegIndex_ppc_64().size());
506     // Calls write to pretty much every register we use for code generation
507     callWritten64_[machRegIndex_ppc_64()[ppc64::r0]] = true;
508
509     callWritten64_[machRegIndex_ppc_64()[ppc64::r3]] = true;
510     callWritten64_[machRegIndex_ppc_64()[ppc64::r4]] = true;
511     callWritten64_[machRegIndex_ppc_64()[ppc64::r5]] = true;
512     callWritten64_[machRegIndex_ppc_64()[ppc64::r6]] = true;
513     callWritten64_[machRegIndex_ppc_64()[ppc64::r7]] = true;
514     callWritten64_[machRegIndex_ppc_64()[ppc64::r8]] = true;
515     callWritten64_[machRegIndex_ppc_64()[ppc64::r9]] = true;
516     callWritten64_[machRegIndex_ppc_64()[ppc64::r10]] = true;
517     callWritten64_[machRegIndex_ppc_64()[ppc64::r11]] = true;
518     callWritten64_[machRegIndex_ppc_64()[ppc64::r12]] = true;
519
520     callWritten64_[machRegIndex_ppc_64()[ppc64::fpr0]] = true;
521     callWritten64_[machRegIndex_ppc_64()[ppc64::fpr1]] = true;
522     callWritten64_[machRegIndex_ppc_64()[ppc64::fpr2]] = true;
523     callWritten64_[machRegIndex_ppc_64()[ppc64::fpr3]] = true;
524     callWritten64_[machRegIndex_ppc_64()[ppc64::fpr4]] = true;
525     callWritten64_[machRegIndex_ppc_64()[ppc64::fpr5]] = true;
526     callWritten64_[machRegIndex_ppc_64()[ppc64::fpr6]] = true;
527     callWritten64_[machRegIndex_ppc_64()[ppc64::fpr7]] = true;
528     callWritten64_[machRegIndex_ppc_64()[ppc64::fpr8]] = true;
529     callWritten64_[machRegIndex_ppc_64()[ppc64::fpr9]] = true;
530     callWritten64_[machRegIndex_ppc_64()[ppc64::fpr10]] = true;
531     callWritten64_[machRegIndex_ppc_64()[ppc64::fpr11]] = true;
532     callWritten64_[machRegIndex_ppc_64()[ppc64::fpr12]] = true;
533     callWritten64_[machRegIndex_ppc_64()[ppc64::fpr13]] = true;
534
535     // Syscall - assume the same as call
536     syscallRead64_ = getBitArray(machRegIndex_ppc_64().size()).set();
537     syscallWritten64_ = getBitArray(machRegIndex_ppc_64().size()).set();
538
539     allRegs64_ = getBitArray(machRegIndex_ppc_64().size()).set();
540 }
541 #endif
542
543 //#warning "This is not verified!"
544 #if defined(arch_aarch64)
545 void ABI::initialize32(){
546         assert(0);
547 }
548
549 void ABI::initialize64(){
550         assert(0);
551 }
552 #endif