llvm: convert intrinsics to using `Builder`

1 files changed, 13 insertions, 334 deletions

diff --git a/src/zig_llvm.cpp b/src/zig_llvm.cpp
index e6568e97a8..5b599d8e0e 100644
--- a/src/zig_llvm.cpp
+++ b/src/zig_llvm.cpp
@@ -78,30 +78,6 @@
 
 using namespace llvm;
 
-void ZigLLVMInitializeLoopStrengthReducePass(LLVMPassRegistryRef R) {
-    initializeLoopStrengthReducePass(*unwrap(R));
-}
-
-void ZigLLVMInitializeLowerIntrinsicsPass(LLVMPassRegistryRef R) {
-    initializeLowerIntrinsicsPass(*unwrap(R));
-}
-
-char *ZigLLVMGetHostCPUName(void) {
-    return strdup((const char *)sys::getHostCPUName().bytes_begin());
-}
-
-char *ZigLLVMGetNativeFeatures(void) {
-    SubtargetFeatures features;
-
-    StringMap<bool> host_features;
-    if (sys::getHostCPUFeatures(host_features)) {
-        for (auto &F : host_features)
-            features.AddFeature(F.first(), F.second);
-    }
-
-    return strdup((const char *)StringRef(features.getString()).bytes_begin());
-}
-
 #ifndef NDEBUG
 static const bool assertions_on = true;
 #else
@@ -179,14 +155,6 @@ LLVMTargetMachineRef ZigLLVMCreateTargetMachine(LLVMTargetRef T, const char *Tri
     return reinterpret_cast<LLVMTargetMachineRef>(TM);
 }
 
