/3rd_party/llvm/include/llvm/Transforms/Utils/AddrModeMatcher.h

  1//===- AddrModeMatcher.h - Addressing mode matching facility ----*- C++ -*-===//
  2//
  3//                     The LLVM Compiler Infrastructure
  4//
  5// This file is distributed under the University of Illinois Open Source
  6// License. See LICENSE.TXT for details.
  7//
  8//===----------------------------------------------------------------------===//
  9//
 10// AddressingModeMatcher - This class exposes a single public method, which is
 11// used to construct a "maximal munch" of the addressing mode for the target
 12// specified by TLI for an access to "V" with an access type of AccessTy.  This
 13// returns the addressing mode that is actually matched by value, but also
 14// returns the list of instructions involved in that addressing computation in
 15// AddrModeInsts.
 16//
 17//===----------------------------------------------------------------------===//
 18
 19#ifndef LLVM_TRANSFORMS_UTILS_ADDRMODEMATCHER_H
 20#define LLVM_TRANSFORMS_UTILS_ADDRMODEMATCHER_H
 21
 22#include "llvm/ADT/SmallVector.h"
 23#include "llvm/Target/TargetLowering.h"
 24
 25namespace llvm {
 26
 27class GlobalValue;
 28class Instruction;
 29class Value;
 30class Type;
 31class User;
 32class raw_ostream;
 33
 34/// ExtAddrMode - This is an extended version of TargetLowering::AddrMode
 35/// which holds actual Value*'s for register values.
 36struct ExtAddrMode : public TargetLowering::AddrMode {
 37  Value *BaseReg;
 38  Value *ScaledReg;
 39  ExtAddrMode() : BaseReg(0), ScaledReg(0) {}
 40  void print(raw_ostream &OS) const;
 41  void dump() const;
 42  
 43  bool operator==(const ExtAddrMode& O) const {
 44    return (BaseReg == O.BaseReg) && (ScaledReg == O.ScaledReg) &&
 45           (BaseGV == O.BaseGV) && (BaseOffs == O.BaseOffs) &&
 46           (HasBaseReg == O.HasBaseReg) && (Scale == O.Scale);
 47  }
 48};
 49
 50static inline raw_ostream &operator<<(raw_ostream &OS, const ExtAddrMode &AM) {
 51  AM.print(OS);
 52  return OS;
 53}
 54
 55class AddressingModeMatcher {
 56  SmallVectorImpl<Instruction*> &AddrModeInsts;
 57  const TargetLowering &TLI;
 58
 59  /// AccessTy/MemoryInst - This is the type for the access (e.g. double) and
 60  /// the memory instruction that we're computing this address for.
 61  Type *AccessTy;
 62  Instruction *MemoryInst;
 63  
 64  /// AddrMode - This is the addressing mode that we're building up.  This is
 65  /// part of the return value of this addressing mode matching stuff.
 66  ExtAddrMode &AddrMode;
 67  
 68  /// IgnoreProfitability - This is set to true when we should not do
 69  /// profitability checks.  When true, IsProfitableToFoldIntoAddressingMode
 70  /// always returns true.
 71  bool IgnoreProfitability;
 72  
 73  AddressingModeMatcher(SmallVectorImpl<Instruction*> &AMI,
 74                        const TargetLowering &T, Type *AT,
 75                        Instruction *MI, ExtAddrMode &AM)
 76    : AddrModeInsts(AMI), TLI(T), AccessTy(AT), MemoryInst(MI), AddrMode(AM) {
 77    IgnoreProfitability = false;
 78  }
 79public:
 80  
 81  /// Match - Find the maximal addressing mode that a load/store of V can fold,
 82  /// give an access type of AccessTy.  This returns a list of involved
 83  /// instructions in AddrModeInsts.
 84  static ExtAddrMode Match(Value *V, Type *AccessTy,
 85                           Instruction *MemoryInst,
 86                           SmallVectorImpl<Instruction*> &AddrModeInsts,
 87                           const TargetLowering &TLI) {
 88    ExtAddrMode Result;
 89
 90    bool Success = 
 91      AddressingModeMatcher(AddrModeInsts, TLI, AccessTy,
 92                            MemoryInst, Result).MatchAddr(V, 0);
 93    (void)Success; assert(Success && "Couldn't select *anything*?");
 94    return Result;
 95  }
 96private:
 97  bool MatchScaledValue(Value *ScaleReg, int64_t Scale, unsigned Depth);
 98  bool MatchAddr(Value *V, unsigned Depth);
 99  bool MatchOperationAddr(User *Operation, unsigned Opcode, unsigned Depth);
100  bool IsProfitableToFoldIntoAddressingMode(Instruction *I,
101                                            ExtAddrMode &AMBefore,
102                                            ExtAddrMode &AMAfter);
103  bool ValueAlreadyLiveAtInst(Value *Val, Value *KnownLive1, Value *KnownLive2);
104};
105
106} // End llvm namespace
107
108#endif