Rebased PNaCl localmods in LLVM to 223109

lib/Transforms/NaCl/SimplifyAllocas.cpp

+//===- SimplifyAllocas.cpp - Simplify allocas to arrays of bytes         --===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Simplify all allocas into allocas of byte arrays.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/DataLayout.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/IR/Module.h"
+#include "llvm/Transforms/NaCl.h"
+
+using namespace llvm;
+namespace {
+class SimplifyAllocas : public BasicBlockPass {
+public:
+  static char ID; // Pass identification, replacement for typeid
+  SimplifyAllocas()
+      : BasicBlockPass(ID), Initialized(false), M(nullptr), IntPtrType(nullptr),
+        Int8Type(nullptr), DL(nullptr) {
+    initializeSimplifyAllocasPass(*PassRegistry::getPassRegistry());
+  }
+
+private:
+  bool Initialized;
+  const Module *M;
+  Type *IntPtrType;
+  Type *Int8Type;
+  const DataLayout *DL;
+
+  using llvm::Pass::doInitialization;
+  bool doInitialization(Function &F) override {
+    if (!Initialized) {
+      M = F.getParent();
+      DL = M->getDataLayout();
+      IntPtrType = DL->getIntPtrType(M->getContext());
+      Int8Type = Type::getInt8Ty(M->getContext());
+      Initialized = true;
+      return true;
+    }
+    return false;
+  }
+
+  bool runOnBasicBlock(BasicBlock &BB) override {
+    bool Changed = false;
+    for (BasicBlock::iterator I = BB.getFirstInsertionPt(), E = BB.end();
+         I != E;) {
+      if (AllocaInst *Alloca = dyn_cast<AllocaInst>(I++)) {
+        Changed = true;
+        Type *ElementTy = Alloca->getType()->getPointerElementType();
+        Constant *ElementSize =
+            ConstantInt::get(IntPtrType, DL->getTypeAllocSize(ElementTy));
+        // Expand out alloca's built-in multiplication.
+        Value *MulSize;
+        if (ConstantInt *C = dyn_cast<ConstantInt>(Alloca->getArraySize())) {
+          const APInt Value =
+              C->getValue().zextOrTrunc(IntPtrType->getScalarSizeInBits());
+          MulSize = ConstantExpr::getMul(ElementSize,
+                                         ConstantInt::get(IntPtrType, Value));
+        } else {
+          Value *ArraySize = Alloca->getArraySize();
+          if (ArraySize->getType() != IntPtrType) {
+            // We assume ArraySize is always positive, and thus is unsigned.
+            assert(!isa<ConstantInt>(ArraySize) ||
+                   !cast<ConstantInt>(ArraySize)->isNegative());
+            ArraySize =
+                CastInst::CreateIntegerCast(ArraySize, IntPtrType,
+                                            /* isSigned = */ false, "", Alloca);
+          }
+          MulSize = CopyDebug(
+              BinaryOperator::Create(Instruction::Mul, ElementSize, ArraySize,
+                                     Alloca->getName() + ".alloca_mul", Alloca),
+              Alloca);
+        }
+        unsigned Alignment = Alloca->getAlignment();
+        if (Alignment == 0)
+          Alignment = DL->getPrefTypeAlignment(ElementTy);
+        AllocaInst *Tmp =
+            new AllocaInst(Int8Type, MulSize, Alignment, "", Alloca);
+        CopyDebug(Tmp, Alloca);
+        Tmp->takeName(Alloca);
+        BitCastInst *BC = new BitCastInst(Tmp, Alloca->getType(),
+                                          Tmp->getName() + ".bc", Alloca);
+        CopyDebug(BC, Alloca);
+        Alloca->replaceAllUsesWith(BC);
+        Alloca->eraseFromParent();
+      }
+    }
+    return Changed;
+  }
+};
+}
+char SimplifyAllocas::ID = 0;
+
+INITIALIZE_PASS(SimplifyAllocas, "simplify-allocas",
+                "Simplify allocas to arrays of bytes", false, false)
+
+BasicBlockPass *llvm::createSimplifyAllocasPass() {
+  return new SimplifyAllocas();
+}