Branch data Line data Source code
1 : : /*
2 : : * Copyright (c) 2015 Andrew Kelley
3 : : *
4 : : * This file is part of zig, which is MIT licensed.
5 : : * See http://opensource.org/licenses/MIT
6 : : */
7 : :
8 : :
9 : : /*
10 : : * The point of this file is to contain all the LLVM C++ API interaction so that:
11 : : * 1. The compile time of other files is kept under control.
12 : : * 2. Provide a C interface to the LLVM functions we need for self-hosting purposes.
13 : : * 3. Prevent C++ from infecting the rest of the project.
14 : : */
15 : :
16 : : #include "zig_llvm.h"
17 : :
18 : : #if __GNUC__ >= 9
19 : : #pragma GCC diagnostic push
20 : : #pragma GCC diagnostic ignored "-Winit-list-lifetime"
21 : : #endif
22 : :
23 : : #include <llvm/Analysis/TargetLibraryInfo.h>
24 : : #include <llvm/Analysis/TargetTransformInfo.h>
25 : : #include <llvm/IR/DIBuilder.h>
26 : : #include <llvm/IR/DiagnosticInfo.h>
27 : : #include <llvm/IR/IRBuilder.h>
28 : : #include <llvm/IR/InlineAsm.h>
29 : : #include <llvm/IR/Instructions.h>
30 : : #include <llvm/IR/LegacyPassManager.h>
31 : : #include <llvm/IR/Module.h>
32 : : #include <llvm/IR/Verifier.h>
33 : : #include <llvm/InitializePasses.h>
34 : : #include <llvm/MC/SubtargetFeature.h>
35 : : #include <llvm/Object/Archive.h>
36 : : #include <llvm/Object/ArchiveWriter.h>
37 : : #include <llvm/PassRegistry.h>
38 : : #include <llvm/Support/FileSystem.h>
39 : : #include <llvm/Support/TargetParser.h>
40 : : #include <llvm/Support/Timer.h>
41 : : #include <llvm/Support/raw_ostream.h>
42 : : #include <llvm/Support/TargetRegistry.h>
43 : : #include <llvm/Target/TargetMachine.h>
44 : : #include <llvm/Target/CodeGenCWrappers.h>
45 : : #include <llvm/Transforms/IPO.h>
46 : : #include <llvm/Transforms/IPO/AlwaysInliner.h>
47 : : #include <llvm/Transforms/IPO/PassManagerBuilder.h>
48 : : #include <llvm/Transforms/Scalar.h>
49 : : #include <llvm/Transforms/Utils.h>
50 : :
51 : : #include <lld/Common/Driver.h>
52 : :
53 : : #if __GNUC__ >= 9
54 : : #pragma GCC diagnostic pop
55 : : #endif
56 : :
57 : : #include <new>
58 : :
59 : : #include <stdlib.h>
60 : :
61 : : using namespace llvm;
62 : :
63 : 0 : void ZigLLVMInitializeLoopStrengthReducePass(LLVMPassRegistryRef R) {
64 : 0 : initializeLoopStrengthReducePass(*unwrap(R));
65 : 0 : }
66 : :
67 : 0 : void ZigLLVMInitializeLowerIntrinsicsPass(LLVMPassRegistryRef R) {
68 : 0 : initializeLowerIntrinsicsPass(*unwrap(R));
69 : 0 : }
70 : :
71 : 14 : char *ZigLLVMGetHostCPUName(void) {
72 : 14 : return strdup((const char *)sys::getHostCPUName().bytes_begin());
73 : : }
74 : :
75 : 14 : char *ZigLLVMGetNativeFeatures(void) {
76 : 28 : SubtargetFeatures features;
77 : :
78 : 28 : StringMap<bool> host_features;
79 [ + - ]: 14 : if (sys::getHostCPUFeatures(host_features)) {
80 [ + + ]: 1008 : for (auto &F : host_features)
81 : 994 : features.AddFeature(F.first(), F.second);
82 : : }
83 : :
84 : 28 : return strdup((const char *)StringRef(features.getString()).bytes_begin());
85 : : }
86 : :
87 : 0 : static void addDiscriminatorsPass(const PassManagerBuilder &Builder, legacy::PassManagerBase &PM) {
88 : 0 : PM.add(createAddDiscriminatorsPass());
89 : 0 : }
90 : :
91 : : #ifndef NDEBUG
92 : : static const bool assertions_on = true;
93 : : #else
94 : : static const bool assertions_on = false;
95 : : #endif
96 : :
97 : 21 : LLVMTargetMachineRef ZigLLVMCreateTargetMachine(LLVMTargetRef T, const char *Triple,
98 : : const char *CPU, const char *Features, LLVMCodeGenOptLevel Level, LLVMRelocMode Reloc,
99 : : LLVMCodeModel CodeModel, bool function_sections)
100 : : {
101 : 42 : Optional<Reloc::Model> RM;
102 [ + + - - : 21 : switch (Reloc){
- - - ]
103 : 6 : case LLVMRelocStatic:
104 : 6 : RM = Reloc::Static;
105 : 6 : break;
106 : 15 : case LLVMRelocPIC:
107 : 15 : RM = Reloc::PIC_;
108 : 15 : break;
109 : 0 : case LLVMRelocDynamicNoPic:
110 : 0 : RM = Reloc::DynamicNoPIC;
111 : 0 : break;
112 : 0 : case LLVMRelocROPI:
113 : 0 : RM = Reloc::ROPI;
114 : 0 : break;
115 : 0 : case LLVMRelocRWPI:
116 : 0 : RM = Reloc::RWPI;
117 : 0 : break;
118 : 0 : case LLVMRelocROPI_RWPI:
119 : 0 : RM = Reloc::ROPI_RWPI;
120 : 0 : break;
121 : 0 : default:
122 : 0 : break;
123 : : }
124 : :
125 : : bool JIT;
126 : 42 : Optional<CodeModel::Model> CM = unwrap(CodeModel, JIT);
127 : :
128 : : CodeGenOpt::Level OL;
129 [ + - - - ]: 21 : switch (Level) {
130 : 21 : case LLVMCodeGenLevelNone:
131 : 21 : OL = CodeGenOpt::None;
132 : 21 : break;
133 : 0 : case LLVMCodeGenLevelLess:
134 : 0 : OL = CodeGenOpt::Less;
135 : 0 : break;
136 : 0 : case LLVMCodeGenLevelAggressive:
137 : 0 : OL = CodeGenOpt::Aggressive;
138 : 0 : break;
139 : 0 : default:
140 : 0 : OL = CodeGenOpt::Default;
141 : 0 : break;
142 : : }
143 : :
144 : 42 : TargetOptions opt;
145 : 21 : opt.FunctionSections = function_sections;
146 : :
147 : 42 : TargetMachine *TM = reinterpret_cast<Target*>(T)->createTargetMachine(Triple, CPU, Features, opt, RM, CM,
148 : 21 : OL, JIT);
149 : 42 : return reinterpret_cast<LLVMTargetMachineRef>(TM);
150 : : }
151 : :
152 : 20 : bool ZigLLVMTargetMachineEmitToFile(LLVMTargetMachineRef targ_machine_ref, LLVMModuleRef module_ref,
153 : : const char *filename, ZigLLVM_EmitOutputType output_type, char **error_message, bool is_debug,
154 : : bool is_small, bool time_report)
155 : : {
156 : 20 : TimePassesIsEnabled = time_report;
157 : :
158 : 20 : std::error_code EC;
159 : 40 : raw_fd_ostream dest(filename, EC, sys::fs::F_None);
160 [ - + ]: 20 : if (EC) {
161 : 0 : *error_message = strdup((const char *)StringRef(EC.message()).bytes_begin());
162 : 0 : return true;
163 : : }
164 : 20 : TargetMachine* target_machine = reinterpret_cast<TargetMachine*>(targ_machine_ref);
165 : 20 : target_machine->setO0WantsFastISel(true);
166 : :
167 : 20 : Module* module = unwrap(module_ref);
168 : :
169 [ + - ]: 20 : PassManagerBuilder *PMBuilder = new(std::nothrow) PassManagerBuilder();
170 [ - + ]: 20 : if (PMBuilder == nullptr) {
171 : 0 : *error_message = strdup("memory allocation failure");
172 : 0 : return true;
173 : : }
174 : 20 : PMBuilder->OptLevel = target_machine->getOptLevel();
175 [ - + ]: 20 : PMBuilder->SizeLevel = is_small ? 2 : 0;
176 : :
177 : 20 : PMBuilder->DisableTailCalls = is_debug;
178 : 20 : PMBuilder->DisableUnitAtATime = is_debug;
179 : 20 : PMBuilder->DisableUnrollLoops = is_debug;
180 : 20 : PMBuilder->SLPVectorize = !is_debug;
181 : 20 : PMBuilder->LoopVectorize = !is_debug;
182 : 20 : PMBuilder->RerollLoops = !is_debug;
183 : : // Leaving NewGVN as default (off) because when on it caused issue #673
184 : : //PMBuilder->NewGVN = !is_debug;
185 : 20 : PMBuilder->DisableGVNLoadPRE = is_debug;
186 : 20 : PMBuilder->VerifyInput = assertions_on;
187 : 20 : PMBuilder->VerifyOutput = assertions_on;
188 : 20 : PMBuilder->MergeFunctions = !is_debug;
189 : 20 : PMBuilder->PrepareForLTO = false;
190 : 20 : PMBuilder->PrepareForThinLTO = false;
191 : 20 : PMBuilder->PerformThinLTO = false;
192 : :
193 : 40 : TargetLibraryInfoImpl tlii(Triple(module->getTargetTriple()));
194 : 20 : PMBuilder->LibraryInfo = &tlii;
195 : :
196 [ + - ]: 20 : if (is_debug) {
197 : 20 : PMBuilder->Inliner = createAlwaysInlinerLegacyPass(false);
198 : : } else {
199 : 0 : target_machine->adjustPassManager(*PMBuilder);
200 : :
201 : 0 : PMBuilder->addExtension(PassManagerBuilder::EP_EarlyAsPossible, addDiscriminatorsPass);
202 : 0 : PMBuilder->Inliner = createFunctionInliningPass(PMBuilder->OptLevel, PMBuilder->SizeLevel, false);
203 : : }
204 : :
205 : : // Set up the per-function pass manager.
206 : 40 : legacy::FunctionPassManager FPM = legacy::FunctionPassManager(module);
207 [ + - ]: 20 : auto tliwp = new(std::nothrow) TargetLibraryInfoWrapperPass(tlii);
208 : 20 : FPM.add(tliwp);
209 : 20 : FPM.add(createTargetTransformInfoWrapperPass(target_machine->getTargetIRAnalysis()));
210 : : if (assertions_on) {
211 : 20 : FPM.add(createVerifierPass());
212 : : }
213 : 20 : PMBuilder->populateFunctionPassManager(FPM);
214 : :
215 : : // Set up the per-module pass manager.
216 : 40 : legacy::PassManager MPM;
217 : 20 : MPM.add(createTargetTransformInfoWrapperPass(target_machine->getTargetIRAnalysis()));
218 : 20 : PMBuilder->populateModulePassManager(MPM);
219 : :
220 : : // Set output pass.
221 : : TargetMachine::CodeGenFileType ft;
222 [ + - ]: 20 : if (output_type != ZigLLVM_EmitLLVMIr) {
223 [ - + - ]: 20 : switch (output_type) {
224 : 0 : case ZigLLVM_EmitAssembly:
225 : 0 : ft = TargetMachine::CGFT_AssemblyFile;
226 : 0 : break;
227 : 20 : case ZigLLVM_EmitBinary:
228 : 20 : ft = TargetMachine::CGFT_ObjectFile;
229 : 20 : break;
230 : 0 : default:
231 : 0 : abort();
232 : : }
233 : :
234 [ - + ]: 20 : if (target_machine->addPassesToEmitFile(MPM, dest, nullptr, ft)) {
235 : 0 : *error_message = strdup("TargetMachine can't emit a file of this type");
236 : 0 : return true;
237 : : }
238 : : }
239 : :
240 : : // run per function optimization passes
241 : 20 : FPM.doInitialization();
242 [ + + ]: 25279 : for (Function &F : *module)
243 [ + + ]: 25259 : if (!F.isDeclaration())
244 : 24362 : FPM.run(F);
245 : 20 : FPM.doFinalization();
246 : :
247 : 20 : MPM.run(*module);
248 : :
249 [ - + ]: 20 : if (output_type == ZigLLVM_EmitLLVMIr) {
250 [ # # ]: 0 : if (LLVMPrintModuleToFile(module_ref, filename, error_message)) {
251 : 0 : return true;
252 : : }
253 : : }
254 : :
255 [ - + ]: 20 : if (time_report) {
256 : 0 : TimerGroup::printAll(errs());
257 : : }
258 : 20 : return false;
259 : : }
260 : :
261 : 0 : ZIG_EXTERN_C LLVMTypeRef ZigLLVMTokenTypeInContext(LLVMContextRef context_ref) {
262 : 0 : return wrap(Type::getTokenTy(*unwrap(context_ref)));
263 : : }
264 : :
265 : 81070 : LLVMValueRef ZigLLVMBuildCall(LLVMBuilderRef B, LLVMValueRef Fn, LLVMValueRef *Args,
266 : : unsigned NumArgs, unsigned CC, ZigLLVM_FnInline fn_inline, const char *Name)
267 : : {
268 : 81070 : CallInst *call_inst = CallInst::Create(unwrap(Fn), makeArrayRef(unwrap(Args), NumArgs), Name);
269 : 81070 : call_inst->setCallingConv(CC);
270 [ + + + - ]: 81070 : switch (fn_inline) {
271 : 80985 : case ZigLLVM_FnInlineAuto:
272 : 80985 : break;
273 : 82 : case ZigLLVM_FnInlineAlways:
274 : 82 : call_inst->addAttribute(AttributeList::FunctionIndex, Attribute::AlwaysInline);
275 : 82 : break;
276 : 3 : case ZigLLVM_FnInlineNever:
277 : 3 : call_inst->addAttribute(AttributeList::FunctionIndex, Attribute::NoInline);
278 : 3 : break;
279 : : }
280 : 81070 : return wrap(unwrap(B)->Insert(call_inst));
281 : : }
282 : :
283 : 8735 : LLVMValueRef ZigLLVMBuildMemCpy(LLVMBuilderRef B, LLVMValueRef Dst, unsigned DstAlign,
284 : : LLVMValueRef Src, unsigned SrcAlign, LLVMValueRef Size, bool isVolatile)
285 : : {
286 : 8735 : CallInst *call_inst = unwrap(B)->CreateMemCpy(unwrap(Dst), DstAlign, unwrap(Src), SrcAlign, unwrap(Size), isVolatile);
287 : 8735 : return wrap(call_inst);
288 : : }
289 : :
290 : 1635 : LLVMValueRef ZigLLVMBuildMemSet(LLVMBuilderRef B, LLVMValueRef Ptr, LLVMValueRef Val, LLVMValueRef Size,
291 : : unsigned Align, bool isVolatile)
292 : : {
293 : 1635 : CallInst *call_inst = unwrap(B)->CreateMemSet(unwrap(Ptr), unwrap(Val), unwrap(Size), Align, isVolatile);
294 : 1635 : return wrap(call_inst);
295 : : }
296 : :
297 : 24304 : void ZigLLVMFnSetSubprogram(LLVMValueRef fn, ZigLLVMDISubprogram *subprogram) {
298 [ - + ]: 24304 : assert( isa<Function>(unwrap(fn)) );
299 : 24304 : Function *unwrapped_function = reinterpret_cast<Function*>(unwrap(fn));
300 : 24304 : unwrapped_function->setSubprogram(reinterpret_cast<DISubprogram*>(subprogram));
301 : 24304 : }
302 : :
303 : :
304 : 17248 : ZigLLVMDIType *ZigLLVMCreateDebugPointerType(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIType *pointee_type,
305 : : uint64_t size_in_bits, uint64_t align_in_bits, const char *name)
306 : : {
307 : 34496 : DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createPointerType(
308 : 17248 : reinterpret_cast<DIType*>(pointee_type), size_in_bits, align_in_bits, Optional<unsigned>(), name);
309 : 17248 : return reinterpret_cast<ZigLLVMDIType*>(di_type);
310 : : }
311 : :
312 : 717 : ZigLLVMDIType *ZigLLVMCreateDebugBasicType(ZigLLVMDIBuilder *dibuilder, const char *name,
313 : : uint64_t size_in_bits, unsigned encoding)
314 : : {
315 : 717 : DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createBasicType(
316 : 717 : name, size_in_bits, encoding);
317 : 717 : return reinterpret_cast<ZigLLVMDIType*>(di_type);
318 : : }
319 : :
320 : 25 : struct ZigLLVMDIType *ZigLLVMDIBuilderCreateVectorType(struct ZigLLVMDIBuilder *dibuilder,
321 : : uint64_t SizeInBits, uint32_t AlignInBits, struct ZigLLVMDIType *Ty, uint32_t elem_count)
322 : : {
323 : 50 : SmallVector<Metadata *, 1> subrange;
324 : 25 : subrange.push_back(reinterpret_cast<DIBuilder*>(dibuilder)->getOrCreateSubrange(0, elem_count));
325 : 25 : DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createVectorType(
326 : : SizeInBits,
327 : : AlignInBits,
328 : : reinterpret_cast<DIType*>(Ty),
329 : 25 : reinterpret_cast<DIBuilder*>(dibuilder)->getOrCreateArray(subrange));
330 : 50 : return reinterpret_cast<ZigLLVMDIType*>(di_type);
331 : : }
332 : :
333 : 2100 : ZigLLVMDIType *ZigLLVMCreateDebugArrayType(ZigLLVMDIBuilder *dibuilder, uint64_t size_in_bits,
334 : : uint64_t align_in_bits, ZigLLVMDIType *elem_type, int elem_count)
335 : : {
336 : 4200 : SmallVector<Metadata *, 1> subrange;
337 : 2100 : subrange.push_back(reinterpret_cast<DIBuilder*>(dibuilder)->getOrCreateSubrange(0, elem_count));
338 : 2100 : DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createArrayType(
339 : : size_in_bits, align_in_bits,
340 : : reinterpret_cast<DIType*>(elem_type),
341 : 2100 : reinterpret_cast<DIBuilder*>(dibuilder)->getOrCreateArray(subrange));
342 : 4200 : return reinterpret_cast<ZigLLVMDIType*>(di_type);
343 : : }
344 : :
345 : 5809 : ZigLLVMDIEnumerator *ZigLLVMCreateDebugEnumerator(ZigLLVMDIBuilder *dibuilder, const char *name, int64_t val) {
346 : 5809 : DIEnumerator *di_enumerator = reinterpret_cast<DIBuilder*>(dibuilder)->createEnumerator(name, val);
347 : 5809 : return reinterpret_cast<ZigLLVMDIEnumerator*>(di_enumerator);
348 : : }
349 : :
350 : 586 : ZigLLVMDIType *ZigLLVMCreateDebugEnumerationType(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIScope *scope,
351 : : const char *name, ZigLLVMDIFile *file, unsigned line_number, uint64_t size_in_bits,
352 : : uint64_t align_in_bits, ZigLLVMDIEnumerator **enumerator_array, int enumerator_array_len,
353 : : ZigLLVMDIType *underlying_type, const char *unique_id)
354 : : {
355 : 1172 : SmallVector<Metadata *, 8> fields;
356 [ + + ]: 4713 : for (int i = 0; i < enumerator_array_len; i += 1) {
357 : 4127 : DIEnumerator *dienumerator = reinterpret_cast<DIEnumerator*>(enumerator_array[i]);
358 : 4127 : fields.push_back(dienumerator);
359 : : }
360 : 586 : DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createEnumerationType(
361 : : reinterpret_cast<DIScope*>(scope),
362 : : name,
363 : : reinterpret_cast<DIFile*>(file),
364 : : line_number, size_in_bits, align_in_bits,
365 : : reinterpret_cast<DIBuilder*>(dibuilder)->getOrCreateArray(fields),
366 : : reinterpret_cast<DIType*>(underlying_type),
367 : 586 : unique_id);
368 : 1172 : return reinterpret_cast<ZigLLVMDIType*>(di_type);
369 : : }
370 : :
371 : 21824 : ZigLLVMDIType *ZigLLVMCreateDebugMemberType(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIScope *scope,
372 : : const char *name, ZigLLVMDIFile *file, unsigned line, uint64_t size_in_bits,
373 : : uint64_t align_in_bits, uint64_t offset_in_bits, unsigned flags, ZigLLVMDIType *type)
374 : : {
375 : 43648 : DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createMemberType(
376 : : reinterpret_cast<DIScope*>(scope),
377 : : name,
378 : : reinterpret_cast<DIFile*>(file),
379 : : line, size_in_bits, align_in_bits, offset_in_bits,
380 : : static_cast<DINode::DIFlags>(flags),
381 : 21824 : reinterpret_cast<DIType*>(type));
382 : 21824 : return reinterpret_cast<ZigLLVMDIType*>(di_type);
383 : : }
384 : :
385 : 358 : ZigLLVMDIType *ZigLLVMCreateDebugUnionType(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIScope *scope,
386 : : const char *name, ZigLLVMDIFile *file, unsigned line_number, uint64_t size_in_bits,
387 : : uint64_t align_in_bits, unsigned flags, ZigLLVMDIType **types_array, int types_array_len,
388 : : unsigned run_time_lang, const char *unique_id)
389 : : {
390 : 716 : SmallVector<Metadata *, 8> fields;
391 [ + + ]: 1103 : for (int i = 0; i < types_array_len; i += 1) {
392 : 745 : DIType *ditype = reinterpret_cast<DIType*>(types_array[i]);
393 : 745 : fields.push_back(ditype);
394 : : }
395 : 358 : DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createUnionType(
396 : : reinterpret_cast<DIScope*>(scope),
397 : : name,
398 : : reinterpret_cast<DIFile*>(file),
399 : : line_number, size_in_bits, align_in_bits,
400 : : static_cast<DINode::DIFlags>(flags),
401 : : reinterpret_cast<DIBuilder*>(dibuilder)->getOrCreateArray(fields),
402 : 358 : run_time_lang, unique_id);
403 : 716 : return reinterpret_cast<ZigLLVMDIType*>(di_type);
404 : : }
405 : :
406 : 6478 : ZigLLVMDIType *ZigLLVMCreateDebugStructType(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIScope *scope,
407 : : const char *name, ZigLLVMDIFile *file, unsigned line_number, uint64_t size_in_bits,
408 : : uint64_t align_in_bits, unsigned flags, ZigLLVMDIType *derived_from,
409 : : ZigLLVMDIType **types_array, int types_array_len, unsigned run_time_lang, ZigLLVMDIType *vtable_holder,
410 : : const char *unique_id)
411 : : {
412 : 12956 : SmallVector<Metadata *, 8> fields;
413 [ + + ]: 27557 : for (int i = 0; i < types_array_len; i += 1) {
414 : 21079 : DIType *ditype = reinterpret_cast<DIType*>(types_array[i]);
415 : 21079 : fields.push_back(ditype);
416 : : }
417 : 6478 : DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createStructType(
418 : : reinterpret_cast<DIScope*>(scope),
419 : : name,
420 : : reinterpret_cast<DIFile*>(file),
421 : : line_number, size_in_bits, align_in_bits,
422 : : static_cast<DINode::DIFlags>(flags),
423 : : reinterpret_cast<DIType*>(derived_from),
424 : : reinterpret_cast<DIBuilder*>(dibuilder)->getOrCreateArray(fields),
425 : : run_time_lang,
426 : : reinterpret_cast<DIType*>(vtable_holder),
427 : 6478 : unique_id);
428 : 12956 : return reinterpret_cast<ZigLLVMDIType*>(di_type);
429 : : }
430 : :
431 : 6582 : ZigLLVMDIType *ZigLLVMCreateReplaceableCompositeType(ZigLLVMDIBuilder *dibuilder, unsigned tag,
432 : : const char *name, ZigLLVMDIScope *scope, ZigLLVMDIFile *file, unsigned line)
433 : : {
434 : 6582 : DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createReplaceableCompositeType(
435 : : tag, name,
436 : : reinterpret_cast<DIScope*>(scope),
437 : : reinterpret_cast<DIFile*>(file),
438 : 6582 : line);
439 : 6582 : return reinterpret_cast<ZigLLVMDIType*>(di_type);
440 : : }
441 : :
442 : 41 : ZigLLVMDIType *ZigLLVMCreateDebugForwardDeclType(ZigLLVMDIBuilder *dibuilder, unsigned tag,
443 : : const char *name, ZigLLVMDIScope *scope, ZigLLVMDIFile *file, unsigned line)
444 : : {
445 : 41 : DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createForwardDecl(
446 : : tag, name,
447 : : reinterpret_cast<DIScope*>(scope),
448 : : reinterpret_cast<DIFile*>(file),
449 : 41 : line);
450 : 41 : return reinterpret_cast<ZigLLVMDIType*>(di_type);
451 : : }
452 : :
453 : 6582 : void ZigLLVMReplaceTemporary(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIType *type,
454 : : ZigLLVMDIType *replacement)
455 : : {
456 : 6582 : reinterpret_cast<DIBuilder*>(dibuilder)->replaceTemporary(
457 : 13164 : TempDIType(reinterpret_cast<DIType*>(type)),
458 : : reinterpret_cast<DIType*>(replacement));
459 : 6582 : }
460 : :
461 : 0 : void ZigLLVMReplaceDebugArrays(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIType *type,
462 : : ZigLLVMDIType **types_array, int types_array_len)
463 : : {
464 : 0 : SmallVector<Metadata *, 8> fields;
465 [ # # ]: 0 : for (int i = 0; i < types_array_len; i += 1) {
466 : 0 : DIType *ditype = reinterpret_cast<DIType*>(types_array[i]);
467 : 0 : fields.push_back(ditype);
468 : : }
469 : 0 : DICompositeType *composite_type = (DICompositeType*)reinterpret_cast<DIType*>(type);
470 : 0 : reinterpret_cast<DIBuilder*>(dibuilder)->replaceArrays(
471 : : composite_type,
472 : 0 : reinterpret_cast<DIBuilder*>(dibuilder)->getOrCreateArray(fields));
473 : 0 : }
474 : :
475 : 10417 : ZigLLVMDIType *ZigLLVMCreateSubroutineType(ZigLLVMDIBuilder *dibuilder_wrapped,
476 : : ZigLLVMDIType **types_array, int types_array_len, unsigned flags)
477 : : {
478 : 20834 : SmallVector<Metadata *, 8> types;
479 [ + + ]: 47433 : for (int i = 0; i < types_array_len; i += 1) {
480 : 37016 : DIType *ditype = reinterpret_cast<DIType*>(types_array[i]);
481 : 37016 : types.push_back(ditype);
482 : : }
483 : 10417 : DIBuilder *dibuilder = reinterpret_cast<DIBuilder*>(dibuilder_wrapped);
484 : 10417 : DISubroutineType *subroutine_type = dibuilder->createSubroutineType(
485 : : dibuilder->getOrCreateTypeArray(types),
486 : 10417 : static_cast<DINode::DIFlags>(flags));
487 : 10417 : DIType *ditype = subroutine_type;
488 : 20834 : return reinterpret_cast<ZigLLVMDIType*>(ditype);
489 : : }
490 : :
491 : 356 : unsigned ZigLLVMEncoding_DW_ATE_unsigned(void) {
492 : 356 : return dwarf::DW_ATE_unsigned;
493 : : }
494 : :
495 : 209 : unsigned ZigLLVMEncoding_DW_ATE_signed(void) {
496 : 209 : return dwarf::DW_ATE_signed;
497 : : }
498 : :
499 : 105 : unsigned ZigLLVMEncoding_DW_ATE_float(void) {
500 : 105 : return dwarf::DW_ATE_float;
501 : : }
502 : :
503 : 21 : unsigned ZigLLVMEncoding_DW_ATE_boolean(void) {
504 : 21 : return dwarf::DW_ATE_boolean;
505 : : }
506 : :
507 : 15 : unsigned ZigLLVMEncoding_DW_ATE_unsigned_char(void) {
508 : 15 : return dwarf::DW_ATE_unsigned_char;
509 : : }
510 : :
511 : 11 : unsigned ZigLLVMEncoding_DW_ATE_signed_char(void) {
512 : 11 : return dwarf::DW_ATE_signed_char;
513 : : }
514 : :
515 : 21 : unsigned ZigLLVMLang_DW_LANG_C99(void) {
516 : 21 : return dwarf::DW_LANG_C99;
517 : : }
518 : :
519 : 0 : unsigned ZigLLVMTag_DW_variable(void) {
520 : 0 : return dwarf::DW_TAG_variable;
521 : : }
522 : :
523 : 6623 : unsigned ZigLLVMTag_DW_structure_type(void) {
524 : 6623 : return dwarf::DW_TAG_structure_type;
525 : : }
526 : :
527 : 0 : unsigned ZigLLVMTag_DW_enumeration_type(void) {
528 : 0 : return dwarf::DW_TAG_enumeration_type;
529 : : }
530 : :
531 : 0 : unsigned ZigLLVMTag_DW_union_type(void) {
532 : 0 : return dwarf::DW_TAG_union_type;
533 : : }
534 : :
535 : 21 : ZigLLVMDIBuilder *ZigLLVMCreateDIBuilder(LLVMModuleRef module, bool allow_unresolved) {
536 [ + - ]: 21 : DIBuilder *di_builder = new(std::nothrow) DIBuilder(*unwrap(module), allow_unresolved);
537 [ - + ]: 21 : if (di_builder == nullptr)
538 : 0 : return nullptr;
539 : 21 : return reinterpret_cast<ZigLLVMDIBuilder *>(di_builder);
540 : : }
541 : :
542 : 0 : void ZigLLVMDisposeDIBuilder(ZigLLVMDIBuilder *dbuilder) {
543 : 0 : DIBuilder *di_builder = reinterpret_cast<DIBuilder *>(dbuilder);
544 [ # # ]: 0 : delete di_builder;
545 : 0 : }
546 : :
547 : 576424 : void ZigLLVMSetCurrentDebugLocation(LLVMBuilderRef builder, int line, int column, ZigLLVMDIScope *scope) {
548 : 576424 : unwrap(builder)->SetCurrentDebugLocation(DebugLoc::get(
549 : : line, column, reinterpret_cast<DIScope*>(scope)));
550 : 576424 : }
551 : :
552 : 42581 : void ZigLLVMClearCurrentDebugLocation(LLVMBuilderRef builder) {
553 : 42581 : unwrap(builder)->SetCurrentDebugLocation(DebugLoc());
554 : 42581 : }
555 : :
556 : :
557 : 36915 : ZigLLVMDILexicalBlock *ZigLLVMCreateLexicalBlock(ZigLLVMDIBuilder *dbuilder, ZigLLVMDIScope *scope,
558 : : ZigLLVMDIFile *file, unsigned line, unsigned col)
559 : : {
560 : : DILexicalBlock *result = reinterpret_cast<DIBuilder*>(dbuilder)->createLexicalBlock(
561 : : reinterpret_cast<DIScope*>(scope),
562 : : reinterpret_cast<DIFile*>(file),
563 : : line,
564 : 36915 : col);
565 : 36915 : return reinterpret_cast<ZigLLVMDILexicalBlock*>(result);
566 : : }
567 : :
568 : 25183 : ZigLLVMDILocalVariable *ZigLLVMCreateAutoVariable(ZigLLVMDIBuilder *dbuilder,
569 : : ZigLLVMDIScope *scope, const char *name, ZigLLVMDIFile *file, unsigned line_no,
570 : : ZigLLVMDIType *type, bool always_preserve, unsigned flags)
571 : : {
572 : 50366 : DILocalVariable *result = reinterpret_cast<DIBuilder*>(dbuilder)->createAutoVariable(
573 : : reinterpret_cast<DIScope*>(scope),
574 : : name,
575 : : reinterpret_cast<DIFile*>(file),
576 : : line_no,
577 : : reinterpret_cast<DIType*>(type),
578 : : always_preserve,
579 : 25183 : static_cast<DINode::DIFlags>(flags));
580 : 25183 : return reinterpret_cast<ZigLLVMDILocalVariable*>(result);
581 : : }
582 : :
583 : 2331 : ZigLLVMDIGlobalVariable *ZigLLVMCreateGlobalVariable(ZigLLVMDIBuilder *dbuilder,
584 : : ZigLLVMDIScope *scope, const char *name, const char *linkage_name, ZigLLVMDIFile *file,
585 : : unsigned line_no, ZigLLVMDIType *di_type, bool is_local_to_unit)
586 : : {
587 : 4662 : DIGlobalVariableExpression *result = reinterpret_cast<DIBuilder*>(dbuilder)->createGlobalVariableExpression(
588 : : reinterpret_cast<DIScope*>(scope),
589 : : name,
590 : : linkage_name,
591 : : reinterpret_cast<DIFile*>(file),
592 : : line_no,
593 : : reinterpret_cast<DIType*>(di_type),
594 : 2331 : is_local_to_unit);
595 : 2331 : return reinterpret_cast<ZigLLVMDIGlobalVariable*>(result);
596 : : }
597 : :
598 : 26582 : ZigLLVMDILocalVariable *ZigLLVMCreateParameterVariable(ZigLLVMDIBuilder *dbuilder,
599 : : ZigLLVMDIScope *scope, const char *name, ZigLLVMDIFile *file, unsigned line_no,
600 : : ZigLLVMDIType *type, bool always_preserve, unsigned flags, unsigned arg_no)
601 : : {
602 [ - + ]: 26582 : assert(arg_no != 0);
603 : 53164 : DILocalVariable *result = reinterpret_cast<DIBuilder*>(dbuilder)->createParameterVariable(
604 : : reinterpret_cast<DIScope*>(scope),
605 : : name,
606 : : arg_no,
607 : : reinterpret_cast<DIFile*>(file),
608 : : line_no,
609 : : reinterpret_cast<DIType*>(type),
610 : : always_preserve,
611 : 26582 : static_cast<DINode::DIFlags>(flags));
612 : 26582 : return reinterpret_cast<ZigLLVMDILocalVariable*>(result);
613 : : }
614 : :
615 : 36915 : ZigLLVMDIScope *ZigLLVMLexicalBlockToScope(ZigLLVMDILexicalBlock *lexical_block) {
616 : 36915 : DIScope *scope = reinterpret_cast<DILexicalBlock*>(lexical_block);
617 : 36915 : return reinterpret_cast<ZigLLVMDIScope*>(scope);
618 : : }
619 : :
620 : 3791 : ZigLLVMDIScope *ZigLLVMCompileUnitToScope(ZigLLVMDICompileUnit *compile_unit) {
621 : 3791 : DIScope *scope = reinterpret_cast<DICompileUnit*>(compile_unit);
622 : 3791 : return reinterpret_cast<ZigLLVMDIScope*>(scope);
623 : : }
624 : :
625 : 6465 : ZigLLVMDIScope *ZigLLVMFileToScope(ZigLLVMDIFile *difile) {
626 : 6465 : DIScope *scope = reinterpret_cast<DIFile*>(difile);
627 : 6465 : return reinterpret_cast<ZigLLVMDIScope*>(scope);
628 : : }
629 : :
630 : 24304 : ZigLLVMDIScope *ZigLLVMSubprogramToScope(ZigLLVMDISubprogram *subprogram) {
631 : 24304 : DIScope *scope = reinterpret_cast<DISubprogram*>(subprogram);
632 : 24304 : return reinterpret_cast<ZigLLVMDIScope*>(scope);
633 : : }
634 : :
635 : 23727 : ZigLLVMDIScope *ZigLLVMTypeToScope(ZigLLVMDIType *type) {
636 : 23727 : DIScope *scope = reinterpret_cast<DIType*>(type);
637 : 23727 : return reinterpret_cast<ZigLLVMDIScope*>(scope);
638 : : }
639 : :
640 : 21 : ZigLLVMDICompileUnit *ZigLLVMCreateCompileUnit(ZigLLVMDIBuilder *dibuilder,
641 : : unsigned lang, ZigLLVMDIFile *difile, const char *producer,
642 : : bool is_optimized, const char *flags, unsigned runtime_version, const char *split_name,
643 : : uint64_t dwo_id, bool emit_debug_info)
644 : : {
645 [ + - ]: 21 : DICompileUnit *result = reinterpret_cast<DIBuilder*>(dibuilder)->createCompileUnit(
646 : : lang,
647 : : reinterpret_cast<DIFile*>(difile),
648 : : producer, is_optimized, flags, runtime_version, split_name,
649 : : (emit_debug_info ? DICompileUnit::DebugEmissionKind::FullDebug : DICompileUnit::DebugEmissionKind::NoDebug),
650 : 21 : dwo_id);
651 : 21 : return reinterpret_cast<ZigLLVMDICompileUnit*>(result);
652 : : }
653 : :
654 : :
655 : 1825 : ZigLLVMDIFile *ZigLLVMCreateFile(ZigLLVMDIBuilder *dibuilder, const char *filename, const char *directory) {
656 : 3650 : DIFile *result = reinterpret_cast<DIBuilder*>(dibuilder)->createFile(filename, directory);
657 : 1825 : return reinterpret_cast<ZigLLVMDIFile*>(result);
658 : : }
659 : :
660 : 24304 : ZigLLVMDISubprogram *ZigLLVMCreateFunction(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIScope *scope,
661 : : const char *name, const char *linkage_name, ZigLLVMDIFile *file, unsigned lineno,
662 : : ZigLLVMDIType *fn_di_type, bool is_local_to_unit, bool is_definition, unsigned scope_line,
663 : : unsigned flags, bool is_optimized, ZigLLVMDISubprogram *decl_subprogram)
664 : : {
665 : 24304 : DISubroutineType *di_sub_type = static_cast<DISubroutineType*>(reinterpret_cast<DIType*>(fn_di_type));
666 : 24304 : DISubprogram *result = reinterpret_cast<DIBuilder*>(dibuilder)->createFunction(
667 : : reinterpret_cast<DIScope*>(scope),
668 : : name, linkage_name,
669 : : reinterpret_cast<DIFile*>(file),
670 : : lineno,
671 : : di_sub_type,
672 : : scope_line,
673 : : static_cast<DINode::DIFlags>(flags),
674 : : DISubprogram::toSPFlags(is_local_to_unit, is_definition, is_optimized),
675 : : nullptr,
676 : : reinterpret_cast<DISubprogram *>(decl_subprogram),
677 : 24304 : nullptr);
678 : 24304 : return reinterpret_cast<ZigLLVMDISubprogram*>(result);
679 : : }
680 : :
681 : 20 : void ZigLLVMDIBuilderFinalize(ZigLLVMDIBuilder *dibuilder) {
682 : 20 : reinterpret_cast<DIBuilder*>(dibuilder)->finalize();
683 : 20 : }
684 : :
685 : 51981 : LLVMValueRef ZigLLVMInsertDeclareAtEnd(ZigLLVMDIBuilder *dibuilder, LLVMValueRef storage,
686 : : ZigLLVMDILocalVariable *var_info, ZigLLVMDILocation *debug_loc, LLVMBasicBlockRef basic_block_ref)
687 : : {
688 : 51981 : Instruction *result = reinterpret_cast<DIBuilder*>(dibuilder)->insertDeclare(
689 : : unwrap(storage),
690 : : reinterpret_cast<DILocalVariable *>(var_info),
691 : : reinterpret_cast<DIBuilder*>(dibuilder)->createExpression(),
692 : : reinterpret_cast<DILocation*>(debug_loc),
693 : 51981 : static_cast<BasicBlock*>(unwrap(basic_block_ref)));
694 : 51981 : return wrap(result);
695 : : }
696 : :
697 : 0 : LLVMValueRef ZigLLVMInsertDeclare(ZigLLVMDIBuilder *dibuilder, LLVMValueRef storage,
698 : : ZigLLVMDILocalVariable *var_info, ZigLLVMDILocation *debug_loc, LLVMValueRef insert_before_instr)
699 : : {
700 : 0 : Instruction *result = reinterpret_cast<DIBuilder*>(dibuilder)->insertDeclare(
701 : : unwrap(storage),
702 : : reinterpret_cast<DILocalVariable *>(var_info),
703 : : reinterpret_cast<DIBuilder*>(dibuilder)->createExpression(),
704 : : reinterpret_cast<DILocation*>(debug_loc),
705 : 0 : static_cast<Instruction*>(unwrap(insert_before_instr)));
706 : 0 : return wrap(result);
707 : : }
708 : :
709 : 51981 : ZigLLVMDILocation *ZigLLVMGetDebugLoc(unsigned line, unsigned col, ZigLLVMDIScope *scope) {
710 : 103962 : DebugLoc debug_loc = DebugLoc::get(line, col, reinterpret_cast<DIScope*>(scope), nullptr);
711 : 51981 : return reinterpret_cast<ZigLLVMDILocation*>(debug_loc.get());
712 : : }
713 : :
714 : 4726 : void ZigLLVMSetFastMath(LLVMBuilderRef builder_wrapped, bool on_state) {
715 [ - + ]: 4726 : if (on_state) {
716 : 0 : FastMathFlags fmf;
717 : 0 : fmf.setFast();
718 : 0 : unwrap(builder_wrapped)->setFastMathFlags(fmf);
719 : : } else {
720 : 4726 : unwrap(builder_wrapped)->clearFastMathFlags();
721 : : }
722 : 4726 : }
723 : :
724 : 48816 : void ZigLLVMAddFunctionAttr(LLVMValueRef fn_ref, const char *attr_name, const char *attr_value) {
725 : 48816 : Function *func = unwrap<Function>(fn_ref);
726 : 48816 : const AttributeList attr_set = func->getAttributes();
727 : 97632 : AttrBuilder attr_builder;
728 [ + + ]: 48816 : if (attr_value) {
729 : 24408 : attr_builder.addAttribute(attr_name, attr_value);
730 : : } else {
731 : 48816 : attr_builder.addAttribute(attr_name);
732 : : }
733 : : const AttributeList new_attr_set = attr_set.addAttributes(func->getContext(),
734 : 48816 : AttributeList::FunctionIndex, attr_builder);
735 : 48816 : func->setAttributes(new_attr_set);
736 : 48816 : }
737 : :
738 : 281 : void ZigLLVMAddFunctionAttrCold(LLVMValueRef fn_ref) {
739 : 281 : Function *func = unwrap<Function>(fn_ref);
740 : 281 : const AttributeList attr_set = func->getAttributes();
741 : : const AttributeList new_attr_set = attr_set.addAttribute(func->getContext(), AttributeList::FunctionIndex,
742 : 281 : Attribute::Cold);
743 : 281 : func->setAttributes(new_attr_set);
744 : 281 : }
745 : :
746 : 0 : void ZigLLVMParseCommandLineOptions(size_t argc, const char *const *argv) {
747 : 0 : llvm::cl::ParseCommandLineOptions(argc, argv);
748 : 0 : }
749 : :
750 : 7106 : const char *ZigLLVMGetArchTypeName(ZigLLVM_ArchType arch) {
751 : 7106 : return (const char*)Triple::getArchTypeName((Triple::ArchType)arch).bytes_begin();
752 : : }
753 : :
754 : 81 : const char *ZigLLVMGetVendorTypeName(ZigLLVM_VendorType vendor) {
755 : 81 : return (const char*)Triple::getVendorTypeName((Triple::VendorType)vendor).bytes_begin();
756 : : }
757 : :
758 : 668 : const char *ZigLLVMGetOSTypeName(ZigLLVM_OSType os) {
759 : 668 : return (const char*)Triple::getOSTypeName((Triple::OSType)os).bytes_begin();
760 : : }
761 : :
762 : 563 : const char *ZigLLVMGetEnvironmentTypeName(ZigLLVM_EnvironmentType env_type) {
763 : 563 : return (const char*)Triple::getEnvironmentTypeName((Triple::EnvironmentType)env_type).bytes_begin();
764 : : }
765 : :
766 : 26 : void ZigLLVMGetNativeTarget(ZigLLVM_ArchType *arch_type, ZigLLVM_SubArchType *sub_arch_type,
767 : : ZigLLVM_VendorType *vendor_type, ZigLLVM_OSType *os_type, ZigLLVM_EnvironmentType *environ_type,
768 : : ZigLLVM_ObjectFormatType *oformat)
769 : : {
770 : 26 : char *native_triple = LLVMGetDefaultTargetTriple();
771 : 52 : Triple triple(Triple::normalize(native_triple));
772 : :
773 : 26 : *arch_type = (ZigLLVM_ArchType)triple.getArch();
774 : 26 : *sub_arch_type = (ZigLLVM_SubArchType)triple.getSubArch();
775 : 26 : *vendor_type = (ZigLLVM_VendorType)triple.getVendor();
776 : 26 : *os_type = (ZigLLVM_OSType)triple.getOS();
777 : 26 : *environ_type = (ZigLLVM_EnvironmentType)triple.getEnvironment();
778 : 26 : *oformat = (ZigLLVM_ObjectFormatType)triple.getObjectFormat();
779 : :
780 : 26 : free(native_triple);
781 : 26 : }
782 : :
783 : 81 : const char *ZigLLVMGetSubArchTypeName(ZigLLVM_SubArchType sub_arch) {
784 [ + - - - : 81 : switch (sub_arch) {
- - - - -
- - - - -
- - - - -
- - - - -
- - - - ]
785 : 81 : case ZigLLVM_NoSubArch:
786 : 81 : return "";
787 : 0 : case ZigLLVM_ARMSubArch_v8_5a:
788 : 0 : return "v8.5a";
789 : 0 : case ZigLLVM_ARMSubArch_v8_4a:
790 : 0 : return "v8.4a";
791 : 0 : case ZigLLVM_ARMSubArch_v8_3a:
792 : 0 : return "v8.3a";
793 : 0 : case ZigLLVM_ARMSubArch_v8_2a:
794 : 0 : return "v8.2a";
795 : 0 : case ZigLLVM_ARMSubArch_v8_1a:
796 : 0 : return "v8.1a";
797 : 0 : case ZigLLVM_ARMSubArch_v8:
798 : 0 : return "v8";
799 : 0 : case ZigLLVM_ARMSubArch_v8r:
800 : 0 : return "v8r";
801 : 0 : case ZigLLVM_ARMSubArch_v8m_baseline:
802 : 0 : return "v8m.base";
803 : 0 : case ZigLLVM_ARMSubArch_v8m_mainline:
804 : 0 : return "v8m.main";
805 : 0 : case ZigLLVM_ARMSubArch_v7:
806 : 0 : return "v7";
807 : 0 : case ZigLLVM_ARMSubArch_v7em:
808 : 0 : return "v7em";
809 : 0 : case ZigLLVM_ARMSubArch_v7m:
810 : 0 : return "v7m";
811 : 0 : case ZigLLVM_ARMSubArch_v7s:
812 : 0 : return "v7s";
813 : 0 : case ZigLLVM_ARMSubArch_v7k:
814 : 0 : return "v7k";
815 : 0 : case ZigLLVM_ARMSubArch_v7ve:
816 : 0 : return "v7ve";
817 : 0 : case ZigLLVM_ARMSubArch_v6:
818 : 0 : return "v6";
819 : 0 : case ZigLLVM_ARMSubArch_v6m:
820 : 0 : return "v6m";
821 : 0 : case ZigLLVM_ARMSubArch_v6k:
822 : 0 : return "v6k";
823 : 0 : case ZigLLVM_ARMSubArch_v6t2:
824 : 0 : return "v6t2";
825 : 0 : case ZigLLVM_ARMSubArch_v5:
826 : 0 : return "v5";
827 : 0 : case ZigLLVM_ARMSubArch_v5te:
828 : 0 : return "v5te";
829 : 0 : case ZigLLVM_ARMSubArch_v4t:
830 : 0 : return "v4t";
831 : 0 : case ZigLLVM_KalimbaSubArch_v3:
832 : 0 : return "v3";
833 : 0 : case ZigLLVM_KalimbaSubArch_v4:
834 : 0 : return "v4";
835 : 0 : case ZigLLVM_KalimbaSubArch_v5:
836 : 0 : return "v5";
837 : 0 : case ZigLLVM_MipsSubArch_r6:
838 : 0 : return "r6";
839 : : }
840 : 0 : abort();
841 : : }
842 : :
843 : 17 : void ZigLLVMAddModuleDebugInfoFlag(LLVMModuleRef module) {
844 : 34 : unwrap(module)->addModuleFlag(Module::Warning, "Debug Info Version", DEBUG_METADATA_VERSION);
845 : 34 : unwrap(module)->addModuleFlag(Module::Warning, "Dwarf Version", 4);
846 : 17 : }
847 : :
848 : 4 : void ZigLLVMAddModuleCodeViewFlag(LLVMModuleRef module) {
849 : 8 : unwrap(module)->addModuleFlag(Module::Warning, "CodeView", 1);
850 : 4 : }
851 : :
852 : 126 : static AtomicOrdering mapFromLLVMOrdering(LLVMAtomicOrdering Ordering) {
853 [ - - + + : 126 : switch (Ordering) {
- - + - ]
854 : 0 : case LLVMAtomicOrderingNotAtomic: return AtomicOrdering::NotAtomic;
855 : 0 : case LLVMAtomicOrderingUnordered: return AtomicOrdering::Unordered;
856 : 19 : case LLVMAtomicOrderingMonotonic: return AtomicOrdering::Monotonic;
857 : 3 : case LLVMAtomicOrderingAcquire: return AtomicOrdering::Acquire;
858 : 0 : case LLVMAtomicOrderingRelease: return AtomicOrdering::Release;
859 : 0 : case LLVMAtomicOrderingAcquireRelease: return AtomicOrdering::AcquireRelease;
860 : 104 : case LLVMAtomicOrderingSequentiallyConsistent: return AtomicOrdering::SequentiallyConsistent;
861 : : }
862 : 0 : abort();
863 : : }
864 : :
865 : 63 : LLVMValueRef ZigLLVMBuildCmpXchg(LLVMBuilderRef builder, LLVMValueRef ptr, LLVMValueRef cmp,
866 : : LLVMValueRef new_val, LLVMAtomicOrdering success_ordering,
867 : : LLVMAtomicOrdering failure_ordering, bool is_weak)
868 : : {
869 : 63 : AtomicCmpXchgInst *inst = unwrap(builder)->CreateAtomicCmpXchg(unwrap(ptr), unwrap(cmp),
870 : 63 : unwrap(new_val), mapFromLLVMOrdering(success_ordering), mapFromLLVMOrdering(failure_ordering));
871 : 63 : inst->setWeak(is_weak);
872 : 63 : return wrap(inst);
873 : : }
874 : :
875 : 0 : LLVMValueRef ZigLLVMBuildNSWShl(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMValueRef RHS,
876 : : const char *name)
877 : : {
878 : 0 : return wrap(unwrap(builder)->CreateShl(unwrap(LHS), unwrap(RHS), name, false, true));
879 : : }
880 : :
881 : 0 : LLVMValueRef ZigLLVMBuildNUWShl(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMValueRef RHS,
882 : : const char *name)
883 : : {
884 : 0 : return wrap(unwrap(builder)->CreateShl(unwrap(LHS), unwrap(RHS), name, true, false));
885 : : }
886 : :
887 : 0 : LLVMValueRef ZigLLVMBuildLShrExact(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMValueRef RHS,
888 : : const char *name)
889 : : {
890 : 0 : return wrap(unwrap(builder)->CreateLShr(unwrap(LHS), unwrap(RHS), name, true));
891 : : }
892 : :
893 : 0 : LLVMValueRef ZigLLVMBuildAShrExact(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMValueRef RHS,
894 : : const char *name)
895 : : {
896 : 0 : return wrap(unwrap(builder)->CreateAShr(unwrap(LHS), unwrap(RHS), name, true));
897 : : }
898 : :
899 : 0 : void ZigLLVMSetTailCall(LLVMValueRef Call) {
900 : 0 : unwrap<CallInst>(Call)->setTailCallKind(CallInst::TCK_MustTail);
901 : 0 : }
902 : :
903 : 824 : void ZigLLVMFunctionSetPrefixData(LLVMValueRef function, LLVMValueRef data) {
904 : 824 : unwrap<Function>(function)->setPrefixData(unwrap<Constant>(data));
905 : 824 : }
906 : :
907 : :
908 : 38 : class MyOStream: public raw_ostream {
909 : : public:
910 : 19 : MyOStream(void (*_append_diagnostic)(void *, const char *, size_t), void *_context) :
911 : 19 : raw_ostream(true), append_diagnostic(_append_diagnostic), context(_context), pos(0) {
912 : :
913 : 19 : }
914 : 0 : void write_impl(const char *ptr, size_t len) override {
915 : 0 : append_diagnostic(context, ptr, len);
916 : 0 : pos += len;
917 : 0 : }
918 : 0 : uint64_t current_pos() const override {
919 : 0 : return pos;
920 : : }
921 : : void (*append_diagnostic)(void *, const char *, size_t);
922 : : void *context;
923 : : size_t pos;
924 : : };
925 : :
926 : 9 : bool ZigLLVMWriteArchive(const char *archive_name, const char **file_names, size_t file_name_count,
927 : : ZigLLVM_OSType os_type)
928 : : {
929 : : object::Archive::Kind kind;
930 [ + + + - : 9 : switch (os_type) {
- ]
931 : 2 : case ZigLLVM_Win32:
932 : : // For some reason llvm-lib passes K_GNU on windows.
933 : : // See lib/ToolDrivers/llvm-lib/LibDriver.cpp:168 in libDriverMain
934 : 2 : kind = object::Archive::K_GNU;
935 : 2 : break;
936 : 6 : case ZigLLVM_Linux:
937 : 6 : kind = object::Archive::K_GNU;
938 : 6 : break;
939 : 1 : case ZigLLVM_MacOSX:
940 : : case ZigLLVM_Darwin:
941 : : case ZigLLVM_IOS:
942 : 1 : kind = object::Archive::K_DARWIN;
943 : 1 : break;
944 : 0 : case ZigLLVM_OpenBSD:
945 : : case ZigLLVM_FreeBSD:
946 : 0 : kind = object::Archive::K_BSD;
947 : 0 : break;
948 : 0 : default:
949 : 0 : kind = object::Archive::K_GNU;
950 : : }
951 : 18 : SmallVector<NewArchiveMember, 4> new_members;
952 [ + + ]: 46 : for (size_t i = 0; i < file_name_count; i += 1) {
953 : 74 : Expected<NewArchiveMember> new_member = NewArchiveMember::getFile(file_names[i], true);
954 [ + - ]: 74 : Error err = new_member.takeError();
955 [ - + ]: 37 : if (err) return true;
956 [ + - ]: 37 : new_members.push_back(std::move(*new_member));
957 : : }
958 : 27 : Error err = writeArchive(archive_name, new_members, true, kind, true, false, nullptr);
959 [ - + ]: 9 : if (err) return true;
960 : 9 : return false;
961 : : }
962 : :
963 : :
964 : 19 : bool ZigLLDLink(ZigLLVM_ObjectFormatType oformat, const char **args, size_t arg_count,
965 : : void (*append_diagnostic)(void *, const char *, size_t), void *context)
966 : : {
967 : 19 : ArrayRef<const char *> array_ref_args(args, arg_count);
968 : :
969 : 38 : MyOStream diag(append_diagnostic, context);
970 : :
971 [ - + + + : 19 : switch (oformat) {
- - ]
972 : 0 : case ZigLLVM_UnknownObjectFormat:
973 : 0 : assert(false); // unreachable
974 : :
975 : 6 : case ZigLLVM_COFF:
976 : 6 : return lld::coff::link(array_ref_args, false, diag);
977 : :
978 : 11 : case ZigLLVM_ELF:
979 : 11 : return lld::elf::link(array_ref_args, false, diag);
980 : :
981 : 2 : case ZigLLVM_MachO:
982 : 2 : return lld::mach_o::link(array_ref_args, false, diag);
983 : :
984 : 0 : case ZigLLVM_Wasm:
985 : 0 : return lld::wasm::link(array_ref_args, false, diag);
986 : : }
987 : 0 : assert(false); // unreachable
988 : : abort();
989 : : }
990 : :
991 : : static_assert((Triple::ArchType)ZigLLVM_UnknownArch == Triple::UnknownArch, "");
992 : : static_assert((Triple::ArchType)ZigLLVM_arm == Triple::arm, "");
993 : : static_assert((Triple::ArchType)ZigLLVM_armeb == Triple::armeb, "");
994 : : static_assert((Triple::ArchType)ZigLLVM_aarch64 == Triple::aarch64, "");
995 : : static_assert((Triple::ArchType)ZigLLVM_aarch64_be == Triple::aarch64_be, "");
996 : : static_assert((Triple::ArchType)ZigLLVM_arc == Triple::arc, "");
997 : : static_assert((Triple::ArchType)ZigLLVM_avr == Triple::avr, "");
998 : : static_assert((Triple::ArchType)ZigLLVM_bpfel == Triple::bpfel, "");
999 : : static_assert((Triple::ArchType)ZigLLVM_bpfeb == Triple::bpfeb, "");
1000 : : static_assert((Triple::ArchType)ZigLLVM_hexagon == Triple::hexagon, "");
1001 : : static_assert((Triple::ArchType)ZigLLVM_mips == Triple::mips, "");
1002 : : static_assert((Triple::ArchType)ZigLLVM_mipsel == Triple::mipsel, "");
1003 : : static_assert((Triple::ArchType)ZigLLVM_mips64 == Triple::mips64, "");
1004 : : static_assert((Triple::ArchType)ZigLLVM_mips64el == Triple::mips64el, "");
1005 : : static_assert((Triple::ArchType)ZigLLVM_msp430 == Triple::msp430, "");
1006 : : static_assert((Triple::ArchType)ZigLLVM_ppc == Triple::ppc, "");
1007 : : static_assert((Triple::ArchType)ZigLLVM_ppc64 == Triple::ppc64, "");
1008 : : static_assert((Triple::ArchType)ZigLLVM_ppc64le == Triple::ppc64le, "");
1009 : : static_assert((Triple::ArchType)ZigLLVM_r600 == Triple::r600, "");
1010 : : static_assert((Triple::ArchType)ZigLLVM_amdgcn == Triple::amdgcn, "");
1011 : : static_assert((Triple::ArchType)ZigLLVM_riscv32 == Triple::riscv32, "");
1012 : : static_assert((Triple::ArchType)ZigLLVM_riscv64 == Triple::riscv64, "");
1013 : : static_assert((Triple::ArchType)ZigLLVM_sparc == Triple::sparc, "");
1014 : : static_assert((Triple::ArchType)ZigLLVM_sparcv9 == Triple::sparcv9, "");
1015 : : static_assert((Triple::ArchType)ZigLLVM_sparcel == Triple::sparcel, "");
1016 : : static_assert((Triple::ArchType)ZigLLVM_systemz == Triple::systemz, "");
1017 : : static_assert((Triple::ArchType)ZigLLVM_tce == Triple::tce, "");
1018 : : static_assert((Triple::ArchType)ZigLLVM_tcele == Triple::tcele, "");
1019 : : static_assert((Triple::ArchType)ZigLLVM_thumb == Triple::thumb, "");
1020 : : static_assert((Triple::ArchType)ZigLLVM_thumbeb == Triple::thumbeb, "");
1021 : : static_assert((Triple::ArchType)ZigLLVM_x86 == Triple::x86, "");
1022 : : static_assert((Triple::ArchType)ZigLLVM_x86_64 == Triple::x86_64, "");
1023 : : static_assert((Triple::ArchType)ZigLLVM_xcore == Triple::xcore, "");
1024 : : static_assert((Triple::ArchType)ZigLLVM_nvptx == Triple::nvptx, "");
1025 : : static_assert((Triple::ArchType)ZigLLVM_nvptx64 == Triple::nvptx64, "");
1026 : : static_assert((Triple::ArchType)ZigLLVM_le32 == Triple::le32, "");
1027 : : static_assert((Triple::ArchType)ZigLLVM_le64 == Triple::le64, "");
1028 : : static_assert((Triple::ArchType)ZigLLVM_amdil == Triple::amdil, "");
1029 : : static_assert((Triple::ArchType)ZigLLVM_amdil64 == Triple::amdil64, "");
1030 : : static_assert((Triple::ArchType)ZigLLVM_hsail == Triple::hsail, "");
1031 : : static_assert((Triple::ArchType)ZigLLVM_hsail64 == Triple::hsail64, "");
1032 : : static_assert((Triple::ArchType)ZigLLVM_spir == Triple::spir, "");
1033 : : static_assert((Triple::ArchType)ZigLLVM_spir64 == Triple::spir64, "");
1034 : : static_assert((Triple::ArchType)ZigLLVM_kalimba == Triple::kalimba, "");
1035 : : static_assert((Triple::ArchType)ZigLLVM_shave == Triple::shave, "");
1036 : : static_assert((Triple::ArchType)ZigLLVM_lanai == Triple::lanai, "");
1037 : : static_assert((Triple::ArchType)ZigLLVM_wasm32 == Triple::wasm32, "");
1038 : : static_assert((Triple::ArchType)ZigLLVM_wasm64 == Triple::wasm64, "");
1039 : : static_assert((Triple::ArchType)ZigLLVM_renderscript32 == Triple::renderscript32, "");
1040 : : static_assert((Triple::ArchType)ZigLLVM_renderscript64 == Triple::renderscript64, "");
1041 : : static_assert((Triple::ArchType)ZigLLVM_LastArchType == Triple::LastArchType, "");
1042 : :
1043 : : static_assert((Triple::SubArchType)ZigLLVM_NoSubArch == Triple::NoSubArch, "");
1044 : : static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v8_4a == Triple::ARMSubArch_v8_4a, "");
1045 : : static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v8_3a == Triple::ARMSubArch_v8_3a, "");
1046 : : static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v8_2a == Triple::ARMSubArch_v8_2a, "");
1047 : : static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v8_1a == Triple::ARMSubArch_v8_1a, "");
1048 : : static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v8 == Triple::ARMSubArch_v8, "");
1049 : : static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v8r == Triple::ARMSubArch_v8r, "");
1050 : : static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v8m_baseline == Triple::ARMSubArch_v8m_baseline, "");
1051 : : static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v8m_mainline == Triple::ARMSubArch_v8m_mainline, "");
1052 : : static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v7 == Triple::ARMSubArch_v7, "");
1053 : : static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v7em == Triple::ARMSubArch_v7em, "");
1054 : : static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v7m == Triple::ARMSubArch_v7m, "");
1055 : : static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v7s == Triple::ARMSubArch_v7s, "");
1056 : : static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v7k == Triple::ARMSubArch_v7k, "");
1057 : : static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v7ve == Triple::ARMSubArch_v7ve, "");
1058 : : static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v6 == Triple::ARMSubArch_v6, "");
1059 : : static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v6m == Triple::ARMSubArch_v6m, "");
1060 : : static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v6k == Triple::ARMSubArch_v6k, "");
1061 : : static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v6t2 == Triple::ARMSubArch_v6t2, "");
1062 : : static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v5 == Triple::ARMSubArch_v5, "");
1063 : : static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v5te == Triple::ARMSubArch_v5te, "");
1064 : : static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v4t == Triple::ARMSubArch_v4t, "");
1065 : : static_assert((Triple::SubArchType)ZigLLVM_KalimbaSubArch_v3 == Triple::KalimbaSubArch_v3, "");
1066 : : static_assert((Triple::SubArchType)ZigLLVM_KalimbaSubArch_v4 == Triple::KalimbaSubArch_v4, "");
1067 : : static_assert((Triple::SubArchType)ZigLLVM_KalimbaSubArch_v5 == Triple::KalimbaSubArch_v5, "");
1068 : : static_assert((Triple::SubArchType)ZigLLVM_KalimbaSubArch_v5 == Triple::KalimbaSubArch_v5, "");
1069 : : static_assert((Triple::SubArchType)ZigLLVM_MipsSubArch_r6 == Triple::MipsSubArch_r6, "");
1070 : :
1071 : : static_assert((Triple::VendorType)ZigLLVM_UnknownVendor == Triple::UnknownVendor, "");
1072 : : static_assert((Triple::VendorType)ZigLLVM_Apple == Triple::Apple, "");
1073 : : static_assert((Triple::VendorType)ZigLLVM_PC == Triple::PC, "");
1074 : : static_assert((Triple::VendorType)ZigLLVM_SCEI == Triple::SCEI, "");
1075 : : static_assert((Triple::VendorType)ZigLLVM_BGP == Triple::BGP, "");
1076 : : static_assert((Triple::VendorType)ZigLLVM_BGQ == Triple::BGQ, "");
1077 : : static_assert((Triple::VendorType)ZigLLVM_Freescale == Triple::Freescale, "");
1078 : : static_assert((Triple::VendorType)ZigLLVM_IBM == Triple::IBM, "");
1079 : : static_assert((Triple::VendorType)ZigLLVM_ImaginationTechnologies == Triple::ImaginationTechnologies, "");
1080 : : static_assert((Triple::VendorType)ZigLLVM_MipsTechnologies == Triple::MipsTechnologies, "");
1081 : : static_assert((Triple::VendorType)ZigLLVM_NVIDIA == Triple::NVIDIA, "");
1082 : : static_assert((Triple::VendorType)ZigLLVM_CSR == Triple::CSR, "");
1083 : : static_assert((Triple::VendorType)ZigLLVM_Myriad == Triple::Myriad, "");
1084 : : static_assert((Triple::VendorType)ZigLLVM_AMD == Triple::AMD, "");
1085 : : static_assert((Triple::VendorType)ZigLLVM_Mesa == Triple::Mesa, "");
1086 : : static_assert((Triple::VendorType)ZigLLVM_SUSE == Triple::SUSE, "");
1087 : : static_assert((Triple::VendorType)ZigLLVM_OpenEmbedded == Triple::OpenEmbedded, "");
1088 : : static_assert((Triple::VendorType)ZigLLVM_LastVendorType == Triple::LastVendorType, "");
1089 : :
1090 : : static_assert((Triple::OSType)ZigLLVM_UnknownOS == Triple::UnknownOS, "");
1091 : : static_assert((Triple::OSType)ZigLLVM_Ananas == Triple::Ananas, "");
1092 : : static_assert((Triple::OSType)ZigLLVM_CloudABI == Triple::CloudABI, "");
1093 : : static_assert((Triple::OSType)ZigLLVM_Darwin == Triple::Darwin, "");
1094 : : static_assert((Triple::OSType)ZigLLVM_DragonFly == Triple::DragonFly, "");
1095 : : static_assert((Triple::OSType)ZigLLVM_FreeBSD == Triple::FreeBSD, "");
1096 : : static_assert((Triple::OSType)ZigLLVM_Fuchsia == Triple::Fuchsia, "");
1097 : : static_assert((Triple::OSType)ZigLLVM_IOS == Triple::IOS, "");
1098 : : // Commented out to work around a Debian/Ubuntu bug.
1099 : : // See https://github.com/ziglang/zig/issues/2076
1100 : : //static_assert((Triple::OSType)ZigLLVM_KFreeBSD == Triple::KFreeBSD, "");
1101 : : static_assert((Triple::OSType)ZigLLVM_Linux == Triple::Linux, "");
1102 : : static_assert((Triple::OSType)ZigLLVM_Lv2 == Triple::Lv2, "");
1103 : : static_assert((Triple::OSType)ZigLLVM_MacOSX == Triple::MacOSX, "");
1104 : : static_assert((Triple::OSType)ZigLLVM_NetBSD == Triple::NetBSD, "");
1105 : : static_assert((Triple::OSType)ZigLLVM_OpenBSD == Triple::OpenBSD, "");
1106 : : static_assert((Triple::OSType)ZigLLVM_Solaris == Triple::Solaris, "");
1107 : : static_assert((Triple::OSType)ZigLLVM_Win32 == Triple::Win32, "");
1108 : : static_assert((Triple::OSType)ZigLLVM_Haiku == Triple::Haiku, "");
1109 : : static_assert((Triple::OSType)ZigLLVM_Minix == Triple::Minix, "");
1110 : : static_assert((Triple::OSType)ZigLLVM_RTEMS == Triple::RTEMS, "");
1111 : : static_assert((Triple::OSType)ZigLLVM_NaCl == Triple::NaCl, "");
1112 : : static_assert((Triple::OSType)ZigLLVM_CNK == Triple::CNK, "");
1113 : : static_assert((Triple::OSType)ZigLLVM_AIX == Triple::AIX, "");
1114 : : static_assert((Triple::OSType)ZigLLVM_CUDA == Triple::CUDA, "");
1115 : : static_assert((Triple::OSType)ZigLLVM_NVCL == Triple::NVCL, "");
1116 : : static_assert((Triple::OSType)ZigLLVM_AMDHSA == Triple::AMDHSA, "");
1117 : : static_assert((Triple::OSType)ZigLLVM_PS4 == Triple::PS4, "");
1118 : : static_assert((Triple::OSType)ZigLLVM_ELFIAMCU == Triple::ELFIAMCU, "");
1119 : : static_assert((Triple::OSType)ZigLLVM_TvOS == Triple::TvOS, "");
1120 : : static_assert((Triple::OSType)ZigLLVM_WatchOS == Triple::WatchOS, "");
1121 : : static_assert((Triple::OSType)ZigLLVM_Mesa3D == Triple::Mesa3D, "");
1122 : : static_assert((Triple::OSType)ZigLLVM_Contiki == Triple::Contiki, "");
1123 : : static_assert((Triple::OSType)ZigLLVM_AMDPAL == Triple::AMDPAL, "");
1124 : : static_assert((Triple::OSType)ZigLLVM_LastOSType == Triple::LastOSType, "");
1125 : :
1126 : : static_assert((Triple::EnvironmentType)ZigLLVM_UnknownEnvironment == Triple::UnknownEnvironment, "");
1127 : : static_assert((Triple::EnvironmentType)ZigLLVM_GNU == Triple::GNU, "");
1128 : : static_assert((Triple::EnvironmentType)ZigLLVM_GNUABIN32 == Triple::GNUABIN32, "");
1129 : : static_assert((Triple::EnvironmentType)ZigLLVM_GNUABI64 == Triple::GNUABI64, "");
1130 : : static_assert((Triple::EnvironmentType)ZigLLVM_GNUEABI == Triple::GNUEABI, "");
1131 : : static_assert((Triple::EnvironmentType)ZigLLVM_GNUEABIHF == Triple::GNUEABIHF, "");
1132 : : static_assert((Triple::EnvironmentType)ZigLLVM_GNUX32 == Triple::GNUX32, "");
1133 : : static_assert((Triple::EnvironmentType)ZigLLVM_CODE16 == Triple::CODE16, "");
1134 : : static_assert((Triple::EnvironmentType)ZigLLVM_EABI == Triple::EABI, "");
1135 : : static_assert((Triple::EnvironmentType)ZigLLVM_EABIHF == Triple::EABIHF, "");
1136 : : static_assert((Triple::EnvironmentType)ZigLLVM_Android == Triple::Android, "");
1137 : : static_assert((Triple::EnvironmentType)ZigLLVM_Musl == Triple::Musl, "");
1138 : : static_assert((Triple::EnvironmentType)ZigLLVM_MuslEABI == Triple::MuslEABI, "");
1139 : : static_assert((Triple::EnvironmentType)ZigLLVM_MuslEABIHF == Triple::MuslEABIHF, "");
1140 : : static_assert((Triple::EnvironmentType)ZigLLVM_MSVC == Triple::MSVC, "");
1141 : : static_assert((Triple::EnvironmentType)ZigLLVM_Itanium == Triple::Itanium, "");
1142 : : static_assert((Triple::EnvironmentType)ZigLLVM_Cygnus == Triple::Cygnus, "");
1143 : : static_assert((Triple::EnvironmentType)ZigLLVM_CoreCLR == Triple::CoreCLR, "");
1144 : : static_assert((Triple::EnvironmentType)ZigLLVM_Simulator == Triple::Simulator, "");
1145 : : static_assert((Triple::EnvironmentType)ZigLLVM_LastEnvironmentType == Triple::LastEnvironmentType, "");
1146 : :
1147 : : static_assert((Triple::ObjectFormatType)ZigLLVM_UnknownObjectFormat == Triple::UnknownObjectFormat, "");
1148 : : static_assert((Triple::ObjectFormatType)ZigLLVM_COFF == Triple::COFF, "");
1149 : : static_assert((Triple::ObjectFormatType)ZigLLVM_ELF == Triple::ELF, "");
1150 : : static_assert((Triple::ObjectFormatType)ZigLLVM_MachO == Triple::MachO, "");
1151 : : static_assert((Triple::ObjectFormatType)ZigLLVM_Wasm == Triple::Wasm, "");
|
