Add support for memory operations (load/store/gep) in C API echo test

[deadalnix]

Summary

As per title.

[mehdi_amini]

include/llvm-c/Core.h

2568

Doxygen.

tools/llvm-c-test/echo.cpp

243

Is it related to the C API addition/modification done in this patch?

[mehdi_amini]

LGTM provided you take into account the two previous comments.

[deadalnix]

include/llvm-c/Core.h

2568

You got it.

tools/llvm-c-test/echo.cpp

243

The test case use a zeroinitializer, and that's how you get one from the API.

include/llvm-c/Core.h

  */
 LLVMTypeRef LLVMGetAllocatedType(LLVMValueRef Alloca);
 
 /**
  * @}
  */
 
 /**
+ * @defgroup LLVMCCoreValueInstructionGetElementPointer GEPs
+ *
+ * Functions in this group only apply to instructions that map to
+ * llvm::GetElementPtrInst instances.
+ *
+ * @{
+ */
+
+LLVMBool LLVMIsInBounds(LLVMValueRef GEP);
+void LLVMSetIsInBounds(LLVMValueRef GEP, LLVMBool b);
+
+/**
+ * @}
+ */
+
+/**
  * @defgroup LLVMCCoreValueInstructionPHINode PHI Nodes
  *
  * Functions in this group only apply to instructions that map to
  * llvm::PHINode instances.
  *
  * @{
  */
 

  * Functions in this group only apply to instructions that map to
  * llvm::ExtractValue and llvm::InsertValue instances.
  *
  * @{
  */
 
 /**
  * Obtain the number of indices.
+ * NB: This also works on GEP.
  */
 unsigned LLVMGetNumIndices(LLVMValueRef Inst);
 
 /**
  * Obtain the indices as an array.
  */
 const unsigned *LLVMGetIndices(LLVMValueRef Inst);
 

lib/IR/Core.cpp

 }
 
 /*--.. Operations on alloca instructions (only) ............................--*/
 
 LLVMTypeRef LLVMGetAllocatedType(LLVMValueRef Alloca) {
   return wrap(unwrap<AllocaInst>(Alloca)->getAllocatedType());
 }
 
+/*--.. Operations on gep instructions (only) ...............................--*/
+
+LLVMBool LLVMIsInBounds(LLVMValueRef GEP) {
+  return unwrap<GetElementPtrInst>(GEP)->isInBounds();
+}
+
+void LLVMSetIsInBounds(LLVMValueRef GEP, LLVMBool b) {
+  return unwrap<GetElementPtrInst>(GEP)->setIsInBounds(b);
+}
+
 /*--.. Operations on phi nodes .............................................--*/
 
 void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
                      LLVMBasicBlockRef *IncomingBlocks, unsigned Count) {
   PHINode *PhiVal = unwrap<PHINode>(PhiNode);
   for (unsigned I = 0; I != Count; ++I)
     PhiVal->addIncoming(unwrap(IncomingValues[I]), unwrap(IncomingBlocks[I]));
 }

 LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index) {
   return wrap(unwrap<PHINode>(PhiNode)->getIncomingBlock(Index));
 }
 
 /*--.. Operations on extractvalue and insertvalue nodes ....................--*/
 
 unsigned LLVMGetNumIndices(LLVMValueRef Inst) {
   auto *I = unwrap(Inst);
+  if (auto *GEP = dyn_cast<GetElementPtrInst>(I))
+    return GEP->getNumIndices();
   if (auto *EV = dyn_cast<ExtractValueInst>(I))
     return EV->getNumIndices();
   if (auto *IV = dyn_cast<InsertValueInst>(I))
     return IV->getNumIndices();
   llvm_unreachable(
     "LLVMGetNumIndices applies only to extractvalue and insertvalue!");
 }
 

test/Bindings/llvm-c/memops.ll

