Skip to content

Commit 21eb18c

Browse files
LemonBoyLemonBoy
committed
Use the LLVM C++ API
1 parent a4305e5 commit 21eb18c

File tree

3 files changed

+142
-54
lines changed

3 files changed

+142
-54
lines changed

‎src/codegen.cpp

Lines changed: 41 additions & 51 deletions
Original file line numberDiff line numberDiff line change
@@ -263,76 +263,66 @@ static const char *get_mangled_name(CodeGen *g, const char *original_name, bool
263263
}
264264
}
265265

266-
static LLVMCallConv get_llvm_cc(CodeGen *g, CallingConvention cc) {
266+
static ZigLLVM_CallingConv get_llvm_cc(CodeGen *g, CallingConvention cc) {
267267
switch (cc) {
268-
case CallingConventionUnspecified: return LLVMFastCallConv;
269-
case CallingConventionC: return LLVMCCallConv;
268+
case CallingConventionUnspecified:
269+
return ZigLLVM_Fast;
270+
case CallingConventionC:
271+
return ZigLLVM_C;
270272
case CallingConventionCold:
271-
// cold calling convention only works on x86.
272-
if (g->zig_target->arch == ZigLLVM_x86 ||
273-
g->zig_target->arch == ZigLLVM_x86_64)
274-
{
275-
// cold calling convention is not supported on windows
276-
if (g->zig_target->os == OsWindows) {
277-
return LLVMCCallConv;
278-
} else {
279-
return LLVMColdCallConv;
280-
}
281-
} else {
282-
return LLVMCCallConv;
283-
}
284-
break;
273+
if ((g->zig_target->arch == ZigLLVM_x86 ||
274+
g->zig_target->arch == ZigLLVM_x86_64) &&
275+
g->zig_target->os != OsWindows)
276+
return ZigLLVM_Cold;
277+
return ZigLLVM_C;
285278
case CallingConventionNaked:
286279
zig_unreachable();
287280
case CallingConventionStdcall:
288281
if (g->zig_target->arch == ZigLLVM_x86)
289-
return LLVMX86StdcallCallConv;
290-
return LLVMCCallConv;
282+
return ZigLLVM_X86_StdCall;
283+
return ZigLLVM_C;
291284
case CallingConventionFastcall:
292285
if (g->zig_target->arch == ZigLLVM_x86)
293-
return LLVMX86FastcallCallConv;
294-
return LLVMCCallConv;
286+
return ZigLLVM_X86_FastCall;
287+
return ZigLLVM_C;
295288
case CallingConventionVectorcall:
296289
if (g->zig_target->arch == ZigLLVM_x86)
297-
return LLVMX86VectorCallCallConv;
298-
// XXX Enable this when the C API exports this enum member too
299-
#if 0
290+
return ZigLLVM_X86_VectorCall;
300291
if (target_is_arm(g->zig_target) &&
301292
target_arch_pointer_bit_width(g->zig_target->arch) == 64)
302-
return LLVMAARCH64VectorCallCallConv;
303-
#endif
304-
return LLVMCCallConv;
293+
return ZigLLVM_AArch64_VectorCall;
294+
return ZigLLVM_C;
305295
case CallingConventionThiscall:
306296
if (g->zig_target->arch == ZigLLVM_x86)
307-
return LLVMX86ThisCallCallConv;
308-
return LLVMCCallConv;
297+
return ZigLLVM_X86_ThisCall;
298+
return ZigLLVM_C;
309299
case CallingConventionAsync:
310-
return LLVMFastCallConv;
300+
return ZigLLVM_Fast;
311301
case CallingConventionAPCS:
312302
if (target_is_arm(g->zig_target))
313-
return LLVMARMAPCSCallConv;
314-
return LLVMCCallConv;
303+
return ZigLLVM_ARM_APCS;
304+
return ZigLLVM_C;
315305
case CallingConventionAAPCS:
316306
if (target_is_arm(g->zig_target))
317-
return LLVMARMAAPCSCallConv;
318-
return LLVMCCallConv;
307+
return ZigLLVM_ARM_AAPCS;
308+
return ZigLLVM_C;
319309
case CallingConventionAAPCSVFP:
320310
if (target_is_arm(g->zig_target))
321-
return LLVMARMAAPCSVFPCallConv;
322-
return LLVMCCallConv;
311+
return ZigLLVM_ARM_AAPCS_VFP;
312+
return ZigLLVM_C;
323313
case CallingConventionInterrupt:
324314
if (g->zig_target->arch == ZigLLVM_x86 ||
325315
g->zig_target->arch == ZigLLVM_x86_64)
326-
return LLVMX86INTRCallConv;
316+
return ZigLLVM_X86_INTR;
327317
if (g->zig_target->arch == ZigLLVM_avr)
328-
return LLVMAVRINTRCallConv;
318+
return ZigLLVM_AVR_INTR;
329319
if (g->zig_target->arch == ZigLLVM_msp430)
330-
return LLVMMSP430INTRCallConv;
331-
return LLVMCCallConv;
320+
return ZigLLVM_MSP430_INTR;
321+
return ZigLLVM_C;
332322
case CallingConventionSignal:
333323
if (g->zig_target->arch == ZigLLVM_avr)
334-
return LLVMAVRSIGNALCallConv;
335-
return LLVMCCallConv;
324+
return ZigLLVM_AVR_SIGNAL;
325+
return ZigLLVM_C;
336326
}
337327
zig_unreachable();
338328
}
@@ -529,7 +519,7 @@ static LLVMValueRef make_fn_llvm_value(CodeGen *g, ZigFn *fn) {
529519
if (cc == CallingConventionNaked) {
530520
addLLVMFnAttr(llvm_fn, "naked");
531521
} else {
532-
LLVMSetFunctionCallConv(llvm_fn, get_llvm_cc(g, fn_type->data.fn.fn_type_id.cc));
522+
ZigLLVMFunctionSetCallingConv(llvm_fn, get_llvm_cc(g, fn_type->data.fn.fn_type_id.cc));
533523
}
534524

535525
bool want_cold = fn->is_cold || cc == CallingConventionCold;
@@ -1024,7 +1014,7 @@ static void gen_panic(CodeGen *g, LLVMValueRef msg_arg, LLVMValueRef stack_trace
10241014
{
10251015
assert(g->panic_fn != nullptr);
10261016
LLVMValueRef fn_val = fn_llvm_value(g, g->panic_fn);
1027-
LLVMCallConv llvm_cc = get_llvm_cc(g, g->panic_fn->type_entry->data.fn.fn_type_id.cc);
1017+
ZigLLVM_CallingConv llvm_cc = get_llvm_cc(g, g->panic_fn->type_entry->data.fn.fn_type_id.cc);
10281018
if (stack_trace_arg == nullptr) {
10291019
stack_trace_arg = LLVMConstNull(get_llvm_type(g, ptr_to_stack_trace_type(g)));
10301020
}
@@ -1135,7 +1125,7 @@ static LLVMValueRef get_add_error_return_trace_addr_fn(CodeGen *g) {
11351125
LLVMValueRef fn_val = LLVMAddFunction(g->module, fn_name, fn_type_ref);
11361126
addLLVMFnAttr(fn_val, "alwaysinline");
11371127
LLVMSetLinkage(fn_val, LLVMInternalLinkage);
1138-
LLVMSetFunctionCallConv(fn_val, get_llvm_cc(g, CallingConventionUnspecified));
1128+
ZigLLVMFunctionSetCallingConv(fn_val, get_llvm_cc(g, CallingConventionUnspecified));
11391129
addLLVMFnAttr(fn_val, "nounwind");
11401130
add_uwtable_attr(g, fn_val);
11411131
// Error return trace memory is in the stack, which is impossible to be at address 0
@@ -1216,7 +1206,7 @@ static LLVMValueRef get_return_err_fn(CodeGen *g) {
12161206
addLLVMFnAttr(fn_val, "noinline"); // so that we can look at return address
12171207
addLLVMFnAttr(fn_val, "cold");
12181208
LLVMSetLinkage(fn_val, LLVMInternalLinkage);
1219-
LLVMSetFunctionCallConv(fn_val, get_llvm_cc(g, CallingConventionUnspecified));
1209+
ZigLLVMFunctionSetCallingConv(fn_val, get_llvm_cc(g, CallingConventionUnspecified));
12201210
addLLVMFnAttr(fn_val, "nounwind");
12211211
add_uwtable_attr(g, fn_val);
12221212
if (codegen_have_frame_pointer(g)) {
@@ -1300,7 +1290,7 @@ static LLVMValueRef get_safety_crash_err_fn(CodeGen *g) {
13001290
addLLVMFnAttr(fn_val, "noreturn");
13011291
addLLVMFnAttr(fn_val, "cold");
13021292
LLVMSetLinkage(fn_val, LLVMInternalLinkage);
1303-
LLVMSetFunctionCallConv(fn_val, get_llvm_cc(g, CallingConventionUnspecified));
1293+
ZigLLVMFunctionSetCallingConv(fn_val, get_llvm_cc(g, CallingConventionUnspecified));
13041294
addLLVMFnAttr(fn_val, "nounwind");
13051295
add_uwtable_attr(g, fn_val);
13061296
if (codegen_have_frame_pointer(g)) {
@@ -2193,7 +2183,7 @@ static LLVMValueRef get_merge_err_ret_traces_fn_val(CodeGen *g) {
21932183
const char *fn_name = get_mangled_name(g, "__zig_merge_error_return_traces", false);
21942184
LLVMValueRef fn_val = LLVMAddFunction(g->module, fn_name, fn_type_ref);
21952185
LLVMSetLinkage(fn_val, LLVMInternalLinkage);
2196-
LLVMSetFunctionCallConv(fn_val, get_llvm_cc(g, CallingConventionUnspecified));
2186+
ZigLLVMFunctionSetCallingConv(fn_val, get_llvm_cc(g, CallingConventionUnspecified));
21972187
addLLVMFnAttr(fn_val, "nounwind");
21982188
add_uwtable_attr(g, fn_val);
21992189
addLLVMArgAttr(fn_val, (unsigned)0, "noalias");
@@ -2370,7 +2360,7 @@ static LLVMValueRef gen_resume(CodeGen *g, LLVMValueRef fn_val, LLVMValueRef tar
23702360
LLVMValueRef arg_val = LLVMConstSub(LLVMConstAllOnes(usize_type_ref),
23712361
LLVMConstInt(usize_type_ref, resume_id, false));
23722362
LLVMValueRef args[] = {target_frame_ptr, arg_val};
2373-
return ZigLLVMBuildCall(g->builder, fn_val, args, 2, LLVMFastCallConv, ZigLLVM_CallAttrAuto, "");
2363+
return ZigLLVMBuildCall(g->builder, fn_val, args, 2, ZigLLVM_Fast, ZigLLVM_CallAttrAuto, "");
23742364
}
23752365

23762366
static LLVMBasicBlockRef gen_suspend_begin(CodeGen *g, const char *name_hint) {
@@ -4260,7 +4250,7 @@ static LLVMValueRef ir_render_call(CodeGen *g, IrExecutable *executable, IrInstr
42604250
break;
42614251
}
42624252

4263-
LLVMCallConv llvm_cc = get_llvm_cc(g, cc);
4253+
ZigLLVM_CallingConv llvm_cc = get_llvm_cc(g, cc);
42644254
LLVMValueRef result;
42654255

42664256
if (callee_is_async) {
@@ -4970,7 +4960,7 @@ static LLVMValueRef get_enum_tag_name_function(CodeGen *g, ZigType *enum_type) {
49704960
buf_ptr(buf_sprintf("__zig_tag_name_%s", buf_ptr(&enum_type->name))), false);
49714961
LLVMValueRef fn_val = LLVMAddFunction(g->module, fn_name, fn_type_ref);
49724962
LLVMSetLinkage(fn_val, LLVMInternalLinkage);
4973-
LLVMSetFunctionCallConv(fn_val, get_llvm_cc(g, CallingConventionUnspecified));
4963+
ZigLLVMFunctionSetCallingConv(fn_val, get_llvm_cc(g, CallingConventionUnspecified));
49744964
addLLVMFnAttr(fn_val, "nounwind");
49754965
add_uwtable_attr(g, fn_val);
49764966
if (codegen_have_frame_pointer(g)) {

‎src/zig_llvm.cpp

Lines changed: 51 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -273,10 +273,10 @@ ZIG_EXTERN_C LLVMTypeRef ZigLLVMTokenTypeInContext(LLVMContextRef context_ref) {
273273
}
274274

275275
LLVMValueRef ZigLLVMBuildCall(LLVMBuilderRef B, LLVMValueRef Fn, LLVMValueRef *Args,
276-
unsigned NumArgs, unsigned CC, ZigLLVM_CallAttr attr, const char *Name)
276+
unsigned NumArgs, ZigLLVM_CallingConv CC, ZigLLVM_CallAttr attr, const char *Name)
277277
{
278278
CallInst *call_inst = CallInst::Create(unwrap(Fn), makeArrayRef(unwrap(Args), NumArgs), Name);
279-
call_inst->setCallingConv(CC);
279+
call_inst->setCallingConv(static_cast<CallingConv::ID>(CC));
280280
switch (attr) {
281281
case ZigLLVM_CallAttrAuto:
282282
break;
@@ -932,6 +932,9 @@ void ZigLLVMFunctionSetPrefixData(LLVMValueRef function, LLVMValueRef data) {
932932
unwrap<Function>(function)->setPrefixData(unwrap<Constant>(data));
933933
}
934934

935+
void ZigLLVMFunctionSetCallingConv(LLVMValueRef function, ZigLLVM_CallingConv cc) {
936+
unwrap<Function>(function)->setCallingConv(static_cast<CallingConv::ID>(cc));
937+
}
935938

936939
class MyOStream: public raw_ostream {
937940
public:
@@ -1265,3 +1268,49 @@ static_assert((Triple::ObjectFormatType)ZigLLVM_ELF == Triple::ELF, "");
12651268
static_assert((Triple::ObjectFormatType)ZigLLVM_MachO == Triple::MachO, "");
12661269
static_assert((Triple::ObjectFormatType)ZigLLVM_Wasm == Triple::Wasm, "");
12671270
static_assert((Triple::ObjectFormatType)ZigLLVM_XCOFF == Triple::XCOFF, "");
1271+
1272+
static_assert((CallingConv::ID)ZigLLVM_C == llvm::CallingConv::C, "");
1273+
static_assert((CallingConv::ID)ZigLLVM_Fast == llvm::CallingConv::Fast, "");
1274+
static_assert((CallingConv::ID)ZigLLVM_Cold == llvm::CallingConv::Cold, "");
1275+
static_assert((CallingConv::ID)ZigLLVM_GHC == llvm::CallingConv::GHC, "");
1276+
static_assert((CallingConv::ID)ZigLLVM_HiPE == llvm::CallingConv::HiPE, "");
1277+
static_assert((CallingConv::ID)ZigLLVM_WebKit_JS == llvm::CallingConv::WebKit_JS, "");
1278+
static_assert((CallingConv::ID)ZigLLVM_AnyReg == llvm::CallingConv::AnyReg, "");
1279+
static_assert((CallingConv::ID)ZigLLVM_PreserveMost == llvm::CallingConv::PreserveMost, "");
1280+
static_assert((CallingConv::ID)ZigLLVM_PreserveAll == llvm::CallingConv::PreserveAll, "");
1281+
static_assert((CallingConv::ID)ZigLLVM_Swift == llvm::CallingConv::Swift, "");
1282+
static_assert((CallingConv::ID)ZigLLVM_CXX_FAST_TLS == llvm::CallingConv::CXX_FAST_TLS, "");
1283+
static_assert((CallingConv::ID)ZigLLVM_FirstTargetCC == llvm::CallingConv::FirstTargetCC, "");
1284+
static_assert((CallingConv::ID)ZigLLVM_X86_StdCall == llvm::CallingConv::X86_StdCall, "");
1285+
static_assert((CallingConv::ID)ZigLLVM_X86_FastCall == llvm::CallingConv::X86_FastCall, "");
1286+
static_assert((CallingConv::ID)ZigLLVM_ARM_APCS == llvm::CallingConv::ARM_APCS, "");
1287+
static_assert((CallingConv::ID)ZigLLVM_ARM_AAPCS == llvm::CallingConv::ARM_AAPCS, "");
1288+
static_assert((CallingConv::ID)ZigLLVM_ARM_AAPCS_VFP == llvm::CallingConv::ARM_AAPCS_VFP, "");
1289+
static_assert((CallingConv::ID)ZigLLVM_MSP430_INTR == llvm::CallingConv::MSP430_INTR, "");
1290+
static_assert((CallingConv::ID)ZigLLVM_X86_ThisCall == llvm::CallingConv::X86_ThisCall, "");
1291+
static_assert((CallingConv::ID)ZigLLVM_PTX_Kernel == llvm::CallingConv::PTX_Kernel, "");
1292+
static_assert((CallingConv::ID)ZigLLVM_PTX_Device == llvm::CallingConv::PTX_Device, "");
1293+
static_assert((CallingConv::ID)ZigLLVM_SPIR_FUNC == llvm::CallingConv::SPIR_FUNC, "");
1294+
static_assert((CallingConv::ID)ZigLLVM_SPIR_KERNEL == llvm::CallingConv::SPIR_KERNEL, "");
1295+
static_assert((CallingConv::ID)ZigLLVM_Intel_OCL_BI == llvm::CallingConv::Intel_OCL_BI, "");
1296+
static_assert((CallingConv::ID)ZigLLVM_X86_64_SysV == llvm::CallingConv::X86_64_SysV, "");
1297+
static_assert((CallingConv::ID)ZigLLVM_Win64 == llvm::CallingConv::Win64, "");
1298+
static_assert((CallingConv::ID)ZigLLVM_X86_VectorCall == llvm::CallingConv::X86_VectorCall, "");
1299+
static_assert((CallingConv::ID)ZigLLVM_HHVM == llvm::CallingConv::HHVM, "");
1300+
static_assert((CallingConv::ID)ZigLLVM_HHVM_C == llvm::CallingConv::HHVM_C, "");
1301+
static_assert((CallingConv::ID)ZigLLVM_X86_INTR == llvm::CallingConv::X86_INTR, "");
1302+
static_assert((CallingConv::ID)ZigLLVM_AVR_INTR == llvm::CallingConv::AVR_INTR, "");
1303+
static_assert((CallingConv::ID)ZigLLVM_AVR_SIGNAL == llvm::CallingConv::AVR_SIGNAL, "");
1304+
static_assert((CallingConv::ID)ZigLLVM_AVR_BUILTIN == llvm::CallingConv::AVR_BUILTIN, "");
1305+
static_assert((CallingConv::ID)ZigLLVM_AMDGPU_VS == llvm::CallingConv::AMDGPU_VS, "");
1306+
static_assert((CallingConv::ID)ZigLLVM_AMDGPU_GS == llvm::CallingConv::AMDGPU_GS, "");
1307+
static_assert((CallingConv::ID)ZigLLVM_AMDGPU_PS == llvm::CallingConv::AMDGPU_PS, "");
1308+
static_assert((CallingConv::ID)ZigLLVM_AMDGPU_CS == llvm::CallingConv::AMDGPU_CS, "");
1309+
static_assert((CallingConv::ID)ZigLLVM_AMDGPU_KERNEL == llvm::CallingConv::AMDGPU_KERNEL, "");
1310+
static_assert((CallingConv::ID)ZigLLVM_X86_RegCall == llvm::CallingConv::X86_RegCall, "");
1311+
static_assert((CallingConv::ID)ZigLLVM_AMDGPU_HS == llvm::CallingConv::AMDGPU_HS, "");
1312+
static_assert((CallingConv::ID)ZigLLVM_MSP430_BUILTIN == llvm::CallingConv::MSP430_BUILTIN, "");
1313+
static_assert((CallingConv::ID)ZigLLVM_AMDGPU_LS == llvm::CallingConv::AMDGPU_LS, "");
1314+
static_assert((CallingConv::ID)ZigLLVM_AMDGPU_ES == llvm::CallingConv::AMDGPU_ES, "");
1315+
static_assert((CallingConv::ID)ZigLLVM_AArch64_VectorCall == llvm::CallingConv::AArch64_VectorCall, "");
1316+
static_assert((CallingConv::ID)ZigLLVM_MaxID == llvm::CallingConv::MaxID, "");

‎src/zig_llvm.h

Lines changed: 50 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -64,6 +64,54 @@ ZIG_EXTERN_C LLVMTargetMachineRef ZigLLVMCreateTargetMachine(LLVMTargetRef T, co
6464

6565
ZIG_EXTERN_C LLVMTypeRef ZigLLVMTokenTypeInContext(LLVMContextRef context_ref);
6666

67+
enum ZigLLVM_CallingConv {
68+
ZigLLVM_C = 0,
69+
ZigLLVM_Fast = 8,
70+
ZigLLVM_Cold = 9,
71+
ZigLLVM_GHC = 10,
72+
ZigLLVM_HiPE = 11,
73+
ZigLLVM_WebKit_JS = 12,
74+
ZigLLVM_AnyReg = 13,
75+
ZigLLVM_PreserveMost = 14,
76+
ZigLLVM_PreserveAll = 15,
77+
ZigLLVM_Swift = 16,
78+
ZigLLVM_CXX_FAST_TLS = 17,
79+
ZigLLVM_FirstTargetCC = 64,
80+
ZigLLVM_X86_StdCall = 64,
81+
ZigLLVM_X86_FastCall = 65,
82+
ZigLLVM_ARM_APCS = 66,
83+
ZigLLVM_ARM_AAPCS = 67,
84+
ZigLLVM_ARM_AAPCS_VFP = 68,
85+
ZigLLVM_MSP430_INTR = 69,
86+
ZigLLVM_X86_ThisCall = 70,
87+
ZigLLVM_PTX_Kernel = 71,
88+
ZigLLVM_PTX_Device = 72,
89+
ZigLLVM_SPIR_FUNC = 75,
90+
ZigLLVM_SPIR_KERNEL = 76,
91+
ZigLLVM_Intel_OCL_BI = 77,
92+
ZigLLVM_X86_64_SysV = 78,
93+
ZigLLVM_Win64 = 79,
94+
ZigLLVM_X86_VectorCall = 80,
95+
ZigLLVM_HHVM = 81,
96+
ZigLLVM_HHVM_C = 82,
97+
ZigLLVM_X86_INTR = 83,
98+
ZigLLVM_AVR_INTR = 84,
99+
ZigLLVM_AVR_SIGNAL = 85,
100+
ZigLLVM_AVR_BUILTIN = 86,
101+
ZigLLVM_AMDGPU_VS = 87,
102+
ZigLLVM_AMDGPU_GS = 88,
103+
ZigLLVM_AMDGPU_PS = 89,
104+
ZigLLVM_AMDGPU_CS = 90,
105+
ZigLLVM_AMDGPU_KERNEL = 91,
106+
ZigLLVM_X86_RegCall = 92,
107+
ZigLLVM_AMDGPU_HS = 93,
108+
ZigLLVM_MSP430_BUILTIN = 94,
109+
ZigLLVM_AMDGPU_LS = 95,
110+
ZigLLVM_AMDGPU_ES = 96,
111+
ZigLLVM_AArch64_VectorCall = 97,
112+
ZigLLVM_MaxID = 1023,
113+
};
114+
67115
enum ZigLLVM_CallAttr {
68116
ZigLLVM_CallAttrAuto,
69117
ZigLLVM_CallAttrNeverTail,
@@ -72,7 +120,7 @@ enum ZigLLVM_CallAttr {
72120
ZigLLVM_CallAttrAlwaysInline,
73121
};
74122
ZIG_EXTERN_C LLVMValueRef ZigLLVMBuildCall(LLVMBuilderRef B, LLVMValueRef Fn, LLVMValueRef *Args,
75-
unsigned NumArgs, unsigned CC, enum ZigLLVM_CallAttr attr, const char *Name);
123+
unsigned NumArgs, ZigLLVM_CallingConv CC, enum ZigLLVM_CallAttr attr, const char *Name);
76124

77125
ZIG_EXTERN_C LLVMValueRef ZigLLVMBuildMemCpy(LLVMBuilderRef B, LLVMValueRef Dst, unsigned DstAlign,
78126
LLVMValueRef Src, unsigned SrcAlign, LLVMValueRef Size, bool isVolatile);
@@ -215,6 +263,7 @@ ZIG_EXTERN_C struct ZigLLVMDILocation *ZigLLVMGetDebugLoc(unsigned line, unsigne
215263
ZIG_EXTERN_C void ZigLLVMSetFastMath(LLVMBuilderRef builder_wrapped, bool on_state);
216264
ZIG_EXTERN_C void ZigLLVMSetTailCall(LLVMValueRef Call);
217265
ZIG_EXTERN_C void ZigLLVMFunctionSetPrefixData(LLVMValueRef fn, LLVMValueRef data);
266+
ZIG_EXTERN_C void ZigLLVMFunctionSetCallingConv(LLVMValueRef function, ZigLLVM_CallingConv cc);
218267

219268
ZIG_EXTERN_C void ZigLLVMAddFunctionAttr(LLVMValueRef fn, const char *attr_name, const char *attr_value);
220269
ZIG_EXTERN_C void ZigLLVMAddByValAttr(LLVMValueRef fn_ref, unsigned ArgNo, LLVMTypeRef type_val);

0 commit comments

Comments
 (0)