[llvm-c] Improve IR Introspection

[• ubsan]

Summary

Rebase D2176 onto modern LLVM.

"This commit adds most of functions needed for introspection of the IR through the C API. It was inspired by additional functions defined in the llvm-general Haskell bindings, which can convert the IR losslessly into Haskell datatypes and vice versa."

[• ubsan]

This was meant to be four diffs; I don't understand the tools fully yet.

include/llvm-c/Core.h

typedef enum {
   LLVMColdCallConv        = 9,
   LLVMWebKitJSCallConv    = 12,
   LLVMAnyRegCallConv      = 13,
   LLVMX86StdcallCallConv  = 64,
   LLVMX86FastcallCallConv = 65
 } LLVMCallConv;
 
 typedef enum {
-  LLVMArgumentValueKind,
-  LLVMBasicBlockValueKind,
-  LLVMInlineAsmValueKind,
-  LLVMMDNodeValueKind,
-  LLVMMDStringValueKind,
-  LLVMUserValueKind,
-  LLVMConstantValueKind,
-  LLVMBlockAddressValueKind,
-  LLVMConstantAggregateZeroValueKind,
-  LLVMConstantArrayValueKind,
-  LLVMConstantDataSequentialValueKind,
-  LLVMConstantDataArrayValueKind,
-  LLVMConstantDataVectorValueKind,
-  LLVMConstantExprValueKind,
-  LLVMConstantFPValueKind,
-  LLVMConstantIntValueKind,
-  LLVMConstantPointerNullValueKind,
-  LLVMConstantStructValueKind,
-  LLVMConstantVectorValueKind,
-  LLVMGlobalValueValueKind,
-  LLVMFunctionValueKind,
-  LLVMGlobalAliasValueKind,
-  LLVMGlobalVariableValueKind,
-  LLVMUndefValueValueKind,
-  LLVMInstructionValueKind
-} LLVMValueKind;
-
-typedef enum {
   LLVMIntEQ = 32, /**< equal */
   LLVMIntNE,      /**< not equal */
   LLVMIntUGT,     /**< unsigned greater than */
   LLVMIntUGE,     /**< unsigned greater or equal */
   LLVMIntULT,     /**< unsigned less than */
   LLVMIntULE,     /**< unsigned less or equal */
   LLVMIntSGT,     /**< signed greater than */
   LLVMIntSGE,     /**< signed greater or equal */
LLVMAtomicRMWBinOpUMax, /**< Sets the value if it's greater than the
                              original using an unsigned comparison and return
                              the old one */
     LLVMAtomicRMWBinOpUMin /**< Sets the value if it's greater than the
                              original using an unsigned comparison  and return
                              the old one */
 } LLVMAtomicRMWBinOp;
 
 typedef enum {
-  LLVMSynchronizationScopeSingleThread,
-  LLVMSynchronizationScopeCrossThread
-} LLVMSyncronizationScope;
-
-typedef enum {
     LLVMDSError,
     LLVMDSWarning,
     LLVMDSRemark,
     LLVMDSNote
 } LLVMDiagnosticSeverity;
 
 /**
  * @}

  * Destroy a module instance.
  *
  * This must be called for every created module or memory will be
  * leaked.
  */
 void LLVMDisposeModule(LLVMModuleRef M);
 
 /**
- * Obtain the identifier of a module. The result must be discarded with
- * LLVMDisposeMessage.
- * @see Module::getModuleIdentifier()
- */
-char *LLVMGetModuleIdentifier(LLVMModuleRef M);
-
-/**
- * Set the identifier of a module.
- * @see Module::setModuleIdentifier()
- */
-void LLVMSetModuleIdentifier(LLVMModuleRef M, const char* ID);
-
-/**
  * Obtain the data layout for a module.
  *
  * @see Module::getDataLayoutStr()
  *
  * LLVMGetDataLayout is DEPRECATED, as the name is not only incorrect,
  * but match the name of another method on the module. Prefer the use
  * of LLVMGetDataLayoutStr, which is not ambiguous.
  */

  * Create a void type in a context.
  */
 LLVMTypeRef LLVMVoidTypeInContext(LLVMContextRef C);
 
 /**
  * Create a label type in a context.
  */
 LLVMTypeRef LLVMLabelTypeInContext(LLVMContextRef C);
-LLVMTypeRef LLVMMetadataTypeInContext(LLVMContextRef C);
 
 /**
  * Create a X86 MMX type in a context.
  */
 LLVMTypeRef LLVMX86MMXTypeInContext(LLVMContextRef C);
 
 /**
  * These are similar to the above functions except they operate on the
  * global context.
  */
 LLVMTypeRef LLVMVoidType(void);
 LLVMTypeRef LLVMLabelType(void);
-LLVMTypeRef LLVMMetadataType(void);
 LLVMTypeRef LLVMX86MMXType(void);
 
 /**
  * @}
  */
 
 /**
  * @}

  * available by looking at the Doxygen source code. Instead, look at the
  * source definition of LLVM_FOR_EACH_VALUE_SUBCLASS and note the list
  * of value names given. These value names also correspond to classes in
  * the llvm::Value hierarchy.
  *
  * @{
  */
 
-#define LLVM_FOR_EACH_VALUE_KIND(macro)     \
-  macro(Argument)                           \
-  macro(BasicBlock)                         \
-  macro(InlineAsm)                          \
-  macro(MDNode)                             \
-  macro(MDString)                           \
-  macro(BlockAddress)                       \
-  macro(ConstantAggregateZero)              \
-  macro(ConstantArray)                      \
-  macro(ConstantDataArray)                  \
-  macro(ConstantDataVector)                 \
-  macro(ConstantExpr)                       \
-  macro(ConstantFP)                         \
-  macro(ConstantInt)                        \
-  macro(ConstantPointerNull)                \
-  macro(ConstantStruct)                     \
-  macro(ConstantVector)                     \
-  macro(Function)                           \
-  macro(GlobalAlias)                        \
-  macro(GlobalVariable)                     \
-  macro(UndefValue)                         \
-  macro(Instruction)
-
 #define LLVM_FOR_EACH_VALUE_SUBCLASS(macro) \
   macro(Argument)                           \
   macro(BasicBlock)                         \
   macro(InlineAsm)                          \
   macro(User)                               \
     macro(Constant)                         \
       macro(BlockAddress)                   \
       macro(ConstantAggregateZero)          \

 /**
  * Obtain the type of a value.
  *
  * @see llvm::Value::getType()
  */
 LLVMTypeRef LLVMTypeOf(LLVMValueRef Val);
 
 /**
- * Obtain the enumerated type of a Value instance.
- *
- * @see llvm::Type:getValueID()
- */
-LLVMValueKind LLVMGetValueKind(LLVMValueRef Val);
-
-/**
  * Obtain the string name of a value.
  *
  * @see llvm::Value::getName()
  */
 const char *LLVMGetValueName(LLVMValueRef Val);
 
 /**
  * Set the string name of a value.

  * specified length.
  *
  * @see llvm::ConstantInt::get()
  */
 LLVMValueRef LLVMConstIntOfStringAndSize(LLVMTypeRef IntTy, const char *Text,
                                          unsigned SLen, uint8_t Radix);
 
 /**
- * Obtain the zero extended value for an integer constant value.
- *
- * @see llvm::ConstantInt::getZExtValue()
- */
-unsigned long long LLVMConstIntGetZExtValue(LLVMValueRef ConstantVal);
-
-/**
- * Obtain the sign extended value for an integer constant value.
- *
- * @see llvm::ConstantInt::getSExtValue()
- */
-long long LLVMConstIntGetSExtValue(LLVMValueRef ConstantVal);
-
-/**
- * Obtain the words of an integer constant value. \p n should point to
- * a variable which will hold the amount of words. The return value
- * points to an array of \p n words, owned by the context. The caller
- * must not capture pointer to the array.
- *
- * @see llvm::ConstantInt::getValue()
- */
-const uint64_t *LLVMConstIntGetWords(LLVMValueRef v, unsigned *n);
-
-/**
  * Obtain a constant value referring to a double floating point value.
  */
 LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N);
 
 /**
  * Obtain a constant for a floating point value parsed from a string.
  *
  * A similar API, LLVMConstRealOfStringAndSize is also available. It
  * should be used if the input string's length is known.
  */
 LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, const char *Text);
 
 /**
  * Obtain a constant for a floating point value parsed from a string.
  */
 LLVMValueRef LLVMConstRealOfStringAndSize(LLVMTypeRef RealTy, const char *Text,
                                           unsigned SLen);
 
 /**
- * Obtain a constant value for a floating point value of arbitrary precision.
+ * Obtain the zero extended value for an integer constant value.
  *
- * @see llvm::ConstantFP::get()
+ * @see llvm::ConstantInt::getZExtValue()
  */