+; RUN: llvm-as < %s | llvm-dis > %t.orig
+; RUN: llvm-as < %s | llvm-c-test --echo > %t.echo
+; RUN: diff -w %t.orig %t.echo
+
+%S = type { i32, i32 }
+
+define i32 @method(%S* %this, i32 %arg.a, i32 %arg.b) {
+  %a = alloca i32
+  store i32 %arg.a, i32* %a, align 4
+  %b = alloca i32
+  store i32 %arg.b, i32* %b
+  %1 = load i32, i32* %a, align 4
+  %2 = load i32, i32* %b, align 4
+  %3 = add i32 %1, %2
+  %4 = getelementptr inbounds %S, %S* %this, i32 0, i32 0
+  %5 = load i32, i32* %4, align 4
+  %6 = add i32 %3, %5
+  %7 = getelementptr inbounds %S, %S* %this, i32 0, i32 1
+  %8 = load i32, i32* %7, align 4
+  %9 = add i32 %6, %8
+  ret i32 %9
+}
+
+define i32 @main() {
+  %s = alloca %S
+  store %S zeroinitializer, %S* %s
+  %1 = getelementptr inbounds %S, %S* %s, i32 0, i32 0
+  %2 = getelementptr inbounds %S, %S* %s, i32 0, i32 1
+  store i32 1, i32* %2
+  store i32 1, i32* %1
+  %3 = insertvalue { %S*, i32 (%S*, i32, i32)* } undef, %S* %s, 0
+  %4 = insertvalue { %S*, i32 (%S*, i32, i32)* } %3, i32 (%S*, i32, i32)* @method, 1
+  %5 = extractvalue { %S*, i32 (%S*, i32, i32)* } %4, 0
+  %6 = extractvalue { %S*, i32 (%S*, i32, i32)* } %4, 1
+  %7 = call i32 %6(%S* %5, i32 38, i32 2)
+  ret i32 %7
+}

tools/llvm-c-test/echo.cpp

if (LLVMIsAGlobalValue(Cst)) {
     exit(-1);
   }
 
   // Try literal
   if (LLVMIsAConstantInt(Cst))
     return LLVMConstInt(TypeCloner(M).Clone(Cst),
                         LLVMConstIntGetZExtValue(Cst), false);
 
+  // Try zeroinitializer
+  if (LLVMIsAConstantAggregateZero(Cst))
+    return LLVMConstNull(TypeCloner(M).Clone(Cst));
+
   // Try undef
   if (LLVMIsUndef(Cst))
     return LLVMGetUndef(TypeCloner(M).Clone(Cst));
 
   // This kind of constant is not supported.
   report_fatal_error("Unsupported contant type");
 }
 
switch(Op) {
         Dst = LLVMBuildXor(Builder, LHS, RHS, Name);
         break;
       }
       case LLVMAlloca: {
         LLVMTypeRef Ty = CloneType(LLVMGetAllocatedType(Src));
         Dst = LLVMBuildAlloca(Builder, Ty, Name);
         break;
       }
+      case LLVMLoad: {
+        LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 0));
+        Dst = LLVMBuildLoad(Builder, Ptr, Name);
+        LLVMSetAlignment(Dst, LLVMGetAlignment(Src));
+        break;
+      }
+      case LLVMStore: {
+        LLVMValueRef Val = CloneValue(LLVMGetOperand(Src, 0));
+        LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 1));
+        Dst = LLVMBuildStore(Builder, Val, Ptr);
+        LLVMSetAlignment(Dst, LLVMGetAlignment(Src));
+        break;
+      }
+      case LLVMGetElementPtr: {
+        LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 0));
+        SmallVector<LLVMValueRef, 8> Idx;
+        int NumIdx = LLVMGetNumIndices(Src);
+        for (int i = 1; i <= NumIdx; i++)
+          Idx.push_back(CloneValue(LLVMGetOperand(Src, i)));
+        if (LLVMIsInBounds(Src))
+          Dst = LLVMBuildInBoundsGEP(Builder, Ptr, Idx.data(), NumIdx, Name);
+        else
+          Dst = LLVMBuildGEP(Builder, Ptr, Idx.data(), NumIdx, Name);
+        break;
+      }
       case LLVMICmp: {
         LLVMIntPredicate Pred = LLVMGetICmpPredicate(Src);
         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
         Dst = LLVMBuildICmp(Builder, Pred, LHS, RHS, Name);
         break;
       }
       case LLVMPHI: {