Index: include/llvm-c/Core.h
===================================================================
--- include/llvm-c/Core.h
+++ include/llvm-c/Core.h
@@ -2556,6 +2556,22 @@
  */
 
 /**
+ * @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
@@ -2601,6 +2617,7 @@
 
 /**
  * Obtain the number of indices.
+ * NB: This also works on GEP.
  */
 unsigned LLVMGetNumIndices(LLVMValueRef Inst);
 
Index: lib/IR/Core.cpp
===================================================================
--- lib/IR/Core.cpp
+++ lib/IR/Core.cpp
@@ -2143,6 +2143,16 @@
   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,
@@ -2168,6 +2178,8 @@
 
 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))
Index: test/Bindings/llvm-c/memops.ll
===================================================================
--- /dev/null
+++ test/Bindings/llvm-c/memops.ll
@@ -0,0 +1,37 @@
+; 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
+}
Index: tools/llvm-c-test/echo.cpp
===================================================================
--- tools/llvm-c-test/echo.cpp
+++ tools/llvm-c-test/echo.cpp
@@ -238,6 +238,10 @@
     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));
@@ -426,6 +430,31 @@
         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));