├── .gitignore ├── .travis.yml ├── LICENSE.txt ├── README.md ├── dub.json ├── examples └── fibonacci │ ├── dub.json │ └── fibonacci.d ├── source └── llvm │ ├── config.d │ ├── constants.d │ ├── functions │ ├── link.d │ ├── load.d │ └── package.d │ ├── package.d │ └── types.d └── tools └── get-targets /.gitignore: -------------------------------------------------------------------------------- 1 | .dub 2 | fibonacci 3 | libllvm-d.a 4 | *.s 5 | *.json -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | language: d 2 | 3 | os: 4 | - linux 5 | - osx 6 | 7 | dist: trusty 8 | sudo: required 9 | 10 | osx_image: xcode11.5 11 | 12 | d: 13 | - dmd-2.092.1 14 | 15 | before_install: 16 | - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then sudo apt-get -qq update; fi 17 | - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then sudo apt-get install llvm-3.6; fi 18 | - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then sudo ln -s /usr/lib/llvm-3.6/lib/libLLVM-3.6.so /usr/lib/libLLVM.so; fi 19 | - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then sudo ln -s /usr/lib/llvm-3.6/lib/libLTO.so /usr/lib/libLTO.so; fi 20 | 21 | - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew update; fi 22 | - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew install llvm@10; fi 23 | 24 | script: 25 | - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then DFLAGS="-version=LLVM_3_6_0" dub run --root=examples/fibonacci --compiler=$DC --config=link-single; fi 26 | 27 | - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then DFLAGS="-version=LLVM_10_0_0" LD_LIBRARY_PATH="/usr/local/opt/llvm/lib" dub run --root=examples/fibonacci --config=load; fi 28 | -------------------------------------------------------------------------------- /LICENSE.txt: -------------------------------------------------------------------------------- 1 | Copyright (c) 2013-2020 Moritz Maxeiner 2 | Copyright (c) 2016 Alex Parrill 3 | 4 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and 5 | associated documentation files (the "Software"), to deal in the Software without restriction, 6 | including without limitation the rights to use, copy, modify, merge, publish, distribute, 7 | sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is 8 | furnished to do so, subject to the following conditions: 9 | 10 | The above copyright notice and this permission notice shall be included in all copies or 11 | substantial portions of the Software. 12 | 13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT 14 | NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 15 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 16 | DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 17 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 18 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | llvm-d 2 | ======== 3 | 4 | [![Build Status](https://travis-ci.org/MoritzMaxeiner/llvm-d.svg?branch=master)](https://travis-ci.org/MoritzMaxeiner/llvm-d) Dub version Dub downloads 5 | 6 | llvm-d provides bindings to LLVM's C API for the D programming language. 7 | It is designed to be linked dynamically against LLVM. 8 | 9 | Usage 10 | ----- 11 | 12 | 1. `import llvm;` all of LLVM's C API's functions should be available 13 | 2. Link against either the correct library (LLVM built as singleton), or the correct libraries (LLVM built as several libraries) 14 | *Note:* That includes ensuring your linker can find them 15 | 16 | For example: 17 | 18 | ```d 19 | import std.stdio; 20 | 21 | import llvm; 22 | 23 | void main(string[] args) 24 | { 25 | static if((asVersion(3, 3, 0) <= LLVM_Version) && (LLVM_Version < asVersion(3, 5, 0))) 26 | { 27 | writefln("LLVM multithreading on? %s", cast(bool) LLVMIsMultithreaded()); 28 | writefln("Turning it on"); LLVMStartMultithreaded(); 29 | writefln("LLVM multithreading on? %s", cast(bool) LLVMIsMultithreaded()); 30 | writefln("Turning it off"); LLVMStopMultithreaded(); 31 | writefln("LLVM multithreading on? %s", cast(bool) LLVMIsMultithreaded()); 32 | } 33 | } 34 | ``` 35 | 36 | Note that a `static if` is used to ensure the function calls are only compiled 37 | in if llvm-d is set to compile for a viable LLVM version 38 | (the multithreaded functions where added to LLVM's C API in the 3.3 development 39 | cycle and removed in the 3.5 development cycle; thus they are only available in versions 3.3 and 3.4). 40 | 41 | A more complex example showing how to create a jitted function calculating 42 | the fibonacci series can be seen at `examples/fibonacci/fibonacci.d`. 43 | 44 | LLVM versions 45 | ------------- 46 | 47 | The LLVM version to be used is selected by setting a [conditional compilation version identifier](https://dlang.org/spec/version.html). 48 | For DMD, this is the `-version` argument; for dub, the `versions` field. 49 | 50 | The identifier to set the LLVM version is defined as 51 | `LLVM_{MAJOR_VERSION}_{MINOR_VERSION}_{PATCH_VERSION}`, so to get LLVM version 3.1.0 use `LLVM_3_1_0`. 52 | 53 | Current supported versions are 3.1.0 - 10.0.0 and if no version is given 54 | at compile time, 10.0.0 will be assumed. 55 | 56 | LLVM targets 57 | ------------ 58 | 59 | As with the LLVM version, LLVM targets are also selected by setting an appropriate [conditional compilation version identifier](https://dlang.org/spec/version.html). 60 | 61 | The identifier to enable an LLVM target XyZ is defined as 62 | `LLVM_Target_XyZ`, which will instruct llvm-d to assume any C API functions for those targets will be linked in, so to enable the X86 LLVM target, use `LLVM_Target_X86`. 63 | 64 | *Note*: The target name is case sensitive. 65 | 66 | *Note*: Multiple targets can be enabled in this manner. 67 | 68 | llvm-d supports all targets for the supported LLVM versions and if no target is given at compile time, none will be assumed to be available. 69 | The dub package's default configuration sets the appropriate identifier to enable the native target for some common platforms. 70 | 71 | Dynamic loading 72 | --------------- 73 | 74 | By default, llvm-d requires you to link against the LLVM library (or libraries in case of a split build). 75 | If you instead wish to load from shared libraries at runtime, set the D version `LLVM_Load`. You can then use `LLVM.load` and `LLVM.unload` for dynamic loading. 76 | If you additionally set the D version `LLVM_Autoload`, llvm-d will attempt to load default libraries at program startup. 77 | 78 | *Note*: Enabling dynamic loading will likely result in noticeable compile time increase, as it uses compile time reflection. 79 | 80 | *Note*: If compilation freezes in release mode with dub, the `--build-mode=allAtOnce` flag may help. 81 | 82 | Documentation 83 | ------------- 84 | 85 | llvm-d exposes C linkage functions, constants, and types with the same names as LLVM's C API. 86 | [See the LLVM Doxygen pages for a reference.](http://llvm.org/doxygen/modules.html) 87 | 88 | License 89 | ------- 90 | 91 | llvm-d is released under the [MIT license](http://opensource.org/licenses/MIT), see LICENSE.txt. 92 | 93 | llvm-d uses source code from LLVM that has been ported to D for accessing LLVM's C API. The above paragraph does not apply 94 | to that source code - it is a redistribution of LLVM source code. 95 | 96 | LLVM is Copyright (c) 2003-2020 University of Illinois at Urbana-Champaign. 97 | All rights reserved. 98 | 99 | LLVM is distributed under the University of Illinois Open Source 100 | License. See http://opensource.org/licenses/UoI-NCSA.php for details. 101 | -------------------------------------------------------------------------------- /dub.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "llvm-d", 3 | "description": "D bindings for LLVM", 4 | "copyright": "Copyright © 2013-2018 Moritz Maxeiner, Copyright © 2016-2017 Alex Parrill", 5 | "license": "MIT", 6 | "authors": [ 7 | "Moritz Maxeiner", 8 | "Alex Parrill" 9 | ], 10 | "homepage": "https://github.com/MoritzMaxeiner/llvm-d", 11 | 12 | "targetType": "library", 13 | "configurations": [ 14 | { 15 | "name": "native-target", 16 | "versions-x86": ["LLVM_Target_X86"], 17 | "versions-x86_64": ["LLVM_Target_X86"], 18 | "versions-sparc": ["LLVM_Target_Sparc"], 19 | "versions-sparc64": ["LLVM_Target_Sparc"], 20 | "versions-ppc": ["LLVM_Target_PowerPC"], 21 | "versions-ppc64": ["LLVM_Target_PowerPC"], 22 | "versions-aarch64": ["LLVM_Target_AArch64"], 23 | "versions-arm": ["LLVM_Target_ARM"], 24 | "versions-mips32": ["LLVM_Target_Mips"], 25 | "versions-mips64": ["LLVM_Target_Mips"], 26 | "versions-systemz": ["LLVM_Target_SystemZ"] 27 | }, 28 | { 29 | "name": "no-target" 30 | } 31 | ] 32 | } 33 | -------------------------------------------------------------------------------- /examples/fibonacci/dub.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "fibonacci", 3 | "description": "Shows how to create a function calculating the Fibonacci series, jit-compile it, and execute it in-memory with llvm-d", 4 | "copyright": "Copyright © 2013-2018 Moritz Maxeiner, Copyright © 2016-2017 Alex Parrill", 5 | "license": "MIT", 6 | "authors": [ 7 | "Moritz Maxeiner", 8 | "Alex Parrill" 9 | ], 10 | 11 | "targetType": "executable", 12 | "sourceFiles": ["fibonacci.d"], 13 | "dependencies": { 14 | "llvm-d": { "path": "../.." } 15 | }, 16 | "configurations": [ 17 | { 18 | "name": "link-single", 19 | "libs": ["LLVM", "LTO"] 20 | }, 21 | { 22 | "name": "link-split", 23 | "libs": [ 24 | "LLVMCore", 25 | "LLVMAnalysis", 26 | "LLVMExecutionEngine", 27 | "LLVMScalarOpts", 28 | "LLVMMCJIT", 29 | "LLVMX86Info", 30 | "LLVMX86CodeGen", 31 | "LLVMX86Desc", 32 | "LLVMX86Disassembler", 33 | "LLVMX86AsmParser", 34 | "LTO" 35 | ] 36 | }, 37 | { 38 | "name": "load", 39 | "versions": ["LLVM_Load", "LLVM_Autoload"] 40 | } 41 | ] 42 | } 43 | -------------------------------------------------------------------------------- /examples/fibonacci/fibonacci.d: -------------------------------------------------------------------------------- 1 | module samples.fibonacci; 2 | 3 | import std.conv : to; 4 | import std.stdio : writefln, writeln; 5 | import std.string : toStringz, fromStringz; 6 | 7 | import llvm; 8 | 9 | immutable useMCJIT = { 10 | // MCJIT does not work on Windows 11 | version(Windows) { return false; } 12 | else { 13 | // Use MCJIT only if LLVMGetFunctionAddress is available, 14 | // as LLVMRunFunction does not work reliably with it. 15 | static if (LLVM_Version >= asVersion(3,6,0)) { return true; } 16 | else { return false; } 17 | } 18 | }(); 19 | 20 | void initJIT(ref LLVMExecutionEngineRef engine, LLVMModuleRef genModule) 21 | { 22 | char* error; 23 | 24 | static if (useMCJIT) { 25 | LLVMMCJITCompilerOptions options; 26 | LLVMInitializeMCJITCompilerOptions(&options, options.sizeof); 27 | 28 | LLVMCreateMCJITCompilerForModule(&engine, genModule, &options, options.sizeof, &error); 29 | } else { 30 | LLVMCreateJITCompilerForModule(&engine, genModule, 2, &error); 31 | } 32 | 33 | if (error) 34 | { 35 | scope (exit) LLVMDisposeMessage(error); 36 | throw new Exception(error.fromStringz().idup); 37 | } 38 | } 39 | 40 | int main(string[] args) 41 | { 42 | char* error; 43 | 44 | LLVMInitializeNativeTarget(); 45 | LLVMInitializeNativeAsmPrinter(); 46 | LLVMInitializeNativeAsmParser(); 47 | 48 | auto genModule = LLVMModuleCreateWithName("fibonacci".toStringz()); 49 | auto genFibParams = [ LLVMInt32Type() ]; 50 | auto genFib = LLVMAddFunction( 51 | genModule, 52 | "fib", 53 | LLVMFunctionType(LLVMInt32Type(), genFibParams.ptr, 1, cast(LLVMBool) false)); 54 | LLVMSetFunctionCallConv(genFib, LLVMCCallConv); 55 | 56 | auto genN = LLVMGetParam(genFib, 0); 57 | 58 | auto genEntryBlk = LLVMAppendBasicBlock(genFib, "entry".toStringz()); 59 | auto genAnchor0Blk = LLVMAppendBasicBlock(genFib, "anchor0".toStringz()); 60 | auto genAnchor1Blk = LLVMAppendBasicBlock(genFib, "anchor1".toStringz()); 61 | auto genRecurseBlk = LLVMAppendBasicBlock(genFib, "recurse".toStringz()); 62 | auto end = LLVMAppendBasicBlock(genFib, "end".toStringz()); 63 | 64 | auto builder = LLVMCreateBuilder(); 65 | 66 | /+ Entry block +/ 67 | LLVMPositionBuilderAtEnd(builder, genEntryBlk); 68 | auto fibSwitch = LLVMBuildSwitch( 69 | builder, 70 | genN, 71 | genRecurseBlk, 72 | 2); 73 | LLVMAddCase(fibSwitch, LLVMConstInt(LLVMInt32Type(), 0, cast(LLVMBool) false), genAnchor0Blk); 74 | LLVMAddCase(fibSwitch, LLVMConstInt(LLVMInt32Type(), 1, cast(LLVMBool) false), genAnchor1Blk); 75 | 76 | /+ Block for n = 0: fib(n) = 0 +/ 77 | LLVMPositionBuilderAtEnd(builder, genAnchor0Blk); 78 | auto genAnchor0Result = LLVMConstInt(LLVMInt32Type(), 0, cast(LLVMBool) false); 79 | LLVMBuildBr(builder, end); 80 | 81 | /+ Block for n = 1: fib(n) = 1 +/ 82 | LLVMPositionBuilderAtEnd(builder, genAnchor1Blk); 83 | auto genAnchor1Result = LLVMConstInt(LLVMInt32Type(), 1, cast(LLVMBool) false); 84 | LLVMBuildBr(builder, end); 85 | 86 | /+ Block for n > 1: fib(n) = fib(n - 1) + fib(n - 2) +/ 87 | LLVMPositionBuilderAtEnd(builder, genRecurseBlk); 88 | 89 | auto genNMinus1 = LLVMBuildSub( 90 | builder, 91 | genN, 92 | LLVMConstInt(LLVMInt32Type(), 1, cast(LLVMBool) false), 93 | "n - 1".toStringz()); 94 | auto genCallFibNMinus1 = LLVMBuildCall(builder, genFib, [genNMinus1].ptr, 1, "fib(n - 1)".toStringz()); 95 | 96 | auto genNMinus2 = LLVMBuildSub( 97 | builder, 98 | genN, 99 | LLVMConstInt(LLVMInt32Type(), 2, cast(LLVMBool) false), 100 | "n - 2".toStringz()); 101 | auto genCallFibNMinus2 = LLVMBuildCall(builder, genFib, [genNMinus2].ptr, 1, "fib(n - 2)".toStringz()); 102 | 103 | auto genRecurseResult = LLVMBuildAdd(builder, genCallFibNMinus1, genCallFibNMinus2, "fib(n - 1) + fib(n - 2)".toStringz()); 104 | LLVMBuildBr(builder, end); 105 | 106 | /+ Block for collecting the final result +/ 107 | LLVMPositionBuilderAtEnd(builder, end); 108 | auto genFinalResult = LLVMBuildPhi(builder, LLVMInt32Type(), "result".toStringz()); 109 | auto phiValues = [ genAnchor0Result, genAnchor1Result, genRecurseResult ]; 110 | auto phiBlocks = [ genAnchor0Blk, genAnchor1Blk, genRecurseBlk ]; 111 | LLVMAddIncoming(genFinalResult, phiValues.ptr, phiBlocks.ptr, 3); 112 | LLVMBuildRet(builder, genFinalResult); 113 | 114 | LLVMVerifyModule(genModule, LLVMAbortProcessAction, &error); 115 | LLVMDisposeMessage(error); 116 | 117 | LLVMExecutionEngineRef engine; 118 | error = null; 119 | 120 | initJIT(engine, genModule); 121 | 122 | auto pass = LLVMCreatePassManager(); 123 | static if (LLVM_Version < asVersion(3,9,0)) 124 | { 125 | LLVMAddTargetData(LLVMGetExecutionEngineTargetData(engine), pass); 126 | } 127 | LLVMAddConstantPropagationPass(pass); 128 | LLVMAddInstructionCombiningPass(pass); 129 | LLVMAddPromoteMemoryToRegisterPass(pass); 130 | LLVMAddGVNPass(pass); 131 | LLVMAddCFGSimplificationPass(pass); 132 | LLVMRunPassManager(pass, genModule); 133 | 134 | writefln("The following module has been generated for the fibonacci series:\n"); 135 | LLVMDumpModule(genModule); 136 | 137 | writeln(); 138 | 139 | int n = 10; 140 | if (args.length > 1) 141 | { 142 | n = to!int(args[1]); 143 | } 144 | else 145 | { 146 | writefln("; Argument for fib missing on command line, using default: \"%d\"", n); 147 | } 148 | 149 | int fib(int n) 150 | { 151 | static if (useMCJIT) { 152 | alias Fib = extern (C) int function(int); 153 | auto fib = cast(Fib) LLVMGetFunctionAddress(engine, "fib".toStringz()); 154 | return fib(n); 155 | } else { 156 | auto args = [ LLVMCreateGenericValueOfInt(LLVMInt32Type(), n, cast(LLVMBool) 0) ]; 157 | return cast(int) LLVMGenericValueToInt(LLVMRunFunction(engine, genFib, 1, args.ptr), 0); 158 | } 159 | } 160 | 161 | writefln("; Running (jit-compiled) fib(%d)...", n); 162 | writefln("; fib(%d) = %d", n, fib(n)); 163 | 164 | LLVMDisposePassManager(pass); 165 | LLVMDisposeBuilder(builder); 166 | LLVMDisposeExecutionEngine(engine); 167 | return 0; 168 | } 169 | -------------------------------------------------------------------------------- /source/llvm/config.d: -------------------------------------------------------------------------------- 1 | module llvm.config; 2 | 3 | import std.conv : to; 4 | import std.array : array, replace, join; 5 | import std.algorithm.iteration : filter, map, joiner; 6 | import std.algorithm.searching : canFind; 7 | 8 | /// LLVM Versions that llvm-d supports 9 | immutable LLVM_Versions = [ 10 | [10,0,0], 11 | [9,0,1], 12 | [9,0,0], 13 | [8,0,1], 14 | [8,0,0], 15 | [7,1,0], 16 | [7,0,1], 17 | [7,0,0], 18 | [6,0,1], 19 | [6,0,0], 20 | [5,0,2], 21 | [5,0,1], 22 | [5,0,0], 23 | [4,0,1], 24 | [4,0,0], 25 | [3,9,1], 26 | [3,9,0], 27 | [3,8,1], 28 | [3,8,0], 29 | [3,7,1], 30 | [3,7,0], 31 | [3,6,2], 32 | [3,6,1], 33 | [3,6,0], 34 | [3,5,2], 35 | [3,5,1], 36 | [3,5,0], 37 | [3,4,2], 38 | [3,4,1], 39 | [3,4,0], 40 | [3,3,0], 41 | [3,2,0], 42 | [3,1,0], 43 | ]; 44 | 45 | mixin(LLVM_Versions.map!(ver => 46 | q{version(LLVM_%MAJOR_%MINOR_%PATCH) { 47 | immutable LLVM_VERSION_MAJOR = %MAJOR; 48 | immutable LLVM_VERSION_MINOR = %MINOR; 49 | immutable LLVM_VERSION_PATCH = %PATCH; 50 | }}.replace("%MAJOR", ver[0].to!string).replace("%MINOR", ver[1].to!string).replace("%PATCH", ver[2].to!string) 51 | ).join("else\n") ~ 52 | q{else { 53 | immutable LLVM_VERSION_MAJOR = LLVM_Versions[0][0]; 54 | immutable LLVM_VERSION_MINOR = LLVM_Versions[0][1]; 55 | immutable LLVM_VERSION_PATCH = LLVM_Versions[0][2]; 56 | }} 57 | ); 58 | 59 | /// Makes an ordered identifier from a major, minor, and patch number 60 | pure nothrow @nogc 61 | ulong asVersion(ushort major, ushort minor, ushort patch) 62 | { 63 | return cast(ulong)(major) << (ushort.sizeof*2*8) | cast(ulong)(minor) << (ushort.sizeof*8) | cast(ulong)(patch); 64 | } 65 | 66 | /// LLVM Version that llvm-d was compiled against 67 | immutable LLVM_Version = asVersion(LLVM_VERSION_MAJOR, LLVM_VERSION_MINOR, LLVM_VERSION_PATCH); 68 | 69 | /// LLVM Version that llvm-d was compiled against as a string 70 | immutable LLVM_VersionString = LLVM_VERSION_MAJOR.to!string ~ "." ~ LLVM_VERSION_MINOR.to!string ~ "." ~ LLVM_VERSION_PATCH.to!string; 71 | 72 | /// LLVM Targets that can be used (enable target Name via version LLVM_Target_Name) 73 | immutable LLVM_Targets = { 74 | string[] targets; 75 | mixin({ 76 | static if (LLVM_Version >= asVersion(10, 0, 0)) { 77 | return ["AArch64","AMDGPU","ARC","ARM","AVR","BPF","Hexagon","Lanai","MSP430","Mips","NVPTX","PowerPC","RISCV","Sparc","SystemZ","VE","WebAssembly","X86","XCore"]; 78 | } else static if (LLVM_Version >= asVersion(9, 0, 1)) { 79 | return ["AArch64","AMDGPU","ARC","ARM","AVR","BPF","Hexagon","Lanai","MSP430","Mips","NVPTX","PowerPC","RISCV","Sparc","SystemZ","WebAssembly","X86","XCore"]; 80 | } else static if (LLVM_Version >= asVersion(9, 0, 0)) { 81 | return ["AArch64","AMDGPU","ARC","ARM","AVR","BPF","Hexagon","Lanai","MSP430","Mips","NVPTX","Nios2","PowerPC","RISCV","Sparc","SystemZ","WebAssembly","X86","XCore"]; 82 | } else static if (LLVM_Version >= asVersion(8, 0, 0)) { 83 | return ["AArch64","AMDGPU","ARC","ARM","AVR","BPF","Hexagon","Lanai","MSP430","Mips","NVPTX","Nios2","PowerPC","RISCV","Sparc","SystemZ","WebAssembly","X86","XCore"]; 84 | } else static if (LLVM_Version >= asVersion(7, 0, 0)) { 85 | return ["AArch64","AMDGPU","ARC","ARM","AVR","BPF","Hexagon","Lanai","Mips","MSP430","Nios2","NVPTX","PowerPC","RISCV","Sparc","SystemZ","WebAssembly","X86","XCore"]; 86 | } else static if (LLVM_Version >= asVersion(6, 0, 0)) { 87 | return ["AArch64","AMDGPU","ARC","ARM","AVR","BPF","Hexagon","Lanai","Mips","MSP430","Nios2","NVPTX","PowerPC","RISCV","Sparc","SystemZ","WebAssembly","X86","XCore"]; 88 | } else static if (LLVM_Version >= asVersion(5, 0, 0)) { 89 | return ["AArch64","AMDGPU","ARM","AVR","BPF","Hexagon","Lanai","Mips","MSP430","Nios2","NVPTX","PowerPC","RISCV","Sparc","SystemZ","WebAssembly","X86","XCore"]; 90 | } else static if (LLVM_Version >= asVersion(4, 0, 0)) { 91 | return ["AArch64","AMDGPU","ARM","AVR","BPF","Hexagon","Lanai","MSP430","Mips","NVPTX","PowerPC","RISCV","Sparc","SystemZ","WebAssembly","X86","XCore"]; 92 | } else static if (LLVM_Version >= asVersion(3, 9, 0)) { 93 | return ["AArch64","AMDGPU","ARM","AVR","BPF","Hexagon","Lanai","MSP430","Mips","NVPTX","PowerPC","Sparc","SystemZ","WebAssembly","X86","XCore"]; 94 | } else static if (LLVM_Version >= asVersion(3, 8, 0)) { 95 | return ["AArch64","AMDGPU","ARM","AVR","BPF","CppBackend","Hexagon","MSP430","Mips","NVPTX","PowerPC","Sparc","SystemZ","WebAssembly","X86","XCore"]; 96 | } else static if (LLVM_Version >= asVersion(3, 7, 0)) { 97 | return ["AArch64","AMDGPU","ARM","BPF","CppBackend","Hexagon","MSP430","Mips","NVPTX","PowerPC","Sparc","SystemZ","WebAssembly","X86","XCore"]; 98 | } else static if (LLVM_Version >= asVersion(3, 6, 0)) { 99 | return ["AArch64","ARM","CppBackend","Hexagon","MSP430","Mips","NVPTX","PowerPC","R600","Sparc","SystemZ","X86","XCore"]; 100 | } else static if (LLVM_Version >= asVersion(3, 5, 0)) { 101 | return ["AArch64","ARM","CppBackend","Hexagon","MSP430","Mips","NVPTX","PowerPC","R600","Sparc","SystemZ","X86","XCore"]; 102 | } else static if (LLVM_Version >= asVersion(3, 4, 0)) { 103 | return ["AArch64","ARM","CppBackend","Hexagon","MSP430","Mips","NVPTX","PowerPC","R600","Sparc","SystemZ","X86","XCore"]; 104 | } else static if (LLVM_Version >= asVersion(3, 3, 0)) { 105 | return ["AArch64","ARM","CppBackend","Hexagon","MBlaze","MSP430","Mips","NVPTX","PowerPC","R600","Sparc","SystemZ","X86","XCore"]; 106 | } else static if (LLVM_Version >= asVersion(3, 2, 0)) { 107 | return ["ARM","CellSPU","CppBackend","Hexagon","MBlaze","MSP430","Mips","NVPTX","PTX","PowerPC","Sparc","X86","XCore"]; 108 | } else { 109 | return ["ARM","CellSPU","CppBackend","Hexagon","MBlaze","MSP430","Mips","PTX","PowerPC","Sparc","X86","XCore"]; 110 | } 111 | }().map!(t => "version (LLVM_Target_" ~ t ~ ") targets ~= \"" ~ t ~ "\";").joiner.array); 112 | return targets; 113 | }(); 114 | 115 | /// LLVM Targets with AsmPrinter capability (if enabled) 116 | immutable LLVM_AsmPrinters = { 117 | 118 | static if (LLVM_Version >= asVersion(10, 0, 0)) { 119 | return ["AArch64","AMDGPU","AMDGPU","ARC","ARM","AVR","BPF","Hexagon","Lanai","MSP430","Mips","NVPTX","PowerPC","RISCV","Sparc","SystemZ","VE","WebAssembly","X86","XCore"]; 120 | } else static if (LLVM_Version >= asVersion(9, 0, 1)) { 121 | return ["AArch64","AMDGPU","AMDGPU","ARC","ARM","AVR","BPF","Hexagon","Lanai","MSP430","Mips","NVPTX","PowerPC","RISCV","Sparc","SystemZ","WebAssembly","X86","XCore"]; 122 | } else static if (LLVM_Version >= asVersion(9, 0, 0)) { 123 | return ["AArch64","AMDGPU","AMDGPU","ARC","ARM","AVR","BPF","Hexagon","Lanai","MSP430","Mips","NVPTX","PowerPC","RISCV","Sparc","SystemZ","WebAssembly","X86","XCore"]; 124 | } else static if (LLVM_Version >= asVersion(8, 0, 0)) { 125 | return ["AArch64","AMDGPU","AMDGPU","ARC","ARM","AVR","BPF","Hexagon","Lanai","MSP430","Mips","NVPTX","PowerPC","RISCV","Sparc","SystemZ","WebAssembly","X86","XCore"]; 126 | } else static if (LLVM_Version >= asVersion(7, 0, 0)) { 127 | return ["AArch64","AMDGPU","AMDGPU","ARC","ARM","AVR","BPF","Hexagon","Lanai","Mips","MSP430","Nios2","NVPTX","PowerPC","RISCV","Sparc","SystemZ","WebAssembly","X86","XCore"]; 128 | } else static if (LLVM_Version >= asVersion(6, 0, 0)) { 129 | return ["AArch64","AMDGPU","ARC","ARM","AVR","BPF","Hexagon","Lanai","Mips","MSP430","Nios2","NVPTX","PowerPC","RISCV","Sparc","SystemZ","WebAssembly","X86","XCore"]; 130 | } else static if (LLVM_Version >= asVersion(5, 0, 0)) { 131 | return ["AArch64","AMDGPU","ARM","AVR","BPF","Hexagon","Lanai","Mips","MSP430","NVPTX","PowerPC","Sparc","SystemZ","WebAssembly","X86","XCore"]; 132 | } else static if (LLVM_Version >= asVersion(4, 0, 0)) { 133 | return ["AArch64","AMDGPU","ARM","AVR","BPF","Hexagon","Lanai","MSP430","Mips","NVPTX","PowerPC","Sparc","SystemZ","WebAssembly","X86","XCore"]; 134 | } else static if (LLVM_Version >= asVersion(3, 9, 0)) { 135 | return ["AArch64","AMDGPU","ARM","BPF","Hexagon","Lanai","MSP430","Mips","NVPTX","PowerPC","Sparc","SystemZ","WebAssembly","X86","XCore"]; 136 | } else static if (LLVM_Version >= asVersion(3, 8, 0)) { 137 | return ["AArch64","AMDGPU","ARM","BPF","Hexagon","MSP430","Mips","NVPTX","PowerPC","Sparc","SystemZ","WebAssembly","X86","XCore"]; 138 | } else static if (LLVM_Version >= asVersion(3, 7, 0)) { 139 | return ["AArch64","AMDGPU","ARM","BPF","Hexagon","MSP430","Mips","NVPTX","PowerPC","Sparc","SystemZ","X86","XCore"]; 140 | } else static if (LLVM_Version >= asVersion(3, 6, 0)) { 141 | return ["AArch64","ARM","Hexagon","MSP430","Mips","NVPTX","PowerPC","R600","Sparc","SystemZ","X86","XCore"]; 142 | } else static if (LLVM_Version >= asVersion(3, 5, 0)) { 143 | return ["AArch64","ARM","Hexagon","MSP430","Mips","NVPTX","PowerPC","R600","Sparc","SystemZ","X86","XCore"]; 144 | } else static if (LLVM_Version >= asVersion(3, 4, 0)) { 145 | return ["AArch64","ARM","Hexagon","MSP430","Mips","NVPTX","PowerPC","R600","Sparc","SystemZ","X86","XCore"]; 146 | } else static if (LLVM_Version >= asVersion(3, 3, 0)) { 147 | return ["AArch64","ARM","Hexagon","MBlaze","MSP430","Mips","NVPTX","PowerPC","R600","Sparc","SystemZ","X86","XCore"]; 148 | } else static if (LLVM_Version >= asVersion(3, 2, 0)) { 149 | return ["ARM","CellSPU","Hexagon","MBlaze","MSP430","Mips","NVPTX","PowerPC","Sparc","X86","XCore"]; 150 | } else { 151 | return ["ARM","CellSPU","Hexagon","MBlaze","MSP430","Mips","PTX","PowerPC","Sparc","X86","XCore"]; 152 | } 153 | }().filter!(t => LLVM_Targets.canFind(t)).array; 154 | 155 | /// LLVM Targets with AsmParser capability (if enabled) 156 | immutable LLVM_AsmParsers = { 157 | static if (LLVM_Version >= asVersion(10, 0, 0)) { 158 | return ["AArch64","AMDGPU","ARM","AVR","BPF","Hexagon","Lanai","MSP430","Mips","PowerPC","RISCV","Sparc","SystemZ","WebAssembly","X86"]; 159 | } else static if (LLVM_Version >= asVersion(9, 0, 1)) { 160 | return ["AArch64","AMDGPU","ARM","AVR","BPF","Hexagon","Lanai","MSP430","Mips","PowerPC","RISCV","Sparc","SystemZ","WebAssembly","X86"]; 161 | } else static if (LLVM_Version >= asVersion(9, 0, 0)) { 162 | return ["AArch64","AMDGPU","ARM","AVR","BPF","Hexagon","Lanai","MSP430","Mips","PowerPC","RISCV","Sparc","SystemZ","WebAssembly","X86"]; 163 | } else static if (LLVM_Version >= asVersion(8, 0, 0)) { 164 | return ["AArch64","AMDGPU","ARM","AVR","BPF","Hexagon","Lanai","MSP430","Mips","PowerPC","RISCV","Sparc","SystemZ","WebAssembly","X86"]; 165 | } else static if (LLVM_Version >= asVersion(7, 0, 0)) { 166 | return ["AArch64","AMDGPU","ARM","AVR","BPF","Hexagon","Lanai","Mips","PowerPC","RISCV","Sparc","SystemZ","WebAssembly","X86"]; 167 | } else static if (LLVM_Version >= asVersion(6, 0, 0)) { 168 | return ["AArch64","AMDGPU","ARM","AVR","BPF","Hexagon","Lanai","Mips","PowerPC","RISCV","Sparc","SystemZ","X86"]; 169 | } else static if (LLVM_Version >= asVersion(5, 0, 0)) { 170 | return ["AArch64","AMDGPU","ARM","AVR","Hexagon","Lanai","Mips","PowerPC","Sparc","SystemZ","X86"]; 171 | } else static if (LLVM_Version >= asVersion(4, 0, 0)) { 172 | return ["AArch64","AMDGPU","ARM","AVR","Hexagon","Lanai","Mips","PowerPC","Sparc","SystemZ","X86"]; 173 | } else static if (LLVM_Version >= asVersion(3, 9, 0)) { 174 | return ["AArch64","AMDGPU","ARM","Hexagon","Lanai","Mips","PowerPC","Sparc","SystemZ","X86"]; 175 | } else static if (LLVM_Version >= asVersion(3, 8, 0)) { 176 | return ["AArch64","AMDGPU","ARM","Hexagon","Mips","PowerPC","Sparc","SystemZ","X86"]; 177 | } else static if (LLVM_Version >= asVersion(3, 7, 0)) { 178 | return ["AArch64","AMDGPU","ARM","Mips","PowerPC","Sparc","SystemZ","X86"]; 179 | } else static if (LLVM_Version >= asVersion(3, 6, 0)) { 180 | return ["AArch64","ARM","Mips","PowerPC","R600","Sparc","SystemZ","X86"]; 181 | } else static if (LLVM_Version >= asVersion(3, 5, 0)) { 182 | return ["AArch64","ARM","Mips","PowerPC","Sparc","SystemZ","X86"]; 183 | } else static if (LLVM_Version >= asVersion(3, 4, 0)) { 184 | return ["AArch64","ARM","Mips","PowerPC","SystemZ","X86"]; 185 | } else static if (LLVM_Version >= asVersion(3, 3, 0)) { 186 | return ["AArch64","ARM","MBlaze","Mips","PowerPC","SystemZ","X86"]; 187 | } else static if (LLVM_Version >= asVersion(3, 2, 0)) { 188 | return ["ARM","MBlaze","Mips","X86"]; 189 | } else { 190 | return ["ARM","MBlaze","Mips","X86"]; 191 | } 192 | }().filter!(t => LLVM_Targets.canFind(t)).array; 193 | 194 | /// LLVM Targets with Disassembler capability (if enabled) 195 | immutable LLVM_Disassemblers = { 196 | static if (LLVM_Version >= asVersion(10, 0, 0)) { 197 | return ["AArch64","AMDGPU","ARC","ARM","AVR","BPF","Hexagon","Lanai","MSP430","Mips","PowerPC","RISCV","Sparc","SystemZ","WebAssembly","X86","XCore"]; 198 | } else static if (LLVM_Version >= asVersion(9, 0, 1)) { 199 | return ["AArch64","AMDGPU","ARC","ARM","AVR","BPF","Hexagon","Lanai","MSP430","Mips","PowerPC","RISCV","Sparc","SystemZ","WebAssembly","X86","XCore"]; 200 | } else static if (LLVM_Version >= asVersion(9, 0, 0)) { 201 | return ["AArch64","AMDGPU","ARC","ARM","AVR","BPF","Hexagon","Lanai","MSP430","Mips","PowerPC","RISCV","Sparc","SystemZ","WebAssembly","X86","XCore"]; 202 | } else static if (LLVM_Version >= asVersion(8, 0, 0)) { 203 | return ["AArch64","AMDGPU","ARC","ARM","AVR","BPF","Hexagon","Lanai","MSP430","Mips","PowerPC","RISCV","Sparc","SystemZ","WebAssembly","X86","XCore"]; 204 | } else static if (LLVM_Version >= asVersion(7, 0, 0)) { 205 | return ["AArch64","AMDGPU","ARC","ARM","AVR","BPF","Hexagon","Lanai","Mips","PowerPC","RISCV","Sparc","SystemZ","WebAssembly","X86","XCore"]; 206 | } else static if (LLVM_Version >= asVersion(6, 0, 0)) { 207 | return ["AArch64","AMDGPU","ARC","ARM","AVR","BPF","Hexagon","Lanai","Mips","PowerPC","RISCV","Sparc","SystemZ","WebAssembly","X86","XCore"]; 208 | } else static if (LLVM_Version >= asVersion(5, 0, 0)) { 209 | return ["AArch64","AMDGPU","ARM","AVR","BPF","Hexagon","Lanai","Mips","PowerPC","Sparc","SystemZ","WebAssembly","X86","XCore"]; 210 | } else static if (LLVM_Version >= asVersion(4, 0, 0)) { 211 | return ["AArch64","AMDGPU","ARM","AVR","BPF","Hexagon","Lanai","Mips","PowerPC","Sparc","SystemZ","WebAssembly","X86","XCore"]; 212 | } else static if (LLVM_Version >= asVersion(3, 9, 0)) { 213 | return ["AArch64","AMDGPU","ARM","Hexagon","Lanai","Mips","PowerPC","Sparc","SystemZ","WebAssembly","X86","XCore"]; 214 | } else static if (LLVM_Version >= asVersion(3, 8, 0)) { 215 | return ["AArch64","ARM","Hexagon","Mips","PowerPC","Sparc","SystemZ","WebAssembly","X86","XCore"]; 216 | } else static if (LLVM_Version >= asVersion(3, 7, 0)) { 217 | return ["AArch64","ARM","Hexagon","Mips","PowerPC","Sparc","SystemZ","X86","XCore"]; 218 | } else static if (LLVM_Version >= asVersion(3, 6, 0)) { 219 | return ["AArch64","ARM","Hexagon","Mips","PowerPC","Sparc","SystemZ","X86","XCore"]; 220 | } else static if (LLVM_Version >= asVersion(3, 5, 0)) { 221 | return ["AArch64","ARM","Mips","PowerPC","Sparc","SystemZ","X86","XCore"]; 222 | } else static if (LLVM_Version >= asVersion(3, 4, 0)) { 223 | return ["AArch64","ARM","Mips","SystemZ","X86","XCore"]; 224 | } else static if (LLVM_Version >= asVersion(3, 3, 0)) { 225 | return ["AArch64","ARM","MBlaze","Mips","X86","XCore"]; 226 | } else static if (LLVM_Version >= asVersion(3, 2, 0)) { 227 | return ["ARM","MBlaze","Mips","X86"]; 228 | } else { 229 | return ["ARM","MBlaze","Mips","X86"]; 230 | } 231 | }().filter!(t => LLVM_Targets.canFind(t)).array; 232 | 233 | /// LLVM Target that corresponds to the native architecture (if enabled) 234 | immutable LLVM_NativeTarget = { 235 | auto t = { 236 | version(X86) return "X86"; 237 | else version(X86_64) return "X86"; 238 | else version(SPARC) return "Sparc"; 239 | else version(SPARC64) return "Sparc"; 240 | else version(PPC) return "PowerPC"; 241 | else version(PPC64) return "PowerPC"; 242 | else version(AArch64) return "AArch64"; 243 | else version(ARM) return "ARM"; 244 | else version(MIPS32) return "Mips"; 245 | else version(MIPS64) return "Mips"; 246 | else version(SystemZ) return "SystemZ"; 247 | else return ""; 248 | }(); 249 | if (t != "" && LLVM_Targets.canFind(t)) return t; 250 | else return ""; 251 | }(); -------------------------------------------------------------------------------- /source/llvm/constants.d: -------------------------------------------------------------------------------- 1 | module llvm.constants; 2 | 3 | import llvm.config; 4 | import llvm.types; 5 | 6 | /+ Analysis +/ 7 | 8 | enum : LLVMVerifierFailureAction 9 | { 10 | LLVMAbortProcessAction, 11 | LLVMPrintMessageAction, 12 | LLVMReturnStatusAction 13 | } 14 | 15 | /+ Core +/ 16 | 17 | /++ Types and Enumerations ++/ 18 | 19 | static if (LLVM_Version < asVersion(4, 0, 0)) 20 | { 21 | enum : LLVMAttribute 22 | { 23 | LLVMZExtAttribute = 1<<0, 24 | LLVMSExtAttribute = 1<<1, 25 | LLVMNoReturnAttribute = 1<<2, 26 | LLVMInRegAttribute = 1<<3, 27 | LLVMStructRetAttribute = 1<<4, 28 | LLVMNoUnwindAttribute = 1<<5, 29 | LLVMNoAliasAttribute = 1<<6, 30 | LLVMByValAttribute = 1<<7, 31 | LLVMNestAttribute = 1<<8, 32 | LLVMReadNoneAttribute = 1<<9, 33 | LLVMReadOnlyAttribute = 1<<10, 34 | LLVMNoInlineAttribute = 1<<11, 35 | LLVMAlwaysInlineAttribute = 1<<12, 36 | LLVMOptimizeForSizeAttribute = 1<<13, 37 | LLVMStackProtectAttribute = 1<<14, 38 | LLVMStackProtectReqAttribute = 1<<15, 39 | LLVMAlignment = 31<<16, 40 | LLVMNoCaptureAttribute = 1<<21, 41 | LLVMNoRedZoneAttribute = 1<<22, 42 | LLVMNoImplicitFloatAttribute = 1<<23, 43 | LLVMNakedAttribute = 1<<24, 44 | LLVMInlineHintAttribute = 1<<25, 45 | LLVMStackAlignment = 7<<26, 46 | LLVMReturnsTwice = 1<<29, 47 | LLVMUWTable = 1<<30, 48 | LLVMNonLazyBind = 1<<31 49 | } 50 | } 51 | 52 | enum : LLVMOpcode 53 | { 54 | LLVMRet = 1, 55 | LLVMBr = 2, 56 | LLVMSwitch = 3, 57 | LLVMIndirectBr = 4, 58 | LLVMInvoke = 5, 59 | LLVMUnreachable = 7, 60 | LLVMAdd = 8, 61 | LLVMFAdd = 9, 62 | LLVMSub = 10, 63 | LLVMFSub = 11, 64 | LLVMMul = 12, 65 | LLVMFMul = 13, 66 | LLVMUDiv = 14, 67 | LLVMSDiv = 15, 68 | LLVMFDiv = 16, 69 | LLVMURem = 17, 70 | LLVMSRem = 18, 71 | LLVMFRem = 19, 72 | LLVMShl = 20, 73 | LLVMLShr = 21, 74 | LLVMAShr = 22, 75 | LLVMAnd = 23, 76 | LLVMOr = 24, 77 | LLVMXor = 25, 78 | LLVMAlloca = 26, 79 | LLVMLoad = 27, 80 | LLVMStore = 28, 81 | LLVMGetElementPtr = 29, 82 | LLVMTrunc = 30, 83 | LLVMZExt = 31, 84 | LLVMSExt = 32, 85 | LLVMFPToUI = 33, 86 | LLVMFPToSI = 34, 87 | LLVMUIToFP = 35, 88 | LLVMSIToFP = 36, 89 | LLVMFPTrunc = 37, 90 | LLVMFPExt = 38, 91 | LLVMPtrToInt = 39, 92 | LLVMIntToPtr = 40, 93 | LLVMBitCast = 41, 94 | LLVMICmp = 42, 95 | LLVMFCmp = 43, 96 | LLVMPHI = 44, 97 | LLVMCall = 45, 98 | LLVMSelect = 46, 99 | LLVMUserOp1 = 47, 100 | LLVMUserOp2 = 48, 101 | LLVMVAArg = 49, 102 | LLVMExtractElement = 50, 103 | LLVMInsertElement = 51, 104 | LLVMShuffleVector = 52, 105 | LLVMExtractValue = 53, 106 | LLVMInsertValue = 54, 107 | LLVMFence = 55, 108 | LLVMAtomicCmpXchg = 56, 109 | LLVMAtomicRMW = 57, 110 | LLVMResume = 58, 111 | LLVMLandingPad = 59, 112 | } 113 | static if (LLVM_Version >= asVersion(3, 4, 0)) 114 | { 115 | enum : LLVMOpcode 116 | { 117 | LLVMAddrSpaceCast = 60 118 | } 119 | } 120 | static if (LLVM_Version >= asVersion(3, 8, 0)) 121 | { 122 | enum : LLVMOpcode 123 | { 124 | LLVMCleanupRet = 61, 125 | LLVMCatchRet = 62, 126 | LLVMCatchPad = 63, 127 | LLVMCleanupPad = 64, 128 | LLVMCatchSwitch = 65 129 | } 130 | } 131 | static if (LLVM_Version >= asVersion(8, 0, 0)) 132 | { 133 | enum : LLVMOpcode 134 | { 135 | LLVMFNeg = 66 136 | } 137 | } 138 | static if (LLVM_Version >= asVersion(9, 0, 0)) 139 | { 140 | enum : LLVMOpcode 141 | { 142 | LLVMCallBr = 67 143 | } 144 | } 145 | static if (LLVM_Version >= asVersion(10, 0, 0)) 146 | { 147 | enum : LLVMOpcode 148 | { 149 | LLVMFreeze = 68 150 | } 151 | } 152 | 153 | static if (LLVM_Version >= asVersion(3, 9, 0)) 154 | { 155 | enum : LLVMValueKind 156 | { 157 | LLVMArgumentValueKind, 158 | LLVMBasicBlockValueKind, 159 | LLVMMemoryUseValueKind, 160 | LLVMMemoryDefValueKind, 161 | LLVMMemoryPhiValueKind, 162 | LLVMFunctionValueKind, 163 | LLVMGlobalAliasValueKind, 164 | LLVMGlobalIFuncValueKind, 165 | LLVMGlobalVariableValueKind, 166 | LLVMBlockAddressValueKind, 167 | LLVMConstantExprValueKind, 168 | LLVMConstantArrayValueKind, 169 | LLVMConstantStructValueKind, 170 | LLVMConstantVectorValueKind, 171 | LLVMUndefValueValueKind, 172 | LLVMConstantAggregateZeroValueKind, 173 | LLVMConstantDataArrayValueKind, 174 | LLVMConstantDataVectorValueKind, 175 | LLVMConstantIntValueKind, 176 | LLVMConstantFPValueKind, 177 | LLVMConstantPointerNullValueKind, 178 | LLVMConstantTokenNoneValueKind, 179 | LLVMMetadataAsValueValueKind, 180 | LLVMInlineAsmValueKind, 181 | LLVMInstructionValueKind, 182 | } 183 | 184 | enum : LLVMAttributeIndex 185 | { 186 | LLVMAttributeReturnIndex = 0U, 187 | LLVMAttributeFunctionIndex = -1, 188 | } 189 | } 190 | 191 | static if (LLVM_Version >= asVersion(3, 8, 0)) { 192 | enum : LLVMTypeKind 193 | { 194 | LLVMVoidTypeKind, 195 | LLVMHalfTypeKind, 196 | LLVMFloatTypeKind, 197 | LLVMDoubleTypeKind, 198 | LLVMX86_FP80TypeKind, 199 | LLVMFP128TypeKind, 200 | LLVMPPC_FP128TypeKind, 201 | LLVMLabelTypeKind, 202 | LLVMIntegerTypeKind, 203 | LLVMFunctionTypeKind, 204 | LLVMStructTypeKind, 205 | LLVMArrayTypeKind, 206 | LLVMPointerTypeKind, 207 | LLVMVectorTypeKind, 208 | LLVMMetadataTypeKind, 209 | LLVMX86_MMXTypeKind, 210 | LLVMTokenTypeKind 211 | } 212 | } else { 213 | enum : LLVMTypeKind 214 | { 215 | LLVMVoidTypeKind, 216 | LLVMHalfTypeKind, 217 | LLVMFloatTypeKind, 218 | LLVMDoubleTypeKind, 219 | LLVMX86_FP80TypeKind, 220 | LLVMFP128TypeKind, 221 | LLVMPPC_FP128TypeKind, 222 | LLVMLabelTypeKind, 223 | LLVMIntegerTypeKind, 224 | LLVMFunctionTypeKind, 225 | LLVMStructTypeKind, 226 | LLVMArrayTypeKind, 227 | LLVMPointerTypeKind, 228 | LLVMVectorTypeKind, 229 | LLVMMetadataTypeKind, 230 | LLVMX86_MMXTypeKind, 231 | LLVMTokenTypeKind 232 | } 233 | } 234 | 235 | static if (LLVM_Version >= asVersion(3, 2, 0)) { 236 | enum : LLVMLinkage 237 | { 238 | LLVMExternalLinkage, 239 | LLVMAvailableExternallyLinkage, 240 | LLVMLinkOnceAnyLinkage, 241 | LLVMLinkOnceODRLinkage, 242 | LLVMLinkOnceODRAutoHideLinkage, 243 | LLVMWeakAnyLinkage, 244 | LLVMWeakODRLinkage, 245 | LLVMAppendingLinkage, 246 | LLVMInternalLinkage, 247 | LLVMPrivateLinkage, 248 | LLVMDLLImportLinkage, 249 | LLVMDLLExportLinkage, 250 | LLVMExternalWeakLinkage, 251 | LLVMGhostLinkage, 252 | LLVMCommonLinkage, 253 | LLVMLinkerPrivateLinkage, 254 | LLVMLinkerPrivateWeakLinkage, 255 | } 256 | } else { 257 | enum : LLVMLinkage 258 | { 259 | LLVMExternalLinkage, 260 | LLVMAvailableExternallyLinkage, 261 | LLVMLinkOnceAnyLinkage, 262 | LLVMLinkOnceODRLinkage, 263 | LLVMWeakAnyLinkage, 264 | LLVMWeakODRLinkage, 265 | LLVMAppendingLinkage, 266 | LLVMInternalLinkage, 267 | LLVMPrivateLinkage, 268 | LLVMDLLImportLinkage, 269 | LLVMDLLExportLinkage, 270 | LLVMExternalWeakLinkage, 271 | LLVMGhostLinkage, 272 | LLVMCommonLinkage, 273 | LLVMLinkerPrivateLinkage, 274 | LLVMLinkerPrivateWeakLinkage, 275 | LLVMLinkerPrivateWeakDefAutoLinkage 276 | } 277 | } 278 | 279 | enum : LLVMVisibility 280 | { 281 | LLVMDefaultVisibility, 282 | LLVMHiddenVisibility, 283 | LLVMProtectedVisibility 284 | } 285 | 286 | static if (LLVM_Version >= asVersion(3, 5, 0)) 287 | { 288 | enum : LLVMDLLStorageClass { 289 | LLVMDefaultStorageClass = 0, 290 | LLVMDLLImportStorageClass = 1, 291 | LLVMDLLExportStorageClass = 2 292 | } 293 | } 294 | 295 | static if (LLVM_Version >= asVersion(7, 0, 0)) 296 | { 297 | enum : LLVMCallConv { 298 | LLVMCCallConv = 0, 299 | LLVMFastCallConv = 8, 300 | LLVMColdCallConv = 9, 301 | LLVMGHCCallConv = 10, 302 | LLVMHiPECallConv = 11, 303 | LLVMWebKitJSCallConv = 12, 304 | LLVMAnyRegCallConv = 13, 305 | LLVMPreserveMostCallConv = 14, 306 | LLVMPreserveAllCallConv = 15, 307 | LLVMSwiftCallConv = 16, 308 | LLVMCXXFASTTLSCallConv = 17, 309 | LLVMX86StdcallCallConv = 64, 310 | LLVMX86FastcallCallConv = 65, 311 | LLVMARMAPCSCallConv = 66, 312 | LLVMARMAAPCSCallConv = 67, 313 | LLVMARMAAPCSVFPCallConv = 68, 314 | LLVMMSP430INTRCallConv = 69, 315 | LLVMX86ThisCallCallConv = 70, 316 | LLVMPTXKernelCallConv = 71, 317 | LLVMPTXDeviceCallConv = 72, 318 | LLVMSPIRFUNCCallConv = 75, 319 | LLVMSPIRKERNELCallConv = 76, 320 | LLVMIntelOCLBICallConv = 77, 321 | LLVMX8664SysVCallConv = 78, 322 | LLVMWin64CallConv = 79, 323 | LLVMX86VectorCallCallConv = 80, 324 | LLVMHHVMCallConv = 81, 325 | LLVMHHVMCCallConv = 82, 326 | LLVMX86INTRCallConv = 83, 327 | LLVMAVRINTRCallConv = 84, 328 | LLVMAVRSIGNALCallConv = 85, 329 | LLVMAVRBUILTINCallConv = 86, 330 | LLVMAMDGPUVSCallConv = 87, 331 | LLVMAMDGPUGSCallConv = 88, 332 | LLVMAMDGPUPSCallConv = 89, 333 | LLVMAMDGPUCSCallConv = 90, 334 | LLVMAMDGPUKERNELCallConv = 91, 335 | LLVMX86RegCallCallConv = 92, 336 | LLVMAMDGPUHSCallConv = 93, 337 | LLVMMSP430BUILTINCallConv = 94, 338 | LLVMAMDGPULSCallConv = 95, 339 | LLVMAMDGPUESCallConv = 96 340 | } 341 | } 342 | else static if (LLVM_Version >= asVersion(3, 4, 0)) 343 | { 344 | enum : LLVMCallConv { 345 | LLVMCCallConv = 0, 346 | LLVMFastCallConv = 8, 347 | LLVMColdCallConv = 9, 348 | LLVMWebKitJSCallConv = 12, 349 | LLVMAnyRegCallConv = 13, 350 | LLVMX86StdcallCallConv = 64, 351 | LLVMX86FastcallCallConv = 65 352 | } 353 | } else { 354 | enum : LLVMCallConv { 355 | LLVMCCallConv = 0, 356 | LLVMFastCallConv = 8, 357 | LLVMColdCallConv = 9, 358 | LLVMX86StdcallCallConv = 64, 359 | LLVMX86FastcallCallConv = 65 360 | } 361 | } 362 | 363 | enum : LLVMIntPredicate 364 | { 365 | LLVMIntEQ = 32, 366 | LLVMIntNE, 367 | LLVMIntUGT, 368 | LLVMIntUGE, 369 | LLVMIntULT, 370 | LLVMIntULE, 371 | LLVMIntSGT, 372 | LLVMIntSGE, 373 | LLVMIntSLT, 374 | LLVMIntSLE 375 | } 376 | 377 | enum : LLVMRealPredicate 378 | { 379 | LLVMRealPredicateFalse, 380 | LLVMRealOEQ, 381 | LLVMRealOGT, 382 | LLVMRealOGE, 383 | LLVMRealOLT, 384 | LLVMRealOLE, 385 | LLVMRealONE, 386 | LLVMRealORD, 387 | LLVMRealUNO, 388 | LLVMRealUEQ, 389 | LLVMRealUGT, 390 | LLVMRealUGE, 391 | LLVMRealULT, 392 | LLVMRealULE, 393 | LLVMRealUNE, 394 | LLVMRealPredicateTrue 395 | } 396 | 397 | enum : LLVMLandingPadClauseTy 398 | { 399 | LLVMLandingPadCatch, 400 | LLVMLandingPadFilter 401 | } 402 | 403 | static if (LLVM_Version >= asVersion(3, 3, 0)) 404 | { 405 | enum : LLVMThreadLocalMode 406 | { 407 | LLVMNotThreadLocal = 0, 408 | LLVMGeneralDynamicTLSModel, 409 | LLVMLocalDynamicTLSModel, 410 | LLVMInitialExecTLSModel, 411 | LLVMLocalExecTLSModel 412 | } 413 | 414 | enum : LLVMAtomicOrdering 415 | { 416 | LLVMAtomicOrderingNotAtomic = 0, 417 | LLVMAtomicOrderingUnordered = 1, 418 | LLVMAtomicOrderingMonotonic = 2, 419 | LLVMAtomicOrderingAcquire = 4, 420 | LLVMAtomicOrderingRelease = 5, 421 | LLVMAtomicOrderingAcquireRelease = 6, 422 | LLVMAtomicOrderingSequentiallyConsistent = 7 423 | } 424 | 425 | static if (LLVM_Version >= asVersion(10, 0, 0)) 426 | { 427 | enum : LLVMAtomicRMWBinOp 428 | { 429 | LLVMAtomicRMWBinOpXchg, 430 | LLVMAtomicRMWBinOpAdd, 431 | LLVMAtomicRMWBinOpSub, 432 | LLVMAtomicRMWBinOpAnd, 433 | LLVMAtomicRMWBinOpNand, 434 | LLVMAtomicRMWBinOpOr, 435 | LLVMAtomicRMWBinOpXor, 436 | LLVMAtomicRMWBinOpMax, 437 | LLVMAtomicRMWBinOpMin, 438 | LLVMAtomicRMWBinOpUMax, 439 | LLVMAtomicRMWBinOpUMin, 440 | LLVMAtomicRMWBinOpFAdd, 441 | LLVMAtomicRMWBinOpFSub 442 | } 443 | } 444 | else 445 | { 446 | enum : LLVMAtomicRMWBinOp 447 | { 448 | LLVMAtomicRMWBinOpXchg, 449 | LLVMAtomicRMWBinOpAdd, 450 | LLVMAtomicRMWBinOpSub, 451 | LLVMAtomicRMWBinOpAnd, 452 | LLVMAtomicRMWBinOpNand, 453 | LLVMAtomicRMWBinOpOr, 454 | LLVMAtomicRMWBinOpXor, 455 | LLVMAtomicRMWBinOpMax, 456 | LLVMAtomicRMWBinOpMin, 457 | LLVMAtomicRMWBinOpUMax, 458 | LLVMAtomicRMWBinOpUMin 459 | } 460 | } 461 | } 462 | static if (LLVM_Version >= asVersion(3, 5, 0)) 463 | { 464 | enum : LLVMDiagnosticSeverity { 465 | LLVMDSError, 466 | LLVMDSWarning, 467 | LLVMDSRemark, 468 | LLVMDSNote 469 | } 470 | } 471 | 472 | /+ Disassembler +/ 473 | 474 | //TODO: replace const with enum? 475 | const 476 | { 477 | uint LLVMDisassembler_VariantKind_None = 0; 478 | uint LLVMDisassembler_VariantKind_ARM_HI16 = 1; 479 | uint LLVMDisassembler_VariantKind_ARM_LO16 = 2; 480 | static if (LLVM_Version >= asVersion(3, 5, 0)) 481 | { 482 | uint LLVMDisassembler_VariantKind_ARM64_PAGE = 1; 483 | uint LLVMDisassembler_VariantKind_ARM64_PAGEOFF = 2; 484 | uint LLVMDisassembler_VariantKind_ARM64_GOTPAGE = 3; 485 | uint LLVMDisassembler_VariantKind_ARM64_GOTPAGEOFF = 4; 486 | uint LLVMDisassembler_VariantKind_ARM64_TLVP = 5; 487 | uint LLVMDisassembler_VariantKind_ARM64_TLVOFF = 6; 488 | } 489 | uint LLVMDisassembler_ReferenceType_InOut_None = 0; 490 | uint LLVMDisassembler_ReferenceType_In_Branch = 1; 491 | uint LLVMDisassembler_ReferenceType_In_PCrel_Load = 2; 492 | static if (LLVM_Version >= asVersion(3, 5, 0)) 493 | { 494 | ulong LLVMDisassembler_ReferenceType_In_ARM64_ADRP = 0x100000001; 495 | ulong LLVMDisassembler_ReferenceType_In_ARM64_ADDXri = 0x100000002; 496 | ulong LLVMDisassembler_ReferenceType_In_ARM64_LDRXui = 0x100000003; 497 | ulong LLVMDisassembler_ReferenceType_In_ARM64_LDRXl = 0x100000004; 498 | ulong LLVMDisassembler_ReferenceType_In_ARM64_ADR = 0x100000005; 499 | } 500 | uint LLVMDisassembler_ReferenceType_Out_SymbolStub = 1; 501 | uint LLVMDisassembler_ReferenceType_Out_LitPool_SymAddr = 2; 502 | uint LLVMDisassembler_ReferenceType_Out_LitPool_CstrAddr = 3; 503 | static if (LLVM_Version >= asVersion(3, 2, 0)) 504 | { 505 | uint LLVMDisassembler_Option_UseMarkup = 1; 506 | } 507 | static if (LLVM_Version >= asVersion(3, 3, 0)) 508 | { 509 | uint LLVMDisassembler_Option_PrintImmHex = 2; 510 | uint LLVMDisassembler_Option_AsmPrinterVariant = 4; 511 | } 512 | static if (LLVM_Version >= asVersion(3, 4, 0)) 513 | { 514 | uint LLVMDisassembler_ReferenceType_Out_Objc_CFString_Ref = 4; 515 | uint LLVMDisassembler_ReferenceType_Out_Objc_Message = 5; 516 | uint LLVMDisassembler_ReferenceType_Out_Objc_Message_Ref = 6; 517 | uint LLVMDisassembler_ReferenceType_Out_Objc_Selector_Ref = 7; 518 | uint LLVMDisassembler_ReferenceType_Out_Objc_Class_Ref = 8; 519 | uint LLVMDisassembler_Option_SetInstrComments = 8; 520 | uint LLVMDisassembler_Option_PrintLatency = 16; 521 | } 522 | static if (LLVM_Version >= asVersion(3, 5, 0)) 523 | { 524 | uint LLVMDisassembler_ReferenceType_DeMangled_Name = 9; 525 | } 526 | } 527 | 528 | static if (LLVM_Version < asVersion(3, 3, 0)) 529 | { 530 | /+ Enhanced Disassembly +/ 531 | 532 | enum : EDAssemblySyntax_t 533 | { 534 | kEDAssemblySyntaxX86Intel = 0, 535 | kEDAssemblySyntaxX86ATT = 1, 536 | kEDAssemblySyntaxARMUAL = 2 537 | } 538 | } 539 | 540 | /+ Linker +/ 541 | static if (LLVM_Version >= asVersion(3, 2, 0)) 542 | { 543 | enum : LLVMLinkerMode 544 | { 545 | LLVMLinkerDestroySource = 0 546 | } 547 | 548 | static if (LLVM_Version < asVersion(3, 7, 0)) 549 | { 550 | enum : LLVMLinkerMode 551 | { 552 | LLVMLinkerPreserveSource = 1 553 | } 554 | } 555 | } 556 | 557 | /+ Link Time Optimization +/ 558 | 559 | enum : llvm_lto_status 560 | { 561 | LLVM_LTO_UNKNOWN, 562 | LLVM_LTO_OPT_SUCCESS, 563 | LLVM_LTO_READ_SUCCESS, 564 | LLVM_LTO_READ_FAILURE, 565 | LLVM_LTO_WRITE_FAILURE, 566 | LLVM_LTO_NO_TARGET, 567 | LLVM_LTO_NO_WORK, 568 | LLVM_LTO_MODULE_MERGE_FAILURE, 569 | LLVM_LTO_ASM_FAILURE, 570 | LLVM_LTO_NULL_OBJECT 571 | } 572 | 573 | /+ LTO +/ 574 | static if (LLVM_Version >= asVersion(10, 0, 0)) 575 | { 576 | const uint LTO_API_VERSION = 26; 577 | } 578 | else static if (LLVM_Version >= asVersion(9, 0, 0)) 579 | { 580 | const uint LTO_API_VERSION = 24; 581 | } 582 | else static if (LLVM_Version >= asVersion(8, 0, 0)) 583 | { 584 | const uint LTO_API_VERSION = 23; 585 | } 586 | else static if (LLVM_Version >= asVersion(7, 0, 0)) 587 | { 588 | const uint LTO_API_VERSION = 22; 589 | } 590 | else static if (LLVM_Version >= asVersion(4, 0, 0)) 591 | { 592 | const uint LTO_API_VERSION = 21; 593 | } 594 | else static if (LLVM_Version >= asVersion(3, 9, 0)) 595 | { 596 | const uint LTO_API_VERSION = 20; 597 | } 598 | else static if (LLVM_Version >= asVersion(3, 7, 0)) 599 | { 600 | const uint LTO_API_VERSION = 17; 601 | } 602 | else static if (LLVM_Version >= asVersion(3, 6, 0)) 603 | { 604 | const uint LTO_API_VERSION = 11; 605 | } 606 | else static if (LLVM_Version >= asVersion(3, 5, 0)) 607 | { 608 | const uint LTO_API_VERSION = 10; 609 | } 610 | else static if (LLVM_Version >= asVersion(3, 4, 0)) 611 | { 612 | const uint LTO_API_VERSION = 5; 613 | } 614 | else 615 | { 616 | const uint LTO_API_VERSION = 4; 617 | } 618 | 619 | enum : lto_symbol_attributes 620 | { 621 | LTO_SYMBOL_ALIGNMENT_MASK = 0x0000001F, 622 | LTO_SYMBOL_PERMISSIONS_MASK = 0x000000E0, 623 | LTO_SYMBOL_PERMISSIONS_CODE = 0x000000A0, 624 | LTO_SYMBOL_PERMISSIONS_DATA = 0x000000C0, 625 | LTO_SYMBOL_PERMISSIONS_RODATA = 0x00000080, 626 | LTO_SYMBOL_DEFINITION_MASK = 0x00000700, 627 | LTO_SYMBOL_DEFINITION_REGULAR = 0x00000100, 628 | LTO_SYMBOL_DEFINITION_TENTATIVE = 0x00000200, 629 | LTO_SYMBOL_DEFINITION_WEAK = 0x00000300, 630 | LTO_SYMBOL_DEFINITION_UNDEFINED = 0x00000400, 631 | LTO_SYMBOL_DEFINITION_WEAKUNDEF = 0x00000500, 632 | LTO_SYMBOL_SCOPE_MASK = 0x00003800, 633 | LTO_SYMBOL_SCOPE_INTERNAL = 0x00000800, 634 | LTO_SYMBOL_SCOPE_HIDDEN = 0x00001000, 635 | LTO_SYMBOL_SCOPE_PROTECTED = 0x00002000, 636 | LTO_SYMBOL_SCOPE_DEFAULT = 0x00001800, 637 | LTO_SYMBOL_SCOPE_DEFAULT_CAN_BE_HIDDEN = 0x00002800, 638 | } 639 | static if (LLVM_Version >= asVersion(3, 7, 0)) 640 | { 641 | enum : lto_symbol_attributes 642 | { 643 | LTO_SYMBOL_COMDAT = 0x00004000, 644 | LTO_SYMBOL_ALIAS = 0x00008000 645 | } 646 | } 647 | 648 | enum : lto_debug_model 649 | { 650 | LTO_DEBUG_MODEL_NONE = 0, 651 | LTO_DEBUG_MODEL_DWARF = 1 652 | } 653 | 654 | enum : lto_codegen_model 655 | { 656 | LTO_CODEGEN_PIC_MODEL_STATIC = 0, 657 | LTO_CODEGEN_PIC_MODEL_DYNAMIC = 1, 658 | LTO_CODEGEN_PIC_MODEL_DYNAMIC_NO_PIC = 2, 659 | LTO_CODEGEN_PIC_MODEL_DEFAULT = 3 660 | } 661 | 662 | static if (LLVM_Version >= asVersion(3, 5, 0)) 663 | { 664 | enum : lto_codegen_diagnostic_severity_t 665 | { 666 | LTO_DS_ERROR = 0, 667 | LTO_DS_WARNING = 1, 668 | LTO_DS_REMARK = 3, 669 | LTO_DS_NOTE = 2 670 | } 671 | } 672 | 673 | /+ Object file reading and writing +/ 674 | 675 | static if (LLVM_Version >= asVersion(9, 0, 0)) 676 | { 677 | enum : LLVMBinaryType 678 | { 679 | LLVMBinaryTypeArchive, 680 | LLVMBinaryTypeMachOUniversalBinary, 681 | LLVMBinaryTypeCOFFImportFile, 682 | LLVMBinaryTypeIR, 683 | LLVMBinaryTypeWinRes, 684 | LLVMBinaryTypeCOFF, 685 | LLVMBinaryTypeELF32L, 686 | LLVMBinaryTypeELF32B, 687 | LLVMBinaryTypeELF64L, 688 | LLVMBinaryTypeELF64B, 689 | LLVMBinaryTypeMachO32L, 690 | LLVMBinaryTypeMachO32B, 691 | LLVMBinaryTypeMachO64L, 692 | LLVMBinaryTypeMachO64B, 693 | LLVMBinaryTypeWasm 694 | } 695 | } 696 | 697 | /+ Target information +/ 698 | 699 | enum : LLVMByteOrdering 700 | { 701 | LLVMBigEndian, 702 | LLVMLittleEndian 703 | } 704 | 705 | /+ Target machine +/ 706 | 707 | enum : LLVMCodeGenOptLevel 708 | { 709 | LLVMCodeGenLevelNone, 710 | LLVMCodeGenLevelLess, 711 | LLVMCodeGenLevelDefault, 712 | LLVMCodeGenLevelAggressive 713 | } 714 | 715 | static if (LLVM_Version >= asVersion(8, 0, 0)) { 716 | enum : LLVMRelocMode 717 | { 718 | LLVMRelocDefault, 719 | LLVMRelocStatic, 720 | LLVMRelocPIC, 721 | LLVMRelocDynamicNoPic, 722 | LLVMRelocROPI, 723 | LLVMRelocRWPI, 724 | LLVMRelocROPI_RWPI 725 | } 726 | } else { 727 | enum : LLVMRelocMode 728 | { 729 | LLVMRelocDefault, 730 | LLVMRelocStatic, 731 | LLVMRelocPIC, 732 | LLVMRelocDynamicNoPic 733 | } 734 | } 735 | 736 | static if (LLVM_Version >= asVersion(8, 0, 0)) { 737 | enum : LLVMCodeModel 738 | { 739 | LLVMCodeModelDefault, 740 | LLVMCodeModelJITDefault, 741 | LLVMCodeModelTiny, 742 | LLVMCodeModelSmall, 743 | LLVMCodeModelKernel, 744 | LLVMCodeModelMedium, 745 | LLVMCodeModelLarge 746 | } 747 | } else { 748 | enum : LLVMCodeModel 749 | { 750 | LLVMCodeModelDefault, 751 | LLVMCodeModelJITDefault, 752 | LLVMCodeModelSmall, 753 | LLVMCodeModelKernel, 754 | LLVMCodeModelMedium, 755 | LLVMCodeModelLarge 756 | } 757 | } 758 | 759 | enum : LLVMCodeGenFileType 760 | { 761 | LLVMAssemblyFile, 762 | LLVMObjectFile 763 | } 764 | 765 | /+ Orc +/ 766 | 767 | static if (LLVM_Version >= asVersion(3, 9, 0) && LLVM_Version < asVersion(8, 0, 0)) 768 | { 769 | enum : LLVMOrcErrorCode 770 | { 771 | LLVMOrcErrSuccess = 0, 772 | LLVMOrcErrGeneric, 773 | } 774 | } 775 | 776 | /+ Debug info flags +/ 777 | 778 | static if (LLVM_Version >= asVersion(10, 0, 0)) 779 | { 780 | enum : LLVMDIFlags { 781 | LLVMDIFlagZero = 0, 782 | LLVMDIFlagPrivate = 1, 783 | LLVMDIFlagProtected = 2, 784 | LLVMDIFlagPublic = 3, 785 | LLVMDIFlagFwdDecl = 1 << 2, 786 | LLVMDIFlagAppleBlock = 1 << 3, 787 | LLVMDIFlagReservedBit4 = 1 << 4, 788 | LLVMDIFlagVirtual = 1 << 5, 789 | LLVMDIFlagArtificial = 1 << 6, 790 | LLVMDIFlagExplicit = 1 << 7, 791 | LLVMDIFlagPrototyped = 1 << 8, 792 | LLVMDIFlagObjcClassComplete = 1 << 9, 793 | LLVMDIFlagObjectPointer = 1 << 10, 794 | LLVMDIFlagVector = 1 << 11, 795 | LLVMDIFlagStaticMember = 1 << 12, 796 | LLVMDIFlagLValueReference = 1 << 13, 797 | LLVMDIFlagRValueReference = 1 << 14, 798 | LLVMDIFlagReserved = 1 << 15, 799 | LLVMDIFlagSingleInheritance = 1 << 16, 800 | LLVMDIFlagMultipleInheritance = 2 << 16, 801 | LLVMDIFlagVirtualInheritance = 3 << 16, 802 | LLVMDIFlagIntroducedVirtual = 1 << 18, 803 | LLVMDIFlagBitField = 1 << 19, 804 | LLVMDIFlagNoReturn = 1 << 20, 805 | LLVMDIFlagTypePassByValue = 1 << 22, 806 | LLVMDIFlagTypePassByReference = 1 << 23, 807 | LLVMDIFlagEnumClass = 1 << 24, 808 | LLVMDIFlagFixedEnum = LLVMDIFlagEnumClass, 809 | LLVMDIFlagThunk = 1 << 25, 810 | LLVMDIFlagNonTrivial = 1 << 26, 811 | LLVMDIFlagBigEndian = 1 << 27, 812 | LLVMDIFlagLittleEndian = 1 << 28, 813 | LLVMDIFlagIndirectVirtualBase = (1 << 2) | (1 << 5), 814 | LLVMDIFlagAccessibility = LLVMDIFlagPrivate | LLVMDIFlagProtected | LLVMDIFlagPublic, 815 | LLVMDIFlagPtrToMemberRep = LLVMDIFlagSingleInheritance | LLVMDIFlagMultipleInheritance | LLVMDIFlagVirtualInheritance 816 | } 817 | } 818 | else static if (LLVM_Version >= asVersion(9, 0, 0)) 819 | { 820 | enum : LLVMDIFlags { 821 | LLVMDIFlagZero = 0, 822 | LLVMDIFlagPrivate = 1, 823 | LLVMDIFlagProtected = 2, 824 | LLVMDIFlagPublic = 3, 825 | LLVMDIFlagFwdDecl = 1 << 2, 826 | LLVMDIFlagAppleBlock = 1 << 3, 827 | LLVMDIFlagBlockByrefStruct = 1 << 4, 828 | LLVMDIFlagVirtual = 1 << 5, 829 | LLVMDIFlagArtificial = 1 << 6, 830 | LLVMDIFlagExplicit = 1 << 7, 831 | LLVMDIFlagPrototyped = 1 << 8, 832 | LLVMDIFlagObjcClassComplete = 1 << 9, 833 | LLVMDIFlagObjectPointer = 1 << 10, 834 | LLVMDIFlagVector = 1 << 11, 835 | LLVMDIFlagStaticMember = 1 << 12, 836 | LLVMDIFlagLValueReference = 1 << 13, 837 | LLVMDIFlagRValueReference = 1 << 14, 838 | LLVMDIFlagReserved = 1 << 15, 839 | LLVMDIFlagSingleInheritance = 1 << 16, 840 | LLVMDIFlagMultipleInheritance = 2 << 16, 841 | LLVMDIFlagVirtualInheritance = 3 << 16, 842 | LLVMDIFlagIntroducedVirtual = 1 << 18, 843 | LLVMDIFlagBitField = 1 << 19, 844 | LLVMDIFlagNoReturn = 1 << 20, 845 | LLVMDIFlagTypePassByValue = 1 << 22, 846 | LLVMDIFlagTypePassByReference = 1 << 23, 847 | LLVMDIFlagEnumClass = 1 << 24, 848 | LLVMDIFlagFixedEnum = LLVMDIFlagEnumClass, 849 | LLVMDIFlagThunk = 1 << 25, 850 | LLVMDIFlagNonTrivial = 1 << 26, 851 | LLVMDIFlagBigEndian = 1 << 27, 852 | LLVMDIFlagLittleEndian = 1 << 28, 853 | LLVMDIFlagIndirectVirtualBase = (1 << 2) | (1 << 5), 854 | LLVMDIFlagAccessibility = LLVMDIFlagPrivate | LLVMDIFlagProtected | LLVMDIFlagPublic, 855 | LLVMDIFlagPtrToMemberRep = LLVMDIFlagSingleInheritance | LLVMDIFlagMultipleInheritance | LLVMDIFlagVirtualInheritance 856 | } 857 | } 858 | else static if (LLVM_Version >= asVersion(8, 0, 0)) 859 | { 860 | enum : LLVMDIFlags { 861 | LLVMDIFlagZero = 0, 862 | LLVMDIFlagPrivate = 1, 863 | LLVMDIFlagProtected = 2, 864 | LLVMDIFlagPublic = 3, 865 | LLVMDIFlagFwdDecl = 1 << 2, 866 | LLVMDIFlagAppleBlock = 1 << 3, 867 | LLVMDIFlagBlockByrefStruct = 1 << 4, 868 | LLVMDIFlagVirtual = 1 << 5, 869 | LLVMDIFlagArtificial = 1 << 6, 870 | LLVMDIFlagExplicit = 1 << 7, 871 | LLVMDIFlagPrototyped = 1 << 8, 872 | LLVMDIFlagObjcClassComplete = 1 << 9, 873 | LLVMDIFlagObjectPointer = 1 << 10, 874 | LLVMDIFlagVector = 1 << 11, 875 | LLVMDIFlagStaticMember = 1 << 12, 876 | LLVMDIFlagLValueReference = 1 << 13, 877 | LLVMDIFlagRValueReference = 1 << 14, 878 | LLVMDIFlagReserved = 1 << 15, 879 | LLVMDIFlagSingleInheritance = 1 << 16, 880 | LLVMDIFlagMultipleInheritance = 2 << 16, 881 | LLVMDIFlagVirtualInheritance = 3 << 16, 882 | LLVMDIFlagIntroducedVirtual = 1 << 18, 883 | LLVMDIFlagBitField = 1 << 19, 884 | LLVMDIFlagNoReturn = 1 << 20, 885 | LLVMDIFlagMainSubprogram = 1 << 21, 886 | LLVMDIFlagTypePassByValue = 1 << 22, 887 | LLVMDIFlagTypePassByReference = 1 << 23, 888 | LLVMDIFlagEnumClass = 1 << 24, 889 | LLVMDIFlagFixedEnum = LLVMDIFlagEnumClass, 890 | LLVMDIFlagThunk = 1 << 25, 891 | LLVMDIFlagTrivial = 1 << 26, 892 | LLVMDIFlagBigEndian = 1 << 27, 893 | LLVMDIFlagLittleEndian = 1 << 28, 894 | LLVMDIFlagIndirectVirtualBase = (1 << 2) | (1 << 5), 895 | LLVMDIFlagAccessibility = LLVMDIFlagPrivate | LLVMDIFlagProtected | LLVMDIFlagPublic, 896 | LLVMDIFlagPtrToMemberRep = LLVMDIFlagSingleInheritance | LLVMDIFlagMultipleInheritance | LLVMDIFlagVirtualInheritance 897 | } 898 | } 899 | else static if (LLVM_Version >= asVersion(7, 0, 0)) 900 | { 901 | enum : LLVMDIFlags { 902 | LLVMDIFlagZero = 0, 903 | LLVMDIFlagPrivate = 1, 904 | LLVMDIFlagProtected = 2, 905 | LLVMDIFlagPublic = 3, 906 | LLVMDIFlagFwdDecl = 1 << 2, 907 | LLVMDIFlagAppleBlock = 1 << 3, 908 | LLVMDIFlagBlockByrefStruct = 1 << 4, 909 | LLVMDIFlagVirtual = 1 << 5, 910 | LLVMDIFlagArtificial = 1 << 6, 911 | LLVMDIFlagExplicit = 1 << 7, 912 | LLVMDIFlagPrototyped = 1 << 8, 913 | LLVMDIFlagObjcClassComplete = 1 << 9, 914 | LLVMDIFlagObjectPointer = 1 << 10, 915 | LLVMDIFlagVector = 1 << 11, 916 | LLVMDIFlagStaticMember = 1 << 12, 917 | LLVMDIFlagLValueReference = 1 << 13, 918 | LLVMDIFlagRValueReference = 1 << 14, 919 | LLVMDIFlagReserved = 1 << 15, 920 | LLVMDIFlagSingleInheritance = 1 << 16, 921 | LLVMDIFlagMultipleInheritance = 2 << 16, 922 | LLVMDIFlagVirtualInheritance = 3 << 16, 923 | LLVMDIFlagIntroducedVirtual = 1 << 18, 924 | LLVMDIFlagBitField = 1 << 19, 925 | LLVMDIFlagNoReturn = 1 << 20, 926 | LLVMDIFlagMainSubprogram = 1 << 21, 927 | LLVMDIFlagTypePassByValue = 1 << 22, 928 | LLVMDIFlagTypePassByReference = 1 << 23, 929 | LLVMDIFlagFixedEnum = 1 << 24, 930 | LLVMDIFlagThunk = 1 << 25, 931 | LLVMDIFlagTrivial = 1 << 26, 932 | LLVMDIFlagIndirectVirtualBase = (1 << 2) | (1 << 5), 933 | LLVMDIFlagAccessibility = LLVMDIFlagPrivate | LLVMDIFlagProtected | LLVMDIFlagPublic, 934 | LLVMDIFlagPtrToMemberRep = LLVMDIFlagSingleInheritance | LLVMDIFlagMultipleInheritance | LLVMDIFlagVirtualInheritance 935 | } 936 | } 937 | else static if (LLVM_Version >= asVersion(6, 0, 0)) 938 | { 939 | enum : LLVMDIFlags { 940 | LLVMDIFlagZero = 0, 941 | LLVMDIFlagPrivate = 1, 942 | LLVMDIFlagProtected = 2, 943 | LLVMDIFlagPublic = 3, 944 | LLVMDIFlagFwdDecl = 1 << 2, 945 | LLVMDIFlagAppleBlock = 1 << 3, 946 | LLVMDIFlagBlockByrefStruct = 1 << 4, 947 | LLVMDIFlagVirtual = 1 << 5, 948 | LLVMDIFlagArtificial = 1 << 6, 949 | LLVMDIFlagExplicit = 1 << 7, 950 | LLVMDIFlagPrototyped = 1 << 8, 951 | LLVMDIFlagObjcClassComplete = 1 << 9, 952 | LLVMDIFlagObjectPointer = 1 << 10, 953 | LLVMDIFlagVector = 1 << 11, 954 | LLVMDIFlagStaticMember = 1 << 12, 955 | LLVMDIFlagLValueReference = 1 << 13, 956 | LLVMDIFlagRValueReference = 1 << 14, 957 | LLVMDIFlagReserved = 1 << 15, 958 | LLVMDIFlagSingleInheritance = 1 << 16, 959 | LLVMDIFlagMultipleInheritance = 2 << 16, 960 | LLVMDIFlagVirtualInheritance = 3 << 16, 961 | LLVMDIFlagIntroducedVirtual = 1 << 18, 962 | LLVMDIFlagBitField = 1 << 19, 963 | LLVMDIFlagNoReturn = 1 << 20, 964 | LLVMDIFlagMainSubprogram = 1 << 21, 965 | LLVMDIFlagIndirectVirtualBase = (1 << 2) | (1 << 5), 966 | LLVMDIFlagAccessibility = LLVMDIFlagPrivate | LLVMDIFlagProtected | 967 | LLVMDIFlagPublic, 968 | LLVMDIFlagPtrToMemberRep = LLVMDIFlagSingleInheritance | 969 | LLVMDIFlagMultipleInheritance | 970 | LLVMDIFlagVirtualInheritance 971 | } 972 | } 973 | 974 | static if (LLVM_Version >= asVersion(6, 0, 0)) 975 | { 976 | enum : LLVMDWARFSourceLanguage { 977 | LLVMDWARFSourceLanguageC89, 978 | LLVMDWARFSourceLanguageC, 979 | LLVMDWARFSourceLanguageAda83, 980 | LLVMDWARFSourceLanguageC_plus_plus, 981 | LLVMDWARFSourceLanguageCobol74, 982 | LLVMDWARFSourceLanguageCobol85, 983 | LLVMDWARFSourceLanguageFortran77, 984 | LLVMDWARFSourceLanguageFortran90, 985 | LLVMDWARFSourceLanguagePascal83, 986 | LLVMDWARFSourceLanguageModula2, 987 | // New in DWARF v3: 988 | LLVMDWARFSourceLanguageJava, 989 | LLVMDWARFSourceLanguageC99, 990 | LLVMDWARFSourceLanguageAda95, 991 | LLVMDWARFSourceLanguageFortran95, 992 | LLVMDWARFSourceLanguagePLI, 993 | LLVMDWARFSourceLanguageObjC, 994 | LLVMDWARFSourceLanguageObjC_plus_plus, 995 | LLVMDWARFSourceLanguageUPC, 996 | LLVMDWARFSourceLanguageD, 997 | // New in DWARF v4: 998 | LLVMDWARFSourceLanguagePython, 999 | // New in DWARF v5: 1000 | LLVMDWARFSourceLanguageOpenCL, 1001 | LLVMDWARFSourceLanguageGo, 1002 | LLVMDWARFSourceLanguageModula3, 1003 | LLVMDWARFSourceLanguageHaskell, 1004 | LLVMDWARFSourceLanguageC_plus_plus_03, 1005 | LLVMDWARFSourceLanguageC_plus_plus_11, 1006 | LLVMDWARFSourceLanguageOCaml, 1007 | LLVMDWARFSourceLanguageRust, 1008 | LLVMDWARFSourceLanguageC11, 1009 | LLVMDWARFSourceLanguageSwift, 1010 | LLVMDWARFSourceLanguageJulia, 1011 | LLVMDWARFSourceLanguageDylan, 1012 | LLVMDWARFSourceLanguageC_plus_plus_14, 1013 | LLVMDWARFSourceLanguageFortran03, 1014 | LLVMDWARFSourceLanguageFortran08, 1015 | LLVMDWARFSourceLanguageRenderScript, 1016 | LLVMDWARFSourceLanguageBLISS, 1017 | // Vendor extensions: 1018 | LLVMDWARFSourceLanguageMips_Assembler, 1019 | LLVMDWARFSourceLanguageGOOGLE_RenderScript, 1020 | LLVMDWARFSourceLanguageBORLAND_Delphi 1021 | } 1022 | } 1023 | 1024 | static if (LLVM_Version >= asVersion(6, 0, 0)) 1025 | { 1026 | enum : LLVMDWARFEmissionKind { 1027 | LLVMDWARFEmissionNone = 0, 1028 | LLVMDWARFEmissionFull, 1029 | LLVMDWARFEmissionLineTablesOnly 1030 | } 1031 | 1032 | } 1033 | 1034 | static if (LLVM_Version >= asVersion(9, 0, 0)) 1035 | { 1036 | enum : LLVMMetadataKind { 1037 | LLVMMDStringMetadataKind, 1038 | LLVMConstantAsMetadataMetadataKind, 1039 | LLVMLocalAsMetadataMetadataKind, 1040 | LLVMDistinctMDOperandPlaceholderMetadataKind, 1041 | LLVMMDTupleMetadataKind, 1042 | LLVMDILocationMetadataKind, 1043 | LLVMDIExpressionMetadataKind, 1044 | LLVMDIGlobalVariableExpressionMetadataKind, 1045 | LLVMGenericDINodeMetadataKind, 1046 | LLVMDISubrangeMetadataKind, 1047 | LLVMDIEnumeratorMetadataKind, 1048 | LLVMDIBasicTypeMetadataKind, 1049 | LLVMDIDerivedTypeMetadataKind, 1050 | LLVMDICompositeTypeMetadataKind, 1051 | LLVMDISubroutineTypeMetadataKind, 1052 | LLVMDIFileMetadataKind, 1053 | LLVMDICompileUnitMetadataKind, 1054 | LLVMDISubprogramMetadataKind, 1055 | LLVMDILexicalBlockMetadataKind, 1056 | LLVMDILexicalBlockFileMetadataKind, 1057 | LLVMDINamespaceMetadataKind, 1058 | LLVMDIModuleMetadataKind, 1059 | LLVMDITemplateTypeParameterMetadataKind, 1060 | LLVMDITemplateValueParameterMetadataKind, 1061 | LLVMDIGlobalVariableMetadataKind, 1062 | LLVMDILocalVariableMetadataKind, 1063 | LLVMDILabelMetadataKind, 1064 | LLVMDIObjCPropertyMetadataKind, 1065 | LLVMDIImportedEntityMetadataKind, 1066 | LLVMDIMacroMetadataKind, 1067 | LLVMDIMacroFileMetadataKind, 1068 | LLVMDICommonBlockMetadataKind 1069 | } 1070 | } 1071 | else static if (LLVM_Version >= asVersion(8, 0, 0)) { 1072 | enum : LLVMMetadataKind { 1073 | LLVMMDStringMetadataKind, 1074 | LLVMConstantAsMetadataMetadataKind, 1075 | LLVMLocalAsMetadataMetadataKind, 1076 | LLVMDistinctMDOperandPlaceholderMetadataKind, 1077 | LLVMMDTupleMetadataKind, 1078 | LLVMDILocationMetadataKind, 1079 | LLVMDIExpressionMetadataKind, 1080 | LLVMDIGlobalVariableExpressionMetadataKind, 1081 | LLVMGenericDINodeMetadataKind, 1082 | LLVMDISubrangeMetadataKind, 1083 | LLVMDIEnumeratorMetadataKind, 1084 | LLVMDIBasicTypeMetadataKind, 1085 | LLVMDIDerivedTypeMetadataKind, 1086 | LLVMDICompositeTypeMetadataKind, 1087 | LLVMDISubroutineTypeMetadataKind, 1088 | LLVMDIFileMetadataKind, 1089 | LLVMDICompileUnitMetadataKind, 1090 | LLVMDISubprogramMetadataKind, 1091 | LLVMDILexicalBlockMetadataKind, 1092 | LLVMDILexicalBlockFileMetadataKind, 1093 | LLVMDINamespaceMetadataKind, 1094 | LLVMDIModuleMetadataKind, 1095 | LLVMDITemplateTypeParameterMetadataKind, 1096 | LLVMDITemplateValueParameterMetadataKind, 1097 | LLVMDIGlobalVariableMetadataKind, 1098 | LLVMDILocalVariableMetadataKind, 1099 | LLVMDILabelMetadataKind, 1100 | LLVMDIObjCPropertyMetadataKind, 1101 | LLVMDIImportedEntityMetadataKind, 1102 | LLVMDIMacroMetadataKind, 1103 | LLVMDIMacroFileMetadataKind 1104 | } 1105 | } 1106 | 1107 | static if (LLVM_Version >= asVersion(7, 0, 0)) 1108 | { 1109 | enum : LLVMComdatSelectionKind { 1110 | LLVMAnyComdatSelectionKind, 1111 | LLVMExactMatchComdatSelectionKind, 1112 | LLVMLargestComdatSelectionKind, 1113 | LLVMNoDuplicatesComdatSelectionKind, 1114 | LLVMSameSizeComdatSelectionKind 1115 | } 1116 | } 1117 | 1118 | static if (LLVM_Version >= asVersion(7, 0, 0)) 1119 | { 1120 | enum : LLVMUnnamedAddr { 1121 | LLVMNoUnnamedAddr, 1122 | LLVMLocalUnnamedAddr, 1123 | LLVMGlobalUnnamedAddr 1124 | } 1125 | } 1126 | 1127 | 1128 | static if (LLVM_Version >= asVersion(7, 0, 0)) 1129 | { 1130 | enum : LLVMInlineAsmDialect { 1131 | LLVMInlineAsmDialectATT, 1132 | LLVMInlineAsmDialectIntel 1133 | } 1134 | } 1135 | 1136 | static if (LLVM_Version >= asVersion(7, 0, 0)) 1137 | { 1138 | enum : LLVMModuleFlagBehavior { 1139 | LLVMModuleFlagBehaviorError, 1140 | LLVMModuleFlagBehaviorWarning, 1141 | LLVMModuleFlagBehaviorRequire, 1142 | LLVMModuleFlagBehaviorOverride, 1143 | LLVMModuleFlagBehaviorAppend, 1144 | LLVMModuleFlagBehaviorAppendUnique, 1145 | } 1146 | } 1147 | 1148 | static if (LLVM_Version >= asVersion(10, 0, 0)) 1149 | { 1150 | enum : LLVMDWARFMacinfoRecordType { 1151 | LLVMDWARFMacinfoRecordTypeDefine = 0x01, 1152 | LLVMDWARFMacinfoRecordTypeMacro = 0x02, 1153 | LLVMDWARFMacinfoRecordTypeStartFile = 0x03, 1154 | LLVMDWARFMacinfoRecordTypeEndFile = 0x04, 1155 | LLVMDWARFMacinfoRecordTypeVendorExt = 0xff 1156 | } 1157 | } 1158 | 1159 | 1160 | /+ Error +/ 1161 | 1162 | static if (LLVM_Version >= asVersion(8, 0, 0)) { 1163 | enum LLVMErrorSuccess = 0; 1164 | } 1165 | 1166 | /+ Remarks / OptRemarks +/ 1167 | 1168 | static if (LLVM_Version >= asVersion(9, 0, 0)) { 1169 | 1170 | static if (LLVM_Version >= asVersion(10, 0, 0)) { 1171 | enum REMARKS_API_VERSION = 1; 1172 | } 1173 | else { 1174 | enum REMARKS_API_VERSION = 0; 1175 | } 1176 | 1177 | enum : LLVMRemarkType { 1178 | LLVMRemarkTypeUnknown, 1179 | LLVMRemarkTypePassed, 1180 | LLVMRemarkTypeMissed, 1181 | LLVMRemarkTypeAnalysis, 1182 | LLVMRemarkTypeAnalysisFPCommute, 1183 | LLVMRemarkTypeAnalysisAliasing, 1184 | LLVMRemarkTypeFailure 1185 | } 1186 | } else static if (LLVM_Version >= asVersion(8, 0, 0)) { 1187 | enum OPT_REMARKS_API_VERSION = 0; 1188 | } 1189 | -------------------------------------------------------------------------------- /source/llvm/functions/load.d: -------------------------------------------------------------------------------- 1 | module llvm.functions.load; 2 | 3 | version (LLVM_Load): 4 | 5 | import std.traits; 6 | import std.meta; 7 | 8 | import link = llvm.functions.link; 9 | 10 | private: 11 | 12 | version(Posix) 13 | { 14 | import core.sys.posix.dlfcn; 15 | 16 | alias SharedLibHandle = void*; 17 | 18 | version(OSX) 19 | { 20 | enum libPrefix = "lib"; 21 | enum libSuffix = "dylib"; 22 | } 23 | else 24 | { 25 | enum libPrefix = "lib"; 26 | enum libSuffix = "so"; 27 | } 28 | 29 | pragma(lib, "dl"); 30 | } 31 | else version(Windows) 32 | { 33 | import core.sys.windows.windows; 34 | import std.path : dirName; 35 | 36 | alias SharedLibHandle = HMODULE; 37 | 38 | enum libPrefix = ""; 39 | enum libSuffix = "dll"; 40 | } else { 41 | static assert(0, "Unsupported operating system"); 42 | } 43 | 44 | struct SharedLib 45 | { 46 | import std.string : fromStringz, toStringz; 47 | private: 48 | SharedLibHandle handle; 49 | public: 50 | @disable this(this); 51 | 52 | this(string filename) 53 | { 54 | version(Posix) 55 | { 56 | if((handle = dlopen(filename.toStringz(), RTLD_NOW)) is null) 57 | { 58 | throw new SharedLibException("Failed to load library " ~ filename ~ ": " ~ dlerror().fromStringz().idup); 59 | } 60 | } 61 | else version(Windows) 62 | { 63 | if((handle = LoadLibraryA(filename.toStringz())) is null) 64 | { 65 | LPCSTR error; 66 | DWORD tchar_length = FormatMessageA( 67 | FORMAT_MESSAGE_ALLOCATE_BUFFER | 68 | FORMAT_MESSAGE_FROM_SYSTEM | 69 | FORMAT_MESSAGE_IGNORE_INSERTS, 70 | null, 71 | GetLastError(), 72 | MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), 73 | cast(char*) &error, 74 | 0, 75 | null); 76 | scope(exit) LocalFree(cast(HLOCAL) error); 77 | 78 | throw new SharedLibException("Failed to load library " ~ filename ~ ": " ~ error[0..tchar_length].idup); 79 | } 80 | } 81 | else static assert(0, "Unsupported operating system"); 82 | } 83 | 84 | ~this() 85 | { 86 | version (Posix) alias close = dlclose; 87 | else version (Windows) alias close = FreeLibrary; 88 | else static assert(0, "Unsupported operating system"); 89 | 90 | if (handle) { 91 | close(handle); 92 | handle = null; 93 | } 94 | } 95 | 96 | T getSymbol(T)(string symbol) 97 | { 98 | version (Posix) alias get = dlsym; 99 | else version (Windows) alias get = GetProcAddress; 100 | else static assert(0, "Unsupported operating system"); 101 | 102 | return cast(T) get(handle, symbol.toStringz()); 103 | } 104 | } 105 | 106 | public: 107 | 108 | final class SharedLibException : Exception 109 | { 110 | this(string msg) @safe pure nothrow 111 | { 112 | super(msg); 113 | } 114 | } 115 | 116 | private 117 | { 118 | bool isSym(string m) { return m != "object" && m != "llvm" && m != "core" && m != "orEmpty"; } 119 | 120 | string declareSymPtr(string m) { return "typeof(link." ~ m ~ ")* " ~ m ~ ";"; } 121 | string getSymPtr(string m) 122 | { 123 | string code; 124 | code ~= "foreach (library; libraries) { "; 125 | code ~= m ~ " = library.getSymbol!(typeof(" ~ m ~ "))(\"" ~ m ~ "\");"; 126 | code ~= "if (" ~ m ~ " !is null) break;"; 127 | code ~= " }"; 128 | return code; 129 | } 130 | } 131 | 132 | __gshared 133 | { 134 | mixin ({ 135 | string code; 136 | foreach (m; __traits(allMembers, link)) if (m.isSym) { 137 | code ~= m.declareSymPtr; 138 | } 139 | return code; 140 | }()); 141 | } 142 | 143 | /// Container for holding the LLVM library and the load/unload functions. 144 | public struct LLVM 145 | { 146 | import llvm.config : LLVM_VersionString; 147 | private: 148 | import std.typecons : RefCounted; 149 | 150 | __gshared static RefCounted!SharedLib[] libraries; 151 | 152 | static void getSymbols() 153 | { 154 | foreach (m; __traits(allMembers, link)) static if (m.isSym) { 155 | mixin (m.getSymPtr); 156 | debug { 157 | import std.stdio : stderr; 158 | if (!mixin(m)) stderr.writeln("Missing LLVM symbol: " ~ m); 159 | } 160 | } 161 | } 162 | public: 163 | /// true iff the LLVM library is loaded 164 | static bool loaded() @property { return libraries.length > 0; } 165 | 166 | /// Loads the LLVM libraries using the specified filenames 167 | static void load(string[] filenames...) 168 | { 169 | if (filenames.length == 0) { 170 | filenames ~= libPrefix ~ "LLVM" ~ "." ~ libSuffix; 171 | filenames ~= libPrefix ~ "LTO" ~ "." ~ libSuffix; 172 | } 173 | 174 | if (loaded) unload(); 175 | 176 | foreach (filename; filenames) { 177 | libraries ~= RefCounted!SharedLib(filename); 178 | } 179 | getSymbols(); 180 | } 181 | 182 | /// Unloads the LLVM library 183 | static void unload() 184 | { 185 | libraries.length = 0; 186 | } 187 | } 188 | 189 | version (LLVM_Autoload) 190 | { 191 | shared static this() 192 | { 193 | LLVM.load(); 194 | } 195 | 196 | shared static ~this() 197 | { 198 | LLVM.unload(); 199 | } 200 | } 201 | -------------------------------------------------------------------------------- /source/llvm/functions/package.d: -------------------------------------------------------------------------------- 1 | module llvm.functions; 2 | 3 | import std.array : array; 4 | import std.algorithm.iteration : map, joiner; 5 | import std.range : chain; 6 | 7 | import llvm.config; 8 | import llvm.types; 9 | 10 | private nothrow auto orEmpty(T)(T v) 11 | { 12 | return v? v : ""; 13 | } 14 | 15 | nothrow void LLVMInitializeAllTargetInfos() 16 | { 17 | mixin(LLVM_Targets.map!(t => "LLVMInitialize" ~ t ~ "TargetInfo();").joiner.array.orEmpty); 18 | } 19 | 20 | nothrow void LLVMInitializeAllTargets() 21 | { 22 | mixin(LLVM_Targets.map!(t => "LLVMInitialize" ~ t ~ "Target();").joiner.array.orEmpty); 23 | } 24 | 25 | nothrow void LLVMInitializeAllTargetMCs() 26 | { 27 | mixin(LLVM_Targets.map!(t => "LLVMInitialize" ~ t ~ "TargetMC();").joiner.array.orEmpty); 28 | } 29 | 30 | nothrow void LLVMInitializeAllAsmPrinters() 31 | { 32 | mixin(LLVM_AsmPrinters.map!(t => "LLVMInitialize" ~ t ~ "AsmPrinter();").joiner.array.orEmpty); 33 | } 34 | 35 | nothrow void LLVMInitializeAllAsmParsers() 36 | { 37 | mixin(LLVM_AsmParsers.map!(t => "LLVMInitialize" ~ t ~ "AsmParser();").joiner.array.orEmpty); 38 | } 39 | 40 | nothrow void LLVMInitializeAllDisassemblers() 41 | { 42 | mixin(LLVM_Disassemblers.map!(t => "LLVMInitialize" ~ t ~ "Disassembler();").joiner.array.orEmpty); 43 | } 44 | 45 | nothrow LLVMBool LLVMInitializeNativeTarget() 46 | { 47 | static if (LLVM_NativeTarget != "") { 48 | mixin("LLVMInitialize" ~ LLVM_NativeTarget ~ "TargetInfo();"); 49 | mixin("LLVMInitialize" ~ LLVM_NativeTarget ~ "Target();"); 50 | mixin("LLVMInitialize" ~ LLVM_NativeTarget ~ "TargetMC();"); 51 | return 0; 52 | } else { 53 | return 1; 54 | } 55 | } 56 | 57 | static if (LLVM_Version >= asVersion(3, 4, 0)) 58 | { 59 | nothrow LLVMBool LLVMInitializeNativeAsmParser() 60 | { 61 | static if (LLVM_NativeTarget != "") { 62 | mixin("LLVMInitialize" ~ LLVM_NativeTarget ~ "AsmParser();"); 63 | return 0; 64 | } else { 65 | return 1; 66 | } 67 | } 68 | 69 | nothrow LLVMBool LLVMInitializeNativeAsmPrinter() 70 | { 71 | static if (LLVM_NativeTarget != "") { 72 | mixin("LLVMInitialize" ~ LLVM_NativeTarget ~ "AsmPrinter();"); 73 | return 0; 74 | } else { 75 | return 1; 76 | } 77 | } 78 | 79 | nothrow LLVMBool LLVMInitializeNativeDisassembler() 80 | { 81 | static if (LLVM_NativeTarget != "") { 82 | mixin("LLVMInitialize" ~ LLVM_NativeTarget ~ "Disassembler();"); 83 | return 0; 84 | } else { 85 | return 1; 86 | } 87 | } 88 | } 89 | 90 | version (LLVM_Load) public import llvm.functions.load; 91 | else public import llvm.functions.link; 92 | -------------------------------------------------------------------------------- /source/llvm/package.d: -------------------------------------------------------------------------------- 1 | module llvm; 2 | 3 | public 4 | { 5 | import llvm.config; 6 | import llvm.types; 7 | import llvm.constants; 8 | import llvm.functions; 9 | } -------------------------------------------------------------------------------- /source/llvm/types.d: -------------------------------------------------------------------------------- 1 | module llvm.types; 2 | 3 | public import std.stdint : uintptr_t; 4 | 5 | import llvm.config; 6 | import core.stdc.stdint; 7 | 8 | /+ Analysis +/ 9 | 10 | alias LLVMVerifierFailureAction = int; 11 | 12 | /+ Transforms +/ 13 | 14 | /++ Interprocedural transformations ++/ 15 | 16 | static if (LLVM_Version >= asVersion(10, 0, 0)) 17 | { 18 | alias MustPreserveCallback = extern(C) LLVMBool function(LLVMValueRef, void*); 19 | } 20 | 21 | /++ Pass manager builder ++/ 22 | 23 | struct LLVMOpaquePassManagerBuilder; alias LLVMPassManagerBuilderRef = LLVMOpaquePassManagerBuilder*; 24 | 25 | /+ Core +/ 26 | 27 | static if (LLVM_Version >= asVersion(3, 4, 0)) 28 | { 29 | alias LLVMFatalErrorHandler = extern(C) void function(const char* Reason); 30 | } 31 | 32 | static if (LLVM_Version >= asVersion(3, 5, 0)) 33 | { 34 | //This is here because putting it where it semantically belongs creates a forward reference issues. 35 | struct LLVMOpaqueDiagnosticInfo; alias LLVMDiagnosticInfoRef = LLVMOpaqueDiagnosticInfo*; 36 | 37 | alias LLVMDiagnosticHandler = extern(C) void function(LLVMDiagnosticInfoRef, void*); 38 | alias LLVMYieldCallback = extern(C) void function(LLVMContextRef, void *); 39 | } 40 | 41 | /++ Types and Enumerations ++/ 42 | 43 | alias LLVMBool = int; 44 | struct LLVMOpaqueContext; alias LLVMContextRef = LLVMOpaqueContext*; 45 | struct LLVMOpaqueModule; alias LLVMModuleRef = LLVMOpaqueModule*; 46 | struct LLVMOpaqueType; alias LLVMTypeRef = LLVMOpaqueType*; 47 | struct LLVMOpaqueValue; alias LLVMValueRef = LLVMOpaqueValue*; 48 | static if (LLVM_Version >= asVersion(5, 0, 0)) { 49 | struct LLVMOpaqueMetadata; alias LLVMMetadataRef = LLVMOpaqueMetadata*; 50 | } 51 | static if (LLVM_Version >= asVersion(8, 0, 0)) { 52 | struct LLVMOpaqueNamedMDNode; alias LLVMNamedMDNodeRef = LLVMOpaqueNamedMDNode*; 53 | 54 | struct LLVMOpaqueValueMetadataEntry; alias LLVMValueMetadataEntry = LLVMOpaqueValueMetadataEntry*; 55 | } 56 | struct LLVMOpaqueBasicBlock; alias LLVMBasicBlockRef = LLVMOpaqueBasicBlock*; 57 | static if (LLVM_Version >= asVersion(5, 0, 0)) { 58 | struct LLVMOpaqueDIBuilder; alias LLVMDIBuilderRef = LLVMOpaqueDIBuilder*; 59 | } 60 | struct LLVMOpaqueBuilder; alias LLVMBuilderRef = LLVMOpaqueBuilder*; 61 | struct LLVMOpaqueModuleProvider; alias LLVMModuleProviderRef = LLVMOpaqueModuleProvider*; 62 | struct LLVMOpaqueMemoryBuffer; alias LLVMMemoryBufferRef = LLVMOpaqueMemoryBuffer*; 63 | struct LLVMOpaquePassManager; alias LLVMPassManagerRef = LLVMOpaquePassManager*; 64 | struct LLVMOpaquePassRegistry; alias LLVMPassRegistryRef = LLVMOpaquePassRegistry*; 65 | struct LLVMOpaqueUse; alias LLVMUseRef = LLVMOpaqueUse*; 66 | 67 | static if (LLVM_Version >= asVersion(3, 9, 0)) { 68 | struct LLVMOpaqueAttributeRef; alias LLVMAttributeRef = LLVMOpaqueAttributeRef*; 69 | } 70 | 71 | alias LLVMAttribute = long; 72 | alias LLVMOpcode = int; 73 | alias LLVMTypeKind = int; 74 | alias LLVMLinkage = int; 75 | alias LLVMVisibility = int; 76 | alias LLVMDLLStorageClass = int; 77 | alias LLVMCallConv = int; 78 | alias LLVMIntPredicate = int; 79 | alias LLVMRealPredicate = int; 80 | alias LLVMLandingPadClauseTy = int; 81 | static if (LLVM_Version >= asVersion(3, 3, 0)) 82 | { 83 | alias LLVMThreadLocalMode = int; 84 | alias LLVMAtomicOrdering = int; 85 | alias LLVMAtomicRMWBinOp = int; 86 | } 87 | static if (LLVM_Version >= asVersion(3, 5, 0)) 88 | { 89 | alias LLVMDiagnosticSeverity = int; 90 | } 91 | static if (LLVM_Version >= asVersion(3, 9, 0)) 92 | { 93 | alias LLVMValueKind = int; 94 | alias LLVMAttributeIndex = uint; 95 | } 96 | /+ Disassembler +/ 97 | 98 | alias LLVMDisasmContextRef = void*; 99 | alias LLVMOpInfoCallback = extern(C) int function(void* DisInfo, ulong PC, ulong Offset, ulong Size, int TagType, void* TagBuf); 100 | alias LLVMSymbolLookupCallback = extern(C) const char* function(void* DisInfo, ulong ReferenceValue, ulong* ReferenceType, ulong ReferencePC, const char** ReferenceName); 101 | 102 | struct LLVMOpInfoSymbol1 103 | { 104 | ulong Present; 105 | const(char)* Name; 106 | ulong Value; 107 | } 108 | 109 | struct LLVMOpInfo1 110 | { 111 | LLVMOpInfoSymbol1 AddSymbol; 112 | LLVMOpInfoSymbol1 SubtractSymbol; 113 | ulong Value; 114 | ulong VariantKind; 115 | } 116 | 117 | static if (LLVM_Version < asVersion(3, 3, 0)) 118 | { 119 | /+ Enhanced Disassembly +/ 120 | 121 | alias EDDisassemblerRef = void*; 122 | alias EDInstRef = void*; 123 | alias EDTokenRef = void*; 124 | alias EDOperandRef = void*; 125 | 126 | alias EDAssemblySyntax_t = int; 127 | 128 | alias EDByteReaderCallback = extern(C) int function(ubyte* Byte, ulong address, void* arg); 129 | alias EDRegisterReaderCallback = extern(C) int function(ulong* value, uint regID, void* arg); 130 | 131 | alias EDByteBlock_t = extern(C) int function(ubyte* Byte, ulong address); 132 | alias EDRegisterBlock_t = extern(C) int function(ulong* value, uint regID); 133 | alias EDTokenVisitor_t = extern(C) int function(EDTokenRef token); 134 | } 135 | 136 | /+ Execution Engine +/ 137 | 138 | struct LLVMOpaqueGenericValue; alias LLVMGenericValueRef = LLVMOpaqueGenericValue*; 139 | struct LLVMOpaqueExecutionEngine; alias LLVMExecutionEngineRef = LLVMOpaqueExecutionEngine*; 140 | 141 | static if (LLVM_Version >= asVersion(3, 3, 0)) 142 | { 143 | static if (LLVM_Version >= asVersion(3, 4, 0)) 144 | { 145 | struct LLVMOpaqueMCJITMemoryManager; alias LLVMMCJITMemoryManagerRef = LLVMOpaqueMCJITMemoryManager*; 146 | 147 | struct LLVMMCJITCompilerOptions 148 | { 149 | uint OptLevel; 150 | LLVMCodeModel CodeModel; 151 | LLVMBool NoFramePointerElim; 152 | LLVMBool EnableFastISel; 153 | LLVMMCJITMemoryManagerRef MCJMM; 154 | } 155 | 156 | alias LLVMMemoryManagerAllocateCodeSectionCallback = extern(C) ubyte function(void* Opaque, uintptr_t Size, uint Alignment, uint SectionID, const char* SectionName); 157 | alias LLVMMemoryManagerAllocateDataSectionCallback = extern(C) ubyte function(void* Opaque, uintptr_t Size, uint Alignment, uint SectionID, const char* SectionName, LLVMBool IsReadOnly); 158 | alias LLVMMemoryManagerFinalizeMemoryCallback = extern(C) LLVMBool function(void* Opaque, char** ErrMsg); 159 | alias LLVMMemoryManagerDestroyCallback = extern(C) void function(void* Opaque); 160 | } 161 | else 162 | { 163 | struct LLVMMCJITCompilerOptions 164 | { 165 | uint OptLevel; 166 | LLVMCodeModel CodeModel; 167 | LLVMBool NoFramePointerElim; 168 | LLVMBool EnableFastISel; 169 | } 170 | } 171 | } 172 | 173 | static if (LLVM_Version >= asVersion(3, 2, 0)) 174 | { 175 | /+ Linker +/ 176 | 177 | alias LLVMLinkerMode = int; 178 | } 179 | 180 | /+ Link Time Optimization +/ 181 | alias lto_bool_t = bool; 182 | alias llvm_lto_t = void*; 183 | alias llvm_lto_status_t = llvm_lto_status; 184 | 185 | 186 | alias llvm_lto_status = int; 187 | 188 | /+ LTO +/ 189 | 190 | static if (LLVM_Version >= asVersion(9, 0, 0)) 191 | { 192 | struct LLVMOpaqueLTOInput; alias lto_input_t = LLVMOpaqueLTOInput*; 193 | } 194 | static if (LLVM_Version >= asVersion(3, 5, 0)) 195 | { 196 | struct LLVMOpaqueLTOModule; alias lto_module_t = LLVMOpaqueLTOModule*; 197 | } 198 | else 199 | { 200 | struct LTOModule; alias lto_module_t = LTOModule*; 201 | } 202 | static if (LLVM_Version >= asVersion(3, 5, 0)) 203 | { 204 | struct LLVMOpaqueLTOCodeGenerator; alias lto_code_gen_t = LLVMOpaqueLTOCodeGenerator*; 205 | } 206 | else 207 | { 208 | struct LTOCodeGenerator; alias lto_code_gen_t = LTOCodeGenerator*; 209 | } 210 | static if (LLVM_Version >= asVersion(3, 9, 0)) 211 | { 212 | struct LLVMOpaqueThinLTOCodeGenerator; alias thinlto_code_gen_t = LLVMOpaqueThinLTOCodeGenerator*; 213 | } 214 | 215 | alias lto_symbol_attributes = int; 216 | alias lto_debug_model = int; 217 | alias lto_codegen_model = int; 218 | alias lto_codegen_diagnostic_severity_t = int; 219 | alias lto_diagnostic_handler_t = extern(C) void function(lto_codegen_diagnostic_severity_t severity, const(char)* diag, void* ctxt); 220 | 221 | /+ Object file reading and writing +/ 222 | 223 | static if (LLVM_Version >= asVersion(9, 0, 0)) 224 | { 225 | alias LLVMBinaryType = int; 226 | 227 | struct LLVMOpaqueBinary; alias LLVMBinaryRef = LLVMOpaqueBinary*; 228 | 229 | deprecated("Use LLVMBinaryRef instead.") struct LLVMOpaqueObjectFile; 230 | deprecated("Use LLVMBinaryRef instead.") alias LLVMObjectFileRef = LLVMOpaqueObjectFile*; 231 | } 232 | else 233 | { 234 | struct LLVMOpaqueObjectFile; alias LLVMObjectFileRef = LLVMOpaqueObjectFile*; 235 | } 236 | struct LLVMOpaqueSectionIterator; alias LLVMSectionIteratorRef = LLVMOpaqueSectionIterator*; 237 | struct LLVMOpaqueSymbolIterator; alias LLVMSymbolIteratorRef = LLVMOpaqueSymbolIterator*; 238 | struct LLVMOpaqueRelocationIterator; alias LLVMRelocationIteratorRef = LLVMOpaqueRelocationIterator*; 239 | 240 | /+ Target information +/ 241 | 242 | struct LLVMOpaqueTargetData; alias LLVMTargetDataRef = LLVMOpaqueTargetData*; 243 | struct LLVMOpaqueTargetLibraryInfotData; alias LLVMTargetLibraryInfoRef = LLVMOpaqueTargetLibraryInfotData*; 244 | static if (LLVM_Version < asVersion(3, 4, 0)) 245 | { 246 | struct LLVMStructLayout; alias LLVMStructLayoutRef = LLVMStructLayout*; 247 | } 248 | alias LLVMByteOrdering = int; 249 | 250 | /+ Target machine +/ 251 | 252 | struct LLVMOpaqueTargetMachine; alias LLVMTargetMachineRef = LLVMOpaqueTargetMachine*; 253 | struct LLVMTarget; alias LLVMTargetRef = LLVMTarget*; 254 | 255 | alias LLVMCodeGenOptLevel = int; 256 | alias LLVMRelocMode = int; 257 | alias LLVMCodeModel = int; 258 | alias LLVMCodeGenFileType = int; 259 | 260 | static if (LLVM_Version >= asVersion(5, 0, 0) && LLVM_Version < asVersion(7, 0, 0)) { 261 | struct LLVMOpaqueSharedModule; alias LLVMSharedModuleRef = LLVMOpaqueSharedModule*; 262 | } 263 | static if (LLVM_Version >= asVersion(5, 0, 0) && LLVM_Version < asVersion(6, 0, 0)) { 264 | struct LLVMOpaqueSharedObjectBuffer; alias LLVMSharedObjectBufferRef = LLVMOpaqueSharedObjectBuffer*; 265 | } 266 | 267 | static if (LLVM_Version >= asVersion(3, 8, 0)) 268 | { 269 | /+ JIT compilation of LLVM IR +/ 270 | 271 | struct LLVMOrcOpaqueJITStack; alias LLVMOrcJITStackRef = LLVMOrcOpaqueJITStack*; 272 | } 273 | 274 | static if (LLVM_Version >= asVersion(7, 0, 0)) 275 | { 276 | alias LLVMOrcModuleHandle = uint64_t; 277 | } 278 | else static if (LLVM_Version >= asVersion(3, 8, 0)) 279 | { 280 | alias LLVMOrcModuleHandle = uint32_t; 281 | } 282 | 283 | static if (LLVM_Version >= asVersion(3, 8, 0)) 284 | { 285 | alias LLVMOrcTargetAddress = ulong; 286 | 287 | alias LLVMOrcSymbolResolverFn = extern(C) ulong function(const(char)* Name, void* LookupCtx); 288 | alias LLVMOrcLazyCompileCallbackFn = extern(C) ulong function(LLVMOrcJITStackRef JITStack, void* CallbackCtx); 289 | } 290 | 291 | static if (LLVM_Version >= asVersion(3, 9, 0)) 292 | { 293 | alias LLVMOrcErrorCode = int; 294 | 295 | struct LTOObjectBuffer 296 | { 297 | const(char)* Buffer; 298 | size_t Size; 299 | } 300 | } 301 | 302 | /+ Debug info flags +/ 303 | 304 | static if (LLVM_Version >= asVersion(6, 0, 0)) 305 | { 306 | alias LLVMDIFlags = int; 307 | alias LLVMDWARFSourceLanguage = int; 308 | alias LLVMDWARFEmissionKind = int; 309 | } 310 | 311 | 312 | static if (LLVM_Version >= asVersion(7, 0, 0)) 313 | { 314 | alias LLVMComdatSelectionKind = int; 315 | alias LLVMUnnamedAddr = int; 316 | alias LLVMInlineAsmDialect = int; 317 | alias LLVMModuleFlagBehavior = int; 318 | alias LLVMDWARFTypeEncoding = int; 319 | 320 | } 321 | 322 | static if (LLVM_Version >= asVersion(10, 0, 0)) 323 | { 324 | alias LLVMDWARFMacinfoRecordType = int; 325 | } 326 | 327 | 328 | static if (LLVM_Version >= asVersion(8, 0, 0)) { 329 | alias LLVMMetadataKind = uint; 330 | } 331 | 332 | static if (LLVM_Version >= asVersion(7, 0, 0)) { 333 | struct LLVMComdat; alias LLVMComdatRef = LLVMComdat*; 334 | } 335 | 336 | static if (LLVM_Version >= asVersion(7, 0, 0)) { 337 | struct LLVMOpaqueModuleFlagEntry; alias LLVMModuleFlagEntry = LLVMOpaqueModuleFlagEntry*; 338 | } 339 | 340 | static if (LLVM_Version >= asVersion(7, 0, 0)) { 341 | struct LLVMOpaqueJITEventListener; alias LLVMJITEventListenerRef = LLVMOpaqueJITEventListener*; 342 | } 343 | 344 | /+ Error +/ 345 | 346 | static if (LLVM_Version >= asVersion(8, 0, 0)) { 347 | struct LLVMOpaqueError; alias LLVMErrorRef = LLVMOpaqueError*; 348 | 349 | alias LLVMErrorTypeId = const void*; 350 | } 351 | 352 | /+ Remarks / OptRemarks +/ 353 | 354 | static if (LLVM_Version >= asVersion(9, 0, 0)) { 355 | struct LLVMRemarkOpaqueString; alias LLVMRemarkStringRef = LLVMRemarkOpaqueString*; 356 | struct LLVMRemarkOpaqueEntry; alias LLVMRemarkEntryRef = LLVMRemarkOpaqueEntry*; 357 | struct LLVMRemarkOpaqueParser; alias LLVMRemarkParserRef = LLVMRemarkOpaqueParser*; 358 | struct LLVMRemarkOpaqueArg; alias LLVMRemarkArgRef = LLVMRemarkOpaqueArg*; 359 | struct LLVMRemarkOpaqueDebugLoc; alias LLVMRemarkDebugLocRef = LLVMRemarkOpaqueDebugLoc*; 360 | 361 | alias LLVMRemarkType = int; 362 | } else static if (LLVM_Version >= asVersion(8, 0, 0)) { 363 | struct LLVMOptRemarkStringRef 364 | { 365 | const(char)* Str; 366 | uint32_t Len; 367 | } 368 | 369 | struct LLVMOptRemarkDebugLoc 370 | { 371 | // File: 372 | LLVMOptRemarkStringRef SourceFile; 373 | // Line: 374 | uint32_t SourceLineNumber; 375 | // Column: 376 | uint32_t SourceColumnNumber; 377 | } 378 | 379 | struct LLVMOptRemarkArg 380 | { 381 | // e.g. "Callee" 382 | LLVMOptRemarkStringRef Key; 383 | // e.g. "malloc" 384 | LLVMOptRemarkStringRef Value; 385 | 386 | // "DebugLoc": Optional 387 | LLVMOptRemarkDebugLoc DebugLoc; 388 | } 389 | 390 | struct LLVMOptRemarkEntry 391 | { 392 | // e.g. !Missed, !Passed 393 | LLVMOptRemarkStringRef RemarkType; 394 | // "Pass": Required 395 | LLVMOptRemarkStringRef PassName; 396 | // "Name": Required 397 | LLVMOptRemarkStringRef RemarkName; 398 | // "Function": Required 399 | LLVMOptRemarkStringRef FunctionName; 400 | 401 | // "DebugLoc": Optional 402 | LLVMOptRemarkDebugLoc DebugLoc; 403 | // "Hotness": Optional 404 | uint32_t Hotness; 405 | // "Args": Optional. It is an array of `num_args` elements. 406 | uint32_t NumArgs; 407 | LLVMOptRemarkArg* Args; 408 | } 409 | 410 | struct LLVMOptRemarkOpaqueParser; alias LLVMOptRemarkParserRef = LLVMOptRemarkOpaqueParser*; 411 | } 412 | -------------------------------------------------------------------------------- /tools/get-targets: -------------------------------------------------------------------------------- 1 | #! /bin/sh 2 | 3 | # See http://stackoverflow.com/questions/1527049/join-elements-of-an-array/17841619#17841619 4 | function join_by { local IFS="$1"; shift; echo -n "$*"; } 5 | 6 | echo -n "LLVM_Targets: return [" 7 | join_by , $(find $1/lib/Target/ -mindepth 1 -maxdepth 1 -type d | grep -oP 'Target/\K[^/]*' | sort | while read target; do echo \"$target\"; done) 8 | echo "];" 9 | 10 | echo -n "LLVM_AsmPrinters: return [" 11 | join_by , $(find $1/lib/Target/*/*AsmPrinter.cpp | grep -oP 'Target/\K[^/]*' | while read target; do echo \"$target\"; done) 12 | echo "];" 13 | 14 | echo -n "LLVM_AsmParsers: return [" 15 | join_by , $(find $1/lib/Target/*/AsmParser/CMakeLists.txt | grep -oP 'Target/\K[^/]*' | while read target; do echo \"$target\"; done) 16 | echo "];" 17 | 18 | echo -n "LLVM_Disassemblers: return [" 19 | join_by , $(find $1/lib/Target/*/Disassembler/CMakeLists.txt | grep -oP 'Target/\K[^/]*' | while read target; do echo \"$target\"; done) 20 | echo "];" 21 | --------------------------------------------------------------------------------