-unsigned ZigLLVMDataLayoutGetStackAlignment(LLVMTargetDataRef TD) {
-    return unwrap(TD)->getStackAlignment().value();
-}
-
-unsigned ZigLLVMDataLayoutGetProgramAddressSpace(LLVMTargetDataRef TD) {
-    return unwrap(TD)->getProgramAddressSpace();
-}
-
 namespace {
 // LLVM's time profiler can provide a hierarchy view of the time spent
 // in each component. It generates JSON report in Chrome's "Trace Event"
@@ -410,12 +378,7 @@ bool ZigLLVMTargetMachineEmitToFile(LLVMTargetMachineRef targ_machine_ref, LLVMM
     return false;
 }
 
-ZIG_EXTERN_C LLVMTypeRef ZigLLVMTokenTypeInContext(LLVMContextRef context_ref) {
-  return wrap(Type::getTokenTy(*unwrap(context_ref)));
-}
-
-
-ZIG_EXTERN_C void ZigLLVMSetOptBisectLimit(LLVMContextRef context_ref, int limit) {
+void ZigLLVMSetOptBisectLimit(LLVMContextRef context_ref, int limit) {
     static OptBisect opt_bisect;
     opt_bisect.setLimit(limit);
     unwrap(context_ref)->setOptPassGate(opt_bisect);
@@ -426,35 +389,23 @@ LLVMValueRef ZigLLVMAddFunctionInAddressSpace(LLVMModuleRef M, const char *Name,
     return wrap(func);
 }
 
-LLVMValueRef ZigLLVMBuildCall(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef Fn,
-        LLVMValueRef *Args, unsigned NumArgs, ZigLLVM_CallingConv CC, ZigLLVM_CallAttr attr,
-        const char *Name)
-{
-    FunctionType *FTy = unwrap<FunctionType>(Ty);
-    CallInst *call_inst = unwrap(B)->CreateCall(FTy, unwrap(Fn),
-        ArrayRef(unwrap(Args), NumArgs), Name);
-    call_inst->setCallingConv(static_cast<CallingConv::ID>(CC));
-    switch (attr) {
-        case ZigLLVM_CallAttrAuto:
-            break;
-        case ZigLLVM_CallAttrNeverTail:
-            call_inst->setTailCallKind(CallInst::TCK_NoTail);
+void ZigLLVMSetTailCallKind(LLVMValueRef Call, enum ZigLLVMTailCallKind TailCallKind) {
+    CallInst::TailCallKind TCK;
+    switch (TailCallKind) {
+        case ZigLLVMTailCallKindNone:
+            TCK = CallInst::TCK_None;
             break;
-        case ZigLLVM_CallAttrNeverInline:
-            call_inst->addFnAttr(Attribute::NoInline);
+        case ZigLLVMTailCallKindTail:
+            TCK = CallInst::TCK_Tail;
             break;
-        case ZigLLVM_CallAttrAlwaysTail:
-            call_inst->setTailCallKind(CallInst::TCK_MustTail);
+        case ZigLLVMTailCallKindMustTail:
+            TCK = CallInst::TCK_MustTail;
             break;
-        case ZigLLVM_CallAttrAlwaysInline:
-            call_inst->addFnAttr(Attribute::AlwaysInline);
+        case ZigLLVMTailCallKindNoTail:
+            TCK = CallInst::TCK_NoTail;
             break;
     }
-    return wrap(call_inst);
-}
-
-ZIG_EXTERN_C void ZigLLVMSetTailCallKind(LLVMValueRef Call, CallInst::TailCallKind TailCallKind) {
-    unwrap<CallInst>(Call)->setTailCallKind(TailCallKind);
+    unwrap<CallInst>(Call)->setTailCallKind(TCK);
 }
 
 void ZigLLVMAddAttributeAtIndex(LLVMValueRef Val, unsigned Idx, LLVMAttributeRef A) {
@@ -481,188 +432,6 @@ LLVMValueRef ZigLLVMBuildMemSet(LLVMBuilderRef B, LLVMValueRef Ptr, LLVMValueRef
     return wrap(call_inst);
 }
 
-LLVMValueRef ZigLLVMBuildCeil(LLVMBuilderRef B, LLVMValueRef V, const char *name) {
-    CallInst *call_inst = unwrap(B)->CreateUnaryIntrinsic(Intrinsic::ceil, unwrap(V), nullptr, name);
-    return wrap(call_inst);
-}
-
-LLVMValueRef ZigLLVMBuildCos(LLVMBuilderRef B, LLVMValueRef V, const char *name) {
-    CallInst *call_inst = unwrap(B)->CreateUnaryIntrinsic(Intrinsic::cos, unwrap(V), nullptr, name);
-    return wrap(call_inst);
-}
-
-LLVMValueRef ZigLLVMBuildExp(LLVMBuilderRef B, LLVMValueRef V, const char *name) {
-    CallInst *call_inst = unwrap(B)->CreateUnaryIntrinsic(Intrinsic::exp, unwrap(V), nullptr, name);
-    return wrap(call_inst);
-}
-
-LLVMValueRef ZigLLVMBuildExp2(LLVMBuilderRef B, LLVMValueRef V, const char *name) {
-    CallInst *call_inst = unwrap(B)->CreateUnaryIntrinsic(Intrinsic::exp2, unwrap(V), nullptr, name);
-    return wrap(call_inst);
-}
-
-LLVMValueRef ZigLLVMBuildFAbs(LLVMBuilderRef B, LLVMValueRef V, const char *name) {
-    CallInst *call_inst = unwrap(B)->CreateUnaryIntrinsic(Intrinsic::fabs, unwrap(V), nullptr, name);
-    return wrap(call_inst);
-}
-
-LLVMValueRef ZigLLVMBuildFloor(LLVMBuilderRef B, LLVMValueRef V, const char *name) {
-    CallInst *call_inst = unwrap(B)->CreateUnaryIntrinsic(Intrinsic::floor, unwrap(V), nullptr, name);
-    return wrap(call_inst);
-}
-
-LLVMValueRef ZigLLVMBuildLog(LLVMBuilderRef B, LLVMValueRef V, const char *name) {
-    CallInst *call_inst = unwrap(B)->CreateUnaryIntrinsic(Intrinsic::log, unwrap(V), nullptr, name);
-    return wrap(call_inst);
-}
-
-LLVMValueRef ZigLLVMBuildLog10(LLVMBuilderRef B, LLVMValueRef V, const char *name) {
-    CallInst *call_inst = unwrap(B)->CreateUnaryIntrinsic(Intrinsic::log10, unwrap(V), nullptr, name);
-    return wrap(call_inst);
-}
-
-LLVMValueRef ZigLLVMBuildLog2(LLVMBuilderRef B, LLVMValueRef V, const char *name) {
-    CallInst *call_inst = unwrap(B)->CreateUnaryIntrinsic(Intrinsic::log2, unwrap(V), nullptr, name);
-    return wrap(call_inst);
-}
-
-LLVMValueRef ZigLLVMBuildRound(LLVMBuilderRef B, LLVMValueRef V, const char *name) {
-    CallInst *call_inst = unwrap(B)->CreateUnaryIntrinsic(Intrinsic::round, unwrap(V), nullptr, name);
-    return wrap(call_inst);
-}
-
-LLVMValueRef ZigLLVMBuildSin(LLVMBuilderRef B, LLVMValueRef V, const char *name) {
-    CallInst *call_inst = unwrap(B)->CreateUnaryIntrinsic(Intrinsic::sin, unwrap(V), nullptr, name);
-    return wrap(call_inst);
-}
-
-LLVMValueRef ZigLLVMBuildSqrt(LLVMBuilderRef B, LLVMValueRef V, const char *name) {
-    CallInst *call_inst = unwrap(B)->CreateUnaryIntrinsic(Intrinsic::sqrt, unwrap(V), nullptr, name);
-    return wrap(call_inst);
-}
-
-LLVMValueRef ZigLLVMBuildFTrunc(LLVMBuilderRef B, LLVMValueRef V, const char *name) {
-    CallInst *call_inst = unwrap(B)->CreateUnaryIntrinsic(Intrinsic::trunc, unwrap(V), nullptr, name);
-    return wrap(call_inst);
-}
-
-LLVMValueRef ZigLLVMBuildBitReverse(LLVMBuilderRef B, LLVMValueRef V, const char *name) {
-    CallInst *call_inst = unwrap(B)->CreateUnaryIntrinsic(Intrinsic::bitreverse, unwrap(V), nullptr, name);
-    return wrap(call_inst);
-}
-
-LLVMValueRef ZigLLVMBuildBSwap(LLVMBuilderRef B, LLVMValueRef V, const char *name) {
-    CallInst *call_inst = unwrap(B)->CreateUnaryIntrinsic(Intrinsic::bswap, unwrap(V), nullptr, name);
-    return wrap(call_inst);
-}
-
-LLVMValueRef ZigLLVMBuildCTPop(LLVMBuilderRef B, LLVMValueRef V, const char *name) {
-    CallInst *call_inst = unwrap(B)->CreateUnaryIntrinsic(Intrinsic::ctpop, unwrap(V), nullptr, name);
-    return wrap(call_inst);
-}
-
-LLVMValueRef ZigLLVMBuildCTLZ(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *name) {
-    CallInst *call_inst = unwrap(B)->CreateBinaryIntrinsic(Intrinsic::ctlz, unwrap(LHS), unwrap(RHS), nullptr, name);
-    return wrap(call_inst);
-}
-
-LLVMValueRef ZigLLVMBuildCTTZ(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *name) {
-    CallInst *call_inst = unwrap(B)->CreateBinaryIntrinsic(Intrinsic::cttz, unwrap(LHS), unwrap(RHS), nullptr, name);
-    return wrap(call_inst);
-}
-
-LLVMValueRef ZigLLVMBuildFMA(LLVMBuilderRef builder, LLVMValueRef A, LLVMValueRef B, LLVMValueRef C, const char *name) {
-    llvm::Type* types[1] = {
-        unwrap(A)->getType(),
-    };
-    llvm::Value* values[3] = {unwrap(A), unwrap(B), unwrap(C)};
-
-    CallInst *call_inst = unwrap(builder)->CreateIntrinsic(Intrinsic::fma, types, values, nullptr, name);
-    return wrap(call_inst);
-}
-
-LLVMValueRef ZigLLVMBuildMaxNum(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *name) {
-    CallInst *call_inst = unwrap(B)->CreateMaxNum(unwrap(LHS), unwrap(RHS), name);
-    return wrap(call_inst);
-}
-
-LLVMValueRef ZigLLVMBuildMinNum(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *name) {
-    CallInst *call_inst = unwrap(B)->CreateMinNum(unwrap(LHS), unwrap(RHS), name);
-    return wrap(call_inst);
-}
-
-LLVMValueRef ZigLLVMBuildUMax(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *name) {
-    CallInst *call_inst = unwrap(B)->CreateBinaryIntrinsic(Intrinsic::umax, unwrap(LHS), unwrap(RHS), nullptr, name);
-    return wrap(call_inst);
-}
-
-LLVMValueRef ZigLLVMBuildUMin(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *name) {
-    CallInst *call_inst = unwrap(B)->CreateBinaryIntrinsic(Intrinsic::umin, unwrap(LHS), unwrap(RHS), nullptr, name);
-    return wrap(call_inst);
-}
-
-LLVMValueRef ZigLLVMBuildSMax(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *name) {
-    CallInst *call_inst = unwrap(B)->CreateBinaryIntrinsic(Intrinsic::smax, unwrap(LHS), unwrap(RHS), nullptr, name);
-    return wrap(call_inst);
-}
-
-LLVMValueRef ZigLLVMBuildSMin(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *name) {
-    CallInst *call_inst = unwrap(B)->CreateBinaryIntrinsic(Intrinsic::smin, unwrap(LHS), unwrap(RHS), nullptr, name);
-    return wrap(call_inst);
-}
-
-LLVMValueRef ZigLLVMBuildSAddSat(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *name) {
-    CallInst *call_inst = unwrap(B)->CreateBinaryIntrinsic(Intrinsic::sadd_sat, unwrap(LHS), unwrap(RHS), nullptr, name);
-    return wrap(call_inst);
-}
-
-LLVMValueRef ZigLLVMBuildUAddSat(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *name) {
-    CallInst *call_inst = unwrap(B)->CreateBinaryIntrinsic(Intrinsic::uadd_sat, unwrap(LHS), unwrap(RHS), nullptr, name);
-    return wrap(call_inst);
-}
-
-LLVMValueRef ZigLLVMBuildSSubSat(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *name) {
-    CallInst *call_inst = unwrap(B)->CreateBinaryIntrinsic(Intrinsic::ssub_sat, unwrap(LHS), unwrap(RHS), nullptr, name);
-    return wrap(call_inst);
-}
-
-LLVMValueRef ZigLLVMBuildUSubSat(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *name) {
-    CallInst *call_inst = unwrap(B)->CreateBinaryIntrinsic(Intrinsic::usub_sat, unwrap(LHS), unwrap(RHS), nullptr, name);
-    return wrap(call_inst);
-}
-
-LLVMValueRef ZigLLVMBuildSMulFixSat(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *name) {
-    llvm::Type* types[1] = {
-        unwrap(LHS)->getType(),
-    };
-    // pass scale = 0 as third argument
-    llvm::Value* values[3] = {unwrap(LHS), unwrap(RHS), unwrap(B)->getInt32(0)};
-
-    CallInst *call_inst = unwrap(B)->CreateIntrinsic(Intrinsic::smul_fix_sat, types, values, nullptr, name);
-    return wrap(call_inst);
-}
-
-LLVMValueRef ZigLLVMBuildUMulFixSat(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *name) {
-    llvm::Type* types[1] = {
-        unwrap(LHS)->getType(),
-    };
-    // pass scale = 0 as third argument
-    llvm::Value* values[3] = {unwrap(LHS), unwrap(RHS), unwrap(B)->getInt32(0)};
-
-    CallInst *call_inst = unwrap(B)->CreateIntrinsic(Intrinsic::umul_fix_sat, types, values, nullptr, name);
-    return wrap(call_inst);
-}
-
-LLVMValueRef ZigLLVMBuildSShlSat(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *name) {
-    CallInst *call_inst = unwrap(B)->CreateBinaryIntrinsic(Intrinsic::sshl_sat, unwrap(LHS), unwrap(RHS), nullptr, name);
-    return wrap(call_inst);
-}
-
-LLVMValueRef ZigLLVMBuildUShlSat(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *name) {
-    CallInst *call_inst = unwrap(B)->CreateBinaryIntrinsic(Intrinsic::ushl_sat, unwrap(LHS), unwrap(RHS), nullptr, name);
-    return wrap(call_inst);
-}
-
 void ZigLLVMFnSetSubprogram(LLVMValueRef fn, ZigLLVMDISubprogram *subprogram) {
     assert( isa<Function>(unwrap(fn)) );
     Function *unwrapped_function = reinterpret_cast<Function*>(unwrap(fn));
@@ -1206,14 +975,6 @@ void ZigLLVMAddSretAttr(LLVMValueRef fn_ref, LLVMTypeRef type_val) {
     func->addParamAttrs(0, attr_builder);
 }
 
-void ZigLLVMAddFunctionElemTypeAttr(LLVMValueRef fn_ref, size_t arg_index, LLVMTypeRef elem_ty) {
-    Function *func = unwrap<Function>(fn_ref);
-    AttrBuilder attr_builder(func->getContext());
-    Type *llvm_type = unwrap<Type>(elem_ty);
-    attr_builder.addTypeAttr(Attribute::ElementType, llvm_type);
-    func->addParamAttrs(arg_index, attr_builder);
-}
-
 void ZigLLVMAddFunctionAttr(LLVMValueRef fn_ref, const char *attr_name, const char *attr_value) {
     Function *func = unwrap<Function>(fn_ref);
     func->addFnAttr(attr_name, attr_value);
@@ -1223,40 +984,6 @@ void ZigLLVMParseCommandLineOptions(size_t argc, const char *const *argv) {
     cl::ParseCommandLineOptions(argc, argv);
 }
 
-const char *ZigLLVMGetArchTypeName(ZigLLVM_ArchType arch) {
-    return (const char*)Triple::getArchTypeName((Triple::ArchType)arch).bytes_begin();
-}
-
-const char *ZigLLVMGetVendorTypeName(ZigLLVM_VendorType vendor) {
-    return (const char*)Triple::getVendorTypeName((Triple::VendorType)vendor).bytes_begin();
-}
-
-const char *ZigLLVMGetOSTypeName(ZigLLVM_OSType os) {
-    const char* name = (const char*)Triple::getOSTypeName((Triple::OSType)os).bytes_begin();
-    if (strcmp(name, "macosx") == 0) return "macos";
-    return name;
-}
-
-const char *ZigLLVMGetEnvironmentTypeName(ZigLLVM_EnvironmentType env_type) {
-    return (const char*)Triple::getEnvironmentTypeName((Triple::EnvironmentType)env_type).bytes_begin();
-}
-
-void ZigLLVMGetNativeTarget(ZigLLVM_ArchType *arch_type,
-        ZigLLVM_VendorType *vendor_type, ZigLLVM_OSType *os_type, ZigLLVM_EnvironmentType *environ_type,
-        ZigLLVM_ObjectFormatType *oformat)
-{
-    char *native_triple = LLVMGetDefaultTargetTriple();
-    Triple triple(Triple::normalize(native_triple));
-
-    *arch_type = (ZigLLVM_ArchType)triple.getArch();
-    *vendor_type = (ZigLLVM_VendorType)triple.getVendor();
-    *os_type = (ZigLLVM_OSType)triple.getOS();
-    *environ_type = (ZigLLVM_EnvironmentType)triple.getEnvironment();
-    *oformat = (ZigLLVM_ObjectFormatType)triple.getObjectFormat();
-
-    free(native_triple);
-}
-
 void ZigLLVMAddModuleDebugInfoFlag(LLVMModuleRef module, bool produce_dwarf64) {
     unwrap(module)->addModuleFlag(Module::Warning, "Debug Info Version", DEBUG_METADATA_VERSION);
     unwrap(module)->addModuleFlag(Module::Warning, "Dwarf Version", 4);
@@ -1314,50 +1041,6 @@ LLVMValueRef ZigLLVMBuildAllocaInAddressSpace(LLVMBuilderRef builder, LLVMTypeRe
   return wrap(unwrap(builder)->CreateAlloca(unwrap(Ty), AddressSpace, nullptr, Name));
 }
 
-void ZigLLVMSetTailCall(LLVMValueRef Call) {
-    unwrap<CallInst>(Call)->setTailCallKind(CallInst::TCK_MustTail);
-}
-
-void ZigLLVMSetCallSret(LLVMValueRef Call, LLVMTypeRef return_type) {
-    CallInst *call_inst = unwrap<CallInst>(Call);
-    Type *llvm_type = unwrap<Type>(return_type);
-    call_inst->addParamAttr(AttributeList::ReturnIndex,
-            Attribute::getWithStructRetType(call_inst->getContext(), llvm_type));
-}
-
-void ZigLLVMSetCallElemTypeAttr(LLVMValueRef Call, size_t arg_index, LLVMTypeRef return_type) {
-    CallInst *call_inst = unwrap<CallInst>(Call);
-    Type *llvm_type = unwrap<Type>(return_type);
-    call_inst->addParamAttr(arg_index,
-            Attribute::get(call_inst->getContext(), Attribute::ElementType, llvm_type));
-}
-
-void ZigLLVMFunctionSetPrefixData(LLVMValueRef function, LLVMValueRef data) {
-    unwrap<Function>(function)->setPrefixData(unwrap<Constant>(data));
-}
-
-void ZigLLVMFunctionSetCallingConv(LLVMValueRef function, ZigLLVM_CallingConv cc) {
-    unwrap<Function>(function)->setCallingConv(static_cast<CallingConv::ID>(cc));
-}
-
-class MyOStream: public raw_ostream {
-    public:
-        MyOStream(void (*_append_diagnostic)(void *, const char *, size_t), void *_context) :
-            raw_ostream(true), append_diagnostic(_append_diagnostic), context(_context), pos(0) {
-
-        }
-        void write_impl(const char *ptr, size_t len) override {
-            append_diagnostic(context, ptr, len);
-            pos += len;
-        }
-        uint64_t current_pos() const override {
-            return pos;
-        }
-        void (*append_diagnostic)(void *, const char *, size_t);
-        void *context;
-        size_t pos;
-};
-
 bool ZigLLVMWriteImportLibrary(const char *def_path, const ZigLLVM_ArchType arch,
                                const char *output_lib_path, bool kill_at)
 {
@@ -1549,10 +1232,6 @@ ZigLLVMDIGlobalVariable* ZigLLVMGlobalGetVariable(ZigLLVMDIGlobalVariableExpress
 	return reinterpret_cast<ZigLLVMDIGlobalVariable*>(reinterpret_cast<DIGlobalVariableExpression*>(global_variable_expression)->getVariable());
 }
 
-ZigLLVMDIGlobalExpression* ZigLLVMGlobalGetExpression(ZigLLVMDIGlobalVariableExpression *global_variable_expression) {
-	return reinterpret_cast<ZigLLVMDIGlobalExpression*>(reinterpret_cast<DIGlobalVariableExpression*>(global_variable_expression)->getExpression());
-}
-
 void ZigLLVMAttachMetaData(LLVMValueRef Val, ZigLLVMDIGlobalVariableExpression *global_variable_expression) {
 	unwrap<GlobalVariable>(Val)->addDebugInfo(reinterpret_cast<DIGlobalVariableExpression*>(global_variable_expression));
 }