LLVM  14.0.0git
Analysis.h
Go to the documentation of this file.
1 //===- CodeGen/Analysis.h - CodeGen LLVM IR Analysis Utilities --*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file declares several CodeGen-specific LLVM IR analysis utilities.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef LLVM_CODEGEN_ANALYSIS_H
14 #define LLVM_CODEGEN_ANALYSIS_H
15 
16 #include "llvm/ADT/ArrayRef.h"
17 #include "llvm/ADT/DenseMap.h"
18 #include "llvm/ADT/SmallVector.h"
19 #include "llvm/ADT/Triple.h"
21 #include "llvm/IR/InlineAsm.h"
22 #include "llvm/IR/Instructions.h"
23 #include "llvm/Support/CodeGen.h"
24 
25 namespace llvm {
26 class GlobalValue;
27 class LLT;
28 class MachineBasicBlock;
29 class MachineFunction;
30 class TargetLoweringBase;
31 class TargetLowering;
32 class TargetMachine;
33 struct EVT;
34 
35 /// Compute the linearized index of a member in a nested
36 /// aggregate/struct/array.
37 ///
38 /// Given an LLVM IR aggregate type and a sequence of insertvalue or
39 /// extractvalue indices that identify a member, return the linearized index of
40 /// the start of the member, i.e the number of element in memory before the
41 /// sought one. This is disconnected from the number of bytes.
42 ///
43 /// \param Ty is the type indexed by \p Indices.
44 /// \param Indices is an optional pointer in the indices list to the current
45 /// index.
46 /// \param IndicesEnd is the end of the indices list.
47 /// \param CurIndex is the current index in the recursion.
48 ///
49 /// \returns \p CurIndex plus the linear index in \p Ty the indices list.
50 unsigned ComputeLinearIndex(Type *Ty,
51  const unsigned *Indices,
52  const unsigned *IndicesEnd,
53  unsigned CurIndex = 0);
54 
55 inline unsigned ComputeLinearIndex(Type *Ty,
56  ArrayRef<unsigned> Indices,
57  unsigned CurIndex = 0) {
58  return ComputeLinearIndex(Ty, Indices.begin(), Indices.end(), CurIndex);
59 }
60 
61 /// ComputeValueVTs - Given an LLVM IR type, compute a sequence of
62 /// EVTs that represent all the individual underlying
63 /// non-aggregate types that comprise it.
64 ///
65 /// If Offsets is non-null, it points to a vector to be filled in
66 /// with the in-memory offsets of each of the individual values.
67 ///
68 void ComputeValueVTs(const TargetLowering &TLI, const DataLayout &DL, Type *Ty,
69  SmallVectorImpl<EVT> &ValueVTs,
70  SmallVectorImpl<uint64_t> *Offsets = nullptr,
71  uint64_t StartingOffset = 0);
72 
73 /// Variant of ComputeValueVTs that also produces the memory VTs.
74 void ComputeValueVTs(const TargetLowering &TLI, const DataLayout &DL, Type *Ty,
75  SmallVectorImpl<EVT> &ValueVTs,
76  SmallVectorImpl<EVT> *MemVTs,
77  SmallVectorImpl<uint64_t> *Offsets = nullptr,
78  uint64_t StartingOffset = 0);
79 
80 /// computeValueLLTs - Given an LLVM IR type, compute a sequence of
81 /// LLTs that represent all the individual underlying
82 /// non-aggregate types that comprise it.
83 ///
84 /// If Offsets is non-null, it points to a vector to be filled in
85 /// with the in-memory offsets of each of the individual values.
86 ///
87 void computeValueLLTs(const DataLayout &DL, Type &Ty,
88  SmallVectorImpl<LLT> &ValueTys,
89  SmallVectorImpl<uint64_t> *Offsets = nullptr,
90  uint64_t StartingOffset = 0);
91 
92 /// ExtractTypeInfo - Returns the type info, possibly bitcast, encoded in V.
93 GlobalValue *ExtractTypeInfo(Value *V);
94 
95 /// getFCmpCondCode - Return the ISD condition code corresponding to
96 /// the given LLVM IR floating-point condition code. This includes
97 /// consideration of global floating-point math flags.
98 ///
100 
101 /// getFCmpCodeWithoutNaN - Given an ISD condition code comparing floats,
102 /// return the equivalent code if we're allowed to assume that NaNs won't occur.
104 
105 /// getICmpCondCode - Return the ISD condition code corresponding to
106 /// the given LLVM IR integer condition code.
107 ///
109 
110 /// Test if the given instruction is in a position to be optimized
111 /// with a tail-call. This roughly means that it's in a block with
112 /// a return and there's nothing that needs to be scheduled
113 /// between it and the return.
114 ///
115 /// This function only tests target-independent requirements.
116 bool isInTailCallPosition(const CallBase &Call, const TargetMachine &TM);
117 
118 /// Test if given that the input instruction is in the tail call position, if
119 /// there is an attribute mismatch between the caller and the callee that will
120 /// inhibit tail call optimizations.
121 /// \p AllowDifferingSizes is an output parameter which, if forming a tail call
122 /// is permitted, determines whether it's permitted only if the size of the
123 /// caller's and callee's return types match exactly.
124 bool attributesPermitTailCall(const Function *F, const Instruction *I,
125  const ReturnInst *Ret,
126  const TargetLoweringBase &TLI,
127  bool *AllowDifferingSizes = nullptr);
128 
129 /// Test if given that the input instruction is in the tail call position if the
130 /// return type or any attributes of the function will inhibit tail call
131 /// optimization.
132 bool returnTypeIsEligibleForTailCall(const Function *F, const Instruction *I,
133  const ReturnInst *Ret,
134  const TargetLoweringBase &TLI);
135 
136 DenseMap<const MachineBasicBlock *, int>
137 getEHScopeMembership(const MachineFunction &MF);
138 
139 } // End llvm namespace
140 
141 #endif
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::getFCmpCondCode
ISD::CondCode getFCmpCondCode(FCmpInst::Predicate Pred)
getFCmpCondCode - Return the ISD condition code corresponding to the given LLVM IR floating-point con...
Definition: Analysis.cpp:190
llvm::CmpInst::Predicate
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:720
InlineAsm.h
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
DenseMap.h
llvm::ComputeLinearIndex
unsigned ComputeLinearIndex(Type *Ty, const unsigned *Indices, const unsigned *IndicesEnd, unsigned CurIndex=0)
Compute the linearized index of a member in a nested aggregate/struct/array.
Definition: Analysis.cpp:36
llvm::MipsISD::Ret
@ Ret
Definition: MipsISelLowering.h:116
F
#define F(x, y, z)
Definition: MD5.cpp:56
llvm::ComputeValueVTs
void ComputeValueVTs(const TargetLowering &TLI, const DataLayout &DL, Type *Ty, SmallVectorImpl< EVT > &ValueVTs, SmallVectorImpl< uint64_t > *Offsets=nullptr, uint64_t StartingOffset=0)
ComputeValueVTs - Given an LLVM IR type, compute a sequence of EVTs that represent all the individual...
Definition: Analysis.cpp:124
llvm::MCID::Call
@ Call
Definition: MCInstrDesc.h:153
llvm::getICmpCondCode
ISD::CondCode getICmpCondCode(ICmpInst::Predicate Pred)
getICmpCondCode - Return the ISD condition code corresponding to the given LLVM IR integer condition ...
Definition: Analysis.cpp:227
uint64_t
llvm::ExtractTypeInfo
GlobalValue * ExtractTypeInfo(Value *V)
ExtractTypeInfo - Returns the type info, possibly bitcast, encoded in V.
Definition: Analysis.cpp:168
llvm::returnTypeIsEligibleForTailCall
bool returnTypeIsEligibleForTailCall(const Function *F, const Instruction *I, const ReturnInst *Ret, const TargetLoweringBase &TLI)
Test if given that the input instruction is in the tail call position if the return type or any attri...
Definition: Analysis.cpp:624
I
#define I(x, y, z)
Definition: MD5.cpp:59
ArrayRef.h
TemplateParamKind::Type
@ Type
llvm::ISD::CondCode
CondCode
ISD::CondCode enum - These are ordered carefully to make the bitfields below work out,...
Definition: ISDOpcodes.h:1355
llvm::attributesPermitTailCall
bool attributesPermitTailCall(const Function *F, const Instruction *I, const ReturnInst *Ret, const TargetLoweringBase &TLI, bool *AllowDifferingSizes=nullptr)
Test if given that the input instruction is in the tail call position, if there is an attribute misma...
Definition: Analysis.cpp:549
Triple.h
llvm::ArrayRef< unsigned >
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition: AArch64SLSHardening.cpp:76
llvm::computeValueLLTs
void computeValueLLTs(const DataLayout &DL, Type &Ty, SmallVectorImpl< LLT > &ValueTys, SmallVectorImpl< uint64_t > *Offsets=nullptr, uint64_t StartingOffset=0)
computeValueLLTs - Given an LLVM IR type, compute a sequence of LLTs that represent all the individua...
Definition: Analysis.cpp:132
llvm::ArrayRef::begin
iterator begin() const
Definition: ArrayRef.h:153
ISDOpcodes.h
llvm::TargetStackID::Value
Value
Definition: TargetFrameLowering.h:27
CodeGen.h
Instructions.h
SmallVector.h
llvm::isInTailCallPosition
bool isInTailCallPosition(const CallBase &Call, const TargetMachine &TM)
Test if the given instruction is in a position to be optimized with a tail-call.
Definition: Analysis.cpp:501
TM
const char LLVMTargetMachineRef TM
Definition: PassBuilderBindings.cpp:47
llvm::getEHScopeMembership
DenseMap< const MachineBasicBlock *, int > getEHScopeMembership(const MachineFunction &MF)
Definition: Analysis.cpp:738
llvm::SI::KernelInputOffsets::Offsets
Offsets
Offsets in bytes from the start of the input buffer.
Definition: SIInstrInfo.h:1263
llvm::getFCmpCodeWithoutNaN
ISD::CondCode getFCmpCodeWithoutNaN(ISD::CondCode CC)
getFCmpCodeWithoutNaN - Given an ISD condition code comparing floats, return the equivalent code if w...
Definition: Analysis.cpp:212
llvm::ArrayRef::end
iterator end() const
Definition: ArrayRef.h:154