Improve testing for the C API

[deadalnix]

Summary

This basically add an echo test case in C. The support is limited right now, but full support would just be too much to review at once.

The echo test case simply get a module as input and try to output the same exact module. This allow to check the both reading and writing API are working as expected.

I want to improve this test over time to support more and more of the API, in order to improve coverage (coverage is quite poor right now).

[chandlerc]

So, I really like this as a way to ensure we have reasonable binding coverage of IR manipulation. But I'd like to hear others' opinions.

If we're going this direction, as discussed in IRC, i'd try to come up with a nice pattern so we don't have to manually CHECK everything.

I'd also like to float the idea of writing the code for this in C++, and just restricting it to interface via the C API. I think that would make the code here a lot cleaner and simpler. We can still use extern "C" to wire it into main.c. As part of that, I'd pick a naming convention and stick to it. My preference is to use C++ and use the LLVM naming convention consistently here. We can update the rest of llvm-c-test as we go.

Finally, running clang-format over it would be nice.

[deadalnix]

Updated the test to use diff.

I'd say i wouldn't be against writting part of this in C++ . Some of the C code is really ugly, but I wanted ot have something up and running fast enough.

[deadalnix]

Ping ping ? How do we go with that ?

[deadalnix]

ping

[deadalnix]

Update to use DenseMap and make the echo thing a cpp file.

[deadalnix]

Rebase, ping ping ping ?

[deadalnix]

ping ping ping ?

[deadalnix]

Testing is good. Let's have testing.

[echristo]

Hi,

I agree with you in general, but I would like a resolution and plan forward
in the C API thread before moving forward with adding testing.

Thanks :)

-eric

[deadalnix]

Well somone need to make a judgement call. Ther are people willing to do the work already and there is need. Right now all work on the C API is suspended in limbo, that's not good.

I think this is pretty clear that people want the C API, are willing to see some part of it being modified from one version to the other granted that :

• These changes are only done when strictly necessary by change in LLVM. The ptr change for instance seems to be a reasonable reason to change it.
• Preferably, new function have different names than existing ones, as C do not mangle signature, so changing the signature of a function mid-road can cause silent breakage.

It seems clear that core devs want to move fast (and I support that direction as well) and be able to refactor in depth, so there is no 50 ways around all of this.

I don't think anyone has anythign to add the the thread at this stage, everythign has been said, doesn't it ?

[deadalnix]

Just fix a messed up comment block.

[deadalnix]

ping !

[deadalnix]

Rebase, ping ?

[deadalnix]

Rebase and ping.

[deadalnix]

rebase ping

[deadalnix]

ping ping ping ping ping ping ??!?

[deadalnix]

Rebase and remove LLVMIsGlobalValue as LLVMIsAGlobalValue already exists.

[deadalnix]

Rebase.

@echristo , how are things coming along on the C API policy side of things ? Can we move forward with this ?

[echristo]

@echristo , how are things coming along on the C API policy side of things
? Can we move forward with this ?

I sent mail to the list today. Should just be another couple of days.

Thanks!

-eric

http://reviews.llvm.org/D10725

Files:

include/llvm-c/Core.h
test/Bindings/llvm-c/echo.ll
tools/llvm-c-test/CMakeLists.txt
tools/llvm-c-test/calc.c
tools/llvm-c-test/echo.cpp
tools/llvm-c-test/llvm-c-test.h
tools/llvm-c-test/main.c
tools/llvm-c-test/metadata.c
tools/llvm-c-test/module.c

[echristo]

For the record this is a short week, so I'm going to wait until next
tuesday to commit the new policy. Thanks for the patience.

-eric

[deadalnix]

Ok now that we have a policy for C API and that D13426 is in, it is time to come back to this.

[deadalnix]

Reabse and fix conflict.

[echristo]

Seems like a good direction, I'm going to let Chandler give the final ack here.

-eric

[deadalnix]

rebase, fix conflicts

[chandlerc]

Purely stylistic stuff, only super important point is the one on the test itself.

I'm happy for Eric to finish the code style review, but I think we should get the C code here to at least be consistent with the rest of llvm-c-test, and ideally as consistent as possible with LLVM's general coding conventions.

Feel free to land whenever Eric is happy.

test/Bindings/llvm-c/echo.ll

15

The location of the TODOs seems odd to me. Maybe collect them at the top?

tools/llvm-c-test/echo.cpp

175–179

This seems a particularly awkward conditional expression... Maybe just use ifs?

286

You're relying on C99 elsewhere, please just pull ind <stdbool.h> and use normal bool syntax?

[echristo]

OK, I'll do a more detailed style review. Found a couple of things.

[deadalnix]

@chandlerc comments

[chandlerc]

tools/llvm-c-test/echo.cpp

2–13

Note that as this is now C++ code just using the C API, this header should be updated to be the normal C++ header...

287

