mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2025-01-23 02:32:11 +00:00
8383b539ff
This commit adds the infrastructure for performing bottom-up SLP vectorization (and other optimizations) on parallel computations.
The infrastructure has three potential users:
1. The loop vectorizer needs to be able to vectorize AOS data structures such as (sum += A[i] + A[i+1]).
2. The BB-vectorizer needs this infrastructure for bottom-up SLP vectorization, because bottom-up vectorization is faster to compute.
3. A loop-roller needs to be able to analyze consecutive chains and roll them into a loop, in order to reduce code size. A loop roller does not need to create vector instructions, and this infrastructure separates the chain analysis from the vectorization.
This patch also includes a simple (100 LOC) bottom up SLP vectorizer that uses the infrastructure, and can vectorize this code:
void SAXPY(int *x, int *y, int a, int i) {
x[i] = a * x[i] + y[i];
x[i+1] = a * x[i+1] + y[i+1];
x[i+2] = a * x[i+2] + y[i+2];
x[i+3] = a * x[i+3] + y[i+3];
}
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@179117 91177308-0d34-0410-b5e6-96231b3b80d8
109 lines
3.8 KiB
C++
109 lines
3.8 KiB
C++
//===- VecUtils.cpp - Vectorization Utilities -----------------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This family of classes and functions manipulate vectors and chains of
|
|
// vectors.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_TRANSFORMS_VECTORIZE_AOSVECTORIZER_H
|
|
#define LLVM_TRANSFORMS_VECTORIZE_AOSVECTORIZER_H
|
|
|
|
#include "llvm/ADT/DenseMap.h"
|
|
#include "llvm/ADT/SmallPtrSet.h"
|
|
#include "llvm/ADT/SmallSet.h"
|
|
#include "llvm/ADT/SmallVector.h"
|
|
#include "llvm/Analysis/AliasAnalysis.h"
|
|
#include <vector>
|
|
|
|
using namespace llvm;
|
|
|
|
namespace llvm {
|
|
|
|
class BasicBlock; class Instruction; class Type;
|
|
class VectorType; class StoreInst; class Value;
|
|
class ScalarEvolution; class DataLayout;
|
|
class TargetTransformInfo; class AliasAnalysis;
|
|
|
|
/// Bottom Up SLP vectorization utility class.
|
|
struct BoUpSLP {
|
|
typedef SmallVector<Value*, 8> ValueList;
|
|
typedef SmallPtrSet<Value*, 16> ValueSet;
|
|
typedef SmallVector<StoreInst*, 8> StoreList;
|
|
static const int max_cost = 1<<20;
|
|
|
|
// \brief C'tor.
|
|
BoUpSLP(BasicBlock *Bb, ScalarEvolution *Se, DataLayout *Dl,
|
|
TargetTransformInfo *Tti, AliasAnalysis *Aa);
|
|
|
|
/// \returns true if the memory operations A and B are consecutive.
|
|
bool isConsecutiveAccess(Value *A, Value *B);
|
|
|
|
/// \brief Vectorize the tree that starts with the elements in \p VL.
|
|
/// \returns the vectorized value.
|
|
Value *vectorizeTree(ValueList &VL, int VF);
|
|
|
|
/// \returns the vectorization cost of the subtree that starts at \p VL.
|
|
/// A negative number means that this is profitable.
|
|
int getTreeRollCost(ValueList &VL, unsigned Depth);
|
|
|
|
/// \brief Take the pointer operand from the Load/Store instruction.
|
|
/// \returns NULL if this is not a valid Load/Store instruction.
|
|
static Value *getPointerOperand(Value *I);
|
|
|
|
/// \brief Take the address space operand from the Load/Store instruction.
|
|
/// \returns -1 if this is not a valid Load/Store instruction.
|
|
static unsigned getAddressSpaceOperand(Value *I);
|
|
|
|
/// \brief Attempts to order and vectorize a sequence of stores. This
|
|
/// function does a quadratic scan of the given stores.
|
|
/// \returns true if the basic block was modified.
|
|
bool vectorizeStores(StoreList &Stores, int costThreshold);
|
|
|
|
/// \brief Number all of the instructions in the block.
|
|
void numberInstructions();
|
|
|
|
private:
|
|
/// \returns the scalarization cost for this type. Scalarization in this
|
|
/// context means the creation of vectors from a group of scalars.
|
|
int getScalarizationCost(Type *Ty);
|
|
|
|
/// \returns the AA location that is being access by the instruction.
|
|
AliasAnalysis::Location getLocation(Instruction *I);
|
|
|
|
/// \brief Checks if it is possible to sink an instruction from
|
|
/// \p Src to \p Dst.
|
|
/// \returns the pointer to the barrier instruction if we can't sink.
|
|
Value *isUnsafeToSink(Instruction *Src, Instruction *Dst);
|
|
|
|
/// \returns the instruction that appears last in the BB from \p VL.
|
|
/// Only consider the first \p VF elements.
|
|
Instruction *GetLastInstr(ValueList &VL, unsigned VF);
|
|
|
|
/// \returns a vector from a collection of scalars in \p VL.
|
|
Value *Scalarize(ValueList &VL, VectorType *Ty);
|
|
|
|
// Maps instructions to numbers and back.
|
|
SmallDenseMap<Value*, int> InstrIdx;
|
|
std::vector<Instruction*> InstrVec;
|
|
// A list of instructions to ignore while sinking
|
|
// memory instructions.
|
|
SmallSet<Value*, 8> MemBarrierIgnoreList;
|
|
// Analysis and block reference.
|
|
BasicBlock *BB;
|
|
ScalarEvolution *SE;
|
|
DataLayout *DL;
|
|
TargetTransformInfo *TTI;
|
|
AliasAnalysis *AA;
|
|
};
|
|
|
|
} // end of namespace
|
|
# endif //LLVM_TRANSFORMS_VECTORIZE_AOSVECTORIZER_H
|
|
|