authorgravatar for jacobly@ziglang.orgJacob Young <jacobly@ziglang.org> 2022-12-04 23:50:11-05:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2022-12-06 12:15:04-07:00
logce4e5fee6346d142a7a98d5c56a056ff8a25e1f1
tree94b8d22278a63ce484a09394adf0378e7f32516c
parent54b960aa4dc335a9f9c6985ac869dd88fdf2321a

wasm2c: avoid aliasing issues on memory access

1 files changed, 170 insertions(+), 212 deletions(-)

stage1/wasm2c.c+170-212
...@@ -78,7 +78,7 @@ int main(int argc, char **argv) {...@@ -78,7 +78,7 @@ int main(int argc, char **argv) {
78 }78 }
7979
80 const char *mod = "wasm";80 const char *mod = "wasm";
81 bool isBigEndian = false; // TODO81 bool is_big_endian = false; // TODO
8282
83 struct InputStream in;83 struct InputStream in;
84 InputStream_open(&in, argv[1]);84 InputStream_open(&in, argv[1]);
...@@ -95,6 +95,112 @@ int main(int argc, char **argv) {...@@ -95,6 +95,112 @@ int main(int argc, char **argv) {
95 "#include <stdint.h>\n"95 "#include <stdint.h>\n"
96 "#include <stdlib.h>\n"96 "#include <stdlib.h>\n"
97 "#include <string.h>\n"97 "#include <string.h>\n"
98 "\n", out);
99 if (is_big_endian)
100 fputs("static uint16_t i16_byteswap(uint16_t src) {\n"
101 " return (uint16_t)(uint8_t)(src >> 0) << 8 |\n"
102 " (uint16_t)(uint8_t)(src >> 8) << 0;\n"
103 "}\n"
104 "static uint32_t i32_byteswap(uint32_t src) {\n"
105 " return (uint32_t)i16_byteswap(src >> 0) << 16 |\n"
106 " (uint32_t)i16_byteswap(src >> 16) << 0;\n"
107 "}\n"
108 "static uint64_t i64_byteswap(uint64_t src) {\n"
109 " return (uint64_t)i32_byteswap(src >> 0) << 32 |\n"
110 " (uint64_t)i32_byteswap(src >> 32) << 0;\n"
111 "}\n"
112 "\n", out);
113 fputs("static uint16_t load16_align0(const uint8_t *ptr) {\n"
114 " uint16_t val;\n"
115 " memcpy(&val, ptr, sizeof(val));\n", out);
116 if (is_big_endian) fputs(" val = i16_byteswap(val);", out);
117 fputs(" return val;\n"
118 "}\n"
119 "static uint16_t load16_align1(const uint16_t *ptr) {\n"
120 " uint16_t val;\n"
121 " memcpy(&val, ptr, sizeof(val));\n", out);
122 if (is_big_endian) fputs(" val = i16_byteswap(val);", out);
123 fputs(" return val;\n"
124 "}\n"
125 "static uint32_t load32_align0(const uint8_t *ptr) {\n"
126 " uint32_t val;\n"
127 " memcpy(&val, ptr, sizeof(val));\n", out);
128 if (is_big_endian) fputs(" val = i32_byteswap(val);", out);
129 fputs(" return val;\n"
130 "}\n"
131 "static uint32_t load32_align1(const uint16_t *ptr) {\n"
132 " uint32_t val;\n"
133 " memcpy(&val, ptr, sizeof(val));\n", out);
134 if (is_big_endian) fputs(" val = i32_byteswap(val);", out);
135 fputs(" return val;\n"
136 "}\n"
137 "static uint32_t load32_align2(const uint32_t *ptr) {\n"
138 " uint32_t val;\n"
139 " memcpy(&val, ptr, sizeof(val));\n", out);
140 if (is_big_endian) fputs(" val = i32_byteswap(val);", out);
141 fputs(" return val;\n"
142 "}\n"
143 "static uint64_t load64_align0(const uint8_t *ptr) {\n"
144 " uint64_t val;\n"
145 " memcpy(&val, ptr, sizeof(val));\n", out);
146 if (is_big_endian) fputs(" val = i64_byteswap(val);", out);
147 fputs(" return val;\n"
148 "}\n"
149 "static uint64_t load64_align1(const uint16_t *ptr) {\n"
150 " uint64_t val;\n"
151 " memcpy(&val, ptr, sizeof(val));\n", out);
152 if (is_big_endian) fputs(" val = i64_byteswap(val);", out);
153 fputs(" return val;\n"
154 "}\n"
155 "static uint64_t load64_align2(const uint32_t *ptr) {\n"
156 " uint64_t val;\n"
157 " memcpy(&val, ptr, sizeof(val));\n", out);
158 if (is_big_endian) fputs(" val = i64_byteswap(val);", out);
159 fputs(" return val;\n"
160 "}\n"
161 "static uint64_t load64_align3(const uint64_t *ptr) {\n"
162 " uint64_t val;\n"
163 " memcpy(&val, ptr, sizeof(val));\n", out);
164 if (is_big_endian) fputs(" val = i64_byteswap(val);", out);
165 fputs(" return val;\n"
166 "}\n"
167 "\n"
168 "static void store16_align0(uint8_t *ptr, uint16_t val) {\n", out);
169 if (is_big_endian) fputs(" val = i16_byteswap(val);", out);
170 fputs(" memcpy(ptr, &val, sizeof(val));\n"
171 "}\n"
172 "static void store16_align1(uint16_t *ptr, uint16_t val) {\n", out);
173 if (is_big_endian) fputs(" val = i16_byteswap(val);", out);
174 fputs(" memcpy(ptr, &val, sizeof(val));\n"
175 "}\n"
176 "static void store32_align0(uint8_t *ptr, uint32_t val) {\n", out);
177 if (is_big_endian) fputs(" val = i32_byteswap(val);", out);
178 fputs(" memcpy(ptr, &val, sizeof(val));\n"
179 "}\n"
180 "static void store32_align1(uint16_t *ptr, uint32_t val) {\n", out);
181 if (is_big_endian) fputs(" val = i32_byteswap(val);", out);
182 fputs(" memcpy(ptr, &val, sizeof(val));\n"
183 "}\n"
184 "static void store32_align2(uint32_t *ptr, uint32_t val) {\n", out);
185 if (is_big_endian) fputs(" val = i32_byteswap(val);", out);
186 fputs(" memcpy(ptr, &val, sizeof(val));\n"
187 "}\n"
188 "static void store64_align0(uint8_t *ptr, uint64_t val) {\n", out);
189 if (is_big_endian) fputs(" val = i64_byteswap(val);", out);
190 fputs(" memcpy(ptr, &val, sizeof(val));\n"
191 "}\n"
192 "static void store64_align1(uint16_t *ptr, uint64_t val) {\n", out);
193 if (is_big_endian) fputs(" val = i64_byteswap(val);", out);
194 fputs(" memcpy(ptr, &val, sizeof(val));\n"
195 "}\n"
196 "static void store64_align2(uint32_t *ptr, uint64_t val) {\n", out);
197 if (is_big_endian) fputs(" val = i64_byteswap(val);", out);
198 fputs(" memcpy(ptr, &val, sizeof(val));\n"
199 "}\n"
200 "static void store64_align3(uint64_t *ptr, uint64_t val) {\n", out);
201 if (is_big_endian) fputs(" val = i64_byteswap(val);", out);
202 fputs(" memcpy(ptr, &val, sizeof(val));\n"
203 "}\n"
98 "\n"204 "\n"
99 "static uint32_t i32_reinterpret_f32(const float src) {\n"205 "static uint32_t i32_reinterpret_f32(const float src) {\n"
100 " uint32_t dst;\n"206 " uint32_t dst;\n"
...@@ -912,18 +1018,9 @@ int main(int argc, char **argv) {...@@ -912,18 +1018,9 @@ int main(int argc, char **argv) {
912 if (unreachable_depth == 0) {1018 if (unreachable_depth == 0) {
913 uint32_t base = FuncGen_stackPop(&fg);1019 uint32_t base = FuncGen_stackPop(&fg);
914 FuncGen_stackPush(&fg, out, WasmValType_i32);1020 FuncGen_stackPush(&fg, out, WasmValType_i32);
915 if (align < 2 || isBigEndian) {1021 fprintf(out, "load32_align%" PRIu32 "((const uint%" PRIu32 "_t *)&m%" PRIu32
916 fseek(out, -1, SEEK_CUR);1022 "[l%" PRIu32 " + UINT32_C(%" PRIu32 ")]);\n",
917 fputc('\n', out);1023 align, 8 << align, 0, base, offset);
918 for (uint8_t byte_i = 0; byte_i < 4; byte_i += 1) {
919 if (byte_i > 0) fputs(" |\n", out);
920 FuncGen_cont(&fg, out);
921 fprintf(out, "(uint32_t)m%" PRIu32 "[l%" PRIu32 " + UINT32_C(%"
922 PRIu32 ")] << %2u", 0, base, offset + byte_i, byte_i << 3);
923 }
924 } else fprintf(out, "*(const uint32_t *)&m%" PRIu32 "[l%" PRIu32
925 " + UINT32_C(%" PRIu32 ")]", 0, base, offset);
926 fputs(";\n", out);
927 }1024 }
928 break;1025 break;
929 }1026 }
...@@ -933,18 +1030,9 @@ int main(int argc, char **argv) {...@@ -933,18 +1030,9 @@ int main(int argc, char **argv) {
933 if (unreachable_depth == 0) {1030 if (unreachable_depth == 0) {
934 uint32_t base = FuncGen_stackPop(&fg);1031 uint32_t base = FuncGen_stackPop(&fg);
935 FuncGen_stackPush(&fg, out, WasmValType_i64);1032 FuncGen_stackPush(&fg, out, WasmValType_i64);
936 if (align < 3 || isBigEndian) {1033 fprintf(out, "load64_align%" PRIu32 "((const uint%" PRIu32 "_t *)&m%" PRIu32
937 fseek(out, -1, SEEK_CUR);1034 "[l%" PRIu32 " + UINT32_C(%" PRIu32 ")]);\n",
938 fputc('\n', out);1035 align, 8 << align, 0, base, offset);
939 for (uint8_t byte_i = 0; byte_i < 8; byte_i += 1) {
940 if (byte_i > 0) fputs(" |\n", out);
941 FuncGen_cont(&fg, out);
942 fprintf(out, "(uint64_t)m%" PRIu32 "[l%" PRIu32 " + UINT32_C(%"
943 PRIu32 ")] << %2u", 0, base, offset + byte_i, byte_i << 3);
944 }
945 } else fprintf(out, "*(const uint64_t *)&m%" PRIu32 "[l%" PRIu32
946 " + UINT32_C(%" PRIu32 ")]", 0, base, offset);
947 fputs(";\n", out);
948 }1036 }
949 break;1037 break;
950 }1038 }
...@@ -954,18 +1042,9 @@ int main(int argc, char **argv) {...@@ -954,18 +1042,9 @@ int main(int argc, char **argv) {
954 if (unreachable_depth == 0) {1042 if (unreachable_depth == 0) {
955 uint32_t base = FuncGen_stackPop(&fg);1043 uint32_t base = FuncGen_stackPop(&fg);
956 FuncGen_stackPush(&fg, out, WasmValType_f32);1044 FuncGen_stackPush(&fg, out, WasmValType_f32);
957 if (align < 2 || isBigEndian) {1045 fprintf(out, "f32_reinterpret_i32(load32_align%" PRIu32 "((const uint%" PRIu32
958 fputs("f32_reinterpret_i32(\n", out);1046 "_t *)&m%" PRIu32 "[l%" PRIu32 " + UINT32_C(%" PRIu32 ")]));\n",
959 for (uint8_t byte_i = 0; byte_i < 4; byte_i += 1) {1047 align, 8 << align, 0, base, offset);
960 if (byte_i > 0) fputs(" |\n", out);
961 FuncGen_cont(&fg, out);
962 fprintf(out, "(uint32_t)m%" PRIu32 "[l%" PRIu32 " + UINT32_C(%"
963 PRIu32 ")] << %2u", 0, base, offset + byte_i, byte_i << 3);
964 }
965 fputc(')', out);
966 } else fprintf(out, "*(const float *)&m%" PRIu32 "[l%" PRIu32
967 " + UINT32_C(%" PRIu32 ")]", 0, base, offset);
968 fputs(";\n", out);
969 }1048 }
970 break;1049 break;
971 }1050 }
...@@ -975,18 +1054,9 @@ int main(int argc, char **argv) {...@@ -975,18 +1054,9 @@ int main(int argc, char **argv) {
975 if (unreachable_depth == 0) {1054 if (unreachable_depth == 0) {
976 uint32_t base = FuncGen_stackPop(&fg);1055 uint32_t base = FuncGen_stackPop(&fg);
977 FuncGen_stackPush(&fg, out, WasmValType_f64);1056 FuncGen_stackPush(&fg, out, WasmValType_f64);
978 if (align < 3 || isBigEndian) {1057 fprintf(out, "f64_reinterpret_i64(load64_align%" PRIu32 "((const uint%" PRIu32
979 fputs("f64_reinterpret_i64(\n", out);1058 "_t *)&m%" PRIu32 "[l%" PRIu32 " + UINT32_C(%" PRIu32 ")]));\n",
980 for (uint8_t byte_i = 0; byte_i < 8; byte_i += 1) {1059 align, 8 << align, 0, base, offset);
981 if (byte_i > 0) fputs(" |\n", out);
982 FuncGen_cont(&fg, out);
983 fprintf(out, "(uint64_t)m%" PRIu32 "[l%" PRIu32 " + UINT32_C(%"
984 PRIu32 ")] << %2u", 0, base, offset + byte_i, byte_i << 3);
985 }
986 fputc(')', out);
987 } else fprintf(out, "*(const double *)&m%" PRIu32 "[l%" PRIu32
988 " + UINT32_C(%" PRIu32 ")]", 0, base, offset);
989 fputs(";\n", out);
990 }1060 }
991 break;1061 break;
992 }1062 }
...@@ -1018,18 +1088,9 @@ int main(int argc, char **argv) {...@@ -1018,18 +1088,9 @@ int main(int argc, char **argv) {
1018 if (unreachable_depth == 0) {1088 if (unreachable_depth == 0) {
1019 uint32_t base = FuncGen_stackPop(&fg);1089 uint32_t base = FuncGen_stackPop(&fg);
1020 FuncGen_stackPush(&fg, out, WasmValType_i32);1090 FuncGen_stackPush(&fg, out, WasmValType_i32);
1021 if (align < 1 || isBigEndian) {1091 fprintf(out, "(int16_t)load16_align%" PRIu32 "((const uint%" PRIu32 "_t *)&m%"
1022 fputs("(int16_t)(\n", out);1092 PRIu32 "[l%" PRIu32 " + UINT32_C(%" PRIu32 ")]);\n",
1023 for (uint8_t byte_i = 0; byte_i < 2; byte_i += 1) {1093 align, 8 << align, 0, base, offset);
1024 if (byte_i > 0) fputs(" |\n", out);
1025 FuncGen_cont(&fg, out);
1026 fprintf(out, "(uint16_t)m%" PRIu32 "[l%" PRIu32 " + UINT32_C(%"
1027 PRIu32 ")] << %2u", 0, base, offset + byte_i, byte_i << 3);
1028 }
1029 fputc(')', out);
1030 } else fprintf(out, "*(const int16_t *)&m%" PRIu32 "[l%" PRIu32
1031 " + UINT32_C(%" PRIu32 ")]", 0, base, offset);
1032 fputs(";\n", out);
1033 }1094 }
1034 break;1095 break;
1035 }1096 }
...@@ -1039,18 +1100,9 @@ int main(int argc, char **argv) {...@@ -1039,18 +1100,9 @@ int main(int argc, char **argv) {
1039 if (unreachable_depth == 0) {1100 if (unreachable_depth == 0) {
1040 uint32_t base = FuncGen_stackPop(&fg);1101 uint32_t base = FuncGen_stackPop(&fg);
1041 FuncGen_stackPush(&fg, out, WasmValType_i32);1102 FuncGen_stackPush(&fg, out, WasmValType_i32);
1042 if (align < 1 || isBigEndian) {1103 fprintf(out, "load16_align%" PRIu32 "((const uint%" PRIu32 "_t *)&m%"
1043 fseek(out, -1, SEEK_CUR);1104 PRIu32 "[l%" PRIu32 " + UINT32_C(%" PRIu32 ")]);\n",
1044 fputc('\n', out);1105 align, 8 << align, 0, base, offset);
1045 for (uint8_t byte_i = 0; byte_i < 2; byte_i += 1) {
1046 if (byte_i > 0) fputs(" |\n", out);
1047 FuncGen_cont(&fg, out);
1048 fprintf(out, "(uint16_t)m%" PRIu32 "[l%" PRIu32 " + UINT32_C(%"
1049 PRIu32 ")] << %2u", 0, base, offset + byte_i, byte_i << 3);
1050 }
1051 } else fprintf(out, "*(const uint16_t *)&m%" PRIu32 "[l%" PRIu32
1052 " + UINT32_C(%" PRIu32 ")]", 0, base, offset);
1053 fputs(";\n", out);
1054 }1106 }
1055 break;1107 break;
1056 }1108 }
...@@ -1082,18 +1134,9 @@ int main(int argc, char **argv) {...@@ -1082,18 +1134,9 @@ int main(int argc, char **argv) {
1082 if (unreachable_depth == 0) {1134 if (unreachable_depth == 0) {
1083 uint32_t base = FuncGen_stackPop(&fg);1135 uint32_t base = FuncGen_stackPop(&fg);
1084 FuncGen_stackPush(&fg, out, WasmValType_i64);1136 FuncGen_stackPush(&fg, out, WasmValType_i64);
1085 if (align < 1 || isBigEndian) {1137 fprintf(out, "(int16_t)load16_align%" PRIu32 "((const uint%" PRIu32 "_t *)&m%"
1086 fputs("(int16_t)(\n", out);1138 PRIu32 "[l%" PRIu32 " + UINT32_C(%" PRIu32 ")]);\n",
1087 for (uint8_t byte_i = 0; byte_i < 2; byte_i += 1) {1139 align, 8 << align, 0, base, offset);
1088 if (byte_i > 0) fputs(" |\n", out);
1089 FuncGen_cont(&fg, out);
1090 fprintf(out, "(uint16_t)m%" PRIu32 "[l%" PRIu32 " + UINT32_C(%"
1091 PRIu32 ")] << %2u", 0, base, offset + byte_i, byte_i << 3);
1092 }
1093 fputc(')', out);
1094 } else fprintf(out, "*(const int16_t *)&m%" PRIu32 "[l%" PRIu32
1095 " + UINT32_C(%" PRIu32 ")]", 0, base, offset);
1096 fputs(";\n", out);
1097 }1140 }
1098 break;1141 break;
1099 }1142 }
...@@ -1103,18 +1146,9 @@ int main(int argc, char **argv) {...@@ -1103,18 +1146,9 @@ int main(int argc, char **argv) {
1103 if (unreachable_depth == 0) {1146 if (unreachable_depth == 0) {
1104 uint32_t base = FuncGen_stackPop(&fg);1147 uint32_t base = FuncGen_stackPop(&fg);
1105 FuncGen_stackPush(&fg, out, WasmValType_i64);1148 FuncGen_stackPush(&fg, out, WasmValType_i64);
1106 if (align < 1 || isBigEndian) {1149 fprintf(out, "load16_align%" PRIu32 "((const uint%" PRIu32 "_t *)&m%"
1107 fseek(out, -1, SEEK_CUR);1150 PRIu32 "[l%" PRIu32 " + UINT32_C(%" PRIu32 ")]);\n",
1108 fputc('\n', out);1151 align, 8 << align, 0, base, offset);
1109 for (uint8_t byte_i = 0; byte_i < 2; byte_i += 1) {
1110 if (byte_i > 0) fputs(" |\n", out);
1111 FuncGen_cont(&fg, out);
1112 fprintf(out, "(uint16_t)m%" PRIu32 "[l%" PRIu32 " + UINT32_C(%"
1113 PRIu32 ")] << %2u", 0, base, offset + byte_i, byte_i << 3);
1114 }
1115 } else fprintf(out, "*(const uint16_t *)&m%" PRIu32 "[l%" PRIu32
1116 " + UINT32_C(%" PRIu32 ")]", 0, base, offset);
1117 fputs(";\n", out);
1118 }1152 }
1119 break;1153 break;
1120 }1154 }
...@@ -1124,18 +1158,9 @@ int main(int argc, char **argv) {...@@ -1124,18 +1158,9 @@ int main(int argc, char **argv) {
1124 if (unreachable_depth == 0) {1158 if (unreachable_depth == 0) {
1125 uint32_t base = FuncGen_stackPop(&fg);1159 uint32_t base = FuncGen_stackPop(&fg);
1126 FuncGen_stackPush(&fg, out, WasmValType_i64);1160 FuncGen_stackPush(&fg, out, WasmValType_i64);
1127 if (align < 2 || isBigEndian) {1161 fprintf(out, "(int32_t)load32_align%" PRIu32 "((const uint%" PRIu32 "_t *)&m%"
1128 fputs("(int32_t)(\n", out);1162 PRIu32 "[l%" PRIu32 " + UINT32_C(%" PRIu32 ")]);\n",
1129 for (uint8_t byte_i = 0; byte_i < 4; byte_i += 1) {1163 align, 8 << align, 0, base, offset);
1130 if (byte_i > 0) fputs(" |\n", out);
1131 FuncGen_cont(&fg, out);
1132 fprintf(out, "(uint32_t)m%" PRIu32 "[l%" PRIu32 " + UINT32_C(%"
1133 PRIu32 ")] << %2u", 0, base, offset + byte_i, byte_i << 3);
1134 }
1135 fputc(')', out);
1136 } else fprintf(out, "*(const int32_t *)&m%" PRIu32 "[l%" PRIu32
1137 " + UINT32_C(%" PRIu32 ")]", 0, base, offset);
1138 fputs(";\n", out);
1139 }1164 }
1140 break;1165 break;
1141 }1166 }
...@@ -1145,18 +1170,9 @@ int main(int argc, char **argv) {...@@ -1145,18 +1170,9 @@ int main(int argc, char **argv) {
1145 if (unreachable_depth == 0) {1170 if (unreachable_depth == 0) {
1146 uint32_t base = FuncGen_stackPop(&fg);1171 uint32_t base = FuncGen_stackPop(&fg);
1147 FuncGen_stackPush(&fg, out, WasmValType_i64);1172 FuncGen_stackPush(&fg, out, WasmValType_i64);
1148 if (align < 2 || isBigEndian) {1173 fprintf(out, "load32_align%" PRIu32 "((const uint%" PRIu32 "_t *)&m%"
1149 fseek(out, -1, SEEK_CUR);1174 PRIu32 "[l%" PRIu32 " + UINT32_C(%" PRIu32 ")]);\n",
1150 fputc('\n', out);1175 align, 8 << align, 0, base, offset);
1151 for (uint8_t byte_i = 0; byte_i < 4; byte_i += 1) {
1152 if (byte_i > 0) fputs(" |\n", out);
1153 FuncGen_cont(&fg, out);
1154 fprintf(out, "(uint32_t)m%" PRIu32 "[l%" PRIu32 " + UINT32_C(%"
1155 PRIu32 ")] << %2u", 0, base, offset + byte_i, byte_i << 3);
1156 }
1157 } else fprintf(out, "*(const uint32_t *)&m%" PRIu32 "[l%" PRIu32
1158 " + UINT32_C(%" PRIu32 ")]", 0, base, offset);
1159 fputs(";\n", out);
1160 }1176 }
1161 break;1177 break;
1162 }1178 }
...@@ -1167,19 +1183,10 @@ int main(int argc, char **argv) {...@@ -1167,19 +1183,10 @@ int main(int argc, char **argv) {
1167 if (unreachable_depth == 0) {1183 if (unreachable_depth == 0) {
1168 uint32_t value = FuncGen_stackPop(&fg);1184 uint32_t value = FuncGen_stackPop(&fg);
1169 uint32_t base = FuncGen_stackPop(&fg);1185 uint32_t base = FuncGen_stackPop(&fg);
1170 if (align < 2 || isBigEndian) {1186 FuncGen_indent(&fg, out);
1171 for (uint8_t byte_i = 0; byte_i < 4; byte_i += 1) {1187 fprintf(out, "store32_align%" PRIu32 "((uint%" PRIu32 "_t *)&m%"
1172 FuncGen_indent(&fg, out);1188 PRIu32 "[l%" PRIu32 " + UINT32_C(%" PRIu32 ")], l%" PRIu32 ");\n",
1173 fprintf(out, "m%" PRIu32 "[l%" PRIu32 " + UINT32_C(%" PRIu32 ")] = "1189 align, 8 << align, 0, base, offset, value);
1174 "(uint8_t)(l%" PRIu32 " >> %2u);\n",
1175 0, base, offset + byte_i, value, byte_i << 3);
1176 }
1177 } else {
1178 FuncGen_indent(&fg, out);
1179 fprintf(out, "*(uint32_t *)&m%" PRIu32 "[l%" PRIu32
1180 " + UINT32_C(%" PRIu32 ")] = l%" PRIu32 ";\n",
1181 0, base, offset, value);
1182 }
1183 }1190 }
1184 break;1191 break;
1185 }1192 }
...@@ -1189,19 +1196,10 @@ int main(int argc, char **argv) {...@@ -1189,19 +1196,10 @@ int main(int argc, char **argv) {
1189 if (unreachable_depth == 0) {1196 if (unreachable_depth == 0) {
1190 uint32_t value = FuncGen_stackPop(&fg);1197 uint32_t value = FuncGen_stackPop(&fg);
1191 uint32_t base = FuncGen_stackPop(&fg);1198 uint32_t base = FuncGen_stackPop(&fg);
1192 if (align < 3 || isBigEndian) {1199 FuncGen_indent(&fg, out);
1193 for (uint8_t byte_i = 0; byte_i < 8; byte_i += 1) {1200 fprintf(out, "store64_align%" PRIu32 "((uint%" PRIu32 "_t *)&m%"
1194 FuncGen_indent(&fg, out);1201 PRIu32 "[l%" PRIu32 " + UINT32_C(%" PRIu32 ")], l%" PRIu32 ");\n",
1195 fprintf(out, "m%" PRIu32 "[l%" PRIu32 " + UINT32_C(%" PRIu32 ")] = "1202 align, 8 << align, 0, base, offset, value);
1196 "(uint8_t)(l%" PRIu32 " >> %2u);\n",
1197 0, base, offset + byte_i, value, byte_i << 3);
1198 }
1199 } else {
1200 FuncGen_indent(&fg, out);
1201 fprintf(out, "*(uint64_t *)&m%" PRIu32 "[l%" PRIu32
1202 " + UINT32_C(%" PRIu32 ")] = l%" PRIu32 ";\n",
1203 0, base, offset, value);
1204 }
1205 }1203 }
1206 break;1204 break;
1207 }1205 }
...@@ -1211,19 +1209,11 @@ int main(int argc, char **argv) {...@@ -1211,19 +1209,11 @@ int main(int argc, char **argv) {
1211 if (unreachable_depth == 0) {1209 if (unreachable_depth == 0) {
1212 uint32_t value = FuncGen_stackPop(&fg);1210 uint32_t value = FuncGen_stackPop(&fg);
1213 uint32_t base = FuncGen_stackPop(&fg);1211 uint32_t base = FuncGen_stackPop(&fg);
1214 if (align < 2 || isBigEndian) {1212 FuncGen_indent(&fg, out);
1215 for (uint8_t byte_i = 0; byte_i < 4; byte_i += 1) {1213 fprintf(out, "store32_align%" PRIu32 "((uint%" PRIu32 "_t *)&m%"
1216 FuncGen_indent(&fg, out);1214 PRIu32 "[l%" PRIu32 " + UINT32_C(%" PRIu32 ")], "
1217 fprintf(out, "m%" PRIu32 "[l%" PRIu32 " + UINT32_C(%" PRIu32 ")] = "1215 "i32_reinterpret_f32(l%" PRIu32 "));\n",
1218 "(uint8_t)(i32_reinterpret_f32(l%" PRIu32 ") >> %2u);\n",1216 align, 8 << align, 0, base, offset, value);
1219 0, base, offset + byte_i, value, byte_i << 3);
1220 }
1221 } else {
1222 FuncGen_indent(&fg, out);
1223 fprintf(out, "*(float *)&m%" PRIu32 "[l%" PRIu32
1224 " + UINT32_C(%" PRIu32 ")] = l%" PRIu32 ";\n",
1225 0, base, offset, value);
1226 }
1227 }1217 }
1228 break;1218 break;
1229 }1219 }
...@@ -1233,19 +1223,11 @@ int main(int argc, char **argv) {...@@ -1233,19 +1223,11 @@ int main(int argc, char **argv) {
1233 if (unreachable_depth == 0) {1223 if (unreachable_depth == 0) {
1234 uint32_t value = FuncGen_stackPop(&fg);1224 uint32_t value = FuncGen_stackPop(&fg);
1235 uint32_t base = FuncGen_stackPop(&fg);1225 uint32_t base = FuncGen_stackPop(&fg);
1236 if (align < 3 || isBigEndian) {1226 FuncGen_indent(&fg, out);
1237 for (uint8_t byte_i = 0; byte_i < 8; byte_i += 1) {1227 fprintf(out, "store64_align%" PRIu32 "((uint%" PRIu32 "_t *)&m%"
1238 FuncGen_indent(&fg, out);1228 PRIu32 "[l%" PRIu32 " + UINT32_C(%" PRIu32 ")], "
1239 fprintf(out, "m%" PRIu32 "[l%" PRIu32 " + UINT32_C(%" PRIu32 ")] = "1229 "i64_reinterpret_f64(l%" PRIu32 "));\n",
1240 "(uint8_t)(i64_reinterpret_f64(l%" PRIu32 ") >> %2u);\n",1230 align, 8 << align, 0, base, offset, value);
1241 0, base, offset + byte_i, value, byte_i << 3);
1242 }
1243 } else {
1244 FuncGen_indent(&fg, out);
1245 fprintf(out, "*(double *)&m%" PRIu32 "[l%" PRIu32
1246 " + UINT32_C(%" PRIu32 ")] = l%" PRIu32 ";\n",
1247 0, base, offset, value);
1248 }
1249 }1231 }
1250 break;1232 break;
1251 }1233 }
...@@ -1267,19 +1249,11 @@ int main(int argc, char **argv) {...@@ -1267,19 +1249,11 @@ int main(int argc, char **argv) {
1267 if (unreachable_depth == 0) {1249 if (unreachable_depth == 0) {
1268 uint32_t value = FuncGen_stackPop(&fg);1250 uint32_t value = FuncGen_stackPop(&fg);
1269 uint32_t base = FuncGen_stackPop(&fg);1251 uint32_t base = FuncGen_stackPop(&fg);
1270 if (align < 1 || isBigEndian) {1252 FuncGen_indent(&fg, out);
1271 for (uint8_t byte_i = 0; byte_i < 2; byte_i += 1) {1253 fprintf(out, "store16_align%" PRIu32 "((uint%" PRIu32 "_t *)&m%"
1272 FuncGen_indent(&fg, out);1254 PRIu32 "[l%" PRIu32 " + UINT32_C(%" PRIu32 ")], "
1273 fprintf(out, "m%" PRIu32 "[l%" PRIu32 " + UINT32_C(%" PRIu32 ")] = "1255 "(uint16_t)l%" PRIu32 ");\n",
1274 "(uint8_t)(l%" PRIu32 " >> %2u);\n",1256 align, 8 << align, 0, base, offset, value);
1275 0, base, offset + byte_i, value, byte_i << 3);
1276 }
1277 } else {
1278 FuncGen_indent(&fg, out);
1279 fprintf(out, "*(uint16_t *)&m%" PRIu32 "[l%" PRIu32
1280 " + UINT32_C(%" PRIu32 ")] = (uint16_t)l%" PRIu32 ";\n",
1281 0, base, offset, value);
1282 }
1283 }1257 }
1284 break;1258 break;
1285 }1259 }
...@@ -1301,19 +1275,11 @@ int main(int argc, char **argv) {...@@ -1301,19 +1275,11 @@ int main(int argc, char **argv) {
1301 if (unreachable_depth == 0) {1275 if (unreachable_depth == 0) {
1302 uint32_t value = FuncGen_stackPop(&fg);1276 uint32_t value = FuncGen_stackPop(&fg);
1303 uint32_t base = FuncGen_stackPop(&fg);1277 uint32_t base = FuncGen_stackPop(&fg);
1304 if (align < 1 || isBigEndian) {1278 FuncGen_indent(&fg, out);
1305 for (uint8_t byte_i = 0; byte_i < 2; byte_i += 1) {1279 fprintf(out, "store16_align%" PRIu32 "((uint%" PRIu32 "_t *)&m%"
1306 FuncGen_indent(&fg, out);1280 PRIu32 "[l%" PRIu32 " + UINT32_C(%" PRIu32 ")], "
1307 fprintf(out, "m%" PRIu32 "[l%" PRIu32 " + UINT32_C(%" PRIu32 ")] = "1281 "(uint16_t)l%" PRIu32 ");\n",
1308 "(uint8_t)(l%" PRIu32 " >> %2u);\n",1282 align, 8 << align, 0, base, offset, value);
1309 0, base, offset + byte_i, value, byte_i << 3);
1310 }
1311 } else {
1312 FuncGen_indent(&fg, out);
1313 fprintf(out, "*(uint16_t *)&m%" PRIu32 "[l%" PRIu32
1314 " + UINT32_C(%" PRIu32 ")] = (uint16_t)l%" PRIu32 ";\n",
1315 0, base, offset, value);
1316 }
1317 }1283 }
1318 break;1284 break;
1319 }1285 }
...@@ -1323,19 +1289,11 @@ int main(int argc, char **argv) {...@@ -1323,19 +1289,11 @@ int main(int argc, char **argv) {
1323 if (unreachable_depth == 0) {1289 if (unreachable_depth == 0) {
1324 uint32_t value = FuncGen_stackPop(&fg);1290 uint32_t value = FuncGen_stackPop(&fg);
1325 uint32_t base = FuncGen_stackPop(&fg);1291 uint32_t base = FuncGen_stackPop(&fg);
1326 if (align < 2 || isBigEndian) {1292 FuncGen_indent(&fg, out);
1327 for (uint8_t byte_i = 0; byte_i < 4; byte_i += 1) {1293 fprintf(out, "store32_align%" PRIu32 "((uint%" PRIu32 "_t *)&m%"
1328 FuncGen_indent(&fg, out);1294 PRIu32 "[l%" PRIu32 " + UINT32_C(%" PRIu32 ")], "
1329 fprintf(out, "m%" PRIu32 "[l%" PRIu32 " + UINT32_C(%" PRIu32 ")] = "1295 "(uint32_t)l%" PRIu32 ");\n",
1330 "(uint8_t)(l%" PRIu32 " >> %2u);\n",1296 align, 8 << align, 0, base, offset, value);
1331 0, base, offset + byte_i, value, byte_i << 3);
1332 }
1333 } else {
1334 FuncGen_indent(&fg, out);
1335 fprintf(out, "*(uint32_t *)&m%" PRIu32 "[l%" PRIu32
1336 " + UINT32_C(%" PRIu32 ")] = (uint32_t)l%" PRIu32 ";\n",
1337 0, base, offset, value);
1338 }
1339 }1297 }
1340 break;1298 break;
1341 }1299 }