[llvm-commits] [llvm] r47322 - in /llvm/trunk: include/llvm/LinkAllPasses.h include/llvm/Transforms/Scalar.h lib/Transforms/Scalar/LowerPacked.cpp
Chris Lattner
sabre at nondot.org
Mon Feb 18 23:39:17 PST 2008
Author: lattner
Date: Tue Feb 19 01:39:17 2008
New Revision: 47322
URL: http://llvm.org/viewvc/llvm-project?rev=47322&view=rev
Log:
remove the lower packed pass. It can never work and even the parts that
could work don't work fully. This fixes PR1705. Oh yeah, we don't have
packed types anymore either ;-)
Removed:
llvm/trunk/lib/Transforms/Scalar/LowerPacked.cpp
Modified:
llvm/trunk/include/llvm/LinkAllPasses.h
llvm/trunk/include/llvm/Transforms/Scalar.h
Modified: llvm/trunk/include/llvm/LinkAllPasses.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/LinkAllPasses.h?rev=47322&r1=47321&r2=47322&view=diff
==============================================================================
--- llvm/trunk/include/llvm/LinkAllPasses.h (original)
+++ llvm/trunk/include/llvm/LinkAllPasses.h Tue Feb 19 01:39:17 2008
@@ -84,7 +84,6 @@
(void) llvm::createLoopIndexSplitPass();
(void) llvm::createLowerAllocationsPass();
(void) llvm::createLowerInvokePass();
- (void) llvm::createLowerPackedPass();
(void) llvm::createLowerSelectPass();
(void) llvm::createLowerSetJmpPass();
(void) llvm::createLowerSwitchPass();
Modified: llvm/trunk/include/llvm/Transforms/Scalar.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Transforms/Scalar.h?rev=47322&r1=47321&r2=47322&view=diff
==============================================================================
--- llvm/trunk/include/llvm/Transforms/Scalar.h (original)
+++ llvm/trunk/include/llvm/Transforms/Scalar.h Tue Feb 19 01:39:17 2008
@@ -265,13 +265,6 @@
//===----------------------------------------------------------------------===//
//
-// LowerPacked - This pass converts VectorType operations into low-level scalar
-// operations.
-//
-FunctionPass *createLowerPackedPass();
-
-//===----------------------------------------------------------------------===//
-//
// LowerInvoke - This pass converts invoke and unwind instructions to use sjlj
// exception handling mechanisms. Note that after this pass runs the CFG is not
// entirely accurate (exceptional control flow edges are not correct anymore) so
Removed: llvm/trunk/lib/Transforms/Scalar/LowerPacked.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/LowerPacked.cpp?rev=47321&view=auto
==============================================================================
--- llvm/trunk/lib/Transforms/Scalar/LowerPacked.cpp (original)
+++ llvm/trunk/lib/Transforms/Scalar/LowerPacked.cpp (removed)
@@ -1,448 +0,0 @@
-//===- LowerPacked.cpp - Implementation of LowerPacked Transform ---------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file implements lowering vector datatypes into more primitive
-// vector datatypes, and finally to scalar operations.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/Transforms/Scalar.h"
-#include "llvm/Argument.h"
-#include "llvm/Constants.h"
-#include "llvm/DerivedTypes.h"
-#include "llvm/Function.h"
-#include "llvm/Instructions.h"
-#include "llvm/Pass.h"
-#include "llvm/Support/Compiler.h"
-#include "llvm/Support/InstVisitor.h"
-#include "llvm/Support/Streams.h"
-#include "llvm/ADT/STLExtras.h"
-#include "llvm/ADT/StringExtras.h"
-#include <algorithm>
-#include <map>
-#include <functional>
-using namespace llvm;
-
-namespace {
-
-/// This pass converts packed operators to an
-/// equivalent operations on smaller packed data, to possibly
-/// scalar operations. Currently it supports lowering
-/// to scalar operations.
-///
-/// @brief Transforms packed instructions to simpler instructions.
-///
-class VISIBILITY_HIDDEN LowerPacked
- : public FunctionPass, public InstVisitor<LowerPacked> {
-public:
- static char ID; // Pass identification, replacement for typeid
- LowerPacked() : FunctionPass((intptr_t)&ID) {}
-
- /// @brief Lowers packed operations to scalar operations.
- /// @param F The fuction to process
- virtual bool runOnFunction(Function &F);
-
- /// @brief Lowers packed load instructions.
- /// @param LI the load instruction to convert
- void visitLoadInst(LoadInst& LI);
-
- /// @brief Lowers packed store instructions.
- /// @param SI the store instruction to convert
- void visitStoreInst(StoreInst& SI);
-
- /// @brief Lowers packed binary operations.
- /// @param BO the binary operator to convert
- void visitBinaryOperator(BinaryOperator& BO);
-
- /// @brief Lowers packed icmp operations.
- /// @param IC the icmp operator to convert
- void visitICmpInst(ICmpInst& IC);
-
- /// @brief Lowers packed select instructions.
- /// @param SELI the select operator to convert
- void visitSelectInst(SelectInst& SELI);
-
- /// @brief Lowers packed extractelement instructions.
- /// @param EE the extractelement operator to convert
- void visitExtractElementInst(ExtractElementInst& EE);
-
- /// @brief Lowers packed insertelement instructions.
- /// @param IE the insertelement operator to convert
- void visitInsertElementInst(InsertElementInst& IE);
-
- /// This function asserts that the given instruction does not have
- /// vector type. Instructions with vector type should be handled by
- /// the other functions in this class.
- ///
- /// @brief Asserts if VectorType instruction is not handled elsewhere.
- /// @param I the unhandled instruction
- void visitInstruction(Instruction &I) {
- assert(!isa<VectorType>(I.getType()) &&
- "Unhandled Instruction with Packed ReturnType!");
- }
-private:
- /// @brief Retrieves lowered values for a packed value.
- /// @param val the packed value
- /// @return the lowered values
- std::vector<Value*>& getValues(Value* val);
-
- /// @brief Sets lowered values for a packed value.
- /// @param val the packed value
- /// @param values the corresponding lowered values
- void setValues(Value* val,const std::vector<Value*>& values);
-
- // Data Members
- /// @brief whether we changed the function or not
- bool Changed;
-
- /// @brief a map from old packed values to new smaller packed values
- std::map<Value*,std::vector<Value*> > packedToScalarMap;
-
- /// Instructions in the source program to get rid of
- /// after we do a pass (the old packed instructions)
- std::vector<Instruction*> instrsToRemove;
-};
-
-char LowerPacked::ID = 0;
-RegisterPass<LowerPacked>
-X("lower-packed",
- "lowers packed operations to operations on smaller packed datatypes");
-
-} // end namespace
-
-FunctionPass *llvm::createLowerPackedPass() { return new LowerPacked(); }
-
-
-// This function sets lowered values for a corresponding
-// packed value. Note, in the case of a forward reference
-// getValues(Value*) will have already been called for
-// the packed parameter. This function will then replace
-// all references in the in the function of the "dummy"
-// value the previous getValues(Value*) call
-// returned with actual references.
-void LowerPacked::setValues(Value* value,const std::vector<Value*>& values)
-{
- std::map<Value*,std::vector<Value*> >::iterator it =
- packedToScalarMap.lower_bound(value);
- if (it == packedToScalarMap.end() || it->first != value) {
- // there was not a forward reference to this element
- packedToScalarMap.insert(it,std::make_pair(value,values));
- }
- else {
- // replace forward declarations with actual definitions
- assert(it->second.size() == values.size() &&
- "Error forward refences and actual definition differ in size");
- for (unsigned i = 0, e = values.size(); i != e; ++i) {
- // replace and get rid of old forward references
- it->second[i]->replaceAllUsesWith(values[i]);
- delete it->second[i];
- it->second[i] = values[i];
- }
- }
-}
-
-// This function will examine the packed value parameter
-// and if it is a packed constant or a forward reference
-// properly create the lowered values needed. Otherwise
-// it will simply retreive values from a
-// setValues(Value*,const std::vector<Value*>&)
-// call. Failing both of these cases, it will abort
-// the program.
-std::vector<Value*>& LowerPacked::getValues(Value* value)
-{
- assert(isa<VectorType>(value->getType()) &&
- "Value must be VectorType");
-
- // reject further processing if this one has
- // already been handled
- std::map<Value*,std::vector<Value*> >::iterator it =
- packedToScalarMap.lower_bound(value);
- if (it != packedToScalarMap.end() && it->first == value) {
- return it->second;
- }
-
- if (ConstantVector* CP = dyn_cast<ConstantVector>(value)) {
- // non-zero constant case
- std::vector<Value*> results;
- results.reserve(CP->getNumOperands());
- for (unsigned i = 0, e = CP->getNumOperands(); i != e; ++i) {
- results.push_back(CP->getOperand(i));
- }
- return packedToScalarMap.insert(it,
- std::make_pair(value,results))->second;
- }
- else if (ConstantAggregateZero* CAZ =
- dyn_cast<ConstantAggregateZero>(value)) {
- // zero constant
- const VectorType* PKT = cast<VectorType>(CAZ->getType());
- std::vector<Value*> results;
- results.reserve(PKT->getNumElements());
-
- Constant* C = Constant::getNullValue(PKT->getElementType());
- for (unsigned i = 0, e = PKT->getNumElements(); i != e; ++i) {
- results.push_back(C);
- }
- return packedToScalarMap.insert(it,
- std::make_pair(value,results))->second;
- }
- else if (isa<Instruction>(value)) {
- // foward reference
- const VectorType* PKT = cast<VectorType>(value->getType());
- std::vector<Value*> results;
- results.reserve(PKT->getNumElements());
-
- for (unsigned i = 0, e = PKT->getNumElements(); i != e; ++i) {
- results.push_back(new Argument(PKT->getElementType()));
- }
- return packedToScalarMap.insert(it,
- std::make_pair(value,results))->second;
- }
- else {
- // we don't know what it is, and we are trying to retrieve
- // a value for it
- assert(false && "Unhandled VectorType value");
- abort();
- }
-}
-
-void LowerPacked::visitLoadInst(LoadInst& LI)
-{
- // Make sure what we are dealing with is a vector type
- if (const VectorType* PKT = dyn_cast<VectorType>(LI.getType())) {
- // Initialization, Idx is needed for getelementptr needed later
- Value *Idx[2];
- Idx[0] = ConstantInt::get(Type::Int32Ty, 0);
-
- // Convert this load into num elements number of loads
- std::vector<Value*> values;
- values.reserve(PKT->getNumElements());
-
- for (unsigned i = 0, e = PKT->getNumElements(); i != e; ++i) {
- // Calculate the second index we will need
- Idx[1] = ConstantInt::get(Type::Int32Ty,i);
-
- // Get the pointer
- Value* val = new GetElementPtrInst(LI.getPointerOperand(),
- Idx, array_endof(Idx),
- LI.getName() +
- ".ge." + utostr(i),
- &LI);
-
- // generate the new load and save the result in packedToScalar map
- values.push_back(new LoadInst(val, LI.getName()+"."+utostr(i),
- LI.isVolatile(), &LI));
- }
-
- setValues(&LI,values);
- Changed = true;
- instrsToRemove.push_back(&LI);
- }
-}
-
-void LowerPacked::visitBinaryOperator(BinaryOperator& BO)
-{
- // Make sure both operands are VectorTypes
- if (isa<VectorType>(BO.getOperand(0)->getType())) {
- std::vector<Value*>& op0Vals = getValues(BO.getOperand(0));
- std::vector<Value*>& op1Vals = getValues(BO.getOperand(1));
- std::vector<Value*> result;
- assert((op0Vals.size() == op1Vals.size()) &&
- "The two packed operand to scalar maps must be equal in size.");
-
- result.reserve(op0Vals.size());
-
- // generate the new binary op and save the result
- for (unsigned i = 0; i != op0Vals.size(); ++i) {
- result.push_back(BinaryOperator::create(BO.getOpcode(),
- op0Vals[i],
- op1Vals[i],
- BO.getName() +
- "." + utostr(i),
- &BO));
- }
-
- setValues(&BO,result);
- Changed = true;
- instrsToRemove.push_back(&BO);
- }
-}
-
-void LowerPacked::visitICmpInst(ICmpInst& IC)
-{
- // Make sure both operands are VectorTypes
- if (isa<VectorType>(IC.getOperand(0)->getType())) {
- std::vector<Value*>& op0Vals = getValues(IC.getOperand(0));
- std::vector<Value*>& op1Vals = getValues(IC.getOperand(1));
- std::vector<Value*> result;
- assert((op0Vals.size() == op1Vals.size()) &&
- "The two packed operand to scalar maps must be equal in size.");
-
- result.reserve(op0Vals.size());
-
- // generate the new binary op and save the result
- for (unsigned i = 0; i != op0Vals.size(); ++i) {
- result.push_back(CmpInst::create(IC.getOpcode(),
- IC.getPredicate(),
- op0Vals[i],
- op1Vals[i],
- IC.getName() +
- "." + utostr(i),
- &IC));
- }
-
- setValues(&IC,result);
- Changed = true;
- instrsToRemove.push_back(&IC);
- }
-}
-
-void LowerPacked::visitStoreInst(StoreInst& SI)
-{
- if (const VectorType* PKT =
- dyn_cast<VectorType>(SI.getOperand(0)->getType())) {
- // We will need this for getelementptr
- Value *Idx[2];
- Idx[0] = ConstantInt::get(Type::Int32Ty, 0);
-
- std::vector<Value*>& values = getValues(SI.getOperand(0));
-
- assert((values.size() == PKT->getNumElements()) &&
- "Scalar must have the same number of elements as Vector Type");
-
- for (unsigned i = 0, e = PKT->getNumElements(); i != e; ++i) {
- // Generate the indices for getelementptr
- Idx[1] = ConstantInt::get(Type::Int32Ty,i);
- Value* val = new GetElementPtrInst(SI.getPointerOperand(),
- Idx, array_endof(Idx),
- "store.ge." +
- utostr(i) + ".",
- &SI);
- new StoreInst(values[i], val, SI.isVolatile(),&SI);
- }
-
- Changed = true;
- instrsToRemove.push_back(&SI);
- }
-}
-
-void LowerPacked::visitSelectInst(SelectInst& SELI)
-{
- // Make sure both operands are VectorTypes
- if (isa<VectorType>(SELI.getType())) {
- std::vector<Value*>& op0Vals = getValues(SELI.getTrueValue());
- std::vector<Value*>& op1Vals = getValues(SELI.getFalseValue());
- std::vector<Value*> result;
-
- assert((op0Vals.size() == op1Vals.size()) &&
- "The two packed operand to scalar maps must be equal in size.");
-
- for (unsigned i = 0; i != op0Vals.size(); ++i) {
- result.push_back(new SelectInst(SELI.getCondition(),
- op0Vals[i],
- op1Vals[i],
- SELI.getName()+ "." + utostr(i),
- &SELI));
- }
-
- setValues(&SELI,result);
- Changed = true;
- instrsToRemove.push_back(&SELI);
- }
-}
-
-void LowerPacked::visitExtractElementInst(ExtractElementInst& EI)
-{
- std::vector<Value*>& op0Vals = getValues(EI.getOperand(0));
- const VectorType *PTy = cast<VectorType>(EI.getOperand(0)->getType());
- Value *op1 = EI.getOperand(1);
-
- if (ConstantInt *C = dyn_cast<ConstantInt>(op1)) {
- EI.replaceAllUsesWith(op0Vals[C->getZExtValue()]);
- } else {
- AllocaInst *alloca =
- new AllocaInst(PTy->getElementType(),
- ConstantInt::get(Type::Int32Ty, PTy->getNumElements()),
- EI.getName() + ".alloca",
- EI.getParent()->getParent()->getEntryBlock().begin());
- for (unsigned i = 0; i < PTy->getNumElements(); ++i) {
- GetElementPtrInst *GEP =
- new GetElementPtrInst(alloca, ConstantInt::get(Type::Int32Ty, i),
- "store.ge", &EI);
- new StoreInst(op0Vals[i], GEP, &EI);
- }
- GetElementPtrInst *GEP =
- new GetElementPtrInst(alloca, op1, EI.getName() + ".ge", &EI);
- LoadInst *load = new LoadInst(GEP, EI.getName() + ".load", &EI);
- EI.replaceAllUsesWith(load);
- }
-
- Changed = true;
- instrsToRemove.push_back(&EI);
-}
-
-void LowerPacked::visitInsertElementInst(InsertElementInst& IE)
-{
- std::vector<Value*>& Vals = getValues(IE.getOperand(0));
- Value *Elt = IE.getOperand(1);
- Value *Idx = IE.getOperand(2);
- std::vector<Value*> result;
- result.reserve(Vals.size());
-
- if (ConstantInt *C = dyn_cast<ConstantInt>(Idx)) {
- unsigned idxVal = C->getZExtValue();
- for (unsigned i = 0; i != Vals.size(); ++i) {
- result.push_back(i == idxVal ? Elt : Vals[i]);
- }
- } else {
- for (unsigned i = 0; i != Vals.size(); ++i) {
- ICmpInst *icmp =
- new ICmpInst(ICmpInst::ICMP_EQ, Idx,
- ConstantInt::get(Type::Int32Ty, i),
- "icmp", &IE);
- SelectInst *select =
- new SelectInst(icmp, Elt, Vals[i], "select", &IE);
- result.push_back(select);
- }
- }
-
- setValues(&IE, result);
- Changed = true;
- instrsToRemove.push_back(&IE);
-}
-
-bool LowerPacked::runOnFunction(Function& F)
-{
- // initialize
- Changed = false;
-
- // Does three passes:
- // Pass 1) Converts Packed Operations to
- // new Packed Operations on smaller
- // datatypes
- visit(F);
-
- // Pass 2) Drop all references
- std::for_each(instrsToRemove.begin(),
- instrsToRemove.end(),
- std::mem_fun(&Instruction::dropAllReferences));
-
- // Pass 3) Delete the Instructions to remove aka packed instructions
- for (std::vector<Instruction*>::iterator i = instrsToRemove.begin(),
- e = instrsToRemove.end();
- i != e; ++i) {
- (*i)->getParent()->getInstList().erase(*i);
- }
-
- // clean-up
- packedToScalarMap.clear();
- instrsToRemove.clear();
-
- return Changed;
-}
-
More information about the llvm-commits
mailing list