Add a simple pass to make sure that all (non-library) calls to malloc and free

are visible to analysis as intrinsics.  That is, make sure someone doesn't pass
free around by address in some struct (as happens in say 176.gcc).

This doesn't get rid of any indirect calls, just ensure calls to free and malloc
are always direct.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@27560 91177308-0d34-0410-b5e6-96231b3b80d8

1 files changed, 92 insertions, 0 deletions

diff --git a/lib/Transforms/IPO/IndMemRemoval.cpp b/lib/Transforms/IPO/IndMemRemoval.cpp
new file mode 100644
index 0000000000..84a4307228
--- /dev/null
+++ b/lib/Transforms/IPO/IndMemRemoval.cpp
@@ -0,0 +1,92 @@
+//===-- IndMemRemoval.cpp - Remove indirect allocations and frees ----------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This pass finds places where memory allocation functions may escape into
+// indirect land.  Some transforms are much easier (aka possible) only if free 
+// or malloc are not called indirectly.
+// Thus find places where the address of memory functions are taken and construct
+// bounce functions with direct calls of those functions.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Transforms/IPO.h"
+#include "llvm/Pass.h"
+#include "llvm/Module.h"
+#include "llvm/Function.h"
+#include "llvm/Instructions.h"
+#include "llvm/Type.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/ADT/Statistic.h"
+#include <fstream>
+#include <iostream>
+#include <set>
+using namespace llvm;
+
+namespace {
+  Statistic<> NumBounceSites("indmemrem", "Number of sites modified");
+  Statistic<> NumBounce  ("indmemrem", "Number of bounce functions created");
+
+  class IndMemRemPass : public ModulePass {
+
+  public:
+    IndMemRemPass();
+    virtual bool runOnModule(Module &M);
+  };
+  RegisterOpt<IndMemRemPass> X("indmemrem", "Indirect Malloc and Free Removal");
+} // end anonymous namespace
+
+
+IndMemRemPass::IndMemRemPass()
+{
+}
+
+bool IndMemRemPass::runOnModule(Module &M) {
+  //in Theory, all direct calls of malloc and free should be promoted
+  //to intrinsics.  Therefor, this goes through and finds where the
+  //address of free or malloc are taken and replaces those with bounce
+  //functions, ensuring that all malloc and free that might happen
+  //happens through intrinsics.
+  bool changed = false;
+  if (Function* F = M.getNamedFunction("free")) {
+    assert(F->isExternal() && "free not external?");
+    if (F->getNumUses()) {
+      Function* FN = new Function(F->getFunctionType(), 
+				  GlobalValue::LinkOnceLinkage, 
+				  "free_llvm_bounce", &M);
+      BasicBlock* bb = new BasicBlock("entry",FN);
+      Instruction* R = new ReturnInst(bb);
+      new FreeInst(FN->arg_begin(), R);
+      ++NumBounce;
+      NumBounceSites += F->getNumUses();
+      F->replaceAllUsesWith(FN);
+      changed = true;
+    }
+  }
+  if (Function* F = M.getNamedFunction("malloc")) {
+    assert(F->isExternal() && "malloc not external?");
+    if (F->getNumUses()) {
+      Function* FN = new Function(F->getFunctionType(), 
+				  GlobalValue::LinkOnceLinkage, 
+				  "malloc_llvm_bounce", &M);
+      BasicBlock* bb = new BasicBlock("entry",FN);
+      Instruction* c = new CastInst(FN->arg_begin(), Type::UIntTy, "c", bb);
+      Instruction* a = new MallocInst(Type::SByteTy, c, "m", bb);
+      Instruction* R = new ReturnInst(a, bb);
+      ++NumBounce;
+      NumBounceSites += F->getNumUses();
+      F->replaceAllUsesWith(FN);
+      changed = true;
+    }
+  }
+  return changed;
+}
+
+ModulePass *llvm::createIndMemRemPass() {
+  return new IndMemRemPass();
+}