Perhaps more relevantly, this is C++ code now, so you don't need stdbool.h or anything ,you can use all the glorious power of C++. ;]

[deadalnix]

update header, use C++'s bool

[deadalnix]

Rebase, add support to be able to do DenseMap of opaque types.

[echristo]

OK, I've started in on the inline comments. I started adding one about naming conventions on the functions, but I notice now that this just goes with the rest of the files - which is fine I guess. In the C++ code, as much as possible, do use the llvm naming/style conventions.

Thanks!

-eric

tools/llvm-c-test/calc.c

17

Commit this separately if it isn't necessary.

tools/llvm-c-test/echo.cpp

11–12

Please elaborate here on what this testing tool is doing and how it's testing things.

18–19

Shouldn't be necessary anymore?

21

Move this with the rest of the llvm includes.

26

You changed it to use a DenseMap, but I'm curious why?

77–81

This is C++ now yes?

149

Can you make the comments here more elaborate of what you're looking for here?

301–303

llvm coding style is no braces around single line blocks. (And in other places).

[deadalnix]

tools/llvm-c-test/echo.cpp

26

The default implementation require knowledge of pointer alignement. The C API pointer are opaques, so it doesn't work. The solution was suggested by @chandlerc on IRC.

77–81

Yes, but still very much C style. Do you want me to use a Vector or something alike ?

[deadalnix]

tools/llvm-c-test/calc.c

17

Core is now included in llvm-c-test.h so not needed here anymore.

[deadalnix]

• Rebase
• Use nullptr
• Braceless one line ifs
• Added comments on top to explain what this does and why.
• Change clone_instruction into clone_value as this is what it does.
• Rework various comments.

[Wallbraker]

Adding another pair of eyes to this review, spotted one thing, looks good otherwise.
(That said this is my first review of LLVM code).

include/llvm-c/Core.h

1203

This change seems completely unrelated.

[deadalnix]

include/llvm-c/Core.h

1203

Indeed, there was a typo here in the past, but it has been fixed and now this change don't make ay sense anymore, good catch.

[deadalnix]

Remove comment change

[mehdi_amini]

tools/llvm-c-test/echo.cpp

33

Comment.

45

Why not just reuse hash_value?

return hash_value(PtrVal);

[deadalnix]

tools/llvm-c-test/echo.cpp

45

I just based myself on the default implementation for DenseMapInfo, I can use that if you think this is more appropriate.

[deadalnix]

Add comment to explain why a custom DenseMapInfo is needed and use hash_value

[echristo]

Few more inline comments and can you mark the ones you've completed as Done please?

Thanks!

-eric

tools/llvm-c-test/calc.c

17

Ah, I see you're doing it in this patch. OK.

tools/llvm-c-test/echo.cpp

14

"This command uses the C API to read a module and output an exact copy of it as output. It is used to check that the resulting module matches the input to validate that the C API can read and write modules properly."

78–82

Yep :)

[deadalnix]

Use SmallVector for call argument. Did not do it for function type as the API dumps it all at once in a buffer and this doesn't map well on top of C++ .

[deadalnix]

test/Bindings/llvm-c/echo.ll

16

Done

tools/llvm-c-test/echo.cpp

22

Done

34

Done

46

Done

82

OK This is not really working for that one (The API expect to dump in a buffer, and the C++y code is worse than straight C) but I did it for call instructions.

150

I think naming the function correctly makes it clear. Also added some comment withing the function to explain what is going on.

180

Just used ifs :)

288

Used true/false and nullptr all over.

304

Removed braces around one liner.

[deadalnix]

Remove unused include

[echristo]

This is starting to shape up nicely. I've got a few more inline nits, and one generic one which is "Could you please document the functions?" Basically document what the arguments and return values are producing and used for.

Thanks!

-eric

tools/llvm-c-test/echo.cpp

83

Can you try to explain a different way? I'm not sure what you mean.

151

Then you should probably add asserts. Also, the coding convention is complete sentences for comments.

Something as simple as "Try to clone everything in the llvm::Value hierarchy." is a start on commenting the function.

219

Go ahead and remove the "add a new binding" todos as they're not relevant here.

228–230

No braces necessary for a single statement.

271

Should probably have a clone_instruction separated out from clone_value so that anything weird is handled?

284

Can you make this an error that's clear about what is going on? Ditto with the rest of them in this function, clone_bbs, etc.

335–338

Can you add a test verifying this is working to your test?

403

"iteration"

[deadalnix]

tools/llvm-c-test/echo.cpp

83

Sure. The trick part is that LLVMGetParamTypes require a buffer passed down as a pointer and will fill it all. So we need to create a buffer and fill it. Vector like API do not really lend itself to this.

[dblaikie]

tools/llvm-c-test/echo.cpp

83

It's pretty common to use std::vector when interacting with C APIs from C++ - not sure if we're picturing the same thing. This is what I'd imagine:

std::vector<LLVMTypeRef> Params(ParamCount);
LLVMGetParamTypes(Src, Params.data());
... (probably use Params directly without using ParamCount at this point)
... (skip the "if ParamCount / free" part, because it'll be cleaned up naturally)

Is there something about that that doesn't work/did you have something else in mind, etc?

[deadalnix]

tools/llvm-c-test/echo.cpp

83

Yeah I can do that, but at the end, the Vector is fed to the C API as pointer + length, so none of the feature of vector are use or are usable.

[deadalnix]

tools/llvm-c-test/echo.cpp

271

Can we defers that to a subsequent diff ? Changing this in that one will end up in rebase hell on my side as I have prepared various extension on that diff.

284

What wording would you suggest ? I have hard time coming up with something much better. This just check that when you do one step forward and one step backward, you end up where you came from.

335–338

Well if the code ever go through this codepath, that means there is a bug in the C API. I'm not sure how I can trigger it.

[deadalnix]

• Removed TODOs
• Remove braces for loop
• Fix typos

[deadalnix]

Ping !

[deadalnix]

ping ?!??!

[echristo]

This is looking pretty good. Definitely for a first start. Thanks for doing this and sticking with it.

-eric

tools/llvm-c-test/echo.cpp

272

Sure.

285

Nothing is coming to mind at the moment, we can just defer it.

336–339

I think I was just wanting a testcase with more than zero parameters when I asked.

[deadalnix]

tools/llvm-c-test/echo.cpp

336–339

I have more coming :)

include/llvm-c/Core.h

 /**
  * Replace all uses of a value with another one.
  *
  * @see llvm::Value::replaceAllUsesWith()
  */
 void LLVMReplaceAllUsesWith(LLVMValueRef OldVal, LLVMValueRef NewVal);
 
 /**
- * Determine whether the specified constant instance is constant.
+ * Determine whether the specified value instance is constant.
  */
 LLVMBool LLVMIsConstant(LLVMValueRef Val);
 
 /**
  * Determine whether a value instance is undefined.
  */
 LLVMBool LLVMIsUndef(LLVMValueRef Val);
 

test/Bindings/llvm-c/echo.ll

+; RUN: llvm-as < %s | llvm-dis > %t.orig
+; RUN: llvm-as < %s | llvm-c-test --echo > %t.echo
+; RUN: diff %t.orig %t.echo
+
+declare void @decl()
+
+; TODO: label, struct and metadata types
+define void @types() {
+  %1 = alloca half
+  %2 = alloca float
+  %3 = alloca double
+  %4 = alloca x86_fp80
+  %5 = alloca fp128
+  %6 = alloca ppc_fp128
+  %7 = alloca i7
+  %8 = alloca void (i1)*
+  %9 = alloca [3 x i22]
+  %10 = alloca i328 addrspace(5)*
+  %11 = alloca <5 x i23*>
+  %12 = alloca x86_mmx
+  ret void
+}
+
+define i32 @add(i32 %a, i32 %b) {
+  %1 = add i32 %a, %b
+  ret i32 %1
+}
+
+define i32 @call() {
+  %1 = call i32 @add(i32 23, i32 19)
+  ret i32 %1
+}

tools/llvm-c-test/CMakeLists.txt

 
 if (LLVM_COMPILER_IS_GCC_COMPATIBLE)
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=gnu99 -Wstrict-prototypes")
 endif ()
 
 add_llvm_tool(llvm-c-test
   calc.c
   disassemble.c
+  echo.cpp
   helpers.c
   include-all.c
   main.c
   module.c
   metadata.c
   object.c
   targets.c
   )
 
 if(USE_LLVM_DYLIB)
   target_link_libraries(llvm-c-test LLVM)
 endif()

tools/llvm-c-test/calc.c

 /*===-- calc.c - tool for testing libLLVM and llvm-c API ------------------===*\
 |*                                                                            *|
 |*                     The LLVM Compiler Infrastructure                       *|
 |*                                                                            *|
 |* This file is distributed under the University of Illinois Open Source      *|
 |* License. See LICENSE.TXT for details.                                      *|
 |*                                                                            *|
 |*===----------------------------------------------------------------------===*|
 |*                                                                            *|
 |* This file implements the --calc command in llvm-c-test. --calc reads lines *|
 |* from stdin, parses them as a name and an expression in reverse polish      *|
 |* notation and prints a module with a function with the expression.          *|
 |*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
 #include "llvm-c-test.h"
-#include "llvm-c/Core.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
 
 typedef LLVMValueRef (*binop_func_t)(LLVMBuilderRef, LLVMValueRef LHS,
                                      LLVMValueRef RHS, const char *Name);
 

tools/llvm-c-test/echo.cpp

+//===-- echo.cpp - tool for testing libLLVM and llvm-c API ----------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the --echo commands in llvm-c-test.
+//
+// This command use the C API to read a module and output an exact copy of it
+// as output. It used to check that the output matches the input in order to
+// validate that the C API allow to read and write modules properly.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm-c-test.h"
+#include "llvm-c/ErrorHandling.h"
+#include "llvm/ADT/DenseMap.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+using namespace llvm;
+
+// Provide DenseMapInfo for C API opaque types.
+template<typename T>
+struct CAPIDenseMap {};
+
+template<typename T>
+struct CAPIDenseMap<T*> {
+  struct CAPIDenseMapInfo {
+    static inline T* getEmptyKey() {
+      uintptr_t Val = static_cast<uintptr_t>(-1);
+      return reinterpret_cast<T*>(Val);
+    }
+    static inline T* getTombstoneKey() {
+      uintptr_t Val = static_cast<uintptr_t>(-2);
+      return reinterpret_cast<T*>(Val);
+    }
+    static unsigned getHashValue(const T *PtrVal) {
+      return (unsigned((uintptr_t)PtrVal) >> 4) ^
+             (unsigned((uintptr_t)PtrVal) >> 9);
+    }
+    static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
+  };
+
+  typedef DenseMap<T*, T*, CAPIDenseMapInfo> Map;
+};
+
+typedef CAPIDenseMap<LLVMValueRef>::Map ValueMap;
+
+static LLVMTypeRef clone_type(LLVMTypeRef Src, LLVMContextRef Ctx) {
+  LLVMTypeKind Kind = LLVMGetTypeKind(Src);
+  switch (Kind) {
+    case LLVMVoidTypeKind:
+      return LLVMVoidTypeInContext(Ctx);
+    case LLVMHalfTypeKind:
+      return LLVMHalfTypeInContext(Ctx);
+    case LLVMFloatTypeKind:
+      return LLVMFloatTypeInContext(Ctx);
+    case LLVMDoubleTypeKind:
+      return LLVMDoubleTypeInContext(Ctx);
+    case LLVMX86_FP80TypeKind:
+      return LLVMX86FP80TypeInContext(Ctx);
+    case LLVMFP128TypeKind:
+      return LLVMFP128TypeInContext(Ctx);
+    case LLVMPPC_FP128TypeKind:
+      return LLVMPPCFP128TypeInContext(Ctx);
+    case LLVMLabelTypeKind:
+      return LLVMLabelTypeInContext(Ctx);
+    case LLVMIntegerTypeKind:
+      return LLVMIntTypeInContext(Ctx, LLVMGetIntTypeWidth(Src));
+    case LLVMFunctionTypeKind: {
+      unsigned ParamCount = LLVMCountParamTypes(Src);
+      LLVMTypeRef* Params = nullptr;
+      if (ParamCount > 0) {
+        Params = (LLVMTypeRef*) malloc(ParamCount * sizeof(LLVMTypeRef));
+        LLVMGetParamTypes(Src, Params);
+        for (unsigned i = 0; i < ParamCount; i++) {
+          Params[i] = clone_type(Params[i], Ctx);
+        }
+      }
+
+      LLVMTypeRef FunTy = LLVMFunctionType(
+        clone_type(LLVMGetReturnType(Src), Ctx),
+        Params, ParamCount,
+        LLVMIsFunctionVarArg(Src)
+      );
+
+      if (ParamCount > 0)
+        free(Params);
+
+      return FunTy;
+    }
+    case LLVMStructTypeKind:
+      break;
+    case LLVMArrayTypeKind:
+      return LLVMArrayType(
+        clone_type(LLVMGetElementType(Src), Ctx),
+        LLVMGetArrayLength(Src)
+      );
+    case LLVMPointerTypeKind:
+      return LLVMPointerType(
+        clone_type(LLVMGetElementType(Src), Ctx),
+        LLVMGetPointerAddressSpace(Src)
+      );
+    case LLVMVectorTypeKind:
+      return LLVMVectorType(
+        clone_type(LLVMGetElementType(Src), Ctx),
+        LLVMGetVectorSize(Src)
+      );
+    case LLVMMetadataTypeKind:
+      break;
+    case LLVMX86_MMXTypeKind:
+      return LLVMX86MMXTypeInContext(Ctx);
+    default:
+      break;
+  }
+
+  fprintf(stderr, "%d is not a supported typekind\n", Kind);
+  exit(-1);
+}
+
+static LLVMValueRef clone_literal(LLVMValueRef Src, LLVMContextRef Ctx) {
+  LLVMTypeRef Ty = clone_type(LLVMTypeOf(Src), Ctx);
+
+  LLVMTypeKind Kind = LLVMGetTypeKind(Ty);
+  switch (Kind) {
+    case LLVMIntegerTypeKind:
+      return LLVMConstInt(Ty, LLVMConstIntGetZExtValue(Src), false);
+    default:
+      break;
+  }
+
+  fprintf(stderr, "%d is not a supported constant typekind\n", Kind);
+  exit(-1);
+}
+
+static LLVMModuleRef get_module(LLVMBuilderRef Builder) {
+  LLVMBasicBlockRef BB = LLVMGetInsertBlock(Builder);
+  LLVMValueRef Fn = LLVMGetBasicBlockParent(BB);
+  return LLVMGetGlobalParent(Fn);
+}
+
+static LLVMValueRef clone_value(LLVMValueRef Src, LLVMBuilderRef Builder, ValueMap &VMap) {
+  const char *Name = LLVMGetValueName(Src);
+
+  // First, the value may be constant.
+  if (LLVMIsAConstant(Src)) {
+    LLVMModuleRef M = get_module(Builder);
+
+    // Maybe it is a symbol
+    if (LLVMIsAGlobalValue(Src)) {
+      // Try function
+      LLVMValueRef Dst = LLVMGetNamedFunction(M, Name);
+      if (Dst != nullptr)
+        return Dst;
+
+      // Try global variable
+      Dst = LLVMGetNamedGlobal(M, Name);
+      if (Dst != nullptr)
+        return Dst;
+
+      fprintf(stderr, "Could not find @%s\n", Name);
+      exit(-1);
+    }
+
+    // Try literal
+    LLVMContextRef Ctx = LLVMGetModuleContext(M);
+    return clone_literal(Src, Ctx);
+  }
+
+  // Try undef
+  if (LLVMIsUndef(Src)) {
+    LLVMContextRef Ctx = LLVMGetModuleContext(get_module(Builder));
+    LLVMTypeRef Ty = clone_type(LLVMTypeOf(Src), Ctx);
+    return LLVMGetUndef(Ty);
+  }
+
+  // Check if this is something we already computed.
+  {
+    auto i = VMap.find(Src);
+    if (i != VMap.end())
+      return i->second;
+  }
+
+  // We tried everything, it must be an instruction
+  // that hasn't been generated already.
+  LLVMValueRef Dst = nullptr;
+
+  LLVMOpcode Op = LLVMGetInstructionOpcode(Src);
+  switch(Op) {
+    case LLVMRet: {
+      int OpCount = LLVMGetNumOperands(Src);
+      if (OpCount == 0)
+        Dst = LLVMBuildRetVoid(Builder);
+      else
+        Dst = LLVMBuildRet(Builder, clone_value(LLVMGetOperand(Src, 0),
+                                                Builder, VMap));
+      break;
+    }
+    case LLVMBr:
+    case LLVMSwitch:
+    case LLVMIndirectBr:
+    case LLVMInvoke:
+    case LLVMUnreachable:
+      break;
+    case LLVMAdd: {
+      LLVMValueRef LHS = clone_value(LLVMGetOperand(Src, 0), Builder, VMap);
+      LLVMValueRef RHS = clone_value(LLVMGetOperand(Src, 1), Builder, VMap);
+      Dst = LLVMBuildAdd(Builder, LHS, RHS, Name);
+      break;
+    }
+    case LLVMAlloca: {
+      // TODO: Add a binding for AllocaInst::getAllocatedType
+      LLVMTypeRef Ty = LLVMGetElementType(LLVMTypeOf(Src));
+      Dst = LLVMBuildAlloca(Builder, Ty, Name);
+      break;
+    }
+    case LLVMCall: {
+      // TODO: Add binding for CallInst API
+      int ArgCount = LLVMGetNumOperands(Src) - 1;
+      LLVMValueRef* Args = (LLVMValueRef*) malloc(ArgCount * sizeof(LLVMValueRef));
+      for (int i = 0; i < ArgCount; i++) {
+        Args[i] = clone_value(LLVMGetOperand(Src, i), Builder, VMap);
+      }
+
+      LLVMValueRef Fn = clone_value(LLVMGetOperand(Src, ArgCount), Builder, VMap);
+      Dst = LLVMBuildCall(Builder, Fn, Args, ArgCount, Name);
+      free(Args);
+      break;
+    }
+    default:
+      break;
+  }
+
+  if (Dst == nullptr) {
+    fprintf(stderr, "%d is not a supported opcode\n", Op);
+    exit(-1);
+  }
+
+  return VMap[Src] = Dst;
+}
+
+static LLVMBasicBlockRef clone_bb(LLVMBasicBlockRef Src, LLVMValueRef Dst, ValueMap &VMap) {
+  // TODO: Extend C API to be able to get that name.
+  LLVMBasicBlockRef BB = LLVMAppendBasicBlock(Dst, "");
+
+  LLVMValueRef First = LLVMGetFirstInstruction(Src);
+  LLVMValueRef Last = LLVMGetLastInstruction(Src);
+
+  if (First == nullptr) {
+    if (Last != nullptr) {
+      fprintf(stderr, "Has no first instruction, but last one\n");
+      exit(-1);
+    }
+
+    return BB;
+  }
+
+  LLVMContextRef Ctx = LLVMGetModuleContext(LLVMGetGlobalParent(Dst));
+  LLVMBuilderRef Builder = LLVMCreateBuilderInContext(Ctx);
+  LLVMPositionBuilderAtEnd(Builder, BB);
+
+  LLVMValueRef Cur = First;
+  LLVMValueRef Next = nullptr;
+  while(true) {
+    clone_value(Cur, Builder, VMap);
+    Next = LLVMGetNextInstruction(Cur);
+    if (Next == nullptr) {
+      if (Cur != Last) {
+        fprintf(stderr, "Final instruction does not match Last\n");
+        exit(-1);
+      }
+
+      break;
+    }
+
+    LLVMValueRef Prev = LLVMGetPreviousInstruction(Next);
+    if (Prev != Cur) {
+      fprintf(stderr, "Next.Previous instruction is not Current\n");
+      exit(-1);
+    }
+
+    Cur = Next;
+  }
+
+  LLVMDisposeBuilder(Builder);
+  return BB;
+}
+
+static void clone_bbs(LLVMValueRef Src, LLVMValueRef Dst, ValueMap &VMap) {
+  unsigned Count = LLVMCountBasicBlocks(Src);
+  if (Count == 0)
+    return;
+
+  LLVMBasicBlockRef First = LLVMGetFirstBasicBlock(Src);
+  LLVMBasicBlockRef Last = LLVMGetLastBasicBlock(Src);
+
+  LLVMBasicBlockRef Cur = First;
+  LLVMBasicBlockRef Next = nullptr;
+  while(true) {
+    clone_bb(Cur, Dst, VMap);
+    Count--;
+    Next = LLVMGetNextBasicBlock(Cur);
+    if (Next == nullptr) {
+      if (Cur != Last) {
+        fprintf(stderr, "Final basic block does not match Last\n");
+        exit(-1);
+      }
+
+      break;
+    }
+
+    LLVMBasicBlockRef Prev = LLVMGetPreviousBasicBlock(Next);
+    if (Prev != Cur) {
+      fprintf(stderr, "Next.Previous basic bloc is not Current\n");
+      exit(-1);
+    }
+
+    Cur = Next;
+  }
+
+  if (Count != 0) {
+    fprintf(stderr, "Basic block count does not match iterration\n");
+    exit(-1);
+  }
+}
+
+static ValueMap clone_params(LLVMValueRef Src, LLVMValueRef Dst) {
+  unsigned Count = LLVMCountParams(Src);
+  if (Count != LLVMCountParams(Dst)) {
+    fprintf(stderr, "Parameter count mismatch\n");
+    exit(-1);
+  }
+
+  ValueMap VMap;
+  if (Count == 0)
+    return VMap;
+
+  LLVMValueRef SrcFirst = LLVMGetFirstParam(Src);
+  LLVMValueRef DstFirst = LLVMGetFirstParam(Dst);
+  LLVMValueRef SrcLast = LLVMGetLastParam(Src);
+  LLVMValueRef DstLast = LLVMGetLastParam(Dst);
+
+  LLVMValueRef SrcCur = SrcFirst;
+  LLVMValueRef DstCur = DstFirst;
+  LLVMValueRef SrcNext = nullptr;
+  LLVMValueRef DstNext = nullptr;
+  while (true) {
+    const char *Name = LLVMGetValueName(SrcCur);
+    LLVMSetValueName(DstCur, Name);
+
+    VMap[SrcCur] = DstCur;
+
+    Count--;
+    SrcNext = LLVMGetNextParam(SrcCur);
+    DstNext = LLVMGetNextParam(DstCur);
+    if (SrcNext == nullptr && DstNext == nullptr) {
+      if (SrcCur != SrcLast) {
+        fprintf(stderr, "SrcLast param does not match End\n");
+        exit(-1);
+      }
+
+      if (DstCur != DstLast) {
+        fprintf(stderr, "DstLast param does not match End\n");
+        exit(-1);
+      }
+
+      break;
+    }
+
+    if (SrcNext == nullptr) {
+      fprintf(stderr, "SrcNext was unexpectedly null\n");
+      exit(-1);
+    }
+
+    if (DstNext == nullptr) {
+      fprintf(stderr, "DstNext was unexpectedly null\n");
+      exit(-1);
+    }
+
+    LLVMValueRef SrcPrev = LLVMGetPreviousParam(SrcNext);
+    if (SrcPrev != SrcCur) {
+      fprintf(stderr, "SrcNext.Previous param is not Current\n");
+      exit(-1);
+    }
+
+    LLVMValueRef DstPrev = LLVMGetPreviousParam(DstNext);
+    if (DstPrev != DstCur) {
+      fprintf(stderr, "DstNext.Previous param is not Current\n");
+      exit(-1);
+    }
+
+    SrcCur = SrcNext;
+    DstCur = DstNext;
+  }
+
+  if (Count != 0) {
+    fprintf(stderr, "Parameter count does not match iterration\n");
+    exit(-1);
+  }
+
+  return VMap;
+}
+
+static LLVMValueRef clone_function(LLVMValueRef Src, LLVMModuleRef Dst) {
+  const char *Name = LLVMGetValueName(Src);
+  LLVMValueRef Fun = LLVMGetNamedFunction(Dst, Name);
+  if (Fun != nullptr)
+    return Fun;
+
+  LLVMTypeRef SrcTy = LLVMTypeOf(Src);
+  LLVMTypeRef DstTy = clone_type(SrcTy, LLVMGetModuleContext(Dst));
+  LLVMTypeRef FunTy = LLVMGetElementType(DstTy);
+
+  Fun = LLVMAddFunction(Dst, Name, FunTy);
+
+  ValueMap VMap = clone_params(Src, Fun);
+  clone_bbs(Src, Fun, VMap);
+
+  return Fun;
+}
+
+static void clone_functions(LLVMModuleRef Src, LLVMModuleRef Dst) {
+  LLVMValueRef Begin = LLVMGetFirstFunction(Src);
+  LLVMValueRef End = LLVMGetLastFunction(Src);
+
+  LLVMValueRef Cur = Begin;
+  LLVMValueRef Next = nullptr;
+  while (true) {
+    clone_function(Cur, Dst);
+    Next = LLVMGetNextFunction(Cur);
+    if (Next == nullptr) {
+      if (Cur != End) {
+        fprintf(stderr, "Last function does not match End\n");
+        exit(-1);
+      }
+
+      break;
+    }
+
+    LLVMValueRef Prev = LLVMGetPreviousFunction(Next);
+    if (Prev != Cur) {
+      fprintf(stderr, "Next.Previous function is not Current\n");
+      exit(-1);
+    }
+
+    Cur = Next;
+  }
+}
+
+int echo(void) {
+  LLVMEnablePrettyStackTrace();
+
+  LLVMModuleRef Src = load_module(false, true);
+
+  LLVMContextRef Ctx = LLVMContextCreate();
+  LLVMModuleRef Dst = LLVMModuleCreateWithNameInContext("<stdin>", Ctx);
+
+  clone_functions(Src, Dst);
+  char *Str = LLVMPrintModuleToString(Dst);
+  fputs(Str, stdout);
+
+  LLVMDisposeMessage(Str);
+  LLVMDisposeModule(Dst);
+  LLVMContextDispose(Ctx);
+
+  return 0;
+}

tools/llvm-c-test/llvm-c-test.h

 /*===-- llvm-c-test.h - tool for testing libLLVM and llvm-c API -----------===*\
 |*                                                                            *|
 |*                     The LLVM Compiler Infrastructure                       *|
 |*                                                                            *|
 |* This file is distributed under the University of Illinois Open Source      *|
 |* License. See LICENSE.TXT for details.                                      *|
 |*                                                                            *|
 |*===----------------------------------------------------------------------===*|
 |*                                                                            *|
 |* Header file for llvm-c-test                                                *|
 |*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 #ifndef LLVM_C_TEST_H
 #define LLVM_C_TEST_H
 
 #include <stdbool.h>
+#include "llvm-c/Core.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 // helpers.c
 void tokenize_stdin(void (*cb)(char **tokens, int ntokens));
 
 // module.c
+LLVMModuleRef load_module(bool Lazy, bool New);
 int module_dump(bool Lazy, bool New);
 int module_list_functions(void);
 int module_list_globals(void);
 
 // calc.c
 int calc(void);
 
 // disassemble.c
 int disassemble(void);
 
 // metadata.c
 int add_named_metadata_operand(void);
 int set_metadata(void);
 
 // object.c
 int object_list_sections(void);
 int object_list_symbols(void);
 
 // targets.c
 int targets_list(void);
 
+// echo.c
+int echo(void);
+
+#ifdef __cplusplus
+}
+#endif /* !defined(__cplusplus) */
+
 #endif

tools/llvm-c-test/main.c

 /*===-- main.c - tool for testing libLLVM and llvm-c API ------------------===*\
 |*                                                                            *|
 |*                     The LLVM Compiler Infrastructure                       *|
 |*                                                                            *|
 |* This file is distributed under the University of Illinois Open Source      *|
 |* License. See LICENSE.TXT for details.                                      *|
 |*                                                                            *|
 |*===----------------------------------------------------------------------===*|
 |*                                                                            *|
 |* Main file for llvm-c-tests. "Parses" arguments and dispatches.             *|
 |*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
 #include "llvm-c-test.h"
 #include "llvm-c/BitReader.h"
-#include "llvm-c/Core.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 static void print_usage(void) {
   fprintf(stderr, "llvm-c-test command\n\n");
   fprintf(stderr, " Commands:\n");
   fprintf(stderr, "  * --module-dump\n");
static void print_usage(void) {
   fprintf(stderr, "    Read object file form stdin - list sections\n\n");
   fprintf(stderr, "  * --object-list-symbols\n");
   fprintf(stderr,
           "    Read object file form stdin - list symbols (like nm)\n\n");
   fprintf(stderr, "  * --disassemble\n");
   fprintf(stderr, "    Read lines of triple, hex ascii machine code from stdin "
                   "- print disassembly\n\n");
   fprintf(stderr, "  * --calc\n");
+  fprintf(stderr, "  * --echo\n");
+  fprintf(stderr,
+          "    Read object file form stdin - and print it back out\n\n");
   fprintf(
       stderr,
       "    Read lines of name, rpn from stdin - print generated module\n\n");
 }
 
 int main(int argc, char **argv) {
   LLVMPassRegistryRef pr = LLVMGetGlobalPassRegistry();
 
int main(int argc, char **argv) {
   } else if (argc == 2 && !strcmp(argv[1], "--disassemble")) {
     return disassemble();
   } else if (argc == 2 && !strcmp(argv[1], "--calc")) {
     return calc();
   } else if (argc == 2 && !strcmp(argv[1], "--add-named-metadata-operand")) {
     return add_named_metadata_operand();
   } else if (argc == 2 && !strcmp(argv[1], "--set-metadata")) {
     return set_metadata();
+  } else if (argc == 2 && !strcmp(argv[1], "--echo")) {
+    return echo();
   } else {
     print_usage();
   }
 
   return 1;
 }

tools/llvm-c-test/metadata.c

 /*===-- object.c - tool for testing libLLVM and llvm-c API ----------------===*\
 |*                                                                            *|
 |*                     The LLVM Compiler Infrastructure                       *|
 |*                                                                            *|
 |* This file is distributed under the University of Illinois Open Source      *|
 |* License. See LICENSE.TXT for details.                                      *|
 |*                                                                            *|
 |*===----------------------------------------------------------------------===*|
 |*                                                                            *|
 |* This file implements the --add-named-metadata-operand and --set-metadata   *|
 |* commands in llvm-c-test.                                                   *|
 |*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
 #include "llvm-c-test.h"
-#include "llvm-c/Core.h"
 
 int add_named_metadata_operand(void) {
   LLVMModuleRef m = LLVMModuleCreateWithName("Mod");
   LLVMValueRef values[] = { LLVMConstInt(LLVMInt32Type(), 0, 0) };
 
   // This used to trigger an assertion
   LLVMAddNamedMetadataOperand(m, "name", LLVMMDNode(values, 1));
 

tools/llvm-c-test/module.c

 /*===-- module.c - tool for testing libLLVM and llvm-c API ----------------===*\
 |*                                                                            *|
 |*                     The LLVM Compiler Infrastructure                       *|
 |*                                                                            *|
 |* This file is distributed under the University of Illinois Open Source      *|
 |* License. See LICENSE.TXT for details.                                      *|
 |*                                                                            *|
 |*===----------------------------------------------------------------------===*|
 |*                                                                            *|
 |* This file implements the --module-dump, --module-list-functions and        *|
 |* --module-list-globals commands in llvm-c-test.                             *|
 |*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
 #include "llvm-c-test.h"
 #include "llvm-c/BitReader.h"
-#include "llvm-c/Core.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 static void diagnosticHandler(LLVMDiagnosticInfoRef DI, void *C) {
   char *CErr = LLVMGetDiagInfoDescription(DI);
   fprintf(stderr, "Error with new bitcode parser: %s\n", CErr);
   LLVMDisposeMessage(CErr);
   exit(1);
 }
 
-static LLVMModuleRef load_module(bool Lazy, bool New) {
+LLVMModuleRef load_module(bool Lazy, bool New) {
   LLVMMemoryBufferRef MB;
   LLVMModuleRef M;
   char *msg = NULL;
 
   if (LLVMCreateMemoryBufferWithSTDIN(&MB, &msg)) {
     fprintf(stderr, "Error reading file: %s\n", msg);
     exit(1);
   }

tools/llvm-c-test/object.c

 /*===-- object.c - tool for testing libLLVM and llvm-c API ----------------===*\
 |*                                                                            *|
 |*                     The LLVM Compiler Infrastructure                       *|
 |*                                                                            *|
 |* This file is distributed under the University of Illinois Open Source      *|
 |* License. See LICENSE.TXT for details.                                      *|
 |*                                                                            *|
 |*===----------------------------------------------------------------------===*|
 |*                                                                            *|
 |* This file implements the --object-list-sections and --object-list-symbols  *|
 |* commands in llvm-c-test.                                                   *|
 |*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
 #include "llvm-c-test.h"
-#include "llvm-c/Core.h"
 #include "llvm-c/Object.h"
 #include <stdio.h>
 #include <stdlib.h>
 
 int object_list_sections(void) {
   LLVMMemoryBufferRef MB;
   LLVMObjectFileRef O;
   LLVMSectionIteratorRef sect;