Mercurial > pub > dyncall > dyncall

comparison doc/disas_examples/sparc64.sparc64.disas @ 475:5be9f5ccdd35

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
- doc: ppc64 clarifications
author Tassilo Philipp
date Sat, 19 Feb 2022 19:27:22 +0100
parents c9e19249ecd3
children c73c59c8b553
comparison
equal deleted inserted replaced
474:c9e19249ecd3 475:5be9f5ccdd35
998 58: 9d e3 bf 10 save %sp, -240, %sp ; prolog 998 58: 9d e3 bf 10 save %sp, -240, %sp ; prolog
999 5c: 2f 00 00 00 sethi %hi(0), %l7 ; | 999 5c: 2f 00 00 00 sethi %hi(0), %l7 ; |
1000 60: ae 05 e0 00 add %l7, 0, %l7 ! 0 <leaf_call> ; | @@@ unsure, call to some code stub adding o7 to l7 1000 60: ae 05 e0 00 add %l7, 0, %l7 ! 0 <leaf_call> ; | @@@ unsure, call to some code stub adding o7 to l7
1001 64: 7f ff ff fa call 4c <leaf_call+0x4c> ; | 1001 64: 7f ff ff fa call 4c <leaf_call+0x4c> ; |
1002 68: 01 00 00 00 nop ; / 1002 68: 01 00 00 00 nop ; /
1003 ; leaf_call((struct A){0,1.f}, (struct B){2.f,3}, (struct C){4.f,5,6}, (struct D){7,8.f});
1004 6c: c0 27 a7 df clr [ %fp + 0x7df ] ; \ 1003 6c: c0 27 a7 df clr [ %fp + 0x7df ] ; \
1005 70: 03 00 00 00 sethi %hi(0), %g1 ; | 1004 70: 03 00 00 00 sethi %hi(0), %g1 ; |
1006 74: 82 10 60 00 mov %g1, %g1 ! 0 <leaf_call> ; | 1005 74: 82 10 60 00 mov %g1, %g1 ! 0 <leaf_call> ; |
1007 78: c2 5d c0 01 ldx [ %l7 + %g1 ], %g1 ; | put together local struct A 1006 78: c2 5d c0 01 ldx [ %l7 + %g1 ], %g1 ; | put together local struct A
1008 7c: d1 00 40 00 ld [ %g1 ], %f8 ; | 1007 7c: d1 00 40 00 ld [ %g1 ], %f8 ; |
1051 128: 82 10 20 00 clr %g1 ! 0 <leaf_call> ; \ 1050 128: 82 10 20 00 clr %g1 ! 0 <leaf_call> ; \
1052 12c: 83 38 60 00 sra %g1, 0, %g1 ; / return value 1051 12c: 83 38 60 00 sra %g1, 0, %g1 ; / return value
1053 130: b0 10 00 01 mov %g1, %i0 ; \ 1052 130: b0 10 00 01 mov %g1, %i0 ; \
1054 134: 81 cf e0 08 rett %i7 + 8 ; | epilog 1053 134: 81 cf e0 08 rett %i7 + 8 ; | epilog
1055 138: 01 00 00 00 nop ; | branch delay slot 1054 138: 01 00 00 00 nop ; | branch delay slot
1055
1056
1057
1058 ; ---------- passing structs with only fp parts ---------->
1059 ;
1060 ; struct A { float a; };
1061 ; struct B { float a, b; };
1062 ; struct C { float a, b, c; };
1063 ; struct D { double a; };
1064 ; struct E { double a, b; };
1065 ; struct F { double a, b, c; };
1066 ;
1067 ; void leaf_call(struct A a, struct B b, struct C c, struct D d, struct E e, struct F f)
1068 ; {
1069 ; }
1070 ;
1071 ; int main()
1072 ; {
1073 ; leaf_call((struct A){1.f}, (struct B){2.f,3.f}, (struct C){4.f,5.f,6.f}, (struct D){1.}, (struct E){2.,3.}, (struct F){4.,5.,6.});
1074 ; return 0;
1075 ; }
1076
1077
1078
1079 ; output from openbsd-6.0-sparc64 w/ gcc 4.2.1
1080
1081 0000000000000000 <leaf_call>:
1082 0: 9d e3 bf 30 save %sp, -208, %sp
1083 4: c1 27 a8 7f st %f0, [ %fp + 0x87f ]
1084 8: 9d a0 00 22 fmovs %f2, %f14
1085 c: 9f a0 00 23 fmovs %f3, %f15
1086 10: a1 a0 00 24 fmovs %f4, %f16
1087 14: a3 a0 00 25 fmovs %f5, %f17
1088 18: a5 a0 00 26 fmovs %f6, %f18
1089 1c: d1 3f a8 9f std %f8, [ %fp + 0x89f ]
1090 20: 91 a0 00 4a fmovd %f10, %f8
1091 24: 95 a0 00 4c fmovd %f12, %f10
1092 28: d1 3f a8 a7 std %f8, [ %fp + 0x8a7 ]
1093 2c: d5 3f a8 af std %f10, [ %fp + 0x8af ]
1094 30: dd 27 a8 87 st %f14, [ %fp + 0x887 ]
1095 34: df 27 a8 8b st %f15, [ %fp + 0x88b ]
1096 38: e1 27 a8 8f st %f16, [ %fp + 0x88f ]
1097 3c: e3 27 a8 93 st %f17, [ %fp + 0x893 ]
1098 40: e5 27 a8 97 st %f18, [ %fp + 0x897 ]
1099 44: 81 cf e0 08 rett %i7 + 8
1100 48: 01 00 00 00 nop
1101 4c: ae 03 c0 17 add %o7, %l7, %l7
1102 50: 81 c3 e0 08 retl
1103 54: 01 00 00 00 nop
1104
1105 0000000000000058 <main>:
1106 58: 9d e3 be b0 save %sp, -336, %sp ; prolog
1107 5c: 2f 00 00 00 sethi %hi(0), %l7 ; |
1108 60: ae 05 e0 00 add %l7, 0, %l7 ! 0 <leaf_call> ; | @@@ unsure, call to some code stub adding o7 to l7
1109 64: 7f ff ff fa call 4c <leaf_call+0x4c> ; |
1110 68: 01 00 00 00 nop ; /
1111 6c: 03 00 00 00 sethi %hi(0), %g1 ; \
1112 70: 82 10 60 00 mov %g1, %g1 ! 0 <leaf_call> ; |
1113 74: c2 5d c0 01 ldx [ %l7 + %g1 ], %g1 ; | put together local struct A
1114 78: d1 00 40 00 ld [ %g1 ], %f8 ; |
1115 7c: d1 27 a7 e3 st %f8, [ %fp + 0x7e3 ] ; /
1116 80: 03 00 00 00 sethi %hi(0), %g1 ; \
1117 84: 82 10 60 00 mov %g1, %g1 ! 0 <leaf_call> ; |
1118 88: c2 5d c0 01 ldx [ %l7 + %g1 ], %g1 ; |
1119 8c: d1 00 40 00 ld [ %g1 ], %f8 ; |
1120 90: d1 27 a7 db st %f8, [ %fp + 0x7db ] ; |
1121 94: 03 00 00 00 sethi %hi(0), %g1 ; | put together local struct B
1122 98: 82 10 60 00 mov %g1, %g1 ! 0 <leaf_call> ; |
1123 9c: c2 5d c0 01 ldx [ %l7 + %g1 ], %g1 ; |
1124 a0: d1 00 40 00 ld [ %g1 ], %f8 ; |
1125 a4: d1 27 a7 df st %f8, [ %fp + 0x7df ] ; /
1126 a8: 03 00 00 00 sethi %hi(0), %g1 ; \
1127 ac: 82 10 60 00 mov %g1, %g1 ! 0 <leaf_call> ; |
1128 b0: c2 5d c0 01 ldx [ %l7 + %g1 ], %g1 ; |
1129 b4: d1 00 40 00 ld [ %g1 ], %f8 ; |
1130 b8: d1 27 a7 c3 st %f8, [ %fp + 0x7c3 ] ; |
1131 bc: 03 00 00 00 sethi %hi(0), %g1 ; |
1132 c0: 82 10 60 00 mov %g1, %g1 ! 0 <leaf_call> ; |
1133 c4: c2 5d c0 01 ldx [ %l7 + %g1 ], %g1 ; |
1134 c8: d1 00 40 00 ld [ %g1 ], %f8 ; | put together local struct C
1135 cc: d1 27 a7 c7 st %f8, [ %fp + 0x7c7 ] ; |
1136 d0: 03 00 00 00 sethi %hi(0), %g1 ; |
1137 d4: 82 10 60 00 mov %g1, %g1 ! 0 <leaf_call> ; |
1138 d8: c2 5d c0 01 ldx [ %l7 + %g1 ], %g1 ; |
1139 dc: d1 00 40 00 ld [ %g1 ], %f8 ; |
1140 e0: d1 27 a7 cb st %f8, [ %fp + 0x7cb ] ; /
1141 e4: 03 00 00 00 sethi %hi(0), %g1 ; \
1142 e8: 82 10 60 00 mov %g1, %g1 ! 0 <leaf_call> ; |
1143 ec: c2 5d c0 01 ldx [ %l7 + %g1 ], %g1 ; | put together local struct D
1144 f0: d1 18 40 00 ldd [ %g1 ], %f8 ; |
1145 f4: d1 3f a7 cf std %f8, [ %fp + 0x7cf ] ; /
1146 f8: 03 00 00 00 sethi %hi(0), %g1 ; \
1147 fc: 82 10 60 00 mov %g1, %g1 ! 0 <leaf_call> ; |
1148 100: c2 5d c0 01 ldx [ %l7 + %g1 ], %g1 ; |
1149 104: d1 18 40 00 ldd [ %g1 ], %f8 ; |
1150 108: d1 3f a7 af std %f8, [ %fp + 0x7af ] ; |
1151 10c: 03 00 00 00 sethi %hi(0), %g1 ; | put together local struct E
1152 110: 82 10 60 00 mov %g1, %g1 ! 0 <leaf_call> ; |
1153 114: c2 5d c0 01 ldx [ %l7 + %g1 ], %g1 ; |
1154 118: d1 18 40 00 ldd [ %g1 ], %f8 ; |
1155 11c: d1 3f a7 b7 std %f8, [ %fp + 0x7b7 ] ; /
1156 120: 03 00 00 00 sethi %hi(0), %g1 ; \
1157 124: 82 10 60 00 mov %g1, %g1 ! 0 <leaf_call> ; |
1158 128: c2 5d c0 01 ldx [ %l7 + %g1 ], %g1 ; |
1159 12c: d1 18 40 00 ldd [ %g1 ], %f8 ; |
1160 130: d1 3f a7 97 std %f8, [ %fp + 0x797 ] ; |
1161 134: 03 00 00 00 sethi %hi(0), %g1 ; |
1162 138: 82 10 60 00 mov %g1, %g1 ! 0 <leaf_call> ; |
1163 13c: c2 5d c0 01 ldx [ %l7 + %g1 ], %g1 ; |
1164 140: d1 18 40 00 ldd [ %g1 ], %f8 ; | put together local struct F
1165 144: d1 3f a7 9f std %f8, [ %fp + 0x79f ] ; |
1166 148: 03 00 00 00 sethi %hi(0), %g1 ; |
1167 14c: 82 10 60 00 mov %g1, %g1 ! 0 <leaf_call> ; |
1168 150: c2 5d c0 01 ldx [ %l7 + %g1 ], %g1 ; |
1169 154: d1 18 40 00 ldd [ %g1 ], %f8 ; |
1170 158: d1 3f a7 a7 std %f8, [ %fp + 0x7a7 ] ; /
1171 15c: c2 5f a7 97 ldx [ %fp + 0x797 ], %g1 ; \
1172 160: c2 77 a7 6f stx %g1, [ %fp + 0x76f ] ; |
1173 164: c2 5f a7 9f ldx [ %fp + 0x79f ], %g1 ; | prep arg 5 (struct F, copied entirely onto stack, as > 16b, to pass indirectly)
1174 168: c2 77 a7 77 stx %g1, [ %fp + 0x777 ] ; |
1175 16c: c2 5f a7 a7 ldx [ %fp + 0x7a7 ], %g1 ; |
1176 170: c2 77 a7 7f stx %g1, [ %fp + 0x77f ] ; /
1177 174: d1 07 a7 e3 ld [ %fp + 0x7e3 ], %f8 ; prep arg 0 (struct A)
1178 178: d3 07 a7 db ld [ %fp + 0x7db ], %f9 ; \
1179 17c: dd 07 a7 df ld [ %fp + 0x7df ], %f14 ; / prep arg 1 (struct B)
1180 180: df 07 a7 c3 ld [ %fp + 0x7c3 ], %f15 ; \
1181 184: e1 07 a7 c7 ld [ %fp + 0x7c7 ], %f16 ; | prep arg 2 (struct C)
1182 188: e3 07 a7 cb ld [ %fp + 0x7cb ], %f17 ; /
1183 18c: e5 1f a7 cf ldd [ %fp + 0x7cf ], %f18 ; prep arg 3 (struct D)
1184 190: 82 07 a7 6f add %fp, 0x76f, %g1 ; \
1185 194: c2 73 a8 b7 stx %g1, [ %sp + 0x8b7 ] ; / arg 5 (struct F, passed indirectly as ptr to copy; via stack as all %o* regs already skipped)
1186 198: c2 5f a7 b7 ldx [ %fp + 0x7b7 ], %g1 ; @@@ unsure ...
1187 19c: c2 73 a8 af stx %g1, [ %sp + 0x8af ] ; @@@ ... last float of struct E pushed onto stack (maybe register save area? maybe for some iteration facilitation?)
1188 1a0: d5 1f a7 af ldd [ %fp + 0x7af ], %f10 ; \ arg 4 (struct E) first double
1189 1a4: d9 1f a7 b7 ldd [ %fp + 0x7b7 ], %f12 ; / second double
1190 1a8: 81 a0 00 28 fmovs %f8, %f0 ; arg 0 (entire struct A, takes full %d0 slot despite not being 64bit, as only field of struct)
1191 1ac: 85 a0 00 29 fmovs %f9, %f2 ; \ arg 1 (struct B) first float
1192 1b0: 87 a0 00 2e fmovs %f14, %f3 ; / second float
1193 1b4: 89 a0 00 2f fmovs %f15, %f4 ; \ first float
1194 1b8: 8b a0 00 30 fmovs %f16, %f5 ; | arg 2 (struct C) second float
1195 1bc: 8d a0 00 31 fmovs %f17, %f6 ; / third float
1196 1c0: 91 a0 00 52 fmovd %f18, %f8 ; arg 3 (entire struct D, single field double)
1197 1c4: 40 00 00 00 call 1c4 <main+0x16c> ; call nonleaf_call (objdump not from final link but .o)
1198 1c8: 01 00 00 00 nop ; branch delay slot
1199 1cc: 82 10 20 00 clr %g1 ! 0 <leaf_call> ; \
1200 1d0: 83 38 60 00 sra %g1, 0, %g1 ; / return value
1201 1d4: b0 10 00 01 mov %g1, %i0 ; \
1202 1d8: 81 cf e0 08 rett %i7 + 8 ; | epilog
1203 1dc: 01 00 00 00 nop ; | branch delay slot
1204
1205
1206
1207 ; ---------- passing only unions with only fp parts ---------->
1208 ;
1209 ; union A { float a; };
1210 ; union B { float a, b; };
1211 ; union C { float a, b, c; };
1212 ; union D { double a; };
1213 ; union E { double a, b; };
1214 ; union F { double a, b, c; };
1215 ;
1216 ; void leaf_call(union A a, union B b, union C c, union D d, union E e, union F f)
1217 ; {
1218 ; }
1219 ;
1220 ; int main()
1221 ; {
1222 ; leaf_call((union A){1.f}, (union B){2.f,3.f}, (union C){4.f,5.f,6.f}, (union D){1.}, (union E){2.,3.}, (union F){4.,5.,6.});
1223 ; return 0;
1224 ; }
1225
1226
1227
1228 ; output from openbsd-6.0-sparc64 w/ gcc 4.2.1
1229
1230 0000000000000000 <leaf_call>:
1231 0: 9d e3 bf 30 save %sp, -208, %sp
1232 4: 84 10 00 18 mov %i0, %g2
1233 8: 86 10 00 19 mov %i1, %g3
1234 c: 88 10 00 1a mov %i2, %g4
1235 10: f6 77 a8 97 stx %i3, [ %fp + 0x897 ]
1236 14: f8 77 a8 9f stx %i4, [ %fp + 0x89f ]
1237 18: fa 77 a8 a7 stx %i5, [ %fp + 0x8a7 ]
1238 1c: 85 38 b0 20 srax %g2, 0x20, %g2
1239 20: c2 07 a8 7f ld [ %fp + 0x87f ], %g1
1240 24: 82 08 60 00 and %g1, 0, %g1
1241 28: 82 10 40 02 or %g1, %g2, %g1
1242 2c: c2 27 a8 7f st %g1, [ %fp + 0x87f ]
1243 30: 87 38 f0 20 srax %g3, 0x20, %g3
1244 34: c2 07 a8 87 ld [ %fp + 0x887 ], %g1
1245 38: 82 08 60 00 and %g1, 0, %g1
1246 3c: 82 10 40 03 or %g1, %g3, %g1
1247 40: c2 27 a8 87 st %g1, [ %fp + 0x887 ]
1248 44: 89 39 30 20 srax %g4, 0x20, %g4
1249 48: c2 07 a8 8f ld [ %fp + 0x88f ], %g1
1250 4c: 82 08 60 00 and %g1, 0, %g1
1251 50: 82 10 40 04 or %g1, %g4, %g1
1252 54: c2 27 a8 8f st %g1, [ %fp + 0x88f ]
1253 58: 81 cf e0 08 rett %i7 + 8
1254 5c: 01 00 00 00 nop
1255 60: ae 03 c0 17 add %o7, %l7, %l7
1256 64: 81 c3 e0 08 retl
1257 68: 01 00 00 00 nop
1258
1259 000000000000006c <main>:
1260 6c: 9d e3 bf 10 save %sp, -240, %sp ; prolog
1261 70: 2f 00 00 00 sethi %hi(0), %l7 ; |
1262 74: ae 05 e0 00 add %l7, 0, %l7 ! 0 <leaf_call> ; | @@@ unsure, call to some code stub adding o7 to l7
1263 78: 7f ff ff fa call 60 <leaf_call+0x60> ; |
1264 7c: 01 00 00 00 nop ; /
1265 80: 03 00 00 00 sethi %hi(0), %g1 ; \
1266 84: 82 10 60 00 mov %g1, %g1 ! 0 <leaf_call> ; |
1267 88: c2 5d c0 01 ldx [ %l7 + %g1 ], %g1 ; | put together local union A
1268 8c: d1 00 40 00 ld [ %g1 ], %f8 ; |
1269 90: d1 27 a7 e3 st %f8, [ %fp + 0x7e3 ] ; /
1270 94: 03 00 00 00 sethi %hi(0), %g1 ; \
1271 98: 82 10 60 00 mov %g1, %g1 ! 0 <leaf_call> ; |
1272 9c: c2 5d c0 01 ldx [ %l7 + %g1 ], %g1 ; | put together local union B (only writes one val)
1273 a0: d1 00 40 00 ld [ %g1 ], %f8 ; |
1274 a4: d1 27 a7 df st %f8, [ %fp + 0x7df ] ; /
1275 a8: 03 00 00 00 sethi %hi(0), %g1 ; \
1276 ac: 82 10 60 00 mov %g1, %g1 ! 0 <leaf_call> ; |
1277 b0: c2 5d c0 01 ldx [ %l7 + %g1 ], %g1 ; | put together local union C (only writes one val)
1278 b4: d1 00 40 00 ld [ %g1 ], %f8 ; |
1279 b8: d1 27 a7 db st %f8, [ %fp + 0x7db ] ; /
1280 bc: 03 00 00 00 sethi %hi(0), %g1 ; \
1281 c0: 82 10 60 00 mov %g1, %g1 ! 0 <leaf_call> ; |
1282 c4: c2 5d c0 01 ldx [ %l7 + %g1 ], %g1 ; | put together local union D
1283 c8: d1 18 40 00 ldd [ %g1 ], %f8 ; |
1284 cc: d1 3f a7 cf std %f8, [ %fp + 0x7cf ] ; /
1285 d0: 03 00 00 00 sethi %hi(0), %g1 ; \
1286 d4: 82 10 60 00 mov %g1, %g1 ! 0 <leaf_call> ; |
1287 d8: c2 5d c0 01 ldx [ %l7 + %g1 ], %g1 ; | put together local union A (only writes one val)
1288 dc: d1 18 40 00 ldd [ %g1 ], %f8 ; |
1289 e0: d1 3f a7 c7 std %f8, [ %fp + 0x7c7 ] ; /
1290 e4: 03 00 00 00 sethi %hi(0), %g1 ; \
1291 e8: 82 10 60 00 mov %g1, %g1 ! 0 <leaf_call> ; |
1292 ec: c2 5d c0 01 ldx [ %l7 + %g1 ], %g1 ; | put together local union A (only writes one val)
1293 f0: d1 18 40 00 ldd [ %g1 ], %f8 ; |
1294 f4: d1 3f a7 bf std %f8, [ %fp + 0x7bf ] ; /
1295 f8: c2 07 a7 e3 ld [ %fp + 0x7e3 ], %g1 ; \
1296 fc: 87 30 60 00 srl %g1, 0, %g3 ; | prep arg 0
1297 100: 87 28 f0 20 sllx %g3, 0x20, %g3 ; / left-justify
1298 104: c2 5f a7 df ldx [ %fp + 0x7df ], %g1 ; \
1299 108: 85 30 70 20 srlx %g1, 0x20, %g2 ; | prep arg 1
1300 10c: 85 28 b0 20 sllx %g2, 0x20, %g2 ; /
1301 110: c2 07 a7 db ld [ %fp + 0x7db ], %g1 ; \
1302 114: 83 30 60 00 srl %g1, 0, %g1 ; | prep arg 2
1303 118: 83 28 70 20 sllx %g1, 0x20, %g1 ; /
1304 11c: c8 5f a7 cf ldx [ %fp + 0x7cf ], %g4 ; prep arg 3 | a bit pointless, could be written
1305 120: ca 5f a7 c7 ldx [ %fp + 0x7c7 ], %g5 ; prep arg 4 | directly to %o3 and %o4
1306 124: da 5f a7 bf ldx [ %fp + 0x7bf ], %o5 ; arg 5
1307 128: 90 10 00 03 mov %g3, %o0 ; arg 0 |
1308 12c: 92 10 00 02 mov %g2, %o1 ; arg 1 | note: all left-justified
1309 130: 94 10 00 01 mov %g1, %o2 ; arg 2 |
1310 134: 96 10 00 04 mov %g4, %o3 ; arg 3
1311 138: 98 10 00 05 mov %g5, %o4 ; arg 4
1312 13c: 40 00 00 00 call 13c <main+0xd0> ; call nonleaf_call (objdump not from final link but .o)
1313 140: 01 00 00 00 nop ; branch delay slot
1314 144: 82 10 20 00 clr %g1 ! 0 <leaf_call> ; \
1315 148: 83 38 60 00 sra %g1, 0, %g1 ; / return value
1316 14c: b0 10 00 01 mov %g1, %i0 ; \
1317 150: 81 cf e0 08 rett %i7 + 8 ; | epilog
1318 154: 01 00 00 00 nop ; | branch delay slot
1056 1319
1057 1320
1058 1321
1059 ; ---------- returning structs by value ----------> 1322 ; ---------- returning structs by value ---------->
1060 ; 1323 ;