-LLVMValueRef LLVMConstRealOfArbitraryPrecision(LLVMTypeRef RealTy,
-                                               unsigned NumWords,
-                                               const uint64_t Words[]);
+unsigned long long LLVMConstIntGetZExtValue(LLVMValueRef ConstantVal);
 
 /**
- * Obtain the double value for an floating point constant value.
- * losesInfo indicates if some precision was lost in the conversion.
+ * Obtain the sign extended value for an integer constant value.
  *
- * @see llvm::ConstantFP::getDoubleValue
+ * @see llvm::ConstantInt::getSExtValue()
  */
-double LLVMConstRealGetDouble(LLVMValueRef ConstantVal, LLVMBool *losesInfo);
+long long LLVMConstIntGetSExtValue(LLVMValueRef ConstantVal);
 
 /**
- * Obtain the words of a floating point constant value. \p n should point to
- * a variable which will hold the amount of words. The return value
- * points to an array of \p n words, owned by the context. The caller
- * must not capture pointer to the array.
+ * Obtain the double value for an floating point constant value.
+ * losesInfo indicates if some precision was lost in the conversion.
  *
- * @see llvm::ConstantFP::getValueAPF()
+ * @see llvm::ConstantFP::getDoubleValue
  */
-const uint64_t *LLVMConstRealGetWords(LLVMValueRef v, unsigned *n);
+double LLVMConstRealGetDouble(LLVMValueRef ConstantVal, LLVMBool *losesInfo);
 
 /**
  * @}
  */
 
 /**
  * @defgroup LLVMCCoreValueConstantComposite Composite Constants
  *

  *
  * Functions in this group correspond to APIs on llvm::ConstantExpr.
  *
  * @see llvm::ConstantExpr.
  *
  * @{
  */
 LLVMOpcode LLVMGetConstOpcode(LLVMValueRef ConstantVal);
-LLVMValueRef LLVMGetElementAsConstant(LLVMValueRef ConstantVal, unsigned n);
 LLVMValueRef LLVMAlignOf(LLVMTypeRef Ty);
 LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty);
 LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal);
 LLVMValueRef LLVMConstNSWNeg(LLVMValueRef ConstantVal);
 LLVMValueRef LLVMConstNUWNeg(LLVMValueRef ConstantVal);
 LLVMValueRef LLVMConstFNeg(LLVMValueRef ConstantVal);
 LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal);
 LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
LLVMValueRef LLVMConstInsertValue(LLVMValueRef AggConstant,
                                   LLVMValueRef ElementValueConstant,
                                   unsigned *IdxList, unsigned NumIdx);
 LLVMValueRef LLVMConstInlineAsm(LLVMTypeRef Ty,
                                 const char *AsmString, const char *Constraints,
                                 LLVMBool HasSideEffects, LLVMBool IsAlignStack);
 LLVMValueRef LLVMBlockAddress(LLVMValueRef F, LLVMBasicBlockRef BB);
 
 /**
- * Obtain the function of a blockaddress expression.
- * @see llvm::BlockAdress::getFunction()
- */
-LLVMValueRef LLVMGetBlockAddressFunction(LLVMValueRef BA);
-
-/**
- * Obtain the basic block of a blockaddress expression.
- * @see llvm::BlockAddress::getBasicBlock()
- */
-LLVMBasicBlockRef LLVMGetBlockAddressBlock(LLVMValueRef BA);
-
-/**
  * @}
  */
 
 /**
  * @defgroup LLVMCCoreValueConstantGlobals Global Values
  *
  * This group contains functions that operate on global values. Functions in
  * this group relate to functions in the llvm::GlobalValue class tree.

  * This group contains function that operate on global alias values.
  *
  * @see llvm::GlobalAlias
  *
  * @{
  */
 LLVMValueRef LLVMAddAlias(LLVMModuleRef M, LLVMTypeRef Ty, LLVMValueRef Aliasee,
                           const char *Name);
