Remove EDX from x86 return registers.
[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::syscallRead_;
43 bitArray ABI::syscallWritten_;
44
45 bitArray ABI::callRead64_;
46 bitArray ABI::callWritten64_;
47 bitArray ABI::returnRead64_;
48 bitArray ABI::returnRegs64_;
49 bitArray ABI::syscallRead64_;
50 bitArray ABI::syscallWritten64_;
51 bitArray ABI::allRegs_;
52 bitArray ABI::allRegs64_;
53 ABI* ABI::globalABI_ = NULL;
54 ABI* ABI::globalABI64_ = NULL;
55
56 int ABI::getIndex(MachRegister machReg){
57         if (index->find(machReg) == index->end()){
58             return -1;
59         }
60         return (*index)[machReg];
61 }
62 std::map<MachRegister,int>* ABI::getIndexMap(){
63         return index;
64 }
65
66 ABI* ABI::getABI(int addr_width){
67     if (globalABI_ == NULL){
68         globalABI_ = new ABI();
69         globalABI_->addr_width = 4;
70         globalABI64_ = new ABI();
71
72 #if defined(arch_x86) || defined(arch_x86_64)
73         globalABI64_->addr_width = 8;
74         globalABI_->index = &machRegIndex_x86();
75         globalABI64_->index = &machRegIndex_x86_64();
76 #endif
77
78 #if defined(arch_power)
79         globalABI64_->addr_width = 4;
80         globalABI_->index = &machRegIndex_ppc();
81         globalABI64_->index = &machRegIndex_ppc();
82
83 #endif
84
85 //#warning "This is not verified yet!"
86 #if defined(arch_aarch64)
87         globalABI64_->addr_width = 8;
88         globalABI_->index = &machRegIndex_ppc();
89         globalABI64_->index = &machRegIndex_ppc();
90 #endif
91
92         initialize32();
93 #if defined(cap_32_64)
94         initialize64();
95 #endif
96     }
97     return (addr_width == 4) ? globalABI_ : globalABI64_;
98 }
99
100
101 const bitArray &ABI::getCallReadRegisters() const {
102     if (addr_width == 4)
103         return callRead_;
104     else if (addr_width == 8)
105         return callRead64_;
106     else {
107         assert(0);
108         return callRead_;
109     }
110 }
111 const bitArray &ABI::getCallWrittenRegisters() const {
112     if (addr_width == 4)
113         return callWritten_;
114     else if (addr_width == 8)
115         return callWritten64_;
116     else {
117         assert(0);
118         return callWritten_;
119     }
120 }
121
122 const bitArray &ABI::getReturnReadRegisters() const {
123     if (addr_width == 4)
124         return returnRead_;
125     else if (addr_width == 8)
126         return returnRead64_;
127     else {
128         assert(0);
129         return returnRead_;
130     }
131 }
132
133 const bitArray &ABI::getReturnRegisters() const {
134     if (addr_width == 4)
135         return returnRegs_;
136     else if (addr_width == 8)
137         return returnRegs64_;
138     else {
139         assert(0);
140         return returnRegs_;
141     }
142 }
143
144 const bitArray &ABI::getSyscallReadRegisters() const {
145     if (addr_width == 4)
146         return syscallRead_;
147     else if (addr_width == 8)
148         return syscallRead64_;
149     else {
150         assert(0);
151         return syscallRead_;
152     }
153 }
154 const bitArray &ABI::getSyscallWrittenRegisters() const {
155     if (addr_width == 4)
156         return syscallWritten_;
157     else if (addr_width == 8)
158         return syscallWritten64_;
159     else {
160         assert(0);
161         return syscallWritten_;
162     }
163 }
164
165 const bitArray &ABI::getAllRegs() const
166 {
167    if (addr_width == 4)
168       return allRegs_;
169    else if (addr_width == 8)
170       return allRegs64_;
171    else {
172       assert(0);
173       return allRegs_;
174    }
175 }
176
177 bitArray ABI::getBitArray()  {
178   return bitArray(index->size());
179 }
180 #if defined(arch_x86) || defined(arch_x86_64)
181 void ABI::initialize32(){
182
183    returnRegs_ = getBitArray(machRegIndex_x86().size());
184    returnRegs_[machRegIndex_x86()[x86::eax]] = true;
185
186
187    returnRead_ = getBitArray(machRegIndex_x86().size());
188    // Callee-save registers...
189    returnRead_[machRegIndex_x86()[x86::ebx]] = true;
190    returnRead_[machRegIndex_x86()[x86::esi]] = true;
191    returnRead_[machRegIndex_x86()[x86::edi]] = true;
192    // And return value
193    returnRead_[machRegIndex_x86()[x86::eax]] = true;
194    // Return reads no registers
195
196    callRead_ = getBitArray(machRegIndex_x86().size());
197    // CallRead reads no registers
198    // We wish...
199    callRead_[machRegIndex_x86()[x86::ecx]] = true;
200    callRead_[machRegIndex_x86()[x86::edx]] = true;
201
202    // PLT entries use ebx
203    callRead_[machRegIndex_x86()[x86::ebx]] = true;
204
205    // TODO: Fix this for platform-specific calling conventions
206
207    // Assume calls write flags
208    callWritten_ = callRead_;
209
210    callWritten_[machRegIndex_x86()[x86::of]] = true;
211    callWritten_[machRegIndex_x86()[x86::sf]] = true;
212    callWritten_[machRegIndex_x86()[x86::zf]] = true;
213    callWritten_[machRegIndex_x86()[x86::af]] = true;
214    callWritten_[machRegIndex_x86()[x86::pf]] = true;
215    callWritten_[machRegIndex_x86()[x86::cf]] = true;
216    callWritten_[machRegIndex_x86()[x86::tf]] = true;
217    callWritten_[machRegIndex_x86()[x86::if_]] = true;
218    callWritten_[machRegIndex_x86()[x86::df]] = true;
219    callWritten_[machRegIndex_x86()[x86::nt_]] = true;
220    callWritten_[machRegIndex_x86()[x86::rf]] = true;
221
222
223
224     // And eax...
225     callWritten_[machRegIndex_x86()[x86::eax]] = true;
226
227
228     // And assume a syscall reads or writes _everything_
229     syscallRead_ = getBitArray(machRegIndex_x86().size()).set();
230     syscallWritten_ = syscallRead_;
231
232 #if defined(os_windows)
233     // VERY conservative, but it's safe wrt the ABI.
234     // Let's set everything and unset flags
235     callRead_ = syscallRead_;
236     callRead_[machRegIndex_x86()[x86::of]] = false;
237     callRead_[machRegIndex_x86()[x86::sf]] = false;
238     callRead_[machRegIndex_x86()[x86::zf]] = false;
239     callRead_[machRegIndex_x86()[x86::af]] = false;
240     callRead_[machRegIndex_x86()[x86::pf]] = false;
241     callRead_[machRegIndex_x86()[x86::cf]] = false;
242     callRead_[machRegIndex_x86()[x86::tf]] = false;
243     callRead_[machRegIndex_x86()[x86::if_]] = false;
244     callRead_[machRegIndex_x86()[x86::df]] = false;
245     callRead_[machRegIndex_x86()[x86::nt_]] = false;
246     callRead_[machRegIndex_x86()[x86::rf]] = false;
247
248
249     callWritten_ = syscallWritten_;
250
251 // IF DEFINED KEVIN FUNKY MODE
252         returnRead_ = callRead_;
253         // Doesn't exist, but should
254         //returnWritten_ = callWritten_;
255 // ENDIF DEFINED KEVIN FUNKY MODE
256
257
258 #endif
259
260         allRegs_ = getBitArray(machRegIndex_x86().size()).set();
261
262 }
263
264 void ABI::initialize64(){
265
266     returnRegs64_ = getBitArray(machRegIndex_x86_64().size());
267     returnRegs64_[machRegIndex_x86_64()[x86_64::rax]] = true;
268     returnRegs64_[machRegIndex_x86_64()[x86_64::rdx]] = true;
269
270
271     returnRead64_ = getBitArray(machRegIndex_x86_64().size());
272     returnRead64_[machRegIndex_x86_64()[x86_64::rax]] = true;
273     returnRead64_[machRegIndex_x86_64()[x86_64::rcx]] = true; //Not correct, temporary
274     // Returns also "read" any callee-saved registers
275     returnRead64_[machRegIndex_x86_64()[x86_64::rbx]] = true;
276     returnRead64_[machRegIndex_x86_64()[x86_64::rdx]] = true;
277     returnRead64_[machRegIndex_x86_64()[x86_64::r12]] = true;
278     returnRead64_[machRegIndex_x86_64()[x86_64::r13]] = true;
279     returnRead64_[machRegIndex_x86_64()[x86_64::r14]] = true;
280     returnRead64_[machRegIndex_x86_64()[x86_64::r15]] = true;
281
282     returnRead64_[machRegIndex_x86_64()[x86_64::xmm0]] = true;
283     returnRead64_[machRegIndex_x86_64()[x86_64::xmm1]] = true;
284
285
286     callRead64_ = getBitArray(machRegIndex_x86_64().size());
287     callRead64_[machRegIndex_x86_64()[x86_64::rax]] = true;
288     callRead64_[machRegIndex_x86_64()[x86_64::rcx]] = true;
289     callRead64_[machRegIndex_x86_64()[x86_64::rdx]] = true;
290     callRead64_[machRegIndex_x86_64()[x86_64::r8]] = true;
291     callRead64_[machRegIndex_x86_64()[x86_64::r9]] = true;
292     callRead64_[machRegIndex_x86_64()[x86_64::rdi]] = true;
293     callRead64_[machRegIndex_x86_64()[x86_64::rsi]] = true;
294
295     callRead64_[machRegIndex_x86_64()[x86_64::xmm0]] = true;
296     callRead64_[machRegIndex_x86_64()[x86_64::xmm1]] = true;
297     callRead64_[machRegIndex_x86_64()[x86_64::xmm2]] = true;
298     callRead64_[machRegIndex_x86_64()[x86_64::xmm3]] = true;
299     callRead64_[machRegIndex_x86_64()[x86_64::xmm4]] = true;
300     callRead64_[machRegIndex_x86_64()[x86_64::xmm5]] = true;
301     callRead64_[machRegIndex_x86_64()[x86_64::xmm6]] = true;
302     callRead64_[machRegIndex_x86_64()[x86_64::xmm7]] = true;
303
304     // Anything in those four is not preserved across a call...
305     // So we copy this as a shorthand then augment it
306     callWritten64_ = callRead64_;
307
308     // As well as RAX, R10, R11
309     callWritten64_[machRegIndex_x86_64()[x86_64::rax]] = true;
310     callWritten64_[machRegIndex_x86_64()[x86_64::r10]] = true;
311     callWritten64_[machRegIndex_x86_64()[x86_64::r11]] = true;
312     // And flags
313
314     callWritten64_[machRegIndex_x86_64()[x86_64::of]] = true;
315     callWritten64_[machRegIndex_x86_64()[x86_64::sf]] = true;
316     callWritten64_[machRegIndex_x86_64()[x86_64::zf]] = true;
317     callWritten64_[machRegIndex_x86_64()[x86_64::af]] = true;
318     callWritten64_[machRegIndex_x86_64()[x86_64::pf]] = true;
319     callWritten64_[machRegIndex_x86_64()[x86_64::cf]] = true;
320     callWritten64_[machRegIndex_x86_64()[x86_64::tf]] = true;
321     callWritten64_[machRegIndex_x86_64()[x86_64::if_]] = true;
322     callWritten64_[machRegIndex_x86_64()[x86_64::df]] = true;
323     callWritten64_[machRegIndex_x86_64()[x86_64::nt_]] = true;
324     callWritten64_[machRegIndex_x86_64()[x86_64::rf]] = true;
325
326
327     // And assume a syscall reads or writes _everything_
328     syscallRead64_ = getBitArray(machRegIndex_x86_64().size()).set();
329     syscallWritten64_ = syscallRead64_;
330
331     allRegs64_ = getBitArray(machRegIndex_x86_64().size()).set();
332 }
333
334 #endif
335
336 #if defined(arch_power)
337 void ABI::initialize32(){
338     returnRegs_ = getBitArray(machRegIndex_ppc().size());
339     returnRegs_[machRegIndex_ppc()[ppc32::r3]] = true;
340
341     returnRead_ = getBitArray(machRegIndex_ppc().size());
342     // Return reads r3, r4, fpr1, fpr2
343     returnRead_[machRegIndex_ppc()[ppc32::r3]] = true;
344     returnRead_[machRegIndex_ppc()[ppc32::r4]] = true;
345     returnRead_[machRegIndex_ppc()[ppc32::fpr1]] = true;
346     returnRead_[machRegIndex_ppc()[ppc32::fpr2]] = true;
347
348     // Calls
349     callRead_ = getBitArray(machRegIndex_ppc().size());
350     // Calls read r3 -> r10 (parameters), fpr1 -> fpr13 (volatile FPRs)
351 /*    for (unsigned i = r3; i <= r10; i++)
352         callRead_[i] = true;
353     for (unsigned i = fpr1; i <= fpr13; i++)
354         callRead_[i] = true;*/
355
356     callRead_[machRegIndex_ppc()[ppc32::r3]] = true;
357     callRead_[machRegIndex_ppc()[ppc32::r4]] = true;
358     callRead_[machRegIndex_ppc()[ppc32::r5]] = true;
359     callRead_[machRegIndex_ppc()[ppc32::r6]] = true;
360     callRead_[machRegIndex_ppc()[ppc32::r7]] = true;
361     callRead_[machRegIndex_ppc()[ppc32::r8]] = true;
362     callRead_[machRegIndex_ppc()[ppc32::r9]] = true;
363     callRead_[machRegIndex_ppc()[ppc32::r10]] = true;
364
365     callRead_[machRegIndex_ppc()[ppc32::fpr1]] = true;
366     callRead_[machRegIndex_ppc()[ppc32::fpr2]] = true;
367     callRead_[machRegIndex_ppc()[ppc32::fpr3]] = true;
368     callRead_[machRegIndex_ppc()[ppc32::fpr4]] = true;
369     callRead_[machRegIndex_ppc()[ppc32::fpr5]] = true;
370     callRead_[machRegIndex_ppc()[ppc32::fpr6]] = true;
371     callRead_[machRegIndex_ppc()[ppc32::fpr7]] = true;
372     callRead_[machRegIndex_ppc()[ppc32::fpr8]] = true;
373     callRead_[machRegIndex_ppc()[ppc32::fpr9]] = true;
374     callRead_[machRegIndex_ppc()[ppc32::fpr10]] = true;
375     callRead_[machRegIndex_ppc()[ppc32::fpr11]] = true;
376     callRead_[machRegIndex_ppc()[ppc32::fpr12]] = true;
377     callRead_[machRegIndex_ppc()[ppc32::fpr13]] = true;
378
379     callWritten_ = getBitArray(machRegIndex_ppc().size());
380     // Calls write to pretty much every register we use for code generation
381     callWritten_[machRegIndex_ppc()[ppc32::r0]] = true;
382 /*    for (unsigned i = r3; i <= r12; i++)
383         callWritten_[i] = true;
384     // FPRs 0->13 are volatile
385     for (unsigned i = fpr0; i <= fpr13; i++)
386         callWritten_[i] = true;*/
387
388     callWritten_[machRegIndex_ppc()[ppc32::r3]] = true;
389     callWritten_[machRegIndex_ppc()[ppc32::r4]] = true;
390     callWritten_[machRegIndex_ppc()[ppc32::r5]] = true;
391     callWritten_[machRegIndex_ppc()[ppc32::r6]] = true;
392     callWritten_[machRegIndex_ppc()[ppc32::r7]] = true;
393     callWritten_[machRegIndex_ppc()[ppc32::r8]] = true;
394     callWritten_[machRegIndex_ppc()[ppc32::r9]] = true;
395     callWritten_[machRegIndex_ppc()[ppc32::r10]] = true;
396     callWritten_[machRegIndex_ppc()[ppc32::r11]] = true;
397     callWritten_[machRegIndex_ppc()[ppc32::r12]] = true;
398
399     callWritten_[machRegIndex_ppc()[ppc32::fpr0]] = true;
400     callWritten_[machRegIndex_ppc()[ppc32::fpr1]] = true;
401     callWritten_[machRegIndex_ppc()[ppc32::fpr2]] = true;
402     callWritten_[machRegIndex_ppc()[ppc32::fpr3]] = true;
403     callWritten_[machRegIndex_ppc()[ppc32::fpr4]] = true;
404     callWritten_[machRegIndex_ppc()[ppc32::fpr5]] = true;
405     callWritten_[machRegIndex_ppc()[ppc32::fpr6]] = true;
406     callWritten_[machRegIndex_ppc()[ppc32::fpr7]] = true;
407     callWritten_[machRegIndex_ppc()[ppc32::fpr8]] = true;
408     callWritten_[machRegIndex_ppc()[ppc32::fpr9]] = true;
409     callWritten_[machRegIndex_ppc()[ppc32::fpr10]] = true;
410     callWritten_[machRegIndex_ppc()[ppc32::fpr11]] = true;
411     callWritten_[machRegIndex_ppc()[ppc32::fpr12]] = true;
412     callWritten_[machRegIndex_ppc()[ppc32::fpr13]] = true;
413
414     // Syscall - assume the same as call
415     //syscallRead_ = getBitArray().set();
416     //syscallWritten_ = getBitArray().set();
417     syscallRead_ = callRead_;
418     syscallRead_[machRegIndex_ppc()[ppc32::r0]] = true;
419     syscallWritten_ = callWritten_;
420
421     allRegs_ = getBitArray(machRegIndex_ppc().size()).set();
422 }
423
424 void ABI::initialize64(){
425     returnRegs64_ = getBitArray(machRegIndex_ppc_64().size());
426     returnRegs64_[machRegIndex_ppc_64()[ppc64::r3]] = true;
427
428     returnRead64_ = getBitArray(machRegIndex_ppc_64().size());
429     // Return reads r3, r4, fpr1, fpr2
430     returnRead64_[machRegIndex_ppc_64()[ppc64::r3]] = true;
431     returnRead64_[machRegIndex_ppc_64()[ppc64::r4]] = true;
432     returnRead64_[machRegIndex_ppc_64()[ppc64::fpr3]] = true;
433     returnRead64_[machRegIndex_ppc_64()[ppc64::fpr2]] = true;
434
435     // Calls
436     callRead64_ = getBitArray(machRegIndex_ppc_64().size());
437     // Calls read r3 -> r10 (parameters), fpr1 -> fpr13 (volatile FPRs)
438
439     callRead64_[machRegIndex_ppc_64()[ppc64::r3]] = true;
440     callRead64_[machRegIndex_ppc_64()[ppc64::r4]] = true;
441     callRead64_[machRegIndex_ppc_64()[ppc64::r5]] = true;
442     callRead64_[machRegIndex_ppc_64()[ppc64::r6]] = true;
443     callRead64_[machRegIndex_ppc_64()[ppc64::r7]] = true;
444     callRead64_[machRegIndex_ppc_64()[ppc64::r8]] = true;
445     callRead64_[machRegIndex_ppc_64()[ppc64::r9]] = true;
446     callRead64_[machRegIndex_ppc_64()[ppc64::r10]] = true;
447
448     callRead64_[machRegIndex_ppc_64()[ppc64::fpr1]] = true;
449     callRead64_[machRegIndex_ppc_64()[ppc64::fpr2]] = true;
450     callRead64_[machRegIndex_ppc_64()[ppc64::fpr3]] = true;
451     callRead64_[machRegIndex_ppc_64()[ppc64::fpr4]] = true;
452     callRead64_[machRegIndex_ppc_64()[ppc64::fpr5]] = true;
453     callRead64_[machRegIndex_ppc_64()[ppc64::fpr6]] = true;
454     callRead64_[machRegIndex_ppc_64()[ppc64::fpr7]] = true;
455     callRead64_[machRegIndex_ppc_64()[ppc64::fpr8]] = true;
456     callRead64_[machRegIndex_ppc_64()[ppc64::fpr9]] = true;
457     callRead64_[machRegIndex_ppc_64()[ppc64::fpr10]] = true;
458     callRead64_[machRegIndex_ppc_64()[ppc64::fpr11]] = true;
459     callRead64_[machRegIndex_ppc_64()[ppc64::fpr12]] = true;
460     callRead64_[machRegIndex_ppc_64()[ppc64::fpr13]] = true;
461
462
463     callWritten64_ = getBitArray(machRegIndex_ppc_64().size());
464     // Calls write to pretty much every register we use for code generation
465     callWritten64_[machRegIndex_ppc_64()[ppc64::r0]] = true;
466
467     callWritten64_[machRegIndex_ppc_64()[ppc64::r3]] = true;
468     callWritten64_[machRegIndex_ppc_64()[ppc64::r4]] = true;
469     callWritten64_[machRegIndex_ppc_64()[ppc64::r5]] = true;
470     callWritten64_[machRegIndex_ppc_64()[ppc64::r6]] = true;
471     callWritten64_[machRegIndex_ppc_64()[ppc64::r7]] = true;
472     callWritten64_[machRegIndex_ppc_64()[ppc64::r8]] = true;
473     callWritten64_[machRegIndex_ppc_64()[ppc64::r9]] = true;
474     callWritten64_[machRegIndex_ppc_64()[ppc64::r10]] = true;
475     callWritten64_[machRegIndex_ppc_64()[ppc64::r11]] = true;
476     callWritten64_[machRegIndex_ppc_64()[ppc64::r12]] = true;
477
478     callWritten64_[machRegIndex_ppc_64()[ppc64::fpr0]] = true;
479     callWritten64_[machRegIndex_ppc_64()[ppc64::fpr1]] = true;
480     callWritten64_[machRegIndex_ppc_64()[ppc64::fpr2]] = true;
481     callWritten64_[machRegIndex_ppc_64()[ppc64::fpr3]] = true;
482     callWritten64_[machRegIndex_ppc_64()[ppc64::fpr4]] = true;
483     callWritten64_[machRegIndex_ppc_64()[ppc64::fpr5]] = true;
484     callWritten64_[machRegIndex_ppc_64()[ppc64::fpr6]] = true;
485     callWritten64_[machRegIndex_ppc_64()[ppc64::fpr7]] = true;
486     callWritten64_[machRegIndex_ppc_64()[ppc64::fpr8]] = true;
487     callWritten64_[machRegIndex_ppc_64()[ppc64::fpr9]] = true;
488     callWritten64_[machRegIndex_ppc_64()[ppc64::fpr10]] = true;
489     callWritten64_[machRegIndex_ppc_64()[ppc64::fpr11]] = true;
490     callWritten64_[machRegIndex_ppc_64()[ppc64::fpr12]] = true;
491     callWritten64_[machRegIndex_ppc_64()[ppc64::fpr13]] = true;
492
493     // Syscall - assume the same as call
494     syscallRead64_ = getBitArray(machRegIndex_ppc_64().size()).set();
495     syscallWritten64_ = getBitArray(machRegIndex_ppc_64().size()).set();
496
497     allRegs64_ = getBitArray(machRegIndex_ppc_64().size()).set();
498 }
499 #endif
500
501 //#warning "This is not verified!"
502 #if defined(arch_aarch64)
503 void ABI::initialize32(){
504         assert(0);
505 }
506
507 void ABI::initialize64(){
508         assert(0);
509 }
510 #endif