path: root/tools/bugpoint/CodeGeneratorBug.cpp

//===- CodeGeneratorBug.cpp - Debug code generation bugs ------------------===//
//
// This file implements program code generation debugging support.
//
//===----------------------------------------------------------------------===//

#include "BugDriver.h"
#include "SystemUtils.h"
#include "ListReducer.h"
#include "llvm/Constants.h"
#include "llvm/DerivedTypes.h"
#include "llvm/GlobalValue.h"
#include "llvm/iMemory.h"
#include "llvm/iTerminators.h"
#include "llvm/iOther.h"
#include "llvm/Module.h"
#include "llvm/Pass.h"
#include "llvm/Analysis/Verifier.h"
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
#include "llvm/Transforms/Utils/Cloning.h"
#include "llvm/Transforms/Utils/Linker.h"
#include "Support/Statistic.h"
#include "Support/StringExtras.h"
#include <algorithm>
#include <set>

class ReduceMisCodegenFunctions : public ListReducer<Function*> {
  BugDriver &BD;
public:
  ReduceMisCodegenFunctions(BugDriver &bd) : BD(bd) {}

  virtual TestResult doTest(std::vector<Function*> &Prefix,
                            std::vector<Function*> &Suffix) {
    if (!Prefix.empty() && TestFuncs(Prefix))
      return KeepPrefix;
    if (!Suffix.empty() && TestFuncs(Suffix))
      return KeepSuffix;
    return NoFailure;
  }
  
  bool TestFuncs(const std::vector<Function*> &CodegenTest,
                 bool KeepFiles = false);

  void DisambiguateGlobalSymbols(Module *M);
};


bool ReduceMisCodegenFunctions::TestFuncs(const std::vector<Function*> &Funcs,
                                          bool KeepFiles)
{
  DEBUG(std::cerr << "Test functions are:\n");
  for (std::vector<Function*>::const_iterator I = Funcs.begin(),E = Funcs.end();
       I != E; ++I)
    DEBUG(std::cerr << "\t" << (*I)->getName() << "\n");

  // Clone the module for the two halves of the program we want.
  Module *SafeModule = CloneModule(BD.Program);

  // Make sure functions & globals are all external so that linkage
  // between the two modules will work.
  for (Module::iterator I = SafeModule->begin(), E = SafeModule->end();I!=E;++I)
    I->setLinkage(GlobalValue::ExternalLinkage);
  for (Module::giterator I=SafeModule->gbegin(),E = SafeModule->gend();I!=E;++I)
    I->setLinkage(GlobalValue::ExternalLinkage);

  DisambiguateGlobalSymbols(SafeModule);
  Module *TestModule = CloneModule(SafeModule);

  // Make sure global initializers exist only in the safe module (CBE->.so)
  for (Module::giterator I=TestModule->gbegin(),E = TestModule->gend();I!=E;++I)
    I->setInitializer(0);  // Delete the initializer to make it external

  // Remove the Test functions from the Safe module
  for (unsigned i = 0, e = Funcs.size(); i != e; ++i) {
    Function *TNOF = SafeModule->getFunction(Funcs[i]->getName(),
                                             Funcs[i]->getFunctionType());
    assert(TNOF && "Function doesn't exist in module!");
    DeleteFunctionBody(TNOF);       // Function is now external in this module!
  }

  // Remove the Safe functions from the Test module
  for (Module::iterator I=TestModule->begin(),E=TestModule->end(); I!=E; ++I) {
    bool funcFound = false;
    for (std::vector<Function*>::const_iterator F=Funcs.begin(),Fe=Funcs.end();
         F != Fe; ++F)
      if (I->getName() == (*F)->getName()) funcFound = true;

    if (!funcFound && !(BD.isExecutingJIT() && I->getName() == "main"))
      DeleteFunctionBody(I);
  }

  // This is only applicable if we are debugging the JIT:
  // Find all external functions in the Safe modules that are actually used
  // (called or taken address of), and make them call the JIT wrapper instead
  if (BD.isExecutingJIT()) {
    // Must delete `main' from Safe module if it has it
    for (Module::iterator I=SafeModule->begin(), E=SafeModule->end();I!=E;++I)
      if (I->getName() == "main") DeleteFunctionBody(I);

    // Add an external function "getPointerToNamedFunction" that JIT provides
    // Prototype: void *getPointerToNamedFunction(const char* Name)
    std::vector<const Type*> Params;
    Params.push_back(PointerType::get(Type::SByteTy)); // std::string&
    FunctionType *resolverTy = FunctionType::get(PointerType::get(Type::VoidTy),
                                                 Params, false /* isVarArg */);
    const std::string ResolverFunctionName = "getPointerToNamedFunction";
    Function *resolverFunc = new Function(resolverTy,
                                          GlobalValue::ExternalLinkage,
                                          ResolverFunctionName,
                                          SafeModule);

    // Use the function we just added to get addresses of functions we need
    // Iterate over the global declarations in the Safe module
    for (Module::iterator F=SafeModule->begin(),E=SafeModule->end(); F!=E; ++F){
      if (F->isExternal() && F->use_begin() != F->use_end() &&
          F->getName() != ResolverFunctionName) {
        // If it has a non-zero use list,
        // 1. Add a string constant with its name to the global file
        // The correct type is `const [ NUM x sbyte ]' where NUM is length of
        // function name + 1
        const std::string &Name = F->getName();
        GlobalVariable *funcName =
          new GlobalVariable(ArrayType::get(Type::SByteTy, Name.length()+1),
                             true /* isConstant */,
                             GlobalValue::InternalLinkage,
                             ConstantArray::get(Name),
                             Name + "_name",
                             SafeModule);

        // 2. Use `GetElementPtr *funcName, 0, 0' to convert the string to an
        // sbyte* so it matches the signature of the resolver function.
        Constant *Zero = Constant::getNullValue(Type::LongTy);
        std::vector<Constant*> GEPargs;
        GEPargs.push_back(Zero);
        GEPargs.push_back(Zero);

        // 3. Replace all uses of `func' with calls to resolver by:
        // (a) Iterating through the list of uses of this function
        // (b) Insert a cast instruction in front of each use
        // (c) Replace use of old call with new call

        // Insert code at the beginning of the function

        for (Value::use_iterator i=F->use_begin(), e=F->use_end(); i!=e; ++i) {
          if (Instruction* Inst = dyn_cast<Instruction>(*i)) {
            // GetElementPtr *funcName, ulong 0, ulong 0
            Value *GEP =
              ConstantExpr::getGetElementPtr(ConstantPointerRef::get(funcName),
                                             GEPargs);
            std::vector<Value*> ResolverArgs;
            ResolverArgs.push_back(GEP);
            // call resolver(GetElementPtr...)
            CallInst *resolve = new CallInst(resolverFunc, ResolverArgs, 
                                             "resolver", Inst);
            // cast the result from the resolver to correctly-typed function
            CastInst *castResolver =
              new CastInst(resolve, PointerType::get(F->getFunctionType()),
                           "", Inst);
            // actually use the resolved function
            Inst->replaceUsesOfWith(F, castResolver);

            //BasicBlock::iterator ii(Inst);
            //ReplaceInstWithValue(Inst->getParent()->getInstList(),
            //                     ii, ResolverResult);
          }
        }
      }
    }
  }

  DEBUG(std::cerr << "Safe module:\n");
  for (Module::iterator I = SafeModule->begin(), E = SafeModule->end();I!=E;++I)
    if (!I->isExternal()) DEBUG(std::cerr << "\t" << I->getName() << "\n");
  for (Module::giterator I=SafeModule->gbegin(),E = SafeModule->gend();I!=E;++I)
    if (!I->isExternal()) DEBUG(std::cerr << "\t" << I->getName() << "\n");

  DEBUG(std::cerr << "Test module:\n");
  for (Module::iterator  I =TestModule->begin(),E = TestModule->end(); I!=E;++I)
    if (!I->isExternal()) DEBUG(std::cerr << "\t" << I->getName() << "\n");
  for (Module::giterator I=TestModule->gbegin(),E = TestModule->gend();I!=E;++I)
    if (!I->isExternal()) DEBUG(std::cerr <<