Mercurial > pub > dyncall > dyncall
annotate dyncallback/dyncall_args_arm64_apple.c @ 542:a73a5cd50c19
- fix passing aggregate-by-val on x64/sysv: subaggr classification for
aggr *arrays* was wrong (was problematic when there ware exactly 2 8bytes to
be classified, potentially be passed via registers)
author | Tassilo Philipp |
---|---|
date | Mon, 02 May 2022 15:32:41 +0200 |
parents | 71c884e610f0 |
children | 111236b31c75 |
rev | line source |
---|---|
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 | |
533
71c884e610f0
- integration of patches from Raphael Luba, Thekla, Inc.:
Tassilo Philipp
parents:
281
diff
changeset
|
161 void dcbArgAggr (DCArgs* p, DCpointer target) { /* @@@AGGR not impl */ } |
71c884e610f0
- integration of patches from Raphael Luba, Thekla, Inc.:
Tassilo Philipp
parents:
281
diff
changeset
|
162 void dcbReturnAggr (DCArgs *args, DCValue *result, DCpointer ret) { /* @@@AGGR not impl */ } |
71c884e610f0
- integration of patches from Raphael Luba, Thekla, Inc.:
Tassilo Philipp
parents:
281
diff
changeset
|
163 |