llvm/examples/OrcV2Examples/OrcV2CBindingsAddObjectFile/OrcV2CBindingsAddObjectFile.c

   1 //===-------- BasicOrcV2CBindings.c - Basic OrcV2 C Bindings Demo ---------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "llvm-c/Core.h"
  10 #include "llvm-c/Error.h"
  11 #include "llvm-c/Initialization.h"
  12 #include "llvm-c/LLJIT.h"
  13 #include "llvm-c/Support.h"
  14 #include "llvm-c/Target.h"
  15 #include "llvm-c/TargetMachine.h"
  16
  17 #include <stdio.h>
  18
  19 int handleError(LLVMErrorRef Err) {
  20   char *ErrMsg = LLVMGetErrorMessage(Err);
  21   fprintf(stderr, "Error: %s\n", ErrMsg);
  22   LLVMDisposeErrorMessage(ErrMsg);
  23   return 1;
  24 }
  25
  26 LLVMModuleRef createDemoModule(LLVMContextRef Ctx) {
  27   // Create a new LLVM module.
  28   LLVMModuleRef M = LLVMModuleCreateWithNameInContext("demo", Ctx);
  29
  30   // Add a "sum" function":
  31   //  - Create the function type and function instance.
  32   LLVMTypeRef ParamTypes[] = {LLVMInt32Type(), LLVMInt32Type()};
  33   LLVMTypeRef SumFunctionType =
  34       LLVMFunctionType(LLVMInt32Type(), ParamTypes, 2, 0);
  35   LLVMValueRef SumFunction = LLVMAddFunction(M, "sum", SumFunctionType);
  36
  37   //  - Add a basic block to the function.
  38   LLVMBasicBlockRef EntryBB = LLVMAppendBasicBlock(SumFunction, "entry");
  39
  40   //  - Add an IR builder and point it at the end of the basic block.
  41   LLVMBuilderRef Builder = LLVMCreateBuilder();
  42   LLVMPositionBuilderAtEnd(Builder, EntryBB);
  43
  44   //  - Get the two function arguments and use them co construct an "add"
  45   //    instruction.
  46   LLVMValueRef SumArg0 = LLVMGetParam(SumFunction, 0);
  47   LLVMValueRef SumArg1 = LLVMGetParam(SumFunction, 1);
  48   LLVMValueRef Result = LLVMBuildAdd(Builder, SumArg0, SumArg1, "result");
  49
  50   //  - Build the return instruction.
  51   LLVMBuildRet(Builder, Result);
  52
  53   return M;
  54 }
  55
  56 int main(int argc, char *argv[]) {
  57
  58   int MainResult = 0;
  59
  60   // Parse command line arguments and initialize LLVM Core.
  61   LLVMParseCommandLineOptions(argc, (const char **)argv, "");
  62   LLVMInitializeCore(LLVMGetGlobalPassRegistry());
  63
  64   // Initialize native target codegen and asm printer.
  65   LLVMInitializeNativeTarget();
  66   LLVMInitializeNativeAsmPrinter();
  67
  68   // Create the JIT instance.
  69   LLVMOrcLLJITRef J;
  70   {
  71     LLVMErrorRef Err;
  72     if ((Err = LLVMOrcCreateLLJIT(&J, 0))) {
  73       MainResult = handleError(Err);
  74       goto llvm_shutdown;
  75     }
  76   }
  77
  78   // Create our demo object file.
  79   LLVMMemoryBufferRef ObjectFileBuffer;
  80   {
  81     // Create a module.
  82     LLVMContextRef Ctx = LLVMContextCreate();
  83     LLVMModuleRef M = createDemoModule(Ctx);
  84
  85     // Get the Target.
  86     const char *Triple = LLVMOrcLLJITGetTripleString(J);
  87     LLVMTargetRef Target = 0;
  88     char *ErrorMsg = 0;
  89     if (LLVMGetTargetFromTriple(Triple, &Target, &ErrorMsg)) {
  90       fprintf(stderr, "Error getting target for %s: %s\n", Triple, ErrorMsg);
  91       LLVMDisposeModule(M);
  92       LLVMContextDispose(Ctx);
  93       goto jit_cleanup;
  94     }
  95
  96     // Construct a TargetMachine.
  97     LLVMTargetMachineRef TM =
  98         LLVMCreateTargetMachine(Target, Triple, "", "", LLVMCodeGenLevelNone,
  99                                 LLVMRelocDefault, LLVMCodeModelDefault);
 100
 101     // Run CodeGen to produce the buffer.
 102     if (LLVMTargetMachineEmitToMemoryBuffer(TM, M, LLVMObjectFile, &ErrorMsg,
 103                                             &ObjectFileBuffer)) {
 104       fprintf(stderr, "Error emitting object: %s\n", ErrorMsg);
 105       LLVMDisposeTargetMachine(TM);
 106       LLVMDisposeModule(M);
 107       LLVMContextDispose(Ctx);
 108       goto jit_cleanup;
 109     }
 110   }
 111
 112   // Add our object file buffer to the JIT.
 113   {
 114     LLVMOrcJITDylibRef MainJD = LLVMOrcLLJITGetMainJITDylib(J);
 115     LLVMErrorRef Err;
 116     if ((Err = LLVMOrcLLJITAddObjectFile(J, MainJD, ObjectFileBuffer))) {
 117       MainResult = handleError(Err);
 118       goto jit_cleanup;
 119     }
 120   }
 121
 122   // Look up the address of our demo entry point.
 123   LLVMOrcJITTargetAddress SumAddr;
 124   {
 125     LLVMErrorRef Err;
 126     if ((Err = LLVMOrcLLJITLookup(J, &SumAddr, "sum"))) {
 127       MainResult = handleError(Err);
 128       goto jit_cleanup;
 129     }
 130   }
 131
 132   // If we made it here then everything succeeded. Execute our JIT'd code.
 133   int32_t (*Sum)(int32_t, int32_t) = (int32_t(*)(int32_t, int32_t))SumAddr;
 134   int32_t Result = Sum(1, 2);
 135
 136   // Print the result.
 137   printf("1 + 2 = %i\n", Result);
 138
 139 jit_cleanup:
 140   // Destroy our JIT instance. This will clean up any memory that the JIT has
 141   // taken ownership of. This operation is non-trivial (e.g. it may need to
 142   // JIT static destructors) and may also fail. In that case we want to render
 143   // the error to stderr, but not overwrite any existing return value.
 144   {
 145     LLVMErrorRef Err;
 146     if ((Err = LLVMOrcDisposeLLJIT(J))) {
 147       int NewFailureResult = handleError(Err);
 148       if (MainResult == 0)
 149         MainResult = NewFailureResult;
 150     }
 151   }
 152
 153 llvm_shutdown:
 154   // Shut down LLVM.
 155   LLVMShutdown();
 156
 157   return MainResult;
 158 }