internal.h (19519B)
1 #ifndef KIT_CG_INTERNAL_H 2 #define KIT_CG_INTERNAL_H 3 4 #include <kit/cg.h> 5 #include <stdarg.h> 6 #include <stdint.h> 7 #include <stdio.h> 8 #include <string.h> 9 10 #include "abi/abi.h" 11 #include "asm/asm.h" 12 #include "cg/type.h" 13 #include "core/arena.h" 14 #include "core/heap.h" 15 #include "core/pool.h" 16 #include "core/segvec.h" 17 #include "core/slice.h" 18 #include "core/strbuf.h" 19 #include "debug/debug.h" 20 #include "obj/obj.h" 21 22 typedef struct CgTarget CgTarget; 23 typedef uint32_t ObjSymId; 24 25 typedef enum SResidency { 26 RES_INHERENT, 27 RES_LOCAL, 28 RES_FIXED_LOCAL, 29 } SResidency; 30 31 typedef enum ApiSValueKind { 32 SV_OPERAND, 33 SV_CMP, 34 SV_ARITH, 35 } ApiSValueKind; 36 37 typedef enum ApiDelayedArithKind { 38 API_DELAYED_UNOP, 39 API_DELAYED_BINOP, 40 } ApiDelayedArithKind; 41 42 typedef struct ApiDelayedCmp { 43 Operand a; 44 Operand b; 45 CmpOp op; 46 u8 a_owned; 47 u8 b_owned; 48 u8 pad[2]; 49 } ApiDelayedCmp; 50 51 typedef struct ApiDelayedArith { 52 Operand a; 53 Operand b; 54 BinOp bin_op; 55 UnOp un_op; 56 u8 kind; 57 u8 a_owned; 58 u8 b_owned; 59 u8 pad; 60 } ApiDelayedArith; 61 62 /* Bit-field geometry carried by a bit-field PLACE. `kit_cg_field` fills this 63 * from the record layout when it projects to a bit-field; a plain load/store on 64 * the carrying place then performs the extract/insert. The storage MemAccess is 65 * rebuilt from the place operand + field type at load/store time, so only the 66 * bit geometry needs to ride on the place. width == 0 means "not a bit-field". 67 */ 68 typedef struct ApiBitField { 69 u16 bit_offset; /* target-endian bit offset within the storage unit */ 70 u16 bit_width; /* 0 => the place is not a bit-field place */ 71 u32 bit_storage_size; /* storage-unit size in bytes */ 72 u8 bit_signed; /* signed extraction on load */ 73 u8 pad[3]; 74 } ApiBitField; 75 76 typedef struct ApiSValue { 77 Operand op; 78 union { 79 ApiDelayedCmp cmp; 80 ApiDelayedArith arith; 81 } delayed; 82 KitCgTypeId type; 83 u8 kind; 84 u8 res; 85 u8 pinned; 86 u8 lvalue; 87 KitCgLocal source_local; 88 ApiBitField bitfield; /* bit_width != 0 marks a bit-field PLACE subkind */ 89 } ApiSValue; 90 91 #define API_CG_STACK_INITIAL 16u 92 93 /* Largest scalar the codegen lowers as a native (lock-free) atomic. All 94 * current targets — aa64, x64, rv64, wasm32 — provide 8-byte (i64-width) 95 * atomics, so this is both the legality ceiling and the lock-free ceiling. 96 * Note it is NOT the pointer width: wasm32 has 4-byte pointers but 8-byte 97 * atomics. */ 98 #define CG_MAX_ATOMIC_SIZE 8u 99 100 typedef struct ApiCgScope { 101 Label break_lbl; 102 Label continue_lbl; 103 CGScope target_scope; 104 KitCgTypeId result_type; 105 CGLocal result_local; 106 u32 generation; 107 u8 active; 108 u8 pad[3]; 109 } ApiCgScope; 110 111 #define API_CG_MAX_SCOPES 64 112 113 typedef enum ApiSourceLocalKind { 114 API_SOURCE_LOCAL_AUTO, 115 API_SOURCE_LOCAL_PARAM, 116 } ApiSourceLocalKind; 117 118 typedef struct ApiSourceLocal { 119 KitCgTypeId type; 120 KitSym name; 121 KitCgLocalAttrs attrs; 122 SrcLoc loc; 123 CGLocalDesc desc; 124 CGLocal storage; 125 i64 const_value; 126 u32 param_index; 127 u8 kind; 128 u8 const_valid; 129 u8 pad[2]; 130 } ApiSourceLocal; 131 132 struct KitCg { 133 Compiler* c; 134 ObjBuilder* obj; 135 CgTarget* target; 136 Debug* debug; 137 KitCgUnitOptions cur_unit; 138 u32 nsource_units; 139 /* Monotonic, nonzero per source unit (set at kit_cg_begin_unit). Used to tell 140 * a same-TU re-definition (legal tentative-definition coalescing) apart from a 141 * genuine cross-TU contribution that must go through symresolve_merge. */ 142 u32 cur_unit_seq; 143 u8 unit_active; 144 u8 finished; 145 u8 lifecycle_pad[2]; 146 147 ApiSValue* stack; 148 u32 sp; 149 u32 cap; 150 151 ApiSourceLocal* locals; 152 u32 nlocals; 153 u32 locals_cap; 154 155 KitCgTypeId fn_ret_type; /* KIT_CG_TYPE_NONE/void == no result */ 156 SrcLoc cur_loc; 157 158 CGFuncDesc fn_desc; 159 CGParamDesc fn_params[64]; 160 161 KitCgTypeId* sym_types; 162 KitCgDecl* sym_attrs; 163 u32 sym_cap; 164 165 /* Per-ObjSymId: the cur_unit_seq of the unit that last *defined* this symbol 166 * (0 = not defined by any unit yet). Distinct from sym_attrs, which is reset 167 * on every decl; this is written only when a definition is emitted. */ 168 u32* sym_def_seq; 169 u32 sym_def_seq_cap; 170 171 ApiCgScope scopes[API_CG_MAX_SCOPES]; 172 u32 nscopes; 173 u32 scope_generation; 174 175 u32 rodata_counter; 176 int opt_level; 177 u8 check_only; 178 u8 function_sections; 179 u8 data_sections; 180 u8 section_pad[1]; 181 182 ObjSecId data_sec; 183 ObjSymId data_sym; 184 u32 data_base; 185 u64 data_size; 186 u8 data_local_static_target; 187 u8 data_atomize; 188 u8 data_retain; 189 u8 data_discard; 190 u8 data_tls_collect; 191 u8 data_tls_zero_fill; 192 u8 data_tls_pad[2]; 193 u32 data_tls_align; 194 Buf data_tls_bytes; 195 ObjTlsReloc* data_tls_relocs; 196 u32 data_tls_nrelocs; 197 u32 data_tls_relocs_cap; 198 }; 199 200 void cg_api_fini(Compiler*); 201 202 void api_cg_binop(KitCg* g, BinOp iop, u32 flags); 203 void api_cg_unop(KitCg* g, UnOp iop, u32 flags); 204 void api_cg_cmp(KitCg* g, CmpOp cop); 205 void api_cg_convert_kind(KitCg* g, KitCgTypeId dst_type, ConvKind ck); 206 void kit_cg_int_binop(KitCg* g, KitCgIntBinOp op, uint32_t flags); 207 void kit_cg_int_unop(KitCg* g, KitCgIntUnOp op, uint32_t flags); 208 void kit_cg_int_cmp(KitCg* g, KitCgIntCmpOp op); 209 const char* api_i128_binop_helper(BinOp op); 210 int api_i128_cmp_is_unsigned(CmpOp op); 211 const char* api_f128_binop_helper(KitCgFpBinOp op); 212 int api_f128_stack_top(KitCg* g, u32 depth); 213 void api_f128_call_unary(KitCg* g, const char* name, KitCgTypeId ret, 214 KitCgTypeId param); 215 void kit_cg_fp_binop(KitCg* g, KitCgFpBinOp op, uint32_t flags); 216 void kit_cg_fp_unop(KitCg* g, KitCgFpUnOp op, uint32_t flags); 217 void kit_cg_fp_cmp(KitCg* g, KitCgFpCmpOp op); 218 void kit_cg_sext(KitCg* g, KitCgTypeId dst); 219 void kit_cg_zext(KitCg* g, KitCgTypeId dst); 220 void kit_cg_trunc(KitCg* g, KitCgTypeId dst); 221 void kit_cg_ptr_to_int(KitCg* g, KitCgTypeId dst); 222 void kit_cg_int_to_ptr(KitCg* g, KitCgTypeId dst); 223 void kit_cg_bitcast(KitCg* g, KitCgTypeId dst); 224 void kit_cg_fpext(KitCg* g, KitCgTypeId dst); 225 void kit_cg_fptrunc(KitCg* g, KitCgTypeId dst); 226 void kit_cg_sint_to_float(KitCg* g, KitCgTypeId dst, KitCgRounding rounding); 227 void kit_cg_uint_to_float(KitCg* g, KitCgTypeId dst, KitCgRounding rounding); 228 void kit_cg_float_to_sint(KitCg* g, KitCgTypeId dst, KitCgRounding rounding); 229 void kit_cg_float_to_uint(KitCg* g, KitCgTypeId dst, KitCgRounding rounding); 230 IntrinKind api_map_intrinsic(KitCg* g, KitCgIntrinsic intrin, 231 KitCgTypeId result_type); 232 int api_intrinsic_is_void(KitCgIntrinsic intrin); 233 int api_intrinsic_is_overflow(KitCgIntrinsic intrin); 234 const char* api_intrinsic_name(KitCgIntrinsic intrin); 235 void kit_cg_intrinsic(KitCg* g, KitCgIntrinsic intrin, uint32_t nargs, 236 KitCgTypeId result_type); 237 KitCgTypeId api_atomic_pointee(KitCg* g, KitCgTypeId pty, const char* who); 238 const char* api_sym_cstr(KitCg* g, KitSym sym); 239 int api_asm_parse_match_index(const char* s); 240 const char* api_asm_constraint_body(const char* s); 241 int api_asm_is_early_clobber(const char* s); 242 int api_asm_is_reg_constraint(char c); 243 void api_asm_memory_clobber_sv(KitCg* g, ApiSValue* sv, CGLocal local); 244 void kit_cg_inline_asm(KitCg* g, KitCgInlineAsm asm_block); 245 void kit_cg_file_scope_asm(KitCg* g, KitSlice asm_source); 246 MemAccess api_mem_for_atomic(KitCg* g, KitCgTypeId val_ty); 247 int kit_cg_atomic_is_legal(KitCompiler* c, KitCgMemAccess access, 248 KitCgMemOrder order); 249 int kit_cg_atomic_is_lock_free(KitCompiler* c, KitCgMemAccess access); 250 void kit_cg_atomic_load(KitCg* g, KitCgMemAccess access, KitCgMemOrder order); 251 void kit_cg_atomic_store(KitCg* g, KitCgMemAccess access, KitCgMemOrder order); 252 void kit_cg_atomic_rmw(KitCg* g, KitCgMemAccess access, KitCgAtomicOp op, 253 KitCgMemOrder order); 254 void kit_cg_atomic_cmpxchg(KitCg* g, KitCgMemAccess access, 255 KitCgMemOrder success, KitCgMemOrder failure, 256 int weak); 257 void kit_cg_atomic_fence(KitCg* g, KitCgMemOrder order); 258 CGLocal* api_alloc_call_args(KitCg* g, u32 nargs); 259 void api_pack_call_arg(KitCg* g, CGLocal* out, KitCgTypeId fty, u32 idx); 260 CGLocal api_alloc_call_result(KitCg* g, KitCgTypeId ret_ty); 261 void api_release_call_args(KitCg* g, CGLocal* args, u32 nargs); 262 void api_push_call_result(KitCg* g, CGLocal result, KitCgTypeId ret_ty); 263 void kit_cg_call(KitCg* g, uint32_t nargs, KitCgTypeId fn_type, 264 KitCgCallAttrs attrs); 265 void api_call_symbol_common(KitCg* g, KitCgSym sym, uint32_t nargs, 266 KitCgCallAttrs attrs); 267 void kit_cg_call_symbol(KitCg* g, KitCgSym sym, uint32_t nargs, 268 KitCgCallAttrs attrs); 269 void kit_cg_ret(KitCg* g); 270 KitCgLabel kit_cg_label_new(KitCg* g); 271 void kit_cg_label_place(KitCg* g, KitCgLabel label); 272 void kit_cg_jump(KitCg* g, KitCgLabel label); 273 void api_branch_if(KitCg* g, ApiSValue* v, int branch_when_true, Label label); 274 void kit_cg_branch_true(KitCg* g, KitCgLabel label); 275 void kit_cg_branch_false(KitCg* g, KitCgLabel label); 276 void kit_cg_switch(KitCg* g, KitCgSwitch sw); 277 void kit_cg_push_label_addr(KitCg* g, KitCgLabel label, KitCgTypeId ptr_type); 278 void kit_cg_computed_goto(KitCg* g, const KitCgLabel* valid_targets, 279 uint32_t ntargets); 280 281 void kit_cg_field_bits(KitCg* g, uint16_t bit_offset, uint16_t bit_width, 282 uint32_t bit_storage_size, int bit_signed); 283 void kit_cg_unreachable(KitCg* g); 284 KitCgScope api_scope_handle(u32 idx, u32 generation); 285 ApiCgScope* api_scope_from_handle(KitCg* g, KitCgScope scope, int require_top, 286 const char* who); 287 int api_scope_has_result(const ApiCgScope* s); 288 void api_scope_store_result(KitCg* g, ApiCgScope* s, ApiSValue* result); 289 void api_scope_push_result(KitCg* g, ApiCgScope* s); 290 KitCgScope kit_cg_scope_begin(KitCg* g, KitCgTypeId result_type); 291 void kit_cg_scope_end(KitCg* g, KitCgScope scope); 292 void kit_cg_break(KitCg* g, KitCgScope scope); 293 void kit_cg_break_true(KitCg* g, KitCgScope scope); 294 void kit_cg_break_false(KitCg* g, KitCgScope scope); 295 void kit_cg_continue(KitCg* g, KitCgScope scope); 296 void kit_cg_continue_true(KitCg* g, KitCgScope scope); 297 void kit_cg_continue_false(KitCg* g, KitCgScope scope); 298 void kit_cg_alloca(KitCg* g, uint32_t align, KitCgTypeId result_ptr_type); 299 void kit_cg_vararg_start(KitCg* g); 300 void kit_cg_vararg_next(KitCg* g, KitCgTypeId type); 301 void kit_cg_vararg_end(KitCg* g); 302 void kit_cg_vararg_copy(KitCg* g); 303 void kit_cg_memcpy(KitCg* g, uint64_t size, KitCgMemAccess dst_access, 304 KitCgMemAccess src_access); 305 void kit_cg_memmove(KitCg* g, uint64_t size, KitCgMemAccess dst_access, 306 KitCgMemAccess src_access); 307 void kit_cg_memset(KitCg* g, uint8_t val, uint64_t size, 308 KitCgMemAccess dst_access); 309 void kit_cg_data_begin(KitCg* g, KitCgSym cg_sym, KitCgDataDefAttrs attrs); 310 void kit_cg_data_common(KitCg* g, KitCgSym cg_sym, uint64_t size, 311 uint32_t align); 312 void kit_cg_data_align(KitCg* g, uint32_t align); 313 void kit_cg_data_pad(KitCg* g, uint64_t size, uint8_t value); 314 void kit_cg_data_int(KitCg* g, uint64_t value, KitCgTypeId type); 315 void kit_cg_data_float(KitCg* g, double value, KitCgTypeId type); 316 void kit_cg_data_bytes(KitCg* g, const uint8_t* data, size_t len); 317 void kit_cg_data_zero(KitCg* g, uint64_t size); 318 void api_cg_data_reloc(KitCg* g, KitCgSym target, int64_t addend, 319 uint32_t width, int pcrel); 320 void kit_cg_data_addr(KitCg* g, KitCgSym target, int64_t addend, uint32_t width, 321 uint32_t address_space); 322 void kit_cg_data_label_addr(KitCg* g, KitCgLabel target, int64_t addend, 323 uint32_t width, uint32_t address_space); 324 void kit_cg_data_pcrel(KitCg* g, KitCgSym target, int64_t addend, 325 uint32_t width); 326 void kit_cg_data_symdiff(KitCg* g, KitCgSym lhs, KitCgSym rhs, int64_t addend, 327 uint32_t width); 328 void kit_cg_data_end(KitCg* g); 329 ObjSymId api_emit_label_table(KitCg* g, const Label* labels, u32 n); 330 DebugTypeId api_debug_type(KitCg* g, KitCgTypeId id); 331 int api_local_requires_memory(KitCg* g, KitCgTypeId ty, KitCgLocalAttrs attrs); 332 KitCgLocal api_local_handle(u32 index); 333 int api_grow_locals(KitCg* g, u32 want); 334 ApiSourceLocal* api_local_from_handle(KitCg* g, KitCgLocal local); 335 CGLocal api_frame_local_storage(KitCg* g, const CGLocalDesc* d); 336 KitCgLocal kit_cg_local(KitCg* g, KitCgTypeId type, KitCgLocalAttrs attrs); 337 KitCgLocal kit_cg_param(KitCg* g, uint32_t index, KitCgTypeId type, 338 KitCgLocalAttrs attrs); 339 void kit_cg_push_int(KitCg* g, uint64_t value, KitCgTypeId type); 340 void kit_cg_push_float(KitCg* g, double value, KitCgTypeId type); 341 void kit_cg_push_null(KitCg* g, KitCgTypeId ptr_type); 342 KitCgSym kit_cg_const_data(KitCg* g, const uint8_t* data, size_t len, 343 uint32_t align, KitCgTypeId pointee_type); 344 void api_push_local_lvalue(KitCg* g, CGLocal local, KitCgTypeId type); 345 void api_push_source_local_lvalue(KitCg* g, KitCgLocal local, CGLocal storage, 346 KitCgTypeId type); 347 void kit_cg_push_local(KitCg* g, KitCgLocal local); 348 void kit_cg_push_local_addr(KitCg* g, KitCgLocal local); 349 void kit_cg_push_symbol_addr(KitCg* g, KitCgSym sym, int64_t addend); 350 void kit_cg_load(KitCg* g, KitCgMemAccess access); 351 void kit_cg_addr(KitCg* g); 352 void kit_cg_deref(KitCg* g, int64_t offset); 353 void kit_cg_store(KitCg* g, KitCgMemAccess access); 354 void kit_cg_dup(KitCg* g); 355 void kit_cg_dup2(KitCg* g); 356 void kit_cg_swap(KitCg* g); 357 void kit_cg_drop(KitCg* g); 358 int kit_cg_top_const_int(KitCg* g, int64_t* out_value); 359 void kit_cg_rot3(KitCg* g); 360 KitStatus kit_cg_new(KitCompiler* c, KitCg** cg_out); 361 KitStatus kit_cg_begin(KitCg* g, KitObjBuilder* out, 362 const KitCodeOptions* opts); 363 KitStatus kit_cg_begin_unit(KitCg* g, const KitCgUnitOptions* opts); 364 KitStatus kit_cg_end_unit(KitCg* g); 365 KitStatus kit_cg_finish(KitCg* g, const KitCgFinishOptions* opts); 366 KitStatus kit_cg_detach(KitCg* g); 367 KitStatus kit_cg_abort(KitCg* g); 368 void kit_cg_free(KitCg* g); 369 void kit_cg_set_loc(KitCg* g, KitSrcLoc loc); 370 KitCgSym kit_cg_decl(KitCg* g, KitCgDecl decl); 371 KitCgSym kit_cg_alias(KitCg* g, KitCgAlias alias); 372 void kit_cg_func_begin(KitCg* g, KitCgSym cg_sym); 373 void kit_cg_func_begin_attrs(KitCg* g, KitCgSym cg_sym, KitCgFuncAttrs attrs); 374 void kit_cg_func_end(KitCg* g); 375 SymBind api_map_bind(KitSymBind b); 376 SymVis api_map_vis(KitCgVisibility v); 377 SymKind api_decl_sym_kind(KitCgDecl decl); 378 Sym api_cg_symbol_section_name(KitCg* g, Slice base, KitSym linkage_name); 379 void api_remember_sym(KitCg* g, ObjSymId sym, KitCgTypeId ty, KitCgDecl decl); 380 KitCgTypeId api_sym_type(KitCg* g, KitCgSym sym); 381 KitCgDecl api_sym_attrs(KitCg* g, KitCgSym sym); 382 int api_sym_is_tls(KitCg* g, KitCgSym sym); 383 RelocKind api_data_reloc_kind(int pcrel, uint32_t width); 384 SrcLoc api_no_loc(void); 385 int api_type_is_float(Compiler* c, KitCgTypeId ty); 386 int api_is_f128_type(Compiler* c, KitCgTypeId ty); 387 int api_is_i128_type(Compiler* c, KitCgTypeId ty); 388 int api_is_wide16_scalar_type(Compiler* c, KitCgTypeId ty); 389 int api_is_wide8_scalar_type(Compiler* c, KitCgTypeId ty); 390 Operand api_op_imm(i64 v, KitCgTypeId ty); 391 Operand api_op_local(CGLocal r, KitCgTypeId ty); 392 Operand api_op_global(ObjSymId sym, i64 addend, KitCgTypeId ty); 393 Operand api_op_indirect(CGLocal base, i32 ofs, KitCgTypeId ty); 394 Operand api_op_indirect_indexed(CGLocal base, CGLocal index, u8 log2_scale, 395 i32 ofs, KitCgTypeId ty); 396 u8 api_residency_for(const Operand* o); 397 ApiSValue api_make_sv(Operand op, KitCgTypeId ty); 398 ApiSValue api_make_lv(Operand op, KitCgTypeId ty); 399 ApiSValue api_make_sv_with_local_ownership(Operand op, KitCgTypeId ty, 400 int owned); 401 KitCgTypeId api_sv_type(const ApiSValue* sv); 402 int api_operand_can_address(const Operand* o); 403 int api_sv_op_is(const ApiSValue* sv, OpKind kind); 404 int api_sv_op_is_local_or_imm(const ApiSValue* sv); 405 int api_is_lvalue_sv(const ApiSValue* sv); 406 int api_sv_is_bitfield(const ApiSValue* sv); 407 MemAccess api_mem_for_bitfield(KitCg* g, const ApiSValue* sv, 408 const Operand* storage, KitCgTypeId field_ty); 409 void api_stack_grow(KitCg* g, u32 want); 410 void api_push(KitCg* g, ApiSValue v); 411 ApiSValue api_pop(KitCg* g); 412 CGLocal api_local_of_sv(const ApiSValue* sv); 413 void api_set_owned_local(ApiSValue* sv, CGLocal r); 414 KitCgTypeId api_owned_local_type(KitCg* g, const ApiSValue* sv); 415 void api_temp_locals_begin(KitCg* g); 416 void api_temp_locals_finish(KitCg* g); 417 CGLocal api_alloc_temp_local(KitCg* g, KitCgTypeId ty); 418 void api_release_temp_local(KitCg* g, CGLocal r); 419 MemAccess api_mem_for_lvalue(KitCg* g, const Operand* lv, KitCgTypeId ty); 420 MemAccess api_mem_from_access(KitCg* g, const Operand* lv, 421 KitCgMemAccess access); 422 KitCgTypeId api_mem_access_type(KitCg* g, KitCgMemAccess access, 423 KitCgTypeId fallback, const char* who); 424 u32 api_mem_type_size(KitCg* g, KitCgTypeId ty, const char* who); 425 void api_require_scalar_mem_type(KitCg* g, const char* who, KitCgTypeId ty); 426 void api_require_pointer_value(KitCg* g, const char* who, KitCgTypeId ty); 427 void api_validate_memory_value(KitCg* g, const char* who, KitCgTypeId access_ty, 428 KitCgTypeId value_ty); 429 void api_release_operand_local(KitCg* g, Operand op); 430 int api_sv_owns_operand_local(const ApiSValue* sv, const Operand* op); 431 void api_ensure_local(KitCg* g, ApiSValue* sv); 432 Operand api_force_local(KitCg* g, ApiSValue* v, KitCgTypeId ty); 433 Operand api_force_local_unless_imm(KitCg* g, ApiSValue* v, KitCgTypeId ty); 434 void api_release(KitCg* g, ApiSValue* sv); 435 BinOp api_map_int_binop(KitCgIntBinOp op); 436 BinOp api_map_fp_binop(KitCgFpBinOp op); 437 UnOp api_map_int_unop(KitCgIntUnOp op); 438 CmpOp api_map_int_cmp(KitCgIntCmpOp op); 439 CmpOp api_map_fp_cmp(KitCgFpCmpOp op); 440 Operand api_lvalue_addr(KitCg* g, ApiSValue* v, KitCgTypeId pty); 441 CGLocal api_f128_temp_local(KitCg* g, KitCgTypeId ty); 442 u64 api_u64_from_target_bytes(KitCg* g, const u8* bytes); 443 void api_store_f128_bytes(KitCg* g, CGLocal local, KitCgTypeId ty, 444 const u8 bytes[16]); 445 void api_wide16_sext_imm_bytes(KitCg* g, i64 imm, u8 bytes[16]); 446 ApiSValue api_make_wide16_int_const(KitCg* g, i64 value, KitCgTypeId ty); 447 void api_encode_binary128_from_double(KitCg* g, double value, u8 out[16]); 448 ApiSValue api_make_f128_const(KitCg* g, double value, KitCgTypeId ty); 449 ApiSValue api_wide16_materialize_lvalue(KitCg* g, ApiSValue* v, KitCgTypeId ty); 450 CGLocal api_wide8_temp_local(KitCg* g, KitCgTypeId ty); 451 ApiSValue api_make_wide8_const_bits(KitCg* g, u64 bits, KitCgTypeId ty); 452 ApiSValue api_make_wide8_int_const(KitCg* g, i64 value, KitCgTypeId ty); 453 Operand api_wide8_addr(KitCg* g, ApiSValue* v, KitCgTypeId ty); 454 Operand api_wide8_load_lane(KitCg* g, Operand addr, i32 off); 455 void api_wide8_store_lane(KitCg* g, Operand addr, i32 off, Operand val); 456 Operand api_wide8_or_lanes(KitCg* g, ApiSValue* v, KitCgTypeId ty); 457 KitCgSym api_runtime_helper(KitCg* g, const char* name, KitCgTypeId ret, 458 const KitCgTypeId* params, u32 nparams); 459 void api_runtime_call_values(KitCg* g, const char* name, KitCgTypeId ret, 460 const KitCgTypeId* params, u32 nparams, 461 ApiSValue* args); 462 463 /* The semantic-layer peephole optimizer: constant folding, the delayed 464 * compare/arith forms, and const-local store-to-load forwarding. Included here, 465 * after the operand and value types above, so its declarations can name 466 * ApiSValue / ApiSourceLocal / Operand. */ 467 #include "cg/fold.h" 468 469 #endif