|
0
|
1 /*
|
|
|
2
|
|
|
3 Package: dyncall
|
|
|
4 Library: dyncallback
|
|
|
5 File: dyncallback/dyncall_args_arm64_apple.c
|
|
|
6 Description: Callback's Arguments VM - Implementation for Apple's ARM64 / ARMv8 / AAPCS64
|
|
|
7 License:
|
|
|
8
|
|
281
|
9 Copyright (c) 2015-2018 Daniel Adler <dadler@uni-goettingen.de>,
|
|
|
10 Tassilo Philipp <tphilipp@potion-studios.com>
|
|
0
|
11
|
|
|
12 Permission to use, copy, modify, and distribute this software for any
|
|
|
13 purpose with or without fee is hereby granted, provided that the above
|
|
|
14 copyright notice and this permission notice appear in all copies.
|
|
|
15
|
|
|
16 THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
|
17 WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
|
18 MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
|
19 ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
|
20 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
|
21 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
|
|
22 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
|
23
|
|
|
24 */
|
|
|
25
|
|
|
26 #include "dyncall_args.h"
|
|
|
27
|
|
|
28 #include <stdint.h>
|
|
|
29
|
|
|
30 typedef union {
|
|
|
31 struct { double value; } d;
|
|
|
32 struct { float value; } f;
|
|
|
33 } DCFPU_t;
|
|
|
34
|
|
|
35 struct DCArgs
|
|
|
36 {
|
|
|
37 /* buffers and stack-pointer: */
|
|
|
38
|
|
|
39 uint64_t I[8];
|
|
|
40 DCFPU_t F[8];
|
|
|
41 uint8_t* sp;
|
|
|
42
|
|
|
43 /* counters: */
|
|
|
44 int i;
|
|
|
45 int f;
|
|
|
46 int s;
|
|
|
47 int reserved;
|
|
|
48 };
|
|
|
49
|
|
|
50 static inline uint8_t* align(uint8_t* p, size_t v)
|
|
|
51 {
|
|
|
52 return (uint8_t*) ( ( ( (ptrdiff_t) p ) + v - 1) & (ptrdiff_t) -v );
|
|
|
53 }
|
|
|
54
|
|
|
55
|
|
|
56 DClonglong dcbArgLongLong (DCArgs* p)
|
|
|
57 {
|
|
|
58 if (p->i < 8) {
|
|
|
59 return p->I[p->i++];
|
|
|
60 } else {
|
|
|
61 DClonglong value;
|
|
|
62 p->sp = align(p->sp,sizeof(DClonglong));
|
|
|
63 value = * ( (DClonglong*) p->sp );
|
|
|
64 p->sp += sizeof(DClonglong);
|
|
|
65 return value;
|
|
|
66 }
|
|
|
67 }
|
|
|
68 DCdouble dcbArgDouble (DCArgs* p) {
|
|
|
69 if (p->f < 8) {
|
|
|
70 return p->F[p->f++].d.value;
|
|
|
71 } else {
|
|
|
72 DCdouble value;
|
|
|
73 p->sp = align(p->sp,sizeof(DCdouble));
|
|
|
74 value = * ( (DCdouble*) p->sp );
|
|
|
75 p->sp += sizeof(DCdouble);
|
|
|
76 return value;
|
|
|
77 }
|
|
|
78 }
|
|
|
79 DCfloat dcbArgFloat (DCArgs* p) {
|
|
|
80 if (p->f < 8) {
|
|
|
81 return p->F[p->f++].f.value;
|
|
|
82 } else {
|
|
|
83 DCfloat value;
|
|
|
84 p->sp = align(p->sp,sizeof(DCfloat));
|
|
|
85 value = * ( (DCfloat*) p->sp );
|
|
|
86 p->sp += sizeof(DCfloat);
|
|
|
87 return value;
|
|
|
88 }
|
|
|
89 }
|
|
|
90
|
|
|
91 DClong dcbArgLong (DCArgs* p) {
|
|
|
92 if (p->i < 8) {
|
|
|
93 return (DClong) p->I[p->i++];
|
|
|
94 } else {
|
|
|
95 DClong value;
|
|
|
96 p->sp = align(p->sp,sizeof(DClong));
|
|
|
97 value = * ( (DClong*) p->sp );
|
|
|
98 p->sp += sizeof(DClong);
|
|
|
99 return value;
|
|
|
100 }
|
|
|
101 }
|
|
|
102
|
|
|
103 DCint dcbArgInt (DCArgs* p) {
|
|
|
104 if (p->i < 8) {
|
|
|
105 return (DCint) p->I[p->i++];
|
|
|
106 } else {
|
|
|
107 DCint value;
|
|
|
108 p->sp = align(p->sp,sizeof(DCint));
|
|
|
109 value = * ( (DCint*) p->sp );
|
|
|
110 p->sp += sizeof(DCint);
|
|
|
111 return value;
|
|
|
112 }
|
|
|
113 }
|
|
|
114
|
|
|
115 DCshort dcbArgShort (DCArgs* p) {
|
|
|
116 if (p->i < 8) {
|
|
|
117 return (DCshort) p->I[p->i++];
|
|
|
118 } else {
|
|
|
119 DCshort value;
|
|
|
120 p->sp = align(p->sp,sizeof(DCshort));
|
|
|
121 value = * ( (DCshort*) p->sp );
|
|
|
122 p->sp += sizeof(DCshort);
|
|
|
123 return value;
|
|
|
124 }
|
|
|
125 }
|
|
|
126
|
|
|
127 DCchar dcbArgChar (DCArgs* p) {
|
|
|
128 if (p->i < 8) {
|
|
|
129 return (DCchar) p->I[p->i++];
|
|
|
130 } else {
|
|
|
131 DCchar value;
|
|
|
132 p->sp = align(p->sp,sizeof(DCchar));
|
|
|
133 value = * ( (DCchar*) p->sp );
|
|
|
134 p->sp += sizeof(DCchar);
|
|
|
135 return value;
|
|
|
136 }
|
|
|
137 }
|
|
|
138
|
|
|
139 DCbool dcbArgBool (DCArgs* p) {
|
|
|
140 if (p->i < 8) {
|
|
|
141 return (DCbool) p->I[p->i++];
|
|
|
142 } else {
|
|
|
143 DCbool value;
|
|
|
144 p->sp = align(p->sp,sizeof(DCbool));
|
|
|
145 value = * ( (DCbool*) p->sp );
|
|
|
146 p->sp += sizeof(DCbool);
|
|
|
147 return value;
|
|
|
148 }
|
|
|
149 }
|
|
|
150
|
|
|
151 DCpointer dcbArgPointer(DCArgs* p) {
|
|
|
152 return (DCpointer) dcbArgLongLong(p);
|
|
|
153 }
|
|
|
154
|
|
|
155 DCuint dcbArgUInt (DCArgs* p) { return (DCuint) dcbArgInt(p); }
|
|
|
156 DCuchar dcbArgUChar (DCArgs* p) { return (DCuchar) dcbArgChar(p); }
|
|
|
157 DCushort dcbArgUShort (DCArgs* p) { return (DCushort) dcbArgShort(p); }
|
|
|
158 DCulong dcbArgULong (DCArgs* p) { return (DCulong) dcbArgLong(p); }
|
|
|
159 DCulonglong dcbArgULongLong(DCArgs* p) { return (DCulonglong) dcbArgLongLong(p); }
|
|
|
160
|
