Restore the capability to manipulate datalayout from the C API

[deadalnix]

Summary

This consist in variosu addition to the C API:

LLVMTargetDataRef LLVMGetModuleDataLayout(LLVMModuleRef M);
void LLVMSetModuleDataLayout(LLVMModuleRef M, LLVMTargetDataRef DL);
LLVMTargetDataRef LLVMCreateTargetMachineData(LLVMTargetMachineRef T);

This also removes LLVMAddTargetData, which does nothing and is historical cruft.

[mehdi_amini]

include/llvm-c/Target.h

191

Not clear why it isn't at the same place as LLVMGetDataLayout

194

Separate change?

195

comment seems wrong

203

split code motion in a separate patch (you may commit it and rebase this one).

include/llvm-c/TargetMachine.h

91

remove

include/llvm/IR/DataLayout.h

471

do not mix formatting change with other changes please

lib/IR/Core.cpp

166

Are you planning to deprecate this? Why a new duplicated API?

173

You can commit this change separately now.

lib/Target/TargetMachineC.cpp

177

I don't really like how we're not consistent on the naming. "Data" instead of "DataLayout" has always bothered me.
(Just mentioning, not your fault).

[mehdi_amini]

Oh, and since it is your domain: what about the tests?
Can you add a triple and a random data layout (not the default one) to the echo test?

[deadalnix]

include/llvm-c/Target.h

191

LLVMGetDataLayout really should be named LLVMGetDataLayoutStr as it maps getDataLayourStr, which is the string representation of the layout.

lib/IR/Core.cpp

166

Yes, the name is not only plain wrong but is also the name of anther method that does something else, which is confusing.

173

Got you. Will do.

lib/Target/TargetMachineC.cpp

177

Agreed. Problem is, the good names are taken here already, so I had to come up with something.

[mehdi_amini]

include/llvm-c/Target.h

191

This is a getter on the module right? I'm asking about the location in the header: why here and not in include/llvm-c/Core.h where the other getter for Module are?

lib/IR/Core.cpp

166

So mark it deprecated with a mention to use the other one. Also this sounds like a separate change to the C API (i.e. I'd say a separate review).

lib/Target/TargetMachineC.cpp

177

LLVMCreateTargetDataLayout ? LLVMCreateDataLayoutForTarget ?

[deadalnix]

include/llvm-c/Target.h

191

Yes, but LLVMTargetDataRef is not available from Core.h and making it so would be a bigger change. Also, all LLVMTargetDataRef related method are here, so I don't think this is that much of an issue.

[deadalnix]

Update as per comments

[mehdi_amini]

include/llvm-c/Target.h

191

LLVMTargetDataRef is not available from Core.h

That's a good reason :)

195

comment is still wrong?

lib/Target/TargetMachineC.cpp

177

What about one of these name? (you haven't answered so I'm not even sure you saw it)

[mehdi_amini]

I also asked earlier about adding a data layout and a triple in the "echo" test?

[deadalnix]

Fix comment
Update name

[deadalnix]

Add check in the echo C API test

[mehdi_amini]

LGTM.

bindings/go/llvm/executionengine_test.go

if err != nil {
     t.Errorf("Error creating JIT: %s", err)
     return
   }
   defer engine.Dispose()
 
   pass := NewPassManager()
   defer pass.Dispose()
 
-  pass.Add(engine.TargetData())
   pass.AddConstantPropagationPass()
   pass.AddInstructionCombiningPass()
   pass.AddPromoteMemoryToRegisterPass()
   pass.AddGVNPass()
   pass.AddCFGSimplificationPass()
   pass.Run(mod)
 
   exec_args := []GenericValue{NewGenericValueFromInt(Int32Type(), 10, false)}
   exec_res := engine.RunFunction(fac, exec_args)
   var fac10 uint64 = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1
   if exec_res.Int(false) != fac10 {
     t.Errorf("Expected %d, got %d", fac10, exec_res.Int(false))
   }
 }

bindings/go/llvm/target.go

 // See the constructor llvm::TargetData::TargetData.
 func NewTargetData(rep string) (td TargetData) {
   crep := C.CString(rep)
   defer C.free(unsafe.Pointer(crep))
   td.C = C.LLVMCreateTargetData(crep)
   return
 }
 
-// Adds target data information to a pass manager. This does not take ownership
-// of the target data.
-// See the method llvm::PassManagerBase::add.
-func (pm PassManager) Add(td TargetData) {
-  C.LLVMAddTargetData(td.C, pm.C)
-}
-
 // Converts target data to a target layout string. The string must be disposed
 // with LLVMDisposeMessage.
 // See the constructor llvm::TargetData::TargetData.
 func (td TargetData) String() (s string) {
   cmsg := C.LLVMCopyStringRepOfTargetData(td.C)
   s = C.GoString(cmsg)
   C.LLVMDisposeMessage(cmsg)
   return

include/llvm-c/Core.h

  * This must be called for every created module or memory will be
  * leaked.
  */
 void LLVMDisposeModule(LLVMModuleRef M);
 
 /**
  * Obtain the data layout for a module.
  *
- * @see Module::getDataLayout()
+ * @see Module::getDataLayoutStr()
  */
 const char *LLVMGetDataLayout(LLVMModuleRef M);
+const char *LLVMGetDataLayoutStr(LLVMModuleRef M);
 
 /**
  * Set the data layout for a module.
  *
  * @see Module::setDataLayout()
  */
-void LLVMSetDataLayout(LLVMModuleRef M, const char *Triple);
+void LLVMSetDataLayout(LLVMModuleRef M, const char *DataLayoutStr);
 
 /**
  * Obtain the target triple for a module.
  *
  * @see Module::getTargetTriple()
  */
 const char *LLVMGetTarget(LLVMModuleRef M);
 

include/llvm-c/Target.h

#ifdef LLVM_NATIVE_DISASSEMBLER
   return 0;
 #else
   return 1;
 #endif
 }
 
 /*===-- Target Data -------------------------------------------------------===*/
 
+/**
+ * Obtain the data layout for a module.
+ *
+ * @see Module::getDataLayout()
+ */
+LLVMTargetDataRef LLVMGetModuleDataLayout(LLVMModuleRef M);
+
+/**
+ * Obtain the data layout for a module.
+ *
+ * @see Module::setDataLayout()
+ */
+void LLVMSetModuleDataLayout(LLVMModuleRef M, LLVMTargetDataRef DL);
+
+/** Deallocates a TargetData.
+    See the destructor llvm::DataLayout::~DataLayout. */
+void LLVMDisposeTargetData(LLVMTargetDataRef TD);
+
 /** Creates target data from a target layout string.
     See the constructor llvm::DataLayout::DataLayout. */
 LLVMTargetDataRef LLVMCreateTargetData(const char *StringRep);
 
-/** Adds target data information to a pass manager. This does not take ownership
-    of the target data.
-    See the method llvm::PassManagerBase::add. */
-void LLVMAddTargetData(LLVMTargetDataRef TD, LLVMPassManagerRef PM);
-
 /** Adds target library information to a pass manager. This does not take
     ownership of the target library info.
     See the method llvm::PassManagerBase::add. */
 void LLVMAddTargetLibraryInfo(LLVMTargetLibraryInfoRef TLI,
                               LLVMPassManagerRef PM);
 
 /** Converts target data to a target layout string. The string must be disposed
     with LLVMDisposeMessage.

 unsigned LLVMElementAtOffset(LLVMTargetDataRef TD, LLVMTypeRef StructTy,
                              unsigned long long Offset);
 
 /** Computes the byte offset of the indexed struct element for a target.
     See the method llvm::StructLayout::getElementContainingOffset. */
 unsigned long long LLVMOffsetOfElement(LLVMTargetDataRef TD,
                                        LLVMTypeRef StructTy, unsigned Element);
 
-/** Deallocates a TargetData.
-    See the destructor llvm::DataLayout::~DataLayout. */
-void LLVMDisposeTargetData(LLVMTargetDataRef TD);
-
 /**
  * @}
  */
 
 #ifdef __cplusplus
 }
 #endif /* defined(__cplusplus) */
 
 #endif

include/llvm-c/TargetMachine.h

 
 /** Returns if the target has a TargetMachine associated */
 LLVMBool LLVMTargetHasTargetMachine(LLVMTargetRef T);
 
 /** Returns if the target as an ASM backend (required for emitting output) */
 LLVMBool LLVMTargetHasAsmBackend(LLVMTargetRef T);
 
 /*===-- Target Machine ----------------------------------------------------===*/
+
 /** Creates a new llvm::TargetMachine. See llvm::Target::createTargetMachine */
 LLVMTargetMachineRef LLVMCreateTargetMachine(LLVMTargetRef T,
   const char *Triple, const char *CPU, const char *Features,
   LLVMCodeGenOptLevel Level, LLVMRelocMode Reloc, LLVMCodeModel CodeModel);
 
 /** Dispose the LLVMTargetMachineRef instance generated by
   LLVMCreateTargetMachine. */
 void LLVMDisposeTargetMachine(LLVMTargetMachineRef T);
/** Returns the feature string used creating this target machine. See
   llvm::TargetMachine::getFeatureString. The result needs to be disposed with
   LLVMDisposeMessage. */
 char *LLVMGetTargetMachineFeatureString(LLVMTargetMachineRef T);
 
 /** Set the target machine's ASM verbosity. */
 void LLVMSetTargetMachineAsmVerbosity(LLVMTargetMachineRef T,
                                       LLVMBool VerboseAsm);
 
+/** Create a DataLayout based on the targetMachine. */
+LLVMTargetDataRef LLVMCreateTargetMachineData(LLVMTargetMachineRef T);
+
 /** Emits an asm or object file for the given module to the filename. This
   wraps several c++ only classes (among them a file stream). Returns any
   error in ErrorMessage. Use LLVMDisposeMessage to dispose the message. */
 LLVMBool LLVMTargetMachineEmitToFile(LLVMTargetMachineRef T, LLVMModuleRef M,
   char *Filename, LLVMCodeGenFileType codegen, char **ErrorMessage);
 
 /** Compile the LLVM IR stored in \p M and store the result in \p OutMemBuf. */
 LLVMBool LLVMTargetMachineEmitToMemoryBuffer(LLVMTargetMachineRef T, LLVMModuleRef M,

include/llvm/IR/DataLayout.h

public:
   /// \brief Returns the preferred alignment of the specified global, returned
   /// in log form.
   ///
   /// This includes an explicitly requested alignment (if the global has one).
   unsigned getPreferredAlignmentLog(const GlobalVariable *GV) const;
 };
 
 inline DataLayout *unwrap(LLVMTargetDataRef P) {
-  return reinterpret_cast<DataLayout *>(P);
+  return reinterpret_cast<DataLayout*>(P);
 }
 
 inline LLVMTargetDataRef wrap(const DataLayout *P) {
-  return reinterpret_cast<LLVMTargetDataRef>(const_cast<DataLayout *>(P));
+  return reinterpret_cast<LLVMTargetDataRef>(const_cast<DataLayout*>(P));
 }
 
 /// Used to lazily calculate structure layout information for a target machine,
 /// based on the DataLayout structure.
 class StructLayout {
   uint64_t StructSize;
   unsigned StructAlignment;
   bool IsPadded : 1;

lib/IR/Core.cpp

LLVMModuleRef LLVMModuleCreateWithNameInContext(const char *ModuleID,
   return wrap(new Module(ModuleID, *unwrap(C)));
 }
 
 void LLVMDisposeModule(LLVMModuleRef M) {
   delete unwrap(M);
 }
 
 /*--.. Data layout .........................................................--*/
-const char * LLVMGetDataLayout(LLVMModuleRef M) {
+
+const char *LLVMGetDataLayout(LLVMModuleRef M) {
+  return LLVMGetDataLayoutStr(M);
+}
+
+const char *LLVMGetDataLayoutStr(LLVMModuleRef M) {
   return unwrap(M)->getDataLayoutStr().c_str();
 }
 
-void LLVMSetDataLayout(LLVMModuleRef M, const char *Triple) {
-  unwrap(M)->setDataLayout(Triple);
+void LLVMSetDataLayout(LLVMModuleRef M, const char *DataLayoutStr) {
+  unwrap(M)->setDataLayout(DataLayoutStr);
 }
 
 /*--.. Target triple .......................................................--*/
 const char * LLVMGetTarget(LLVMModuleRef M) {
   return unwrap(M)->getTargetTriple().c_str();
 }
 
 void LLVMSetTarget(LLVMModuleRef M, const char *Triple) {

lib/Target/Target.cpp

void llvm::initializeTarget(PassRegistry &Registry) {
   initializeTargetLibraryInfoWrapperPassPass(Registry);
   initializeTargetTransformInfoWrapperPassPass(Registry);
 }
 
 void LLVMInitializeTarget(LLVMPassRegistryRef R) {
   initializeTarget(*unwrap(R));
 }
 
-LLVMTargetDataRef LLVMCreateTargetData(const char *StringRep) {
-  return wrap(new DataLayout(StringRep));
+LLVMTargetDataRef LLVMGetModuleDataLayout(LLVMModuleRef M) {
+  return wrap(&unwrap(M)->getDataLayout());
+}
+
+void LLVMSetModuleDataLayout(LLVMModuleRef M, LLVMTargetDataRef DL) {
+  unwrap(M)->setDataLayout(*unwrap(DL));
 }
 
-void LLVMAddTargetData(LLVMTargetDataRef TD, LLVMPassManagerRef PM) {
+LLVMTargetDataRef LLVMCreateTargetData(const char *StringRep) {
+  return wrap(new DataLayout(StringRep));
 }
 
 void LLVMAddTargetLibraryInfo(LLVMTargetLibraryInfoRef TLI,
                               LLVMPassManagerRef PM) {
   unwrap(PM)->add(new TargetLibraryInfoWrapperPass(*unwrap(TLI)));
 }
 
 char *LLVMCopyStringRepOfTargetData(LLVMTargetDataRef TD) {

lib/Target/TargetMachineC.cpp

char* LLVMGetTargetMachineFeatureString(LLVMTargetMachineRef T) {
   return strdup(StringRep.c_str());
 }
 
 void LLVMSetTargetMachineAsmVerbosity(LLVMTargetMachineRef T,
                                       LLVMBool VerboseAsm) {
   unwrap(T)->Options.MCOptions.AsmVerbose = VerboseAsm;
 }
 
+LLVMTargetDataRef LLVMCreateTargetMachineData(LLVMTargetMachineRef T) {
+  return wrap(new DataLayout(unwrap(T)->createDataLayout()));
+}
+
 static LLVMBool LLVMTargetMachineEmit(LLVMTargetMachineRef T, LLVMModuleRef M,
                                       raw_pwrite_stream &OS,
                                       LLVMCodeGenFileType codegen,
                                       char **ErrorMessage) {
   TargetMachine* TM = unwrap(T);
   Module* Mod = unwrap(M);
 
   legacy::PassManager pass;

unittests/ExecutionEngine/MCJIT/MCJITCAPITest.cpp

protected:
   void buildMCJITEngine() {
     ASSERT_EQ(
       0, LLVMCreateMCJITCompilerForModule(&Engine, Module, &Options,
                                           sizeof(Options), &Error));
   }
   
   void buildAndRunPasses() {
     LLVMPassManagerRef pass = LLVMCreatePassManager();
-    LLVMAddTargetData(LLVMGetExecutionEngineTargetData(Engine), pass);
     LLVMAddConstantPropagationPass(pass);
     LLVMAddInstructionCombiningPass(pass);
     LLVMRunPassManager(pass, Module);
     LLVMDisposePassManager(pass);
   }
   
   void buildAndRunOptPasses() {
     LLVMPassManagerBuilderRef passBuilder;
     
     passBuilder = LLVMPassManagerBuilderCreate();
     LLVMPassManagerBuilderSetOptLevel(passBuilder, 2);
     LLVMPassManagerBuilderSetSizeLevel(passBuilder, 0);
     
     LLVMPassManagerRef functionPasses =
       LLVMCreateFunctionPassManagerForModule(Module);
     LLVMPassManagerRef modulePasses =
       LLVMCreatePassManager();
     
-    LLVMAddTargetData(LLVMGetExecutionEngineTargetData(Engine), modulePasses);
-    
     LLVMPassManagerBuilderPopulateFunctionPassManager(passBuilder,
                                                       functionPasses);
     LLVMPassManagerBuilderPopulateModulePassManager(passBuilder, modulePasses);
     
     LLVMPassManagerBuilderDispose(passBuilder);
     
     LLVMInitializeFunctionPassManager(functionPasses);
     for (LLVMValueRef value = LLVMGetFirstFunction(Module);