-LLVMValueRef LLVMGetNamedAlias(LLVMModuleRef M, const char *Name);
-LLVMValueRef LLVMGetFirstAlias(LLVMModuleRef M);
-LLVMValueRef LLVMGetLastAlias(LLVMModuleRef M);
-LLVMValueRef LLVMGetNextAlias(LLVMValueRef Alias);
-LLVMValueRef LLVMGetPreviousAlias(LLVMValueRef Alias);
-void LLVMDeleteAlias(LLVMValueRef GlobalVar);
-
-/**
- * Get the aliased value of an alias. The value can be a constant or a constant
- * bitcast.
- * @see llvm::GlobalAlias::getAliasee()
- */
-LLVMValueRef LLVMGetAliasee(LLVMValueRef A);
-
-/**
- * Set the aliased value of an alias. The value can be a constant or a constant
- * bitcast.
- * @see llvm::GlobalAlias::setAliasee()
- */
-void LLVMSetAliasee(LLVMValueRef A, LLVMValueRef Aliasee);
 
 /**
  * @}
  */
 
 /**
  * @defgroup LLVMCCoreValueFunction Function values
  *

 /**
  * Obtain the code opcode for an individual instruction.
  *
  * @see llvm::Instruction::getOpCode()
  */
 LLVMOpcode LLVMGetInstructionOpcode(LLVMValueRef Inst);
 
 /**
- * Create a copy of 'this' instruction that is identical in all ways
- * except the following:
- *   * The instruction has no parent
- *   * The instruction has no name
- *
- * @see llvm::Instruction::clone()
- */
-LLVMValueRef LLVMInstructionClone(LLVMValueRef Inst);
-
-/**
  * Obtain the predicate of an instruction.
  *
  * This is only valid for instructions that correspond to llvm::ICmpInst
  * or llvm::ConstantExpr whose opcode is llvm::Instruction::ICmp.
  *
  * @see llvm::ICmpInst::getPredicate()
  */
 LLVMIntPredicate LLVMGetICmpPredicate(LLVMValueRef Inst);
 
 /**
  * Obtain the float predicate of an instruction.
  *
  * This is only valid for instructions that correspond to llvm::FCmpInst
  * or llvm::ConstantExpr whose opcode is llvm::Instruction::FCmp.
  *
  * @see llvm::FCmpInst::getPredicate()
  */
 LLVMRealPredicate LLVMGetFCmpPredicate(LLVMValueRef Inst);
 
 /**
- * @defgroup LLVMCCoreValueInstructionGEP GetElementPtr
- *
- * Functions in this group apply to instructions that refer to getelementptr
- * instructions or constant expressions. These correspond to C++ types in the
- * llvm::GetElementPtrInst or llvm::GetElementPtrConstantExpr classes.
- *
- * @{
- */
-
-/**
- * Obtain whether a getelementptr is "inbounds".
- *
- * This is only valid for instructions that correspond to
- * llvm::GetElementPtrInst or llvm::GetElementPtrConstantExpr.
- *
- * @see llvm::GetElementPtrInst::isInBounds()
- */
-LLVMBool LLVMIsInBounds(LLVMValueRef Inst);
-
-/**
- * Set whether a getelementptr is "inbounds".
- *
- * This is only valid for instructions that correspond to
- * llvm::GetElementPtrInst or llvm::GetElementPtrConstantExpr.
- *
- * @see llvm::GetElementPtrInst::setIsInBounds()
- */
-void LLVMSetIsInBounds(LLVMValueRef Inst, LLVMBool IsInBounds);
-
-/**
- * @}
- */
-
-/**
- * @defgroup LLVMCCoreValueInstructionBinOp Binary Operators
- *
- * Functions in this group apply to instructions that refer to binary
- * operators. These correspond to C++ types in the llvm::BinaryOperator class
- * tree.
- *
- * @{
- */
-
-/**
- * Obtain whether the operation cannot result in a signed integer wraparound.
- * @see llvm::BinaryOperator::hasNoSignedWrap()
- */
-LLVMBool LLVMHasNoSignedWrap(LLVMValueRef Instr);
-
-/**
- * Set whether the operation cannot result in a signed integer wraparound.
- * @see llvm::BinaryOperator::hasNoSignedWrap()
- */
-void LLVMSetHasNoSignedWrap(LLVMValueRef Instr, LLVMBool HasNoSignedWrap);
-
-/**
- * Obtain whether the operation cannot result in a unsigned integer wraparound.
- * @see llvm::BinaryOperator::hasNoUnsignedWrap()
- */
-LLVMBool LLVMHasNoUnsignedWrap(LLVMValueRef Instr);
-
-/**
- * Set whether the operation cannot result in a unsigned integer wraparound.
- * @see llvm::BinaryOperator::hasNoUnsignedWrap()
- */
-void LLVMSetHasNoUnsignedWrap(LLVMValueRef Instr, LLVMBool HasNoSignedWrap);
-
-/**
- * Obtain whether the operation cannot result in an inexact result.
- * @see llvm::BinaryOperator::isExact()
- */
-LLVMBool LLVMIsExact(LLVMValueRef Instr);
-
-/**
- * Set whether the operation cannot result in an inexact result.
- * @see llvm::BinaryOperator::isExact()
- */
-void LLVMSetIsExact(LLVMValueRef Instr, LLVMBool IsExact);
-
-/**
- * @}
- */
-
-/**
- * @defgroup LLVMCCoreValueInstructionAlloca Alloca
- *
- * Functions in this group apply to the alloca instruction.
- * @see llvm::AllocaInst
- *
- * @{
- */
-
-/**
- * Obtain whether an alloca instruction allocates an array.
- * @see llvm::AllocaInst::isArrayAllocation()
- */
-LLVMBool LLVMIsArrayAlloca(LLVMValueRef Instr);
-
-/**
- * Obtain the number of elements allocated by an alloca instruction.
- * @see llvm::AllocaInst::getArraySize()
- */
-LLVMValueRef LLVMGetAllocaNumElements(LLVMValueRef Instr);
-
-/**
- * Obtain the type of elements allocated by an alloca instruction.
- * @see llvm::AllocaInst::getAllocatedType()
- */
-LLVMTypeRef LLVMGetAllocatedType(LLVMValueRef Instr);
-
-/**
- * @}
- */
-
-/**
- * @defgroup LLVMCCoreValueInstructionAtomic Atomic instructions
- *
- * Functions in this group apply to instructions with atomic forms, that is
- * load, store, fence, atomicrmw and cmpxchg.
- * @see llvm::AtomicRMWInst
- *
- * @{
- */
-
-/**
- * Obtain the atomic ordering of an instruction with an atomic form.
- * @see llvm::LoadInst::getAtomicOrdering()
- * @see llvm::StoreInst::getAtomicOrdering()
- * @see llvm::FenceInst::getAtomicOrdering()
- * @see llvm::AtomicRMWInst::getAtomicOrdering()
- * @see llvm::AtomicCmpXchgInst::getAtomicOrdering()
- */
-LLVMAtomicOrdering LLVMGetAtomicOrdering(LLVMValueRef Instr);
-
-/**
- * Set the atomic ordering of an instruction with an atomic form.
- * @see llvm::LoadInst::setAtomicOrdering()
- * @see llvm::StoreInst::setAtomicOrdering()
- * @see llvm::FenceInst::setAtomicOrdering()
- * @see llvm::AtomicRMWInst::setAtomicOrdering()
- * @see llvm::AtomicCmpXchgInst::setAtomicOrdering()
- */
-void LLVMSetAtomicOrdering(LLVMValueRef Instr, LLVMAtomicOrdering Ordering);
-
-/**
- * Obtain the synchronization scope of an instruction with an atomic form.
- * @see llvm::LoadInst::getSynchronizationScope()
- * @see llvm::StoreInst::getSynchronizationScope()
- * @see llvm::FenceInst::getSynchronizationScope()
- * @see llvm::AtomicRMWInst::getSynchronizationScope()
- * @see llvm::AtomicCmpXchgInst::getSynchronizationScope()
- */
-LLVMSynchronizationScope LLVMGetSynchronizationScope(LLVMValueRef Instr);
-
-/**
- * Set the atomic ordering of an instruction with an atomic form.
- * @see llvm::LoadInst::setSynchronizationScope()
- * @see llvm::StoreInst::setSynchronizationScope()
- * @see llvm::FenceInst::setSynchronizationScope()
- * @see llvm::AtomicRMWInst::setSynchronizationScope()
- * @see llvm::AtomicCmpXchgInst::setSynchronizationScope()
- */
-void LLVMSetSynchronizationScope(LLVMValueRef Instr,
-                                 LLVMSynchronizationScope Scope);
-
-/**
- * @}
- */
-
-/**
- * @defgroup LLVMCCoreValueInstructionAtomicRMW AtomicRMW
- *
- * Functions in this group apply to the atomicrmw instruction.
- * @see llvm::AtomicRMWInst
+ * Create a copy of 'this' instruction that is identical in all ways
+ * except the following:
+ *   * The instruction has no parent
+ *   * The instruction has no name
  *
- * @{
- */
-
-/**
- * Obtain the operation of an atomicrmw instruction.
- * @see llvm::AtomicRMWInst::getOperation()
- */
-LLVMAtomicRMWBinOp LLVMGetAtomicRMWOperation(LLVMValueRef Instr);
-
-/**
- * Set the operation of an atomicrmw instruction.
- * @see llvm::AtomicRMWInst::setOperation()
- */
-void LLVMSetAtomicRMWOperation(LLVMValueRef Instr, LLVMAtomicRMWBinOp Op);
-
-/**
- * @}
+ * @see llvm::Instruction::clone()
  */
