Mercurial > pub > dyncall > dyncall

comparison dyncallback/dyncall_args_arm64_apple.c @ 654:0079a8fa894e

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
- arm64 tweaks/cleanups for callbacks: * using 32b less of stack space * saved one instruction * simplified * cosmetics
author Tassilo Philipp
date Thu, 07 Mar 2024 18:01:54 +0100
parents 2562c89d5bb5
children
comparison
equal deleted inserted replaced
653:0c8838766866 654:0079a8fa894e
33 } DCFPU_t; 33 } DCFPU_t;
34 34
35 struct DCArgs 35 struct DCArgs
36 { 36 {
37 /* buffers and stack-pointer: */ 37 /* buffers and stack-pointer: */
38
39 uint64_t I[8]; 38 uint64_t I[8];
40 DCFPU_t F[8]; 39 DCFPU_t F[8];
41 uint8_t* sp; 40 uint8_t* sp;
42 41
43 /* counters: */ 42 /* counters: */
44 int i; 43 int i;
45 int f; 44 int f;
46 int s;
47 int reserved;
48 }; 45 };
49 46
50 static inline uint8_t* align(uint8_t* p, size_t v) 47 static inline uint8_t* align(uint8_t* p, size_t v)
51 { 48 {
52 return (uint8_t*) ( ( ( (ptrdiff_t) p ) + v - 1) & (ptrdiff_t) -v ); 49 return (uint8_t*) ( ( ( (ptrdiff_t) p ) + v - 1) & (ptrdiff_t) -v );
53 } 50 }
54 51
55 52
56 DClonglong dcbArgLongLong (DCArgs* p) 53 DClonglong dcbArgLongLong(DCArgs* p)
57 { 54 {
58 if (p->i < 8) { 55 if (p->i < 8) {
59 return p->I[p->i++]; 56 return p->I[p->i++];
60 } else { 57 } else {
61 DClonglong value; 58 DClonglong value;
63 value = * ( (DClonglong*) p->sp ); 60 value = * ( (DClonglong*) p->sp );
64 p->sp += sizeof(DClonglong); 61 p->sp += sizeof(DClonglong);
65 return value; 62 return value;
66 } 63 }
67 } 64 }
68 DCdouble dcbArgDouble (DCArgs* p) { 65
69 if (p->f < 8) { 66 DCdouble dcbArgDouble(DCArgs* p)
67 {
68 if (p->f < 8) {
70 return p->F[p->f++].d.value; 69 return p->F[p->f++].d.value;
71 } else { 70 } else {
72 DCdouble value; 71 DCdouble value;
73 p->sp = align(p->sp,sizeof(DCdouble)); 72 p->sp = align(p->sp,sizeof(DCdouble));
74 value = * ( (DCdouble*) p->sp ); 73 value = * ( (DCdouble*) p->sp );
75 p->sp += sizeof(DCdouble); 74 p->sp += sizeof(DCdouble);
76 return value; 75 return value;
77 } 76 }
78 } 77 }
79 DCfloat dcbArgFloat (DCArgs* p) { 78
79 DCfloat dcbArgFloat(DCArgs* p)
80 {
80 if (p->f < 8) { 81 if (p->f < 8) {
81 return p->F[p->f++].f.value; 82 return p->F[p->f++].f.value;
82 } else { 83 } else {
83 DCfloat value; 84 DCfloat value;
84 p->sp = align(p->sp,sizeof(DCfloat)); 85 p->sp = align(p->sp,sizeof(DCfloat));
86 p->sp += sizeof(DCfloat); 87 p->sp += sizeof(DCfloat);
87 return value; 88 return value;
88 } 89 }
89 } 90 }
90 91
91 DClong dcbArgLong (DCArgs* p) { 92 DClong dcbArgLong(DCArgs* p)
93 {
92 if (p->i < 8) { 94 if (p->i < 8) {
93 return (DClong) p->I[p->i++]; 95 return (DClong) p->I[p->i++];
94 } else { 96 } else {
95 DClong value; 97 DClong value;
96 p->sp = align(p->sp,sizeof(DClong)); 98 p->sp = align(p->sp,sizeof(DClong));
98 p->sp += sizeof(DClong); 100 p->sp += sizeof(DClong);
99 return value; 101 return value;
100 } 102 }
101 } 103 }
102 104
103 DCint dcbArgInt (DCArgs* p) { 105 DCint dcbArgInt(DCArgs* p)
106 {
104 if (p->i < 8) { 107 if (p->i < 8) {
105 return (DCint) p->I[p->i++]; 108 return (DCint) p->I[p->i++];
106 } else { 109 } else {
107 DCint value; 110 DCint value;
108 p->sp = align(p->sp,sizeof(DCint)); 111 p->sp = align(p->sp,sizeof(DCint));
110 p->sp += sizeof(DCint); 113 p->sp += sizeof(DCint);
111 return value; 114 return value;
112 } 115 }
113 } 116 }
114 117
115 DCshort dcbArgShort (DCArgs* p) { 118 DCshort dcbArgShort(DCArgs* p)
119 {
116 if (p->i < 8) { 120 if (p->i < 8) {
117 return (DCshort) p->I[p->i++]; 121 return (DCshort) p->I[p->i++];
118 } else { 122 } else {
119 DCshort value; 123 DCshort value;
120 p->sp = align(p->sp,sizeof(DCshort)); 124 p->sp = align(p->sp,sizeof(DCshort));
122 p->sp += sizeof(DCshort); 126 p->sp += sizeof(DCshort);
123 return value; 127 return value;
124 } 128 }
125 } 129 }
126 130
127 DCchar dcbArgChar (DCArgs* p) { 131 DCchar dcbArgChar(DCArgs* p)
132 {
128 if (p->i < 8) { 133 if (p->i < 8) {
129 return (DCchar) p->I[p->i++]; 134 return (DCchar) p->I[p->i++];
130 } else { 135 } else {
131 DCchar value; 136 DCchar value;
132 p->sp = align(p->sp,sizeof(DCchar)); 137 p->sp = align(p->sp,sizeof(DCchar));
134 p->sp += sizeof(DCchar); 139 p->sp += sizeof(DCchar);
135 return value; 140 return value;
136 } 141 }
137 } 142 }
138 143
139 DCbool dcbArgBool (DCArgs* p) { 144 DCbool dcbArgBool(DCArgs* p)
145 {
140 if (p->i < 8) { 146 if (p->i < 8) {
141 return (DCbool) p->I[p->i++]; 147 return (DCbool) p->I[p->i++];
142 } else { 148 } else {
143 DCbool value; 149 DCbool value;
144 p->sp = align(p->sp,sizeof(DCbool)); 150 p->sp = align(p->sp,sizeof(DCbool));
146 p->sp += sizeof(DCbool); 152 p->sp += sizeof(DCbool);
147 return value; 153 return value;
148 } 154 }
149 } 155 }
150 156
151 DCpointer dcbArgPointer(DCArgs* p) { 157 DCpointer dcbArgPointer(DCArgs* p) {
152 return (DCpointer) dcbArgLongLong(p); 158 return (DCpointer) dcbArgLongLong(p);
153 } 159 }
154 160
155 DCuint dcbArgUInt (DCArgs* p) { return (DCuint) dcbArgInt(p); } 161 DCuint dcbArgUInt (DCArgs* p) { return (DCuint) dcbArgInt(p); }
156 DCuchar dcbArgUChar (DCArgs* p) { return (DCuchar) dcbArgChar(p); } 162 DCuchar dcbArgUChar (DCArgs* p) { return (DCuchar) dcbArgChar(p); }
157 DCushort dcbArgUShort (DCArgs* p) { return (DCushort) dcbArgShort(p); } 163 DCushort dcbArgUShort (DCArgs* p) { return (DCushort) dcbArgShort(p); }