Filter nested structs

[oota-llvm.git] / lib / Transforms / Utils / Local.cpp

diff --git a/lib/Transforms/Utils/Local.cpp b/lib/Transforms/Utils/Local.cpp
index 52973f87245a1a229c6a7aa7ed3cf9a5fdfa4770..0d852bb864725f971e4042b0c8747b86f9125c75 100644 (file)
--- a/lib/Transforms/Utils/Local.cpp
+++ b/lib/Transforms/Utils/Local.cpp
@@ -1,27 +1,43 @@
 //===-- Local.cpp - Functions to perform local transformations ------------===//
 //
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
 // This family of functions perform various local transformations to the
 // program.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Transforms/Utils/Local.h"
-#include "llvm/iTerminators.h"
-#include "llvm/iOperators.h"
-#include "llvm/ConstantHandling.h"
+#include "llvm/Constants.h"
+#include "llvm/DerivedTypes.h"
+#include "llvm/Instructions.h"
+#include "llvm/Intrinsics.h"
+#include "llvm/IntrinsicInst.h"
+#include "llvm/Analysis/ConstantFolding.h"
+#include "llvm/Target/TargetData.h"
+#include "llvm/Support/GetElementPtrTypeIterator.h"
+#include "llvm/Support/MathExtras.h"
+#include <cerrno>
+using namespace llvm;
 
 //===----------------------------------------------------------------------===//
 //  Local constant propagation...
 //
 
-// ConstantFoldInstruction - If an instruction references constants, try to fold
-// them together...
-//
-bool doConstantPropagation(BasicBlock::iterator &II) {
-  if (Constant *C = ConstantFoldInstruction(II)) {
+/// doConstantPropagation - If an instruction references constants, try to fold
+/// them together...
+///
+bool llvm::doConstantPropagation(BasicBlock::iterator &II,
+                                 const TargetData *TD) {
+  if (Constant *C = ConstantFoldInstruction(II, TD)) {
     // Replaces all of the uses of a variable with uses of the constant.
     II->replaceAllUsesWith(C);
-    
+
     // Remove the instruction from the basic block...
     II = II->getParent()->getInstList().erase(II);
     return true;
@@ -34,23 +50,23 @@ bool doConstantPropagation(BasicBlock::iterator &II) {
 // constant value, convert it into an unconditional branch to the constant
 // destination.
 //
-bool ConstantFoldTerminator(BasicBlock *BB) {
+bool llvm::ConstantFoldTerminator(BasicBlock *BB) {
   TerminatorInst *T = BB->getTerminator();
-      
+
   // Branch - See if we are conditional jumping on constant
   if (BranchInst *BI = dyn_cast<BranchInst>(T)) {
     if (BI->isUnconditional()) return false;  // Can't optimize uncond branch
     BasicBlock *Dest1 = cast<BasicBlock>(BI->getOperand(0));
     BasicBlock *Dest2 = cast<BasicBlock>(BI->getOperand(1));
 
-    if (ConstantBool *Cond = dyn_cast<ConstantBool>(BI->getCondition())) {
+    if (ConstantInt *Cond = dyn_cast<ConstantInt>(BI->getCondition())) {
       // Are we branching on constant?
       // YES.  Change to unconditional branch...
-      BasicBlock *Destination = Cond->getValue() ? Dest1 : Dest2;
-      BasicBlock *OldDest     = Cond->getValue() ? Dest2 : Dest1;
+      BasicBlock *Destination = Cond->getZExtValue() ? Dest1 : Dest2;
+      BasicBlock *OldDest     = Cond->getZExtValue() ? Dest2 : Dest1;
 
-      //cerr << "Function: " << T->getParent()->getParent() 
-      //     << "\nRemoving branch from " << T->getParent() 
+      //cerr << "Function: " << T->getParent()->getParent()
+      //     << "\nRemoving branch from " << T->getParent()
       //     << "\n\nTo: " << OldDest << endl;
 
       // Let the basic block know that we are letting go of it.  Based on this,
@@ -63,7 +79,7 @@ bool ConstantFoldTerminator(BasicBlock *BB) {
       BI->setUnconditionalDest(Destination);
       return true;
     } else if (Dest2 == Dest1) {       // Conditional branch to same location?
-      // This branch matches something like this:  
+      // This branch matches something like this:
       //     br bool %cond, label %Dest, label %Dest
       // and changes it into:  br label %Dest
 
@@ -137,8 +153,8 @@ bool ConstantFoldTerminator(BasicBlock *BB) {
     } else if (SI->getNumSuccessors() == 2) {
       // Otherwise, we can fold this switch into a conditional branch
       // instruction if it has only one non-default destination.
-      Value *Cond = new SetCondInst(Instruction::SetEQ, SI->getCondition(),
-                                    SI->getSuccessorValue(1), "cond", SI);
+      Value *Cond = new ICmpInst(ICmpInst::ICMP_EQ, SI->getCondition(),
+                                 SI->getSuccessorValue(1), "cond", SI);
       // Insert the new branch...
       new BranchInst(SI->getSuccessor(1), SI->getSuccessor(0), Cond, SI);
 
@@ -151,13 +167,24 @@ bool ConstantFoldTerminator(BasicBlock *BB) {
 }
 
 
-
 //===----------------------------------------------------------------------===//
 //  Local dead code elimination...
 //
 
-bool isInstructionTriviallyDead(Instruction *I) {
-  return I->use_empty() && !I->mayWriteToMemory() && !isa<TerminatorInst>(I);
+bool llvm::isInstructionTriviallyDead(Instruction *I) {
+  if (!I->use_empty() || isa<TerminatorInst>(I)) return false;
+
+  if (!I->mayWriteToMemory())
+    return true;
+
+  // Special case intrinsics that "may write to memory" but can be deleted when
+  // dead.
+  if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I))
+    // Safe to delete llvm.stacksave if dead.
+    if (II->getIntrinsicID() == Intrinsic::stacksave)
+      return true;
+  
+  return false;
 }
 
 // dceInstruction - Inspect the instruction at *BBI and figure out if it's
@@ -165,7 +192,7 @@ bool isInstructionTriviallyDead(Instruction *I) {
 // to point to the instruction that immediately succeeded the original
 // instruction.
 //
-bool dceInstruction(BasicBlock::iterator &BBI) {
+bool llvm::dceInstruction(BasicBlock::iterator &BBI) {
   // Look for un"used" definitions...
   if (isInstructionTriviallyDead(BBI)) {
     BBI = BBI->getParent()->getInstList().erase(BBI);   // Bye bye