+LLVMValueRef LLVMInstructionClone(LLVMValueRef Inst);
 
 /**
  * @defgroup LLVMCCoreValueInstructionCall Call Sites and Invocations
  *
  * Functions in this group apply to instructions that refer to call
  * sites and invocations. These correspond to C++ types in the
  * llvm::CallInst class tree.
  *

  *
  * This is the opposite of LLVMSetInstructionCallConv(). Reads its
  * usage.
  *
  * @see LLVMSetInstructionCallConv()
  */
 unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr);
 
+
 void LLVMAddInstrAttribute(LLVMValueRef Instr, unsigned index, LLVMAttribute);
 void LLVMRemoveInstrAttribute(LLVMValueRef Instr, unsigned index,
                               LLVMAttribute);
 void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index,
                                 unsigned align);
 
 /**
  * Obtain the pointer to the function invoked by this instruction.

  *
  * This only works on llvm::BranchInst instructions.
  *
  * @see llvm::BranchInst::setCondition
  */
 void LLVMSetCondition(LLVMValueRef Branch, LLVMValueRef Cond);
 
 /**
- * @defgroup LLVMCCoreValueInstructionSwitch Switch Instructions
- *
- * Functions in this group only apply to switch instructions.
- *
- * @{
- */
-
-/**
- * Add a case to a switch instruction. \p OnVal must be a constant integer.
- *
- * @see llvm::SwitchInst::addCase()
- */
-void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal,
-                 LLVMBasicBlockRef Dest);
-
-/**
  * Obtain the default destination basic block of a switch instruction.
  *
+ * This only works on llvm::SwitchInst instructions.
+ *
  * @see llvm::SwitchInst::getDefaultDest()
  */
 LLVMBasicBlockRef LLVMGetSwitchDefaultDest(LLVMValueRef SwitchInstr);
 
 /**
- * Obtain the amount of non-default destinations of a switch instruction.
- *
- * @see llvm::SwitchInst::getNumCases()
- */
-unsigned LLVMGetSwitchNumCases(LLVMValueRef SwitchInstr);
-
-/**
- * Obtain the case values and destinations for all cases of a switch
- * instruction. \p Values and \p Successors should point to arrays of
- * sufficient size, which can be determined by \p LLVMGetSwitchNumCases.
- */
-void LLVMGetSwitchCases(LLVMValueRef SwitchInstr, LLVMValueRef *Values,
-                        LLVMBasicBlockRef *Successors);
-
-/**
- * @}
- */
-
-/**
- * @defgroup LLVMCCoreValueInstructionIndirectBr Indirectbr Instructions
- *
- * Functions in this group only apply to indirectbr instructions.
- *
- * @{
- */
-
-/**
- * Add a destination to the indirectbr instruction.
- *
- * @see llvm::IndirectBrInst::addDestination()
- */
-void LLVMAddDestination(LLVMValueRef IndirectBr, LLVMBasicBlockRef Dest);
-
-/**
- * Obtain the amount of  destinations of an indirectbr instruction.
- *
- * @see llvm::IndirectBrInst::getNumDestinations()
- */
-unsigned LLVMGetIndirectBrNumDestinations(LLVMValueRef IndirectBr);
-
-/**
- * Obtain the destinations for all cases of an indirectbr instruction.
- * \p Successors should point to an array of sufficient size, which can be
- * determined by \p LLVMGetIndirectBrNumDestinations.
- */
-void LLVMGetIndirectBrDestinations(LLVMValueRef IndirectBr,
-                                   LLVMBasicBlockRef *Successors);
-
-/**
- * @}
- */
-
-/**
  * @}
  */
 
 /**
  * @defgroup LLVMCCoreValueInstructionAlloca Allocas
  *
  * Functions in this group only apply to instructions that map to
  * llvm::AllocaInst instances.
LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
                              LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
                              const char *Name);
 LLVMValueRef LLVMBuildLandingPad(LLVMBuilderRef B, LLVMTypeRef Ty,
                                  LLVMValueRef PersFn, unsigned NumClauses,
                                  const char *Name);
 LLVMValueRef LLVMBuildResume(LLVMBuilderRef B, LLVMValueRef Exn);
 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
 
+/* Add a case to the switch instruction */
+void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal,
+                 LLVMBasicBlockRef Dest);
+
+/* Add a destination to the indirectbr instruction */
+void LLVMAddDestination(LLVMValueRef IndirectBr, LLVMBasicBlockRef Dest);
+
 /* Get the number of clauses on the landingpad instruction */
 unsigned LLVMGetNumClauses(LLVMValueRef LandingPad);
 
 /* Get the value of the clause at idnex Idx on the landingpad instruction */
 LLVMValueRef LLVMGetClause(LLVMValueRef LandingPad, unsigned Idx);
 
 /* Add a catch or filter clause to the landingpad instruction */
 void LLVMAddClause(LLVMValueRef LandingPad, LLVMValueRef ClauseVal);
 
-/**
- * Obtain the cleanup flag in the landingpad instruction.
- * @see llvm::LandingPadInst::isCleanup()
- */
+/* Get the 'cleanup' flag in the landingpad instruction */
 LLVMBool LLVMIsCleanup(LLVMValueRef LandingPad);
 
-
-/**
- * Set the cleanup flag in the landingpad instruction
- * @see llvm::LandingPadInst::setCleanup()
- */
-void LLVMSetCleanup(LLVMValueRef LandingPad, LLVMBool Cleanup);
+/* Set the 'cleanup' flag in the landingpad instruction */
+void LLVMSetCleanup(LLVMValueRef LandingPad, LLVMBool Val);
 
 /* Arithmetic */
 LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
                           const char *Name);
 LLVMValueRef LLVMBuildNSWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
                              const char *Name);
 LLVMValueRef LLVMBuildNUWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
                              const char *Name);

lib/IR/Core.cpp

LLVMModuleRef LLVMModuleCreateWithNameInContext(const char *ModuleID,
                                                 LLVMContextRef C) {
   return wrap(new Module(ModuleID, *unwrap(C)));
 }
 
 void LLVMDisposeModule(LLVMModuleRef M) {
   delete unwrap(M);
 }
 
-char *LLVMGetModuleIdentifier(LLVMModuleRef M) {
-  return strdup(unwrap(M)->getModuleIdentifier().c_str());
-}
-
-void LLVMSetModuleIdentifier(LLVMModuleRef M, const char *ID) {
-  unwrap(M)->setModuleIdentifier(ID);
-}
-
 /*--.. Data layout .........................................................--*/
 const char *LLVMGetDataLayoutStr(LLVMModuleRef M) {
   return unwrap(M)->getDataLayoutStr().c_str();
 }
 
 const char *LLVMGetDataLayout(LLVMModuleRef M) {
   return LLVMGetDataLayoutStr(M);
 }

 /*--.. Operations on other types ...........................................--*/
 
 LLVMTypeRef LLVMVoidTypeInContext(LLVMContextRef C)  {
   return wrap(Type::getVoidTy(*unwrap(C)));
 }
 LLVMTypeRef LLVMLabelTypeInContext(LLVMContextRef C) {
   return wrap(Type::getLabelTy(*unwrap(C)));
 }
-LLVMTypeRef LLVMMetadataTypeInContext(LLVMContextRef C) {
-  return wrap(Type::getMetadataTy(*unwrap(C)));
-}
 
 LLVMTypeRef LLVMVoidType(void)  {
   return LLVMVoidTypeInContext(LLVMGetGlobalContext());
 }
 LLVMTypeRef LLVMLabelType(void) {
   return LLVMLabelTypeInContext(LLVMGetGlobalContext());
 }
-LLVMTypeRef LLVMMetadataType(void) {
-  return LLVMMetadataTypeInContext(LLVMGetGlobalContext());
-}
 
 /*===-- Operations on values ----------------------------------------------===*/
 
 /*--.. Operations on all values ............................................--*/
 
 LLVMTypeRef LLVMTypeOf(LLVMValueRef Val) {
   return wrap(unwrap(Val)->getType());
 }
 
-LLVMValueKind LLVMGetValueKind(LLVMValueRef Val) {
-  switch(unwrap(Val)->getValueID()) {
-#define VALUE_KIND_CASE(class) \
-  case Value::class ## Val: \
-    return LLVM ## class ## ValueKind;
-  LLVM_FOR_EACH_VALUE_KIND(VALUE_KIND_CASE)
-#undef VALUE_KIND_CASE
-  default: break;
-  }
-  return LLVMValueKind(0);
-}
-
 const char *LLVMGetValueName(LLVMValueRef Val) {
   return unwrap(Val)->getName().data();
 }
 
 void LLVMSetValueName(LLVMValueRef Val, const char *Name) {
   unwrap(Val)->setName(Name);
 }
 

 }
 
 LLVMValueRef LLVMConstIntOfStringAndSize(LLVMTypeRef IntTy, const char Str[],
                                          unsigned SLen, uint8_t Radix) {
   return wrap(ConstantInt::get(unwrap<IntegerType>(IntTy), StringRef(Str, SLen),
                                Radix));
 }
 
-
-unsigned long long LLVMConstIntGetZExtValue(LLVMValueRef ConstantVal) {
-  return unwrap<ConstantInt>(ConstantVal)->getZExtValue();
-}
-
-long long LLVMConstIntGetSExtValue(LLVMValueRef ConstantVal) {
-  return unwrap<ConstantInt>(ConstantVal)->getSExtValue();
-}
-
-const uint64_t *LLVMConstIntGetWords(LLVMValueRef ConstantVal, unsigned *n) {
-  const APInt &Int = unwrap<ConstantInt>(ConstantVal)->getValue();
-
-  *n = Int.getNumWords();
-  return Int.getRawData();
-}
-
 LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N) {
   return wrap(ConstantFP::get(unwrap(RealTy), N));
 }
 
 LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, const char *Text) {
   return wrap(ConstantFP::get(unwrap(RealTy), StringRef(Text)));
 }
 
 LLVMValueRef LLVMConstRealOfStringAndSize(LLVMTypeRef RealTy, const char Str[],
                                           unsigned SLen) {
   return wrap(ConstantFP::get(unwrap(RealTy), StringRef(Str, SLen)));
 }
 
-LLVMValueRef LLVMConstRealOfArbitraryPrecision(LLVMTypeRef RealTy,
-                                               unsigned NumWords,
-                                               const uint64_t Words[]) {
-  Type *Ty = unwrap(RealTy);
-  APInt IntRepr = APInt(Ty->getPrimitiveSizeInBits(),
-                        makeArrayRef(Words, NumWords));
-  APFloat Float = APFloat(Ty->getFltSemantics(), IntRepr);
+unsigned long long LLVMConstIntGetZExtValue(LLVMValueRef ConstantVal) {
+  return unwrap<ConstantInt>(ConstantVal)->getZExtValue();
+}
 
-  return wrap(ConstantFP::get(Ty->getContext(), Float));
+long long LLVMConstIntGetSExtValue(LLVMValueRef ConstantVal) {
+  return unwrap<ConstantInt>(ConstantVal)->getSExtValue();
 }
 
 double LLVMConstRealGetDouble(LLVMValueRef ConstantVal, LLVMBool *LosesInfo) {
   ConstantFP *cFP = unwrap<ConstantFP>(ConstantVal) ;
   Type *Ty = cFP->getType();
 
   if (Ty->isFloatTy()) {
     *LosesInfo = false;
     return cFP->getValueAPF().convertToFloat();
   }
 
   if (Ty->isDoubleTy()) {
     *LosesInfo = false;
     return cFP->getValueAPF().convertToDouble();
   }
 
   bool APFLosesInfo;
   APFloat APF = cFP->getValueAPF();
   APF.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, &APFLosesInfo);
   *LosesInfo = APFLosesInfo;
   return APF.convertToDouble();
 }
 
-const uint64_t *LLVMConstRealGetWords(LLVMValueRef ConstantVal, unsigned *n) {
-  const APFloat &Float = unwrap<ConstantFP>(ConstantVal)->getValueAPF();
-  const APInt &IntRepr = Float.bitcastToAPInt();
-
-  *n = IntRepr.getNumWords();
-  return IntRepr.getRawData();
-}
-
-
 /*--.. Operations on composite constants ...................................--*/
 
 LLVMValueRef LLVMConstStringInContext(LLVMContextRef C, const char *Str,
                                       unsigned Length,
                                       LLVMBool DontNullTerminate) {
   /* Inverted the sense of AddNull because ', 0)' is a
      better mnemonic for null termination than ', 1)'. */
   return wrap(ConstantDataArray::getString(*unwrap(C), StringRef(Str, Length),

 }
 
 /*--.. Constant expressions ................................................--*/
 
 LLVMOpcode LLVMGetConstOpcode(LLVMValueRef ConstantVal) {
   return map_to_llvmopcode(unwrap<ConstantExpr>(ConstantVal)->getOpcode());
 }
 
-LLVMValueRef LLVMGetElementAsConstant(LLVMValueRef ConstantVal, unsigned n) {
-  return wrap(unwrap<ConstantDataSequential>(ConstantVal)->
-              getElementAsConstant(n));
-}
-
 LLVMValueRef LLVMAlignOf(LLVMTypeRef Ty) {
   return wrap(ConstantExpr::getAlignOf(unwrap(Ty)));
 }
 
 LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty) {
   return wrap(ConstantExpr::getSizeOf(unwrap(Ty)));
 }
 
LLVMValueRef LLVMConstInlineAsm(LLVMTypeRef Ty, const char *AsmString,
   return wrap(InlineAsm::get(dyn_cast<FunctionType>(unwrap(Ty)), AsmString,
                              Constraints, HasSideEffects, IsAlignStack));
 }
 
 LLVMValueRef LLVMBlockAddress(LLVMValueRef F, LLVMBasicBlockRef BB) {
   return wrap(BlockAddress::get(unwrap<Function>(F), unwrap(BB)));
 }
 
-LLVMValueRef LLVMGetBlockAddressFunction(LLVMValueRef BA) {
-  return wrap(unwrap<BlockAddress>(BA)->getFunction());
-}
-
-LLVMBasicBlockRef LLVMGetBlockAddressBlock(LLVMValueRef BA) {
-  return wrap(unwrap<BlockAddress>(BA)->getBasicBlock());
-}
-
 /*--.. Operations on global variables, functions, and aliases (globals) ....--*/
 
 LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global) {
   return wrap(unwrap<GlobalValue>(Global)->getParent());
 }
 
 LLVMBool LLVMIsDeclaration(LLVMValueRef Global) {
   return unwrap<GlobalValue>(Global)->isDeclaration();

 LLVMValueRef LLVMAddAlias(LLVMModuleRef M, LLVMTypeRef Ty, LLVMValueRef Aliasee,
                           const char *Name) {
   auto *PTy = cast<PointerType>(unwrap(Ty));
   return wrap(GlobalAlias::create(PTy->getElementType(), PTy->getAddressSpace(),
                                   GlobalValue::ExternalLinkage, Name,
                                   unwrap<Constant>(Aliasee), unwrap(M)));
 }
 
-LLVMValueRef LLVMGetNamedAlias(LLVMModuleRef M, const char *Name) {
-  return wrap(unwrap(M)->getNamedAlias(Name));
-}
-
-LLVMValueRef LLVMGetFirstAlias(LLVMModuleRef M) {
-  Module *Mod = unwrap(M);
-  Module::alias_iterator I = Mod->alias_begin();
-  if (I == Mod->alias_end())
-    return 0;
-  return wrap(I);
-}
-
-LLVMValueRef LLVMGetLastAlias(LLVMModuleRef M) {
-  Module *Mod = unwrap(M);
-  Module::alias_iterator I = Mod->alias_end();
-  if (I == Mod->alias_begin())
-    return 0;
-  return wrap(--I);
-}
-
-LLVMValueRef LLVMGetNextAlias(LLVMValueRef Alias) {
-  GlobalAlias *GV = unwrap<GlobalAlias>(Alias);
-  Module::alias_iterator I = GV;
-  if (++I == GV->getParent()->alias_end())
-    return 0;
-  return wrap(I);
-}
-
-LLVMValueRef LLVMGetPreviousAlias(LLVMValueRef Alias) {
-  GlobalAlias *GV = unwrap<GlobalAlias>(Alias);
-  Module::alias_iterator I = GV;
-  if (I == GV->getParent()->alias_begin())
-    return 0;
-  return wrap(--I);
-}
-
-void LLVMDeleteAlias(LLVMValueRef Alias) {
-  unwrap<GlobalAlias>(Alias)->eraseFromParent();
-}
-
-LLVMValueRef LLVMGetAliasee(LLVMValueRef A) {
-  return wrap(unwrap<GlobalAlias>(A)->getAliasee());
-}
-
-void LLVMSetAliasee(LLVMValueRef A, LLVMValueRef Aliasee) {
-  unwrap<GlobalAlias>(A)->setAliasee(unwrap<Constant>(Aliasee));
-}
-
 /*--.. Operations on functions .............................................--*/
 
 LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name,
                              LLVMTypeRef FunctionTy) {
   return wrap(Function::Create(unwrap<FunctionType>(FunctionTy),
                                GlobalValue::ExternalLinkage, Name, unwrap(M)));
 }
 

 }
 
 LLVMValueRef LLVMInstructionClone(LLVMValueRef Inst) {
   if (Instruction *C = dyn_cast<Instruction>(unwrap(Inst)))
     return wrap(C->clone());
   return nullptr;
 }
 
-/*--.. GetElementPtr instruction ...........................................--*/
-
-LLVMBool LLVMIsInBounds(LLVMValueRef Inst) {
-  return unwrap<GetElementPtrInst>(Inst)->isInBounds();
-}
-
-void LLVMSetIsInBounds(LLVMValueRef Inst, LLVMBool IsInBounds) {
-  unwrap<GetElementPtrInst>(Inst)->setIsInBounds(IsInBounds != 0);
-}
-
-/*--.. Binary operators ....................................................--*/
-
-LLVMBool LLVMHasNoSignedWrap(LLVMValueRef Instr) {
-  return unwrap<BinaryOperator>(Instr)->hasNoSignedWrap();
-}
-
-void LLVMSetHasNoSignedWrap(LLVMValueRef Instr, LLVMBool HasNoSignedWrap) {
-  unwrap<BinaryOperator>(Instr)->setHasNoSignedWrap(HasNoSignedWrap != 0);
-}
-
-LLVMBool LLVMHasNoUnsignedWrap(LLVMValueRef Instr) {
-  return unwrap<BinaryOperator>(Instr)->hasNoUnsignedWrap();
-}
-
-void LLVMSetHasNoUnsignedWrap(LLVMValueRef Instr, LLVMBool HasNoUnsignedWrap) {
-  unwrap<BinaryOperator>(Instr)->setHasNoUnsignedWrap(HasNoUnsignedWrap != 0);
-}
-
-LLVMBool LLVMIsExact(LLVMValueRef Instr) {
-  return unwrap<BinaryOperator>(Instr)->isExact();
-}
-
-void LLVMSetIsExact(LLVMValueRef Instr, LLVMBool IsExact) {
-  unwrap<BinaryOperator>(Instr)->setIsExact(IsExact != 0);
-}
-
-/*--.. Alloca instructions .................................................--*/
-
-LLVMBool LLVMIsArrayAlloca(LLVMValueRef Instr) {
-  return unwrap<AllocaInst>(Instr)->isArrayAllocation();
-}
-
-LLVMValueRef LLVMGetAllocaNumElements(LLVMValueRef Instr) {
-  return wrap(unwrap<AllocaInst>(Instr)->getArraySize());
-}
-
-LLVMTypeRef LLVMGetAllocatedType(LLVMValueRef Instr) {
-  return wrap(unwrap<AllocaInst>(Instr)->getAllocatedType());
-}
-
-/*--.. Atomic instructions .................................................--*/
-
-static LLVMAtomicOrdering wrap(AtomicOrdering Ordering) {
-  switch(Ordering) {
-    case NotAtomic:
-      return LLVMAtomicOrderingNotAtomic;
-    case Unordered:
-      return LLVMAtomicOrderingUnordered;
-    case Monotonic:
-      return LLVMAtomicOrderingMonotonic;
-    case Acquire:
-      return LLVMAtomicOrderingAcquire;
-    case Release:
-      return LLVMAtomicOrderingRelease;
-    case AcquireRelease:
-      return LLVMAtomicOrderingAcquireRelease;
-    case SequentiallyConsistent:
-      return LLVMAtomicOrderingSequentiallyConsistent;
-  }
-}
-
-static AtomicOrdering unwrap(LLVMAtomicOrdering ExtOrdering) {
-  switch(ExtOrdering) {
-    case LLVMAtomicOrderingNotAtomic:
-      return NotAtomic;
-    case LLVMAtomicOrderingUnordered:
-      return Unordered;
-    case LLVMAtomicOrderingMonotonic:
-      return Monotonic;
-    case LLVMAtomicOrderingAcquire:
-      return Acquire;
-    case LLVMAtomicOrderingRelease:
-      return Release;
-    case LLVMAtomicOrderingAcquireRelease:
-      return AcquireRelease;
-    case LLVMAtomicOrderingSequentiallyConsistent:
-      return SequentiallyConsistent;
-  }
-}
-
-LLVMAtomicOrdering LLVMGetAtomicOrdering(LLVMValueRef Instr) {
-  AtomicOrdering Ordering;
-
-  if(LoadInst *LI = dyn_cast_or_null<LoadInst>(unwrap(Instr)))
-    Ordering = LI->getOrdering();
-  else if(StoreInst *SI = dyn_cast_or_null<StoreInst>(unwrap(Instr)))
-    Ordering = SI->getOrdering();
-  else if(FenceInst *FI = dyn_cast_or_null<FenceInst>(unwrap(Instr)))
-    Ordering = FI->getOrdering();
-  else if(AtomicRMWInst *ARMWI = dyn_cast_or_null<AtomicRMWInst>(unwrap(Instr)))
-    Ordering = ARMWI->getOrdering();
-  else if(AtomicCmpXchgInst *ACXI =
-          dyn_cast_or_null<AtomicCmpXchgInst>(unwrap(Instr)))
-    Ordering = ACXI->getOrdering();
-
-  return wrap(Ordering);
-}
-
-void LLVMSetAtomicOrdering(LLVMValueRef Instr, LLVMAtomicOrdering ExtOrdering) {
-  AtomicOrdering Ordering = unwrap(ExtOrdering);
-
-  if(LoadInst *LI = dyn_cast_or_null<LoadInst>(unwrap(Instr)))
-    LI->setOrdering(Ordering);
-  else if(StoreInst *SI = dyn_cast_or_null<StoreInst>(unwrap(Instr)))
-    SI->setOrdering(Ordering);
-  else if(FenceInst *FI = dyn_cast_or_null<FenceInst>(unwrap(Instr)))
-    FI->setOrdering(Ordering);
-  else if(AtomicRMWInst *ARMWI = dyn_cast_or_null<AtomicRMWInst>(unwrap(Instr)))
-    ARMWI->setOrdering(Ordering);
-  else if(AtomicCmpXchgInst *ACXI =
-          dyn_cast_or_null<AtomicCmpXchgInst>(unwrap(Instr)))
-    ACXI->setOrdering(Ordering);
-}
-
-static LLVMSynchronizationScope wrap(SynchronizationScope Scope) {
-  switch(Scope) {
-    case SingleThread:
-      return LLVMSynchronizationScopeSingleThread;
-    case CrossThread:
-      return LLVMSynchronizationScopeCrossThread;
-  }
-}
-
-static SynchronizationScope unwrap(LLVMSynchronizationScope ExtScope) {
-  switch(ExtScope) {
-    case LLVMSynchronizationScopeSingleThread:
-      return SingleThread;
-    case LLVMSynchronizationScopeCrossThread:
-      return CrossThread;
-  }
-}
-
-LLVMSynchronizationScope LLVMGetSynchronizationScope(LLVMValueRef Instr) {
-  SynchronizationScope Scope;
-
-  if(LoadInst *LI = dyn_cast_or_null<LoadInst>(unwrap(Instr)))
-    Scope = LI->getSynchScope();
-  else if(StoreInst *SI = dyn_cast_or_null<StoreInst>(unwrap(Instr)))
-    Scope = SI->getSynchScope();
-  else if(FenceInst *FI = dyn_cast_or_null<FenceInst>(unwrap(Instr)))
-    Scope = FI->getSynchScope();
-  else if(AtomicRMWInst *ARMWI = dyn_cast_or_null<AtomicRMWInst>(unwrap(Instr)))
-    Scope = ARMWI->getSynchScope();
-  else if(AtomicCmpXchgInst *ACXI =
-          dyn_cast_or_null<AtomicCmpXchgInst>(unwrap(Instr)))
-    Scope = ACXI->getSynchScope();
-
-  return wrap(Scope);
-}
-
-void LLVMSetSynchronizationScope(LLVMValueRef Instr,
-                                 LLVMSynchronizationScope ExtScope) {
-  SynchronizationScope Scope = unwrap(ExtScope);
-
-  if(LoadInst *LI = dyn_cast_or_null<LoadInst>(unwrap(Instr)))
-    LI->setSynchScope(Scope);
-  else if(StoreInst *SI = dyn_cast_or_null<StoreInst>(unwrap(Instr)))
-    SI->setSynchScope(Scope);
-  else if(FenceInst *FI = dyn_cast_or_null<FenceInst>(unwrap(Instr)))
-    FI->setSynchScope(Scope);
-  else if(AtomicRMWInst *ARMWI = dyn_cast_or_null<AtomicRMWInst>(unwrap(Instr)))
-    ARMWI->setSynchScope(Scope);
-  else if(AtomicCmpXchgInst *ACXI =
-          dyn_cast_or_null<AtomicCmpXchgInst>(unwrap(Instr)))
-    ACXI->setSynchScope(Scope);
-}
-
-/*--.. AtomicRMW instructions ..............................................--*/
-
-static LLVMAtomicRMWBinOp wrap(AtomicRMWInst::BinOp Op) {
-  switch (Op) {
-    default: llvm_unreachable("Unknown LLVMAtomicRMWBinOp");
-    case AtomicRMWInst::Xchg: return LLVMAtomicRMWBinOpXchg;
-    case AtomicRMWInst::Add:  return LLVMAtomicRMWBinOpAdd;
-    case AtomicRMWInst::Sub:  return LLVMAtomicRMWBinOpSub;
-    case AtomicRMWInst::And:  return LLVMAtomicRMWBinOpAnd;
-    case AtomicRMWInst::Nand: return LLVMAtomicRMWBinOpNand;
-    case AtomicRMWInst::Or:   return LLVMAtomicRMWBinOpOr;
-    case AtomicRMWInst::Xor:  return LLVMAtomicRMWBinOpXor;
-    case AtomicRMWInst::Max:  return LLVMAtomicRMWBinOpMax;
-    case AtomicRMWInst::Min:  return LLVMAtomicRMWBinOpMin;
-    case AtomicRMWInst::UMax: return LLVMAtomicRMWBinOpUMax;
-    case AtomicRMWInst::UMin: return LLVMAtomicRMWBinOpUMin;
-  }
-}
-
-static AtomicRMWInst::BinOp unwrap(LLVMAtomicRMWBinOp ExtOp) {
-  switch (ExtOp) {
-    case LLVMAtomicRMWBinOpXchg: return AtomicRMWInst::Xchg;
-    case LLVMAtomicRMWBinOpAdd:  return AtomicRMWInst::Add;
-    case LLVMAtomicRMWBinOpSub:  return AtomicRMWInst::Sub;
-    case LLVMAtomicRMWBinOpAnd:  return AtomicRMWInst::And;
-    case LLVMAtomicRMWBinOpNand: return AtomicRMWInst::Nand;
-    case LLVMAtomicRMWBinOpOr:   return AtomicRMWInst::Or;
-    case LLVMAtomicRMWBinOpXor:  return AtomicRMWInst::Xor;
-    case LLVMAtomicRMWBinOpMax:  return AtomicRMWInst::Max;
-    case LLVMAtomicRMWBinOpMin:  return AtomicRMWInst::Min;
-    case LLVMAtomicRMWBinOpUMax: return AtomicRMWInst::UMax;
-    case LLVMAtomicRMWBinOpUMin: return AtomicRMWInst::UMin;
-  }
-}
-
-LLVMAtomicRMWBinOp LLVMGetAtomicRMWOperation(LLVMValueRef Instr) {
-  return wrap(unwrap<AtomicRMWInst>(Instr)->getOperation());
-}
-
-void LLVMSetAtomicRMWOperation(LLVMValueRef Instr, LLVMAtomicRMWBinOp ExtOp) {
-  dyn_cast<AtomicRMWInst>(unwrap(Instr))->setOperation(unwrap(ExtOp));
-}
-
-
 /*--.. Call and invoke instructions ........................................--*/
 
 unsigned LLVMGetNumArgOperands(LLVMValueRef Instr) {
   return CallSite(unwrap<Instruction>(Instr)).getNumArgOperands();
 }
 
 unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr) {
   return CallSite(unwrap<Instruction>(Instr)).getCallingConv();

 }
 
 void LLVMSetCondition(LLVMValueRef Branch, LLVMValueRef Cond) {
   return unwrap<BranchInst>(Branch)->setCondition(unwrap(Cond));
 }
 
 /*--.. Operations on switch instructions (only) ............................--*/
 
-void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal,
-                 LLVMBasicBlockRef Dest) {
-  unwrap<SwitchInst>(Switch)->addCase(unwrap<ConstantInt>(OnVal), unwrap(Dest));
-}
-
 LLVMBasicBlockRef LLVMGetSwitchDefaultDest(LLVMValueRef Switch) {
   return wrap(unwrap<SwitchInst>(Switch)->getDefaultDest());
 }
 
-unsigned LLVMGetSwitchNumCases(LLVMValueRef SwitchInstr) {
-  return unwrap<SwitchInst>(SwitchInstr)->getNumCases();
-}
-
-void LLVMGetSwitchCases(LLVMValueRef SwitchInstr, LLVMValueRef *Values,
-                        LLVMBasicBlockRef *Successors) {
-  SwitchInst *SI = unwrap<SwitchInst>(SwitchInstr);
-
-  for (SwitchInst::CaseIt i = SI->case_begin();
-          i != SI->case_end(); ++i, ++Values, ++Successors) {
-    *Values     = wrap(i.getCaseValue());
-    *Successors = wrap(i.getCaseSuccessor());
-  }
-}
-
-/*--.. Operations on indirectbr instructions (only) ........................--*/
-
-void LLVMAddDestination(LLVMValueRef IndirectBr, LLVMBasicBlockRef Dest) {
-  unwrap<IndirectBrInst>(IndirectBr)->addDestination(unwrap(Dest));
-}
-
-unsigned LLVMGetIndirectBrNumDestinations(LLVMValueRef IndirectBr) {
-  return unwrap<IndirectBrInst>(IndirectBr)->getNumDestinations();
-}
-
-void LLVMGetIndirectBrDestinations(LLVMValueRef IndirectBr,
-                                   LLVMBasicBlockRef *Successors) {
-  IndirectBrInst *IBI = unwrap<IndirectBrInst>(IndirectBr);
-
-  for (unsigned i = 0; i != IBI->getNumDestinations(); ++i, ++Successors) {
-    *Successors = wrap(IBI->getDestination(i));
-  }
-}
-
-
 /*--.. Operations on alloca instructions (only) ............................--*/
 
 LLVMTypeRef LLVMGetAllocatedType(LLVMValueRef Alloca) {
   return wrap(unwrap<AllocaInst>(Alloca)->getAllocatedType());
 }
 
 /*--.. Operations on gep instructions (only) ...............................--*/
 

 LLVMValueRef LLVMBuildResume(LLVMBuilderRef B, LLVMValueRef Exn) {
   return wrap(unwrap(B)->CreateResume(unwrap(Exn)));
 }
 
 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef B) {
   return wrap(unwrap(B)->CreateUnreachable());
 }
 
+void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal,
+                 LLVMBasicBlockRef Dest) {
+  unwrap<SwitchInst>(Switch)->addCase(unwrap<ConstantInt>(OnVal), unwrap(Dest));
+}
+
+void LLVMAddDestination(LLVMValueRef IndirectBr, LLVMBasicBlockRef Dest) {
+  unwrap<IndirectBrInst>(IndirectBr)->addDestination(unwrap(Dest));
+}
+
 unsigned LLVMGetNumClauses(LLVMValueRef LandingPad) {
   return unwrap<LandingPadInst>(LandingPad)->getNumClauses();
 }
 
 LLVMValueRef LLVMGetClause(LLVMValueRef LandingPad, unsigned Idx) {
   return wrap(unwrap<LandingPadInst>(LandingPad)->getClause(Idx));
 }
 
LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef B, LLVMValueRef Val,
   return wrap(unwrap(B)->CreateIsNotNull(unwrap(Val), Name));
 }
 
 LLVMValueRef LLVMBuildPtrDiff(LLVMBuilderRef B, LLVMValueRef LHS,
                               LLVMValueRef RHS, const char *Name) {
   return wrap(unwrap(B)->CreatePtrDiff(unwrap(LHS), unwrap(RHS), Name));
 }
 
-
-LLVMValueRef LLVMBuildAtomicRMW(LLVMBuilderRef B, LLVMAtomicRMWBinOp Op,
-                               LLVMValueRef Ptr, LLVMValueRef Val,
-                               LLVMAtomicOrdering Ordering,
-                               LLVMBool oneThread) {
-  return wrap(unwrap(B)->CreateAtomicRMW(unwrap(Op), unwrap(Ptr), unwrap(Val),
-    unwrap(Ordering), oneThread ? SingleThread : CrossThread));
+LLVMValueRef LLVMBuildAtomicRMW(LLVMBuilderRef B,LLVMAtomicRMWBinOp op,
+                               LLVMValueRef PTR, LLVMValueRef Val,
+                               LLVMAtomicOrdering ordering,
+                               LLVMBool singleThread) {
+  AtomicRMWInst::BinOp intop;
+  switch (op) {
+    case LLVMAtomicRMWBinOpXchg: intop = AtomicRMWInst::Xchg; break;
+    case LLVMAtomicRMWBinOpAdd: intop = AtomicRMWInst::Add; break;
+    case LLVMAtomicRMWBinOpSub: intop = AtomicRMWInst::Sub; break;
+    case LLVMAtomicRMWBinOpAnd: intop = AtomicRMWInst::And; break;
+    case LLVMAtomicRMWBinOpNand: intop = AtomicRMWInst::Nand; break;
+    case LLVMAtomicRMWBinOpOr: intop = AtomicRMWInst::Or; break;
+    case LLVMAtomicRMWBinOpXor: intop = AtomicRMWInst::Xor; break;
+    case LLVMAtomicRMWBinOpMax: intop = AtomicRMWInst::Max; break;
+    case LLVMAtomicRMWBinOpMin: intop = AtomicRMWInst::Min; break;
+    case LLVMAtomicRMWBinOpUMax: intop = AtomicRMWInst::UMax; break;
+    case LLVMAtomicRMWBinOpUMin: intop = AtomicRMWInst::UMin; break;
+  }
+  return wrap(unwrap(B)->CreateAtomicRMW(intop, unwrap(PTR), unwrap(Val),
+    mapFromLLVMOrdering(ordering), singleThread ? SingleThread : CrossThread));
 }
 
 LLVMValueRef LLVMBuildAtomicCmpXchg(LLVMBuilderRef B, LLVMValueRef Ptr,
-                                LLVMValueRef Cmp, LLVMValueRef Val,
-                                LLVMAtomicOrdering Ordering,
-                                LLVMSynchronizationScope Scope,
-                                const char *Name) {
-  Value *Instr = unwrap(B)->CreateAtomicCmpXchg(unwrap(Ptr), unwrap(Cmp),
-                    unwrap(Val), unwrap(Ordering), unwrap(Scope));
-  Instr->setName(Name);
-
-  return wrap(Instr);
+                                    LLVMValueRef Cmp, LLVMValueRef New,
+                                    LLVMAtomicOrdering SuccessOrdering,
+                                    LLVMAtomicOrdering FailureOrdering,
+                                    LLVMBool singleThread) {
+
+  return wrap(unwrap(B)->CreateAtomicCmpXchg(unwrap(Ptr), unwrap(Cmp),
+                unwrap(New), mapFromLLVMOrdering(SuccessOrdering),
+                mapFromLLVMOrdering(FailureOrdering),
+                singleThread ? SingleThread : CrossThread));
 }
 
 
 LLVMBool LLVMIsAtomicSingleThread(LLVMValueRef AtomicInst) {
   Value *P = unwrap<Value>(AtomicInst);
 
   if (AtomicRMWInst *I = dyn_cast<AtomicRMWInst>(P))
     return I->getSynchScope() == SingleThread;