This is an archive of the discontinued LLVM Phabricator instance.

Differential D133089

[LLVM] Replace `dyn_cast_or_null` with `dyn_cast_if_present`, NFC.
AbandonedPublic

Authored by bzcheeseman on Aug 31 2022, 9:29 PM.

Details

Reviewers
deadalnix
jdoerfert
sstefan1
zuban32
lattner
Summary

dyn_cast_if_present is simply the new version of dyn_cast_or_null - indeed dyn_cast_or_null calls dyn_cast_if_present. The if_present suffix more closely represents the capabilities of the function now, as it can correctly handle optionals and things that are not "null".

Diff Detail

Event Timeline

bzcheeseman created this revision.Aug 31 2022, 9:29 PM
Herald added a reviewer: deadalnix. · View Herald TranscriptAug 31 2022, 9:29 PM
Herald added a reviewer: ributzka. · View Herald Transcript
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: Enna1, kosarev, jeroen.dobbelaere and 45 others. · View Herald Transcript
bzcheeseman requested review of this revision.Aug 31 2022, 9:29 PM
Herald added a reviewer: jdoerfert. · View Herald TranscriptAug 31 2022, 9:29 PM
Herald added a reviewer: sstefan1. · View Herald Transcript
Herald added a reviewer: zuban32. · View Herald Transcript
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: llvm-commits, • pcwang-thead, vkmr, MaskRay. · View Herald Transcript
bzcheeseman added a child revision: D133090: [LLVM] Replace `cast_or_null` with `cast_if_present`, NFC..Aug 31 2022, 9:29 PM
bzcheeseman added a reviewer: lattner.Aug 31 2022, 9:29 PM
Harbormaster completed remote builds in B184508: Diff 457169.Aug 31 2022, 10:18 PM
nikic added a subscriber: nikic.Sep 1 2022, 12:29 AM

While the new name represents the capabilities better, the way these functions are used in LLVM, we are actually working with null values. I find the original names (both here and in D133090) substantially clearer. I don't think we should do this rename.

bzcheeseman added a comment.EditedSep 1 2022, 7:44 AM

It's also worth noting that the _or_null variants are soft-deprecated (see comments on _or_null) and this is in preparation for actually marking them deprecated. IMO, we want one way to do the "if this value exists, do the dyn_cast/cast" and the if_present naming can apply equally well to pointers and optionals.

bzcheeseman updated this revision to Diff 457273.Sep 1 2022, 7:49 AM
ChuanqiXu added a comment.Sep 1 2022, 7:52 AM

I think it'd better to discuss such topics in https://discourse.llvm.org/ to involve more people in (Although there are many developers got subscribed : )

bzcheeseman added a comment.Sep 1 2022, 8:19 AM

Discourse thread here for folks that want to discuss more long-form: https://discourse.llvm.org/t/psa-swapping-out-or-null-with-if-present/65018

Harbormaster completed remote builds in B184581: Diff 457273.Sep 1 2022, 8:51 AM
ributzka removed a reviewer: ributzka.Oct 5 2022, 2:55 PM
nhaehnle removed a subscriber: nhaehnle.Oct 6 2022, 2:46 AM
bzcheeseman abandoned this revision.Oct 14 2022, 8:38 AM

No consensus, closing this.

Revision Contents

PathSize
llvm/
bindings/
go/
llvm/
2 lines
docs/
4 lines
include/
llvm-c/
2 lines
llvm/
Analysis/
7 lines
CodeGen/
GlobalISel/
2 lines
IR/
20 lines
2 lines
16 lines
17 lines
2 lines
ProfileData/
2 lines
lib/
Analysis/
2 lines
28 lines
2 lines
20 lines
2 lines
7 lines
6 lines
2 lines
7 lines
4 lines
4 lines
10 lines
9 lines
2 lines
5 lines
10 lines
12 lines
AsmParser/
6 lines
Bitcode/
Reader/
33 lines
31 lines
CodeGen/
AsmPrinter/
4 lines
18 lines
20 lines
10 lines
GlobalISel/
2 lines
2 lines
2 lines
2 lines
MIRParser/
4 lines
6 lines
2 lines
SelectionDAG/
10 lines
7 lines
2 lines
6 lines
4 lines
4 lines
4 lines
DebugInfo/
DWARF/
6 lines
PDB/
9 lines
3 lines
Symbolize/
3 lines
ExecutionEngine/
Orc/
31 lines
IR/
18 lines
16 lines
2 lines
2 lines
20 lines
10 lines
4 lines
10 lines
2 lines
14 lines
3 lines
6 lines
22 lines
8 lines
12 lines
2 lines
2 lines
7 lines
36 lines
LTO/
2 lines
Linker/
4 lines
MC/
6 lines
MCParser/
3 lines
2 lines
2 lines
ObjectYAML/
6 lines
ProfileData/
3 lines
Support/
6 lines
TableGen/
5 lines
24 lines
4 lines
Target/
AArch64/
4 lines
6 lines
AsmParser/
4 lines
AMDGPU/
37 lines
8 lines
2 lines
4 lines
2 lines
ARM/
4 lines
2 lines
AsmParser/
4 lines
MCTargetDesc/
5 lines
BPF/
2 lines
5 lines
DirectX/
2 lines
Hexagon/
2 lines
4 lines
2 lines
LoongArch/
2 lines
M68k/
2 lines
2 lines
Mips/
12 lines
PowerPC/
2 lines
2 lines
2 lines
3 lines
2 lines
3 lines
RISCV/
MCTargetDesc/
5 lines
2 lines
8 lines
2 lines
SPIRV/
2 lines
SystemZ/
2 lines
X86/
MCTargetDesc/
4 lines
3 lines
9 lines
2 lines
38 lines
2 lines
2 lines
Transforms/
Coroutines/
6 lines
2 lines
IPO/
2 lines
14 lines
12 lines
2 lines
4 lines
4 lines
2 lines
2 lines
2 lines
2 lines
8 lines
InstCombine/
5 lines
2 lines
4 lines
6 lines
2 lines
2 lines
Instrumentation/
2 lines
2 lines
4 lines
2 lines
4 lines
ObjCARC/
2 lines
2 lines
6 lines
Scalar/
2 lines
2 lines
6 lines
2 lines
2 lines
2 lines
16 lines
2 lines
8 lines
4 lines
15 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
Utils/
4 lines
4 lines
4 lines
6 lines
6 lines
2 lines
10 lines
6 lines
2 lines
2 lines
2 lines
10 lines
7 lines
2 lines
2 lines
Vectorize/
2 lines
13 lines
8 lines
6 lines
9 lines
14 lines
8 lines
4 lines
unittests/
Analysis/
33 lines
6 lines
2 lines
CodeGen/
24 lines
3 lines
Frontend/
15 lines
IR/
2 lines
7 lines
Transforms/
Utils/
10 lines
utils/
TableGen/
6 lines
2 lines
2 lines
4 lines
6 lines

Diff 457273

llvm/bindings/go/llvm/ir.go

Show First 20 Lines • Show All 717 Lines • ▼ Show 20 Linesfunc (v Value) Metadata(kind int) (rv Value) {
return return
} }
func (v Value) SetMetadata(kind int, node Metadata) { func (v Value) SetMetadata(kind int, node Metadata) {
C.LLVMSetMetadata2(v.C, C.unsigned(kind), node.C) C.LLVMSetMetadata2(v.C, C.unsigned(kind), node.C)
} }
// Conversion functions. // Conversion functions.
// Return the input value if it is an instance of the specified class, otherwise NULL. // Return the input value if it is an instance of the specified class, otherwise NULL.
// See llvm::dyn_cast_or_null<>. // See llvm::dyn_cast_if_present<>.
func (v Value) IsAArgument() (rv Value) { rv.C = C.LLVMIsAArgument(v.C); return } func (v Value) IsAArgument() (rv Value) { rv.C = C.LLVMIsAArgument(v.C); return }
func (v Value) IsABasicBlock() (rv Value) { rv.C = C.LLVMIsABasicBlock(v.C); return } func (v Value) IsABasicBlock() (rv Value) { rv.C = C.LLVMIsABasicBlock(v.C); return }
func (v Value) IsAInlineAsm() (rv Value) { rv.C = C.LLVMIsAInlineAsm(v.C); return } func (v Value) IsAInlineAsm() (rv Value) { rv.C = C.LLVMIsAInlineAsm(v.C); return }
func (v Value) IsAUser() (rv Value) { rv.C = C.LLVMIsAUser(v.C); return } func (v Value) IsAUser() (rv Value) { rv.C = C.LLVMIsAUser(v.C); return }
func (v Value) IsAConstant() (rv Value) { rv.C = C.LLVMIsAConstant(v.C); return } func (v Value) IsAConstant() (rv Value) { rv.C = C.LLVMIsAConstant(v.C); return }
func (v Value) IsAConstantAggregateZero() (rv Value) { func (v Value) IsAConstantAggregateZero() (rv Value) {
rv.C = C.LLVMIsAConstantAggregateZero(v.C) rv.C = C.LLVMIsAConstantAggregateZero(v.C)
return return
▲ Show 20 Lines • Show All 1,248 Lines • Show Last 20 Lines

llvm/docs/ProgrammersManual.rst

Show First 20 Lines • Show All 170 Lines • ▼ Show 20 Lines``isa_and_nonnull<>``:
null checks into one. null checks into one.
``cast_or_null<>``: ``cast_or_null<>``:
The ``cast_or_null<>`` operator works just like the ``cast<>`` operator, The ``cast_or_null<>`` operator works just like the ``cast<>`` operator,
except that it allows for a null pointer as an argument (which it then except that it allows for a null pointer as an argument (which it then
propagates). This can sometimes be useful, allowing you to combine several propagates). This can sometimes be useful, allowing you to combine several
null checks into one. null checks into one.
``dyn_cast_or_null<>``: ``dyn_cast_if_present<>``:
The ``dyn_cast_or_null<>`` operator works just like the ``dyn_cast<>`` The ``dyn_cast_if_present<>`` operator works just like the ``dyn_cast<>``
operator, except that it allows for a null pointer as an argument (which it operator, except that it allows for a null pointer as an argument (which it
then propagates). This can sometimes be useful, allowing you to combine then propagates). This can sometimes be useful, allowing you to combine
several null checks into one. several null checks into one.
These five templates can be used with any classes, whether they have a v-table These five templates can be used with any classes, whether they have a v-table
or not. If you want to add support for these templates, see the document or not. If you want to add support for these templates, see the document
:doc:`How to set up LLVM-style RTTI for your class hierarchy :doc:`How to set up LLVM-style RTTI for your class hierarchy
<HowToSetUpLLVMStyleRTTI>` <HowToSetUpLLVMStyleRTTI>`
▲ Show 20 Lines • Show All 3,897 Lines • Show Last 20 Lines

llvm/include/llvm-c/Core.h

Show First 20 Lines • Show All 1,758 Lines • ▼ Show 20 Lines
* Convert value instances between types. * Convert value instances between types.
* *
* Internally, an LLVMValueRef is "pinned" to a specific type. This * Internally, an LLVMValueRef is "pinned" to a specific type. This
* series of functions allows you to cast an instance to a specific * series of functions allows you to cast an instance to a specific
* type. * type.
* *
* If the cast is not valid for the specified type, NULL is returned. * If the cast is not valid for the specified type, NULL is returned.
* *
* @see llvm::dyn_cast_or_null<> * @see llvm::dyn_cast_if_present<>
*/ */
#define LLVM_DECLARE_VALUE_CAST(name) \ #define LLVM_DECLARE_VALUE_CAST(name) \
LLVMValueRef LLVMIsA##name(LLVMValueRef Val); LLVMValueRef LLVMIsA##name(LLVMValueRef Val);
LLVM_FOR_EACH_VALUE_SUBCLASS(LLVM_DECLARE_VALUE_CAST) LLVM_FOR_EACH_VALUE_SUBCLASS(LLVM_DECLARE_VALUE_CAST)
LLVMValueRef LLVMIsAMDNode(LLVMValueRef Val); LLVMValueRef LLVMIsAMDNode(LLVMValueRef Val);
LLVMValueRef LLVMIsAMDString(LLVMValueRef Val); LLVMValueRef LLVMIsAMDString(LLVMValueRef Val);
▲ Show 20 Lines • Show All 2,490 Lines • Show Last 20 Lines

llvm/include/llvm/Analysis/SparsePropagation.h

Show First 20 Lines • Show All 312 Lines • ▼ Show 20 Lines if (BCValue == LatticeFunc->getOverdefinedVal() ||
return; return;
} }
// If undefined, neither is feasible yet. // If undefined, neither is feasible yet.
if (BCValue == LatticeFunc->getUndefVal()) if (BCValue == LatticeFunc->getUndefVal())
return; return;
Constant *C = Constant *C =
dyn_cast_or_null<Constant>(LatticeFunc->GetValueFromLatticeVal( dyn_cast_if_present<Constant>(LatticeFunc->GetValueFromLatticeVal(
std::move(BCValue), BI->getCondition()->getType())); std::move(BCValue), BI->getCondition()->getType()));
if (!C || !isa<ConstantInt>(C)) { if (!C || !isa<ConstantInt>(C)) {
// Non-constant values can go either way. // Non-constant values can go either way.
Succs[0] = Succs[1] = true; Succs[0] = Succs[1] = true;
return; return;
} }
// Constant condition variables mean the branch can only go a single way // Constant condition variables mean the branch can only go a single way
Show All 21 Lines if (SCValue == LatticeFunc->getOverdefinedVal() ||
Succs.assign(TI.getNumSuccessors(), true); Succs.assign(TI.getNumSuccessors(), true);
return; return;
} }
// If undefined, neither is feasible yet. // If undefined, neither is feasible yet.
if (SCValue == LatticeFunc->getUndefVal()) if (SCValue == LatticeFunc->getUndefVal())
return; return;
Constant *C = dyn_cast_or_null<Constant>(LatticeFunc->GetValueFromLatticeVal( Constant *C =
dyn_cast_if_present<Constant>(LatticeFunc->GetValueFromLatticeVal(
std::move(SCValue), SI.getCondition()->getType())); std::move(SCValue), SI.getCondition()->getType()));
if (!C || !isa<ConstantInt>(C)) { if (!C || !isa<ConstantInt>(C)) {
// All destinations are executable! // All destinations are executable!
Succs.assign(TI.getNumSuccessors(), true); Succs.assign(TI.getNumSuccessors(), true);
return; return;
} }
SwitchInst::CaseHandle Case = *SI.findCaseValue(cast<ConstantInt>(C)); SwitchInst::CaseHandle Case = *SI.findCaseValue(cast<ConstantInt>(C));
Succs[Case.getSuccessorIndex()] = true; Succs[Case.getSuccessorIndex()] = true;
} }
▲ Show 20 Lines • Show All 158 Lines • Show Last 20 Lines

llvm/include/llvm/CodeGen/GlobalISel/Utils.h

Show First 20 Lines • Show All 244 Lines • ▼ Show 20 Lines
// Templated variant of getOpcodeDef returning a MachineInstr derived T. // Templated variant of getOpcodeDef returning a MachineInstr derived T.
/// See if Reg is defined by an single def instruction of type T /// See if Reg is defined by an single def instruction of type T
/// Also try to do trivial folding if it's a COPY with /// Also try to do trivial folding if it's a COPY with
/// same types. Returns null otherwise. /// same types. Returns null otherwise.
template <class T> template <class T>
T *getOpcodeDef(Register Reg, const MachineRegisterInfo &MRI) { T *getOpcodeDef(Register Reg, const MachineRegisterInfo &MRI) {
MachineInstr *DefMI = getDefIgnoringCopies(Reg, MRI); MachineInstr *DefMI = getDefIgnoringCopies(Reg, MRI);
return dyn_cast_or_null<T>(DefMI); return dyn_cast_if_present<T>(DefMI);
} }
/// Returns an APFloat from Val converted to the appropriate size. /// Returns an APFloat from Val converted to the appropriate size.
APFloat getAPFloatFromSize(double Val, unsigned Size); APFloat getAPFloatFromSize(double Val, unsigned Size);
/// Modify analysis usage so it preserves passes required for the SelectionDAG /// Modify analysis usage so it preserves passes required for the SelectionDAG
/// fallback. /// fallback.
void getSelectionDAGFallbackAnalysisUsage(AnalysisUsage &AU); void getSelectionDAGFallbackAnalysisUsage(AnalysisUsage &AU);
▲ Show 20 Lines • Show All 253 Lines • Show Last 20 Lines

llvm/include/llvm/IR/DebugInfoMetadata.h

Show First 20 Lines • Show All 1,012 Lines • ▼ Show 20 Linespublic:
} }
Metadata *getRawAnnotations() const { return getOperand(5); } Metadata *getRawAnnotations() const { return getOperand(5); }
/// Get casted version of extra data. /// Get casted version of extra data.
/// @{ /// @{
DIType *getClassType() const; DIType *getClassType() const;
DIObjCProperty *getObjCProperty() const { DIObjCProperty *getObjCProperty() const {
return dyn_cast_or_null<DIObjCProperty>(getExtraData()); return dyn_cast_if_present<DIObjCProperty>(getExtraData());
} }
uint32_t getVBPtrOffset() const; uint32_t getVBPtrOffset() const;
Constant *getStorageOffsetInBits() const; Constant *getStorageOffsetInBits() const;
Constant *getConstant() const; Constant *getConstant() const;
▲ Show 20 Lines • Show All 161 Lines • ▼ Show 20 Linespublic:
Metadata *getRawTemplateParams() const { return getOperand(6); } Metadata *getRawTemplateParams() const { return getOperand(6); }
MDString *getRawIdentifier() const { return getOperandAs<MDString>(7); } MDString *getRawIdentifier() const { return getOperandAs<MDString>(7); }
Metadata *getRawDiscriminator() const { return getOperand(8); } Metadata *getRawDiscriminator() const { return getOperand(8); }
DIDerivedType *getDiscriminator() const { DIDerivedType *getDiscriminator() const {
return getOperandAs<DIDerivedType>(8); return getOperandAs<DIDerivedType>(8);
} }
Metadata *getRawDataLocation() const { return getOperand(9); } Metadata *getRawDataLocation() const { return getOperand(9); }
DIVariable *getDataLocation() const { DIVariable *getDataLocation() const {
return dyn_cast_or_null<DIVariable>(getRawDataLocation()); return dyn_cast_if_present<DIVariable>(getRawDataLocation());
} }
DIExpression *getDataLocationExp() const { DIExpression *getDataLocationExp() const {
return dyn_cast_or_null<DIExpression>(getRawDataLocation()); return dyn_cast_if_present<DIExpression>(getRawDataLocation());
} }
Metadata *getRawAssociated() const { return getOperand(10); } Metadata *getRawAssociated() const { return getOperand(10); }
DIVariable *getAssociated() const { DIVariable *getAssociated() const {
return dyn_cast_or_null<DIVariable>(getRawAssociated()); return dyn_cast_if_present<DIVariable>(getRawAssociated());
} }
DIExpression *getAssociatedExp() const { DIExpression *getAssociatedExp() const {
return dyn_cast_or_null<DIExpression>(getRawAssociated()); return dyn_cast_if_present<DIExpression>(getRawAssociated());
} }
Metadata *getRawAllocated() const { return getOperand(11); } Metadata *getRawAllocated() const { return getOperand(11); }
DIVariable *getAllocated() const { DIVariable *getAllocated() const {
return dyn_cast_or_null<DIVariable>(getRawAllocated()); return dyn_cast_if_present<DIVariable>(getRawAllocated());
} }
DIExpression *getAllocatedExp() const { DIExpression *getAllocatedExp() const {
return dyn_cast_or_null<DIExpression>(getRawAllocated()); return dyn_cast_if_present<DIExpression>(getRawAllocated());
} }
Metadata *getRawRank() const { return getOperand(12); } Metadata *getRawRank() const { return getOperand(12); }
ConstantInt *getRankConst() const { ConstantInt *getRankConst() const {
if (auto *MD = dyn_cast_or_null<ConstantAsMetadata>(getRawRank())) if (auto *MD = dyn_cast_if_present<ConstantAsMetadata>(getRawRank()))
return dyn_cast_or_null<ConstantInt>(MD->getValue()); return dyn_cast_if_present<ConstantInt>(MD->getValue());
return nullptr; return nullptr;
} }
DIExpression *getRankExp() const { DIExpression *getRankExp() const {
return dyn_cast_or_null<DIExpression>(getRawRank()); return dyn_cast_if_present<DIExpression>(getRawRank());
} }
Metadata *getRawAnnotations() const { return getOperand(13); } Metadata *getRawAnnotations() const { return getOperand(13); }
DINodeArray getAnnotations() const { DINodeArray getAnnotations() const {
return cast_or_null<MDTuple>(getRawAnnotations()); return cast_or_null<MDTuple>(getRawAnnotations());
} }
/// Replace operands. /// Replace operands.
▲ Show 20 Lines • Show All 2,465 Lines • Show Last 20 Lines

llvm/include/llvm/IR/InstrTypes.h

Show First 20 Lines • Show All 1,388 Lines • ▼ Show 20 Linespublic:
Value *getCalledOperand() const { return Op<CalledOperandOpEndIdx>(); } Value *getCalledOperand() const { return Op<CalledOperandOpEndIdx>(); }
const Use &getCalledOperandUse() const { return Op<CalledOperandOpEndIdx>(); } const Use &getCalledOperandUse() const { return Op<CalledOperandOpEndIdx>(); }
Use &getCalledOperandUse() { return Op<CalledOperandOpEndIdx>(); } Use &getCalledOperandUse() { return Op<CalledOperandOpEndIdx>(); }
/// Returns the function called, or null if this is an indirect function /// Returns the function called, or null if this is an indirect function
/// invocation or the function signature does not match the call signature. /// invocation or the function signature does not match the call signature.
Function *getCalledFunction() const { Function *getCalledFunction() const {
if (auto *F = dyn_cast_or_null<Function>(getCalledOperand())) if (auto *F = dyn_cast_if_present<Function>(getCalledOperand()))
if (F->getValueType() == getFunctionType()) if (F->getValueType() == getFunctionType())
return F; return F;
return nullptr; return nullptr;
} }
/// Return true if the callsite is an indirect call. /// Return true if the callsite is an indirect call.
bool isIndirectCall() const; bool isIndirectCall() const;
▲ Show 20 Lines • Show All 1,034 Lines • Show Last 20 Lines

llvm/include/llvm/IR/Metadata.h

Show First 20 Lines • Show All 495 Lines • ▼ Show 20 Lines
/// \endcode /// \endcode
/// ///
/// The full set of provided functions includes: /// The full set of provided functions includes:
/// ///
/// mdconst::hasa <=> isa /// mdconst::hasa <=> isa
/// mdconst::extract <=> cast /// mdconst::extract <=> cast
/// mdconst::extract_or_null <=> cast_or_null /// mdconst::extract_or_null <=> cast_or_null
/// mdconst::dyn_extract <=> dyn_cast /// mdconst::dyn_extract <=> dyn_cast
/// mdconst::dyn_extract_or_null <=> dyn_cast_or_null /// mdconst::dyn_extract_or_null <=> dyn_cast_if_present
/// ///
/// The target of the cast must be a subclass of \a Constant. /// The target of the cast must be a subclass of \a Constant.
namespace mdconst { namespace mdconst {
namespace detail { namespace detail {
template <class T> T &make(); template <class T> T &make();
template <class T, class Result> struct HasDereference { template <class T, class Result> struct HasDereference {
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Lines
extract_or_null(Y &&MD) { extract_or_null(Y &&MD) {
if (auto *V = cast_or_null<ConstantAsMetadata>(MD)) if (auto *V = cast_or_null<ConstantAsMetadata>(MD))
return cast<X>(V->getValue()); return cast<X>(V->getValue());
return nullptr; return nullptr;
} }
/// Extract a Value from Metadata, if any. /// Extract a Value from Metadata, if any.
/// ///
/// As an analogue to \a dyn_cast_or_null(), extract the \a Value subclass \c X /// As an analogue to \a dyn_cast_if_present(), extract the \a Value subclass \c
/// from \c MD, return null if \c MD doesn't contain a \a Value or if the \a /// X from \c MD, return null if \c MD doesn't contain a \a Value or if the \a
/// Value it does contain is of the wrong subclass. /// Value it does contain is of the wrong subclass.
template <class X, class Y> template <class X, class Y>
inline std::enable_if_t<detail::IsValidPointer<X, Y>::value, X *> inline std::enable_if_t<detail::IsValidPointer<X, Y>::value, X *>
dyn_extract(Y &&MD) { dyn_extract(Y &&MD) {
if (auto *V = dyn_cast<ConstantAsMetadata>(MD)) if (auto *V = dyn_cast<ConstantAsMetadata>(MD))
return dyn_cast<X>(V->getValue()); return dyn_cast<X>(V->getValue());
return nullptr; return nullptr;
} }
/// Extract a Value from Metadata, if any, allowing null. /// Extract a Value from Metadata, if any, allowing null.
/// ///
/// As an analogue to \a dyn_cast_or_null(), extract the \a Value subclass \c X /// As an analogue to \a dyn_cast_if_present(), extract the \a Value subclass \c
/// from \c MD, return null if \c MD doesn't contain a \a Value or if the \a /// X from \c MD, return null if \c MD doesn't contain a \a Value or if the \a
/// Value it does contain is of the wrong subclass, allowing \c MD to be null. /// Value it does contain is of the wrong subclass, allowing \c MD to be null.
template <class X, class Y> template <class X, class Y>
inline std::enable_if_t<detail::IsValidPointer<X, Y>::value, X *> inline std::enable_if_t<detail::IsValidPointer<X, Y>::value, X *>
dyn_extract_or_null(Y &&MD) { dyn_extract_or_null(Y &&MD) {
if (auto *V = dyn_cast_or_null<ConstantAsMetadata>(MD)) if (auto *V = dyn_cast_if_present<ConstantAsMetadata>(MD))
return dyn_cast<X>(V->getValue()); return dyn_cast<X>(V->getValue());
return nullptr; return nullptr;
} }
} // end namespace mdconst } // end namespace mdconst
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// A single uniqued string. /// A single uniqued string.
▲ Show 20 Lines • Show All 821 Lines • ▼ Show 20 Linespublic:
/// Get the MDNode for this AliasScopeNode. /// Get the MDNode for this AliasScopeNode.
const MDNode *getNode() const { return Node; } const MDNode *getNode() const { return Node; }
/// Get the MDNode for this AliasScopeNode's domain. /// Get the MDNode for this AliasScopeNode's domain.
const MDNode *getDomain() const { const MDNode *getDomain() const {
if (Node->getNumOperands() < 2) if (Node->getNumOperands() < 2)
return nullptr; return nullptr;
return dyn_cast_or_null<MDNode>(Node->getOperand(1)); return dyn_cast_if_present<MDNode>(Node->getOperand(1));
} }
StringRef getName() const { StringRef getName() const {
if (Node->getNumOperands() > 2) if (Node->getNumOperands() > 2)
if (MDString *N = dyn_cast_or_null<MDString>(Node->getOperand(2))) if (MDString *N = dyn_cast_if_present<MDString>(Node->getOperand(2)))
return N->getString(); return N->getString();
return StringRef(); return StringRef();
} }
}; };
/// Typed iterator through MDNode operands. /// Typed iterator through MDNode operands.
/// ///
/// An iterator that transforms an \a MDNode::iterator into an iterator over a /// An iterator that transforms an \a MDNode::iterator into an iterator over a
▲ Show 20 Lines • Show All 247 Lines • Show Last 20 Lines

llvm/include/llvm/IR/PatternMatch.h

Show First 20 Lines • Show All 233 Lines • ▼ Show 20 Linesstruct apint_match {
template <typename ITy> bool match(ITy *V) { template <typename ITy> bool match(ITy *V) {
if (auto *CI = dyn_cast<ConstantInt>(V)) { if (auto *CI = dyn_cast<ConstantInt>(V)) {
Res = &CI->getValue(); Res = &CI->getValue();
return true; return true;
} }
if (V->getType()->isVectorTy()) if (V->getType()->isVectorTy())
if (const auto *C = dyn_cast<Constant>(V)) if (const auto *C = dyn_cast<Constant>(V))
if (auto *CI = if (auto *CI = dyn_cast_if_present<ConstantInt>(
dyn_cast_or_null<ConstantInt>(C->getSplatValue(AllowUndef))) { C->getSplatValue(AllowUndef))) {
Res = &CI->getValue(); Res = &CI->getValue();
return true; return true;
} }
return false; return false;
} }
}; };
// Either constexpr if or renaming ConstantFP::getValueAPF to // Either constexpr if or renaming ConstantFP::getValueAPF to
// ConstantFP::getValue is needed to do it via single template // ConstantFP::getValue is needed to do it via single template
// function for both apint/apfloat. // function for both apint/apfloat.
struct apfloat_match { struct apfloat_match {
const APFloat *&Res; const APFloat *&Res;
bool AllowUndef; bool AllowUndef;
apfloat_match(const APFloat *&Res, bool AllowUndef) apfloat_match(const APFloat *&Res, bool AllowUndef)
: Res(Res), AllowUndef(AllowUndef) {} : Res(Res), AllowUndef(AllowUndef) {}
template <typename ITy> bool match(ITy *V) { template <typename ITy> bool match(ITy *V) {
if (auto *CI = dyn_cast<ConstantFP>(V)) { if (auto *CI = dyn_cast<ConstantFP>(V)) {
Res = &CI->getValueAPF(); Res = &CI->getValueAPF();
return true; return true;
} }
if (V->getType()->isVectorTy()) if (V->getType()->isVectorTy())
if (const auto *C = dyn_cast<Constant>(V)) if (const auto *C = dyn_cast<Constant>(V))
if (auto *CI = if (auto *CI =
dyn_cast_or_null<ConstantFP>(C->getSplatValue(AllowUndef))) { dyn_cast_if_present<ConstantFP>(C->getSplatValue(AllowUndef))) {
Res = &CI->getValueAPF(); Res = &CI->getValueAPF();
return true; return true;
} }
return false; return false;
} }
}; };
/// Match a ConstantInt or splatted ConstantVector, binding the /// Match a ConstantInt or splatted ConstantVector, binding the
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines
/// For fixed width vector constants, undefined elements are ignored. /// For fixed width vector constants, undefined elements are ignored.
template <typename Predicate, typename ConstantVal> template <typename Predicate, typename ConstantVal>
struct cstval_pred_ty : public Predicate { struct cstval_pred_ty : public Predicate {
template <typename ITy> bool match(ITy *V) { template <typename ITy> bool match(ITy *V) {
if (const auto *CV = dyn_cast<ConstantVal>(V)) if (const auto *CV = dyn_cast<ConstantVal>(V))
return this->isValue(CV->getValue()); return this->isValue(CV->getValue());
if (const auto *VTy = dyn_cast<VectorType>(V->getType())) { if (const auto *VTy = dyn_cast<VectorType>(V->getType())) {
if (const auto *C = dyn_cast<Constant>(V)) { if (const auto *C = dyn_cast<Constant>(V)) {
if (const auto *CV = dyn_cast_or_null<ConstantVal>(C->getSplatValue())) if (const auto *CV =
dyn_cast_if_present<ConstantVal>(C->getSplatValue()))
return this->isValue(CV->getValue()); return this->isValue(CV->getValue());
// Number of elements of a scalable vector unknown at compile time // Number of elements of a scalable vector unknown at compile time
auto *FVTy = dyn_cast<FixedVectorType>(VTy); auto *FVTy = dyn_cast<FixedVectorType>(VTy);
if (!FVTy) if (!FVTy)
return false; return false;
// Non-splat vector constant: check each element for a match. // Non-splat vector constant: check each element for a match.
Show All 36 Linestemplate <typename Predicate> struct api_pred_ty : public Predicate {
template <typename ITy> bool match(ITy *V) { template <typename ITy> bool match(ITy *V) {
if (const auto *CI = dyn_cast<ConstantInt>(V)) if (const auto *CI = dyn_cast<ConstantInt>(V))
if (this->isValue(CI->getValue())) { if (this->isValue(CI->getValue())) {
Res = &CI->getValue(); Res = &CI->getValue();
return true; return true;
} }
if (V->getType()->isVectorTy()) if (V->getType()->isVectorTy())
if (const auto *C = dyn_cast<Constant>(V)) if (const auto *C = dyn_cast<Constant>(V))
if (auto *CI = dyn_cast_or_null<ConstantInt>(C->getSplatValue())) if (auto *CI = dyn_cast_if_present<ConstantInt>(C->getSplatValue()))
if (this->isValue(CI->getValue())) { if (this->isValue(CI->getValue())) {
Res = &CI->getValue(); Res = &CI->getValue();
return true; return true;
} }
return false; return false;
} }
}; };
Show All 9 Linestemplate <typename Predicate> struct apf_pred_ty : public Predicate {
template <typename ITy> bool match(ITy *V) { template <typename ITy> bool match(ITy *V) {
if (const auto *CI = dyn_cast<ConstantFP>(V)) if (const auto *CI = dyn_cast<ConstantFP>(V))
if (this->isValue(CI->getValue())) { if (this->isValue(CI->getValue())) {
Res = &CI->getValue(); Res = &CI->getValue();
return true; return true;
} }
if (V->getType()->isVectorTy()) if (V->getType()->isVectorTy())
if (const auto *C = dyn_cast<Constant>(V)) if (const auto *C = dyn_cast<Constant>(V))
if (auto *CI = dyn_cast_or_null<ConstantFP>( if (auto *CI = dyn_cast_if_present<ConstantFP>(
C->getSplatValue(/* AllowUndef */ true))) C->getSplatValue(/* AllowUndef */ true)))
if (this->isValue(CI->getValue())) { if (this->isValue(CI->getValue())) {
Res = &CI->getValue(); Res = &CI->getValue();
return true; return true;
} }
return false; return false;
} }
▲ Show 20 Lines • Show All 371 Lines • ▼ Show 20 Linesstruct specific_fpval {
specific_fpval(double V) : Val(V) {} specific_fpval(double V) : Val(V) {}
template <typename ITy> bool match(ITy *V) { template <typename ITy> bool match(ITy *V) {
if (const auto *CFP = dyn_cast<ConstantFP>(V)) if (const auto *CFP = dyn_cast<ConstantFP>(V))
return CFP->isExactlyValue(Val); return CFP->isExactlyValue(Val);
if (V->getType()->isVectorTy()) if (V->getType()->isVectorTy())
if (const auto *C = dyn_cast<Constant>(V)) if (const auto *C = dyn_cast<Constant>(V))
if (auto *CFP = dyn_cast_or_null<ConstantFP>(C->getSplatValue())) if (auto *CFP = dyn_cast_if_present<ConstantFP>(C->getSplatValue()))
return CFP->isExactlyValue(Val); return CFP->isExactlyValue(Val);
return false; return false;
} }
}; };
/// Match a specific floating point value or vector with all elements /// Match a specific floating point value or vector with all elements
/// equal to the value. /// equal to the value.
inline specific_fpval m_SpecificFP(double V) { return specific_fpval(V); } inline specific_fpval m_SpecificFP(double V) { return specific_fpval(V); }
Show All 22 Linestemplate <bool AllowUndefs> struct specific_intval {
APInt Val; APInt Val;
specific_intval(APInt V) : Val(std::move(V)) {} specific_intval(APInt V) : Val(std::move(V)) {}
template <typename ITy> bool match(ITy *V) { template <typename ITy> bool match(ITy *V) {
const auto *CI = dyn_cast<ConstantInt>(V); const auto *CI = dyn_cast<ConstantInt>(V);
if (!CI && V->getType()->isVectorTy()) if (!CI && V->getType()->isVectorTy())
if (const auto *C = dyn_cast<Constant>(V)) if (const auto *C = dyn_cast<Constant>(V))
CI = dyn_cast_or_null<ConstantInt>(C->getSplatValue(AllowUndefs)); CI = dyn_cast_if_present<ConstantInt>(C->getSplatValue(AllowUndefs));
return CI && APInt::isSameValue(CI->getValue(), Val); return CI && APInt::isSameValue(CI->getValue(), Val);
} }
}; };
/// Match a specific integer value or vector with all elements equal to /// Match a specific integer value or vector with all elements equal to
/// the value. /// the value.
inline specific_intval<false> m_SpecificInt(APInt V) { inline specific_intval<false> m_SpecificInt(APInt V) {
▲ Show 20 Lines • Show All 1,719 Lines • Show Last 20 Lines

llvm/include/llvm/IR/Statepoint.h

Show First 20 Lines • Show All 108 Lines • ▼ Show 20 Linespublic:
/// Return the value actually being called or invoked. /// Return the value actually being called or invoked.
Value *getActualCalledOperand() const { Value *getActualCalledOperand() const {
return getArgOperand(CalledFunctionPos); return getArgOperand(CalledFunctionPos);
} }
/// Returns the function called if this is a wrapping a direct call, and null /// Returns the function called if this is a wrapping a direct call, and null
/// otherwise. /// otherwise.
Function *getActualCalledFunction() const { Function *getActualCalledFunction() const {
return dyn_cast_or_null<Function>(getActualCalledOperand()); return dyn_cast_if_present<Function>(getActualCalledOperand());
} }
/// Return the type of the value returned by the call underlying the /// Return the type of the value returned by the call underlying the
/// statepoint. /// statepoint.
Type *getActualReturnType() const { Type *getActualReturnType() const {
auto *FT = cast<FunctionType>(getParamElementType(CalledFunctionPos)); auto *FT = cast<FunctionType>(getParamElementType(CalledFunctionPos));
return FT->getReturnType(); return FT->getReturnType();
} }
▲ Show 20 Lines • Show All 128 Lines • Show Last 20 Lines

llvm/include/llvm/ProfileData/InstrProfReader.h

Show First 20 Lines • Show All 282 Lines • ▼ Show 20 Linesprivate:
uint64_t BinaryIdsSize; uint64_t BinaryIdsSize;
const uint8_t *BinaryIdsStart; const uint8_t *BinaryIdsStart;
public: public:
RawInstrProfReader(std::unique_ptr<MemoryBuffer> DataBuffer, RawInstrProfReader(std::unique_ptr<MemoryBuffer> DataBuffer,
const InstrProfCorrelator *Correlator) const InstrProfCorrelator *Correlator)
: DataBuffer(std::move(DataBuffer)), : DataBuffer(std::move(DataBuffer)),
Correlator(dyn_cast_or_null<const InstrProfCorrelatorImpl<IntPtrT>>( Correlator(dyn_cast_if_present<const InstrProfCorrelatorImpl<IntPtrT>>(
Correlator)) {} Correlator)) {}
RawInstrProfReader(const RawInstrProfReader &) = delete; RawInstrProfReader(const RawInstrProfReader &) = delete;
RawInstrProfReader &operator=(const RawInstrProfReader &) = delete; RawInstrProfReader &operator=(const RawInstrProfReader &) = delete;
static bool hasFormat(const MemoryBuffer &DataBuffer); static bool hasFormat(const MemoryBuffer &DataBuffer);
Error readHeader() override; Error readHeader() override;
Error readNextRecord(NamedInstrProfRecord &Record) override; Error readNextRecord(NamedInstrProfRecord &Record) override;
Error printBinaryIds(raw_ostream &OS) override; Error printBinaryIds(raw_ostream &OS) override;
▲ Show 20 Lines • Show All 385 Lines • Show Last 20 Lines

llvm/lib/Analysis/CallGraphSCCPass.cpp

Show First 20 Lines • Show All 256 Lines • ▼ Show 20 Lines for (CallGraphNode::iterator I = CGN->begin(); I != CGNEnd;) {
} }
if (RemoveAndCheckForDone(I)) if (RemoveAndCheckForDone(I))
break; break;
continue; continue;
} }
// If this call site is null, then the function pass deleted the call // If this call site is null, then the function pass deleted the call
// entirely and the WeakTrackingVH nulled it out. // entirely and the WeakTrackingVH nulled it out.
auto *Call = dyn_cast_or_null<CallBase>(*I->first); auto *Call = dyn_cast_if_present<CallBase>(*I->first);
if (!Call || if (!Call ||
// If we've already seen this call site, then the FunctionPass RAUW'd // If we've already seen this call site, then the FunctionPass RAUW'd
// one call with another, which resulted in two "uses" in the edge // one call with another, which resulted in two "uses" in the edge
// list of the same call. // list of the same call.
Calls.count(Call) || Calls.count(Call) ||
// If the call edge is not from a call or invoke, or it is a // If the call edge is not from a call or invoke, or it is a
// intrinsic call, then the function pass RAUW'd a call with // intrinsic call, then the function pass RAUW'd a call with
▲ Show 20 Lines • Show All 487 Lines • Show Last 20 Lines

llvm/lib/Analysis/ConstantFolding.cpp

Show First 20 Lines • Show All 81 Lines • ▼ Show 20 Lines for (unsigned i = 0; i != NumSrcElts; ++i) {
else else
Element = C->getAggregateElement(i); Element = C->getAggregateElement(i);
if (Element && isa<UndefValue>(Element)) { if (Element && isa<UndefValue>(Element)) {
Result <<= BitShift; Result <<= BitShift;
continue; continue;
} }
auto *ElementCI = dyn_cast_or_null<ConstantInt>(Element); auto *ElementCI = dyn_cast_if_present<ConstantInt>(Element);
if (!ElementCI) if (!ElementCI)
return ConstantExpr::getBitCast(C, DestTy); return ConstantExpr::getBitCast(C, DestTy);
Result <<= BitShift; Result <<= BitShift;
Result |= ElementCI->getValue().zext(Result.getBitWidth()); Result |= ElementCI->getValue().zext(Result.getBitWidth());
} }
return nullptr; return nullptr;
▲ Show 20 Lines • Show All 118 Lines • ▼ Show 20 Lines for (unsigned i = 0; i != NumDstElt; ++i) {
Constant *Elt = Zero; Constant *Elt = Zero;
unsigned ShiftAmt = isLittleEndian ? 0 : SrcBitSize*(Ratio-1); unsigned ShiftAmt = isLittleEndian ? 0 : SrcBitSize*(Ratio-1);
for (unsigned j = 0; j != Ratio; ++j) { for (unsigned j = 0; j != Ratio; ++j) {
Constant *Src = C->getAggregateElement(SrcElt++); Constant *Src = C->getAggregateElement(SrcElt++);
if (Src && isa<UndefValue>(Src)) if (Src && isa<UndefValue>(Src))
Src = Constant::getNullValue( Src = Constant::getNullValue(
cast<VectorType>(C->getType())->getElementType()); cast<VectorType>(C->getType())->getElementType());
else else
Src = dyn_cast_or_null<ConstantInt>(Src); Src = dyn_cast_if_present<ConstantInt>(Src);
if (!Src) // Reject constantexpr elements. if (!Src) // Reject constantexpr elements.
return ConstantExpr::getBitCast(C, DestTy); return ConstantExpr::getBitCast(C, DestTy);
// Zero extend the element to the right size. // Zero extend the element to the right size.
Src = ConstantExpr::getZExt(Src, Elt->getType()); Src = ConstantExpr::getZExt(Src, Elt->getType());
// Shift it to the right place, depending on endianness. // Shift it to the right place, depending on endianness.
Src = ConstantExpr::getShl(Src, Src = ConstantExpr::getShl(Src,
▲ Show 20 Lines • Show All 2,158 Lines • ▼ Show 20 Lines if (isa<ConstantVector>(Operands[0]) ||
auto *Op = cast<Constant>(Operands[0]); auto *Op = cast<Constant>(Operands[0]);
switch (IntrinsicID) { switch (IntrinsicID) {
default: break; default: break;
case Intrinsic::x86_sse_cvtss2si: case Intrinsic::x86_sse_cvtss2si:
case Intrinsic::x86_sse_cvtss2si64: case Intrinsic::x86_sse_cvtss2si64:
case Intrinsic::x86_sse2_cvtsd2si: case Intrinsic::x86_sse2_cvtsd2si:
case Intrinsic::x86_sse2_cvtsd2si64: case Intrinsic::x86_sse2_cvtsd2si64:
if (ConstantFP *FPOp = if (ConstantFP *FPOp =
dyn_cast_or_null<ConstantFP>(Op->getAggregateElement(0U))) dyn_cast_if_present<ConstantFP>(Op->getAggregateElement(0U)))
return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(), return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(),
/*roundTowardZero=*/false, Ty, /*roundTowardZero=*/false, Ty,
/*IsSigned*/true); /*IsSigned*/ true);
break; break;
case Intrinsic::x86_sse_cvttss2si: case Intrinsic::x86_sse_cvttss2si:
case Intrinsic::x86_sse_cvttss2si64: case Intrinsic::x86_sse_cvttss2si64:
case Intrinsic::x86_sse2_cvttsd2si: case Intrinsic::x86_sse2_cvttsd2si:
case Intrinsic::x86_sse2_cvttsd2si64: case Intrinsic::x86_sse2_cvttsd2si64:
if (ConstantFP *FPOp = if (ConstantFP *FPOp =
dyn_cast_or_null<ConstantFP>(Op->getAggregateElement(0U))) dyn_cast_if_present<ConstantFP>(Op->getAggregateElement(0U)))
return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(), return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(),
/*roundTowardZero=*/true, Ty, /*roundTowardZero=*/true, Ty,
/*IsSigned*/true); /*IsSigned*/ true);
break; break;
} }
} }
return nullptr; return nullptr;
} }
static Constant *evaluateCompare(const APFloat &Op1, const APFloat &Op2, static Constant *evaluateCompare(const APFloat &Op1, const APFloat &Op2,
▲ Show 20 Lines • Show All 344 Lines • ▼ Show 20 Lines if ((isa<ConstantVector>(Operands[0]) ||
auto *Op = cast<Constant>(Operands[0]); auto *Op = cast<Constant>(Operands[0]);
switch (IntrinsicID) { switch (IntrinsicID) {
default: break; default: break;
case Intrinsic::x86_avx512_vcvtss2si32: case Intrinsic::x86_avx512_vcvtss2si32:
case Intrinsic::x86_avx512_vcvtss2si64: case Intrinsic::x86_avx512_vcvtss2si64:
case Intrinsic::x86_avx512_vcvtsd2si32: case Intrinsic::x86_avx512_vcvtsd2si32:
case Intrinsic::x86_avx512_vcvtsd2si64: case Intrinsic::x86_avx512_vcvtsd2si64:
if (ConstantFP *FPOp = if (ConstantFP *FPOp =
dyn_cast_or_null<ConstantFP>(Op->getAggregateElement(0U))) dyn_cast_if_present<ConstantFP>(Op->getAggregateElement(0U)))
return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(), return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(),
/*roundTowardZero=*/false, Ty, /*roundTowardZero=*/false, Ty,
/*IsSigned*/true); /*IsSigned*/ true);
break; break;
case Intrinsic::x86_avx512_vcvtss2usi32: case Intrinsic::x86_avx512_vcvtss2usi32:
case Intrinsic::x86_avx512_vcvtss2usi64: case Intrinsic::x86_avx512_vcvtss2usi64:
case Intrinsic::x86_avx512_vcvtsd2usi32: case Intrinsic::x86_avx512_vcvtsd2usi32:
case Intrinsic::x86_avx512_vcvtsd2usi64: case Intrinsic::x86_avx512_vcvtsd2usi64:
if (ConstantFP *FPOp = if (ConstantFP *FPOp =
dyn_cast_or_null<ConstantFP>(Op->getAggregateElement(0U))) dyn_cast_if_present<ConstantFP>(Op->getAggregateElement(0U)))
return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(), return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(),
/*roundTowardZero=*/false, Ty, /*roundTowardZero=*/false, Ty,
/*IsSigned*/false); /*IsSigned*/ false);
break; break;
case Intrinsic::x86_avx512_cvttss2si: case Intrinsic::x86_avx512_cvttss2si:
case Intrinsic::x86_avx512_cvttss2si64: case Intrinsic::x86_avx512_cvttss2si64:
case Intrinsic::x86_avx512_cvttsd2si: case Intrinsic::x86_avx512_cvttsd2si:
case Intrinsic::x86_avx512_cvttsd2si64: case Intrinsic::x86_avx512_cvttsd2si64:
if (ConstantFP *FPOp = if (ConstantFP *FPOp =
dyn_cast_or_null<ConstantFP>(Op->getAggregateElement(0U))) dyn_cast_if_present<ConstantFP>(Op->getAggregateElement(0U)))
return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(), return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(),
/*roundTowardZero=*/true, Ty, /*roundTowardZero=*/true, Ty,
/*IsSigned*/true); /*IsSigned*/ true);
break; break;
case Intrinsic::x86_avx512_cvttss2usi: case Intrinsic::x86_avx512_cvttss2usi:
case Intrinsic::x86_avx512_cvttss2usi64: case Intrinsic::x86_avx512_cvttss2usi64:
case Intrinsic::x86_avx512_cvttsd2usi: case Intrinsic::x86_avx512_cvttsd2usi:
case Intrinsic::x86_avx512_cvttsd2usi64: case Intrinsic::x86_avx512_cvttsd2usi64:
if (ConstantFP *FPOp = if (ConstantFP *FPOp =
dyn_cast_or_null<ConstantFP>(Op->getAggregateElement(0U))) dyn_cast_if_present<ConstantFP>(Op->getAggregateElement(0U)))
return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(), return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(),
/*roundTowardZero=*/true, Ty, /*roundTowardZero=*/true, Ty,
/*IsSigned*/false); /*IsSigned*/ false);
break; break;
} }
} }
return nullptr; return nullptr;
} }
static APFloat ConstantFoldAMDGCNCubeIntrinsic(Intrinsic::ID IntrinsicID, static APFloat ConstantFoldAMDGCNCubeIntrinsic(Intrinsic::ID IntrinsicID,
const APFloat &S0, const APFloat &S0,
▲ Show 20 Lines • Show All 579 Lines • Show Last 20 Lines

llvm/lib/Analysis/IVDescriptors.cpp

Show First 20 Lines • Show All 945 Lines • ▼ Show 20 Linesbool RecurrenceDescriptor::isFixedOrderRecurrence(
// the initial value comes form the preheader edge. // the initial value comes form the preheader edge.
auto *Previous = dyn_cast<Instruction>(Phi->getIncomingValueForBlock(Latch)); auto *Previous = dyn_cast<Instruction>(Phi->getIncomingValueForBlock(Latch));
// If Previous is a phi in the header, go through incoming values from the // If Previous is a phi in the header, go through incoming values from the
// latch until we find a non-phi value. Use this as the new Previous, all uses // latch until we find a non-phi value. Use this as the new Previous, all uses
// in the header will be dominated by the original phi, but need to be moved // in the header will be dominated by the original phi, but need to be moved
// after the non-phi previous value. // after the non-phi previous value.
SmallPtrSet<PHINode *, 4> SeenPhis; SmallPtrSet<PHINode *, 4> SeenPhis;
while (auto *PrevPhi = dyn_cast_or_null<PHINode>(Previous)) { while (auto *PrevPhi = dyn_cast_if_present<PHINode>(Previous)) {
if (PrevPhi->getParent() != Phi->getParent()) if (PrevPhi->getParent() != Phi->getParent())
return false; return false;
if (!SeenPhis.insert(PrevPhi).second) if (!SeenPhis.insert(PrevPhi).second)
return false; return false;
Previous = dyn_cast<Instruction>(PrevPhi->getIncomingValueForBlock(Latch)); Previous = dyn_cast<Instruction>(PrevPhi->getIncomingValueForBlock(Latch));
} }
if (!Previous || !TheLoop->contains(Previous) || isa<PHINode>(Previous) || if (!Previous || !TheLoop->contains(Previous) || isa<PHINode>(Previous) ||
▲ Show 20 Lines • Show All 621 Lines • Show Last 20 Lines

llvm/lib/Analysis/InlineCost.cpp

Show First 20 Lines • Show All 1,367 Lines • ▼ Show 20 Lines
bool CallAnalyzer::visitAlloca(AllocaInst &I) { bool CallAnalyzer::visitAlloca(AllocaInst &I) {
disableSROA(I.getOperand(0)); disableSROA(I.getOperand(0));
// Check whether inlining will turn a dynamic alloca into a static // Check whether inlining will turn a dynamic alloca into a static
// alloca and handle that case. // alloca and handle that case.
if (I.isArrayAllocation()) { if (I.isArrayAllocation()) {
Constant *Size = SimplifiedValues.lookup(I.getArraySize()); Constant *Size = SimplifiedValues.lookup(I.getArraySize());
if (auto *AllocSize = dyn_cast_or_null<ConstantInt>(Size)) { if (auto *AllocSize = dyn_cast_if_present<ConstantInt>(Size)) {
// Sometimes a dynamic alloca could be converted into a static alloca // Sometimes a dynamic alloca could be converted into a static alloca
// after this constant prop, and become a huge static alloca on an // after this constant prop, and become a huge static alloca on an
// unconditional CFG path. Avoid inlining if this is going to happen above // unconditional CFG path. Avoid inlining if this is going to happen above
// a threshold. // a threshold.
// FIXME: If the threshold is removed or lowered too much, we could end up // FIXME: If the threshold is removed or lowered too much, we could end up
// being too pessimistic and prevent inlining non-problematic code. This // being too pessimistic and prevent inlining non-problematic code. This
// could result in unintended perf regressions. A better overall strategy // could result in unintended perf regressions. A better overall strategy
// is needed to track stack usage during inlining. // is needed to track stack usage during inlining.
▲ Show 20 Lines • Show All 196 Lines • ▼ Show 20 Lines
/// (CandidateCall->getParent()->getParent()), we might be able to determine /// (CandidateCall->getParent()->getParent()), we might be able to determine
/// whether inlining F into F's caller would change how the call to /// whether inlining F into F's caller would change how the call to
/// llvm.is.constant would evaluate. /// llvm.is.constant would evaluate.
bool CallAnalyzer::simplifyIntrinsicCallIsConstant(CallBase &CB) { bool CallAnalyzer::simplifyIntrinsicCallIsConstant(CallBase &CB) {
Value *Arg = CB.getArgOperand(0); Value *Arg = CB.getArgOperand(0);
auto *C = dyn_cast<Constant>(Arg); auto *C = dyn_cast<Constant>(Arg);
if (!C) if (!C)
C = dyn_cast_or_null<Constant>(SimplifiedValues.lookup(Arg)); C = dyn_cast_if_present<Constant>(SimplifiedValues.lookup(Arg));
Type *RT = CB.getFunctionType()->getReturnType(); Type *RT = CB.getFunctionType()->getReturnType();
SimplifiedValues[&CB] = ConstantInt::get(RT, C ? 1 : 0); SimplifiedValues[&CB] = ConstantInt::get(RT, C ? 1 : 0);
return true; return true;
} }
bool CallAnalyzer::visitBitCast(BitCastInst &I) { bool CallAnalyzer::visitBitCast(BitCastInst &I) {
// Propagate constants through bitcasts. // Propagate constants through bitcasts.
▲ Show 20 Lines • Show All 404 Lines • ▼ Show 20 Linesbool CallAnalyzer::visitBinaryOperator(BinaryOperator &I) {
Value *SimpleV = nullptr; Value *SimpleV = nullptr;
if (auto FI = dyn_cast<FPMathOperator>(&I)) if (auto FI = dyn_cast<FPMathOperator>(&I))
SimpleV = simplifyBinOp(I.getOpcode(), CLHS ? CLHS : LHS, CRHS ? CRHS : RHS, SimpleV = simplifyBinOp(I.getOpcode(), CLHS ? CLHS : LHS, CRHS ? CRHS : RHS,
FI->getFastMathFlags(), DL); FI->getFastMathFlags(), DL);
else else
SimpleV = SimpleV =
simplifyBinOp(I.getOpcode(), CLHS ? CLHS : LHS, CRHS ? CRHS : RHS, DL); simplifyBinOp(I.getOpcode(), CLHS ? CLHS : LHS, CRHS ? CRHS : RHS, DL);
if (Constant *C = dyn_cast_or_null<Constant>(SimpleV)) if (Constant *C = dyn_cast_if_present<Constant>(SimpleV))
SimplifiedValues[&I] = C; SimplifiedValues[&I] = C;
if (SimpleV) if (SimpleV)
return true; return true;
// Disable any SROA on arguments to arbitrary, unsimplified binary operators. // Disable any SROA on arguments to arbitrary, unsimplified binary operators.
disableSROA(LHS); disableSROA(LHS);
disableSROA(RHS); disableSROA(RHS);
Show All 14 Linesbool CallAnalyzer::visitFNeg(UnaryOperator &I) {
Value *Op = I.getOperand(0); Value *Op = I.getOperand(0);
Constant *COp = dyn_cast<Constant>(Op); Constant *COp = dyn_cast<Constant>(Op);
if (!COp) if (!COp)
COp = SimplifiedValues.lookup(Op); COp = SimplifiedValues.lookup(Op);
Value *SimpleV = simplifyFNegInst( Value *SimpleV = simplifyFNegInst(
COp ? COp : Op, cast<FPMathOperator>(I).getFastMathFlags(), DL); COp ? COp : Op, cast<FPMathOperator>(I).getFastMathFlags(), DL);
if (Constant *C = dyn_cast_or_null<Constant>(SimpleV)) if (Constant *C = dyn_cast_if_present<Constant>(SimpleV))
SimplifiedValues[&I] = C; SimplifiedValues[&I] = C;
if (SimpleV) if (SimpleV)
return true; return true;
// Disable any SROA on arguments to arbitrary, unsimplified fneg. // Disable any SROA on arguments to arbitrary, unsimplified fneg.
disableSROA(Op); disableSROA(Op);
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines if (!canConstantFoldCallTo(&Call, F))
return false; return false;
// Try to re-map the arguments to constants. // Try to re-map the arguments to constants.
SmallVector<Constant *, 4> ConstantArgs; SmallVector<Constant *, 4> ConstantArgs;
ConstantArgs.reserve(Call.arg_size()); ConstantArgs.reserve(Call.arg_size());
for (Value *I : Call.args()) { for (Value *I : Call.args()) {
Constant *C = dyn_cast<Constant>(I); Constant *C = dyn_cast<Constant>(I);
if (!C) if (!C)
C = dyn_cast_or_null<Constant>(SimplifiedValues.lookup(I)); C = dyn_cast_if_present<Constant>(SimplifiedValues.lookup(I));
if (!C) if (!C)
return false; // This argument doesn't map to a constant. return false; // This argument doesn't map to a constant.
ConstantArgs.push_back(C); ConstantArgs.push_back(C);
} }
if (Constant *C = ConstantFoldCall(&Call, F, ConstantArgs)) { if (Constant *C = ConstantFoldCall(&Call, F, ConstantArgs)) {
SimplifiedValues[&Call] = C; SimplifiedValues[&Call] = C;
return true; return true;
Show All 16 Lines if (isa<CallInst>(Call) && cast<CallInst>(Call).cannotDuplicate())
ContainsNoDuplicateCall = true; ContainsNoDuplicateCall = true;
Function *F = Call.getCalledFunction(); Function *F = Call.getCalledFunction();
bool IsIndirectCall = !F; bool IsIndirectCall = !F;
if (IsIndirectCall) { if (IsIndirectCall) {
// Check if this happens to be an indirect function call to a known function // Check if this happens to be an indirect function call to a known function
// in this inline context. If not, we've done all we can. // in this inline context. If not, we've done all we can.
Value *Callee = Call.getCalledOperand(); Value *Callee = Call.getCalledOperand();
F = dyn_cast_or_null<Function>(SimplifiedValues.lookup(Callee)); F = dyn_cast_if_present<Function>(SimplifiedValues.lookup(Callee));
if (!F || F->getFunctionType() != Call.getFunctionType()) { if (!F || F->getFunctionType() != Call.getFunctionType()) {
onCallArgumentSetup(Call); onCallArgumentSetup(Call);
if (!Call.onlyReadsMemory()) if (!Call.onlyReadsMemory())
disableLoadElimination(); disableLoadElimination();
return Base::visitCallBase(Call); return Base::visitCallBase(Call);
} }
} }
▲ Show 20 Lines • Show All 81 Lines • ▼ Show 20 Linesbool CallAnalyzer::visitSelectInst(SelectInst &SI) {
Constant *TrueC = dyn_cast<Constant>(TrueVal); Constant *TrueC = dyn_cast<Constant>(TrueVal);
if (!TrueC) if (!TrueC)
TrueC = SimplifiedValues.lookup(TrueVal); TrueC = SimplifiedValues.lookup(TrueVal);
Constant *FalseC = dyn_cast<Constant>(FalseVal); Constant *FalseC = dyn_cast<Constant>(FalseVal);
if (!FalseC) if (!FalseC)
FalseC = SimplifiedValues.lookup(FalseVal); FalseC = SimplifiedValues.lookup(FalseVal);
Constant *CondC = Constant *CondC =
dyn_cast_or_null<Constant>(SimplifiedValues.lookup(SI.getCondition())); dyn_cast_if_present<Constant>(SimplifiedValues.lookup(SI.getCondition()));
if (!CondC) { if (!CondC) {
// Select C, X, X => X // Select C, X, X => X
if (TrueC == FalseC && TrueC) { if (TrueC == FalseC && TrueC) {
SimplifiedValues[&SI] = TrueC; SimplifiedValues[&SI] = TrueC;
return true; return true;
} }
▲ Show 20 Lines • Show All 411 Lines • ▼ Show 20 Lines for (unsigned Idx = 0; Idx != BBWorklist.size(); ++Idx) {
Instruction *TI = BB->getTerminator(); Instruction *TI = BB->getTerminator();
// Add in the live successors by first checking whether we have terminator // Add in the live successors by first checking whether we have terminator
// that may be simplified based on the values simplified by this call. // that may be simplified based on the values simplified by this call.
if (BranchInst *BI = dyn_cast<BranchInst>(TI)) { if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
if (BI->isConditional()) { if (BI->isConditional()) {
Value *Cond = BI->getCondition(); Value *Cond = BI->getCondition();
if (ConstantInt *SimpleCond = if (ConstantInt *SimpleCond = dyn_cast_if_present<ConstantInt>(
dyn_cast_or_null<ConstantInt>(SimplifiedValues.lookup(Cond))) { SimplifiedValues.lookup(Cond))) {
BasicBlock *NextBB = BI->getSuccessor(SimpleCond->isZero() ? 1 : 0); BasicBlock *NextBB = BI->getSuccessor(SimpleCond->isZero() ? 1 : 0);
BBWorklist.insert(NextBB); BBWorklist.insert(NextBB);
KnownSuccessors[BB] = NextBB; KnownSuccessors[BB] = NextBB;
findDeadBlocks(BB, NextBB); findDeadBlocks(BB, NextBB);
continue; continue;
} }
} }
} else if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) { } else if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) {
Value *Cond = SI->getCondition(); Value *Cond = SI->getCondition();
if (ConstantInt *SimpleCond = if (ConstantInt *SimpleCond =
dyn_cast_or_null<ConstantInt>(SimplifiedValues.lookup(Cond))) { dyn_cast_if_present<ConstantInt>(SimplifiedValues.lookup(Cond))) {
BasicBlock *NextBB = SI->findCaseValue(SimpleCond)->getCaseSuccessor(); BasicBlock *NextBB = SI->findCaseValue(SimpleCond)->getCaseSuccessor();
BBWorklist.insert(NextBB); BBWorklist.insert(NextBB);
KnownSuccessors[BB] = NextBB; KnownSuccessors[BB] = NextBB;
findDeadBlocks(BB, NextBB); findDeadBlocks(BB, NextBB);
continue; continue;
} }
} }
▲ Show 20 Lines • Show All 450 Lines • Show Last 20 Lines

llvm/lib/Analysis/InstructionSimplify.cpp

Show First 20 Lines • Show All 1,025 Lines • ▼ Show 20 Lines
} }
/// Given a predicate and two operands, return true if the comparison is true. /// Given a predicate and two operands, return true if the comparison is true.
/// This is a helper for div/rem simplification where we return some other value /// This is a helper for div/rem simplification where we return some other value
/// when we can prove a relationship between the operands. /// when we can prove a relationship between the operands.
static bool isICmpTrue(ICmpInst::Predicate Pred, Value *LHS, Value *RHS, static bool isICmpTrue(ICmpInst::Predicate Pred, Value *LHS, Value *RHS,
const SimplifyQuery &Q, unsigned MaxRecurse) { const SimplifyQuery &Q, unsigned MaxRecurse) {
Value *V = simplifyICmpInst(Pred, LHS, RHS, Q, MaxRecurse); Value *V = simplifyICmpInst(Pred, LHS, RHS, Q, MaxRecurse);
Constant *C = dyn_cast_or_null<Constant>(V); Constant *C = dyn_cast_if_present<Constant>(V);
return (C && C->isAllOnesValue()); return (C && C->isAllOnesValue());
} }
/// Return true if we can simplify X / Y to 0. Remainder can adapt that answer /// Return true if we can simplify X / Y to 0. Remainder can adapt that answer
/// to simplify X % Y to X. /// to simplify X % Y to X.
static bool isDivZero(Value *X, Value *Y, const SimplifyQuery &Q, static bool isDivZero(Value *X, Value *Y, const SimplifyQuery &Q,
unsigned MaxRecurse, bool IsSigned) { unsigned MaxRecurse, bool IsSigned) {
// Recursion is always used, so bail out at once if we already hit the limit. // Recursion is always used, so bail out at once if we already hit the limit.
▲ Show 20 Lines • Show All 5,522 Lines • Show Last 20 Lines

llvm/lib/Analysis/LazyValueInfo.cpp

Show First 20 Lines • Show All 1,263 Lines • ▼ Show 20 Lines
static ValueLatticeElement constantFoldUser(User *Usr, Value *Op, static ValueLatticeElement constantFoldUser(User *Usr, Value *Op,
const APInt &OpConstVal, const APInt &OpConstVal,
const DataLayout &DL) { const DataLayout &DL) {
assert(isOperationFoldable(Usr) && "Precondition"); assert(isOperationFoldable(Usr) && "Precondition");
Constant* OpConst = Constant::getIntegerValue(Op->getType(), OpConstVal); Constant* OpConst = Constant::getIntegerValue(Op->getType(), OpConstVal);
// Check if Usr can be simplified to a constant. // Check if Usr can be simplified to a constant.
if (auto *CI = dyn_cast<CastInst>(Usr)) { if (auto *CI = dyn_cast<CastInst>(Usr)) {
assert(CI->getOperand(0) == Op && "Operand 0 isn't Op"); assert(CI->getOperand(0) == Op && "Operand 0 isn't Op");
if (auto *C = dyn_cast_or_null<ConstantInt>( if (auto *C = dyn_cast_if_present<ConstantInt>(
simplifyCastInst(CI->getOpcode(), OpConst, simplifyCastInst(CI->getOpcode(), OpConst, CI->getDestTy(), DL))) {
CI->getDestTy(), DL))) {
return ValueLatticeElement::getRange(ConstantRange(C->getValue())); return ValueLatticeElement::getRange(ConstantRange(C->getValue()));
} }
} else if (auto *BO = dyn_cast<BinaryOperator>(Usr)) { } else if (auto *BO = dyn_cast<BinaryOperator>(Usr)) {
bool Op0Match = BO->getOperand(0) == Op; bool Op0Match = BO->getOperand(0) == Op;
bool Op1Match = BO->getOperand(1) == Op; bool Op1Match = BO->getOperand(1) == Op;
assert((Op0Match || Op1Match) && assert((Op0Match || Op1Match) &&
"Operand 0 nor Operand 1 isn't a match"); "Operand 0 nor Operand 1 isn't a match");
Value *LHS = Op0Match ? OpConst : BO->getOperand(0); Value *LHS = Op0Match ? OpConst : BO->getOperand(0);
Value *RHS = Op1Match ? OpConst : BO->getOperand(1); Value *RHS = Op1Match ? OpConst : BO->getOperand(1);
if (auto *C = dyn_cast_or_null<ConstantInt>( if (auto *C = dyn_cast_if_present<ConstantInt>(
simplifyBinOp(BO->getOpcode(), LHS, RHS, DL))) { simplifyBinOp(BO->getOpcode(), LHS, RHS, DL))) {
return ValueLatticeElement::getRange(ConstantRange(C->getValue())); return ValueLatticeElement::getRange(ConstantRange(C->getValue()));
} }
} else if (isa<FreezeInst>(Usr)) { } else if (isa<FreezeInst>(Usr)) {
assert(cast<FreezeInst>(Usr)->getOperand(0) == Op && "Operand 0 isn't Op"); assert(cast<FreezeInst>(Usr)->getOperand(0) == Op && "Operand 0 isn't Op");
return ValueLatticeElement::getRange(ConstantRange(OpConstVal)); return ValueLatticeElement::getRange(ConstantRange(OpConstVal));
} }
return ValueLatticeElement::getOverdefined(); return ValueLatticeElement::getOverdefined();
▲ Show 20 Lines • Show All 687 Lines • Show Last 20 Lines

llvm/lib/Analysis/LoopAccessAnalysis.cpp

Show First 20 Lines • Show All 2,381 Lines • ▼ Show 20 Linesvoid LoopAccessInfo::analyzeLoop(AAResults *AA, LoopInfo *LI,
// Find pointers with computable bounds. We are going to use this information // Find pointers with computable bounds. We are going to use this information
// to place a runtime bound check. // to place a runtime bound check.
Value *UncomputablePtr = nullptr; Value *UncomputablePtr = nullptr;
bool CanDoRTIfNeeded = bool CanDoRTIfNeeded =
Accesses.canCheckPtrAtRT(*PtrRtChecking, PSE->getSE(), TheLoop, Accesses.canCheckPtrAtRT(*PtrRtChecking, PSE->getSE(), TheLoop,
SymbolicStrides, UncomputablePtr, false); SymbolicStrides, UncomputablePtr, false);
if (!CanDoRTIfNeeded) { if (!CanDoRTIfNeeded) {
auto *I = dyn_cast_or_null<Instruction>(UncomputablePtr); auto *I = dyn_cast_if_present<Instruction>(UncomputablePtr);
recordAnalysis("CantIdentifyArrayBounds", I) recordAnalysis("CantIdentifyArrayBounds", I)
<< "cannot identify array bounds"; << "cannot identify array bounds";
LLVM_DEBUG(dbgs() << "LAA: We can't vectorize because we can't find " LLVM_DEBUG(dbgs() << "LAA: We can't vectorize because we can't find "
<< "the array bounds.\n"); << "the array bounds.\n");
CanVecMem = false; CanVecMem = false;
return; return;
} }
Show All 18 Lines if (!CanVecMem && DepChecker->shouldRetryWithRuntimeCheck()) {
auto *SE = PSE->getSE(); auto *SE = PSE->getSE();
UncomputablePtr = nullptr; UncomputablePtr = nullptr;
CanDoRTIfNeeded = Accesses.canCheckPtrAtRT( CanDoRTIfNeeded = Accesses.canCheckPtrAtRT(
*PtrRtChecking, SE, TheLoop, SymbolicStrides, UncomputablePtr, true); *PtrRtChecking, SE, TheLoop, SymbolicStrides, UncomputablePtr, true);
// Check that we found the bounds for the pointer. // Check that we found the bounds for the pointer.
if (!CanDoRTIfNeeded) { if (!CanDoRTIfNeeded) {
auto *I = dyn_cast_or_null<Instruction>(UncomputablePtr); auto *I = dyn_cast_if_present<Instruction>(UncomputablePtr);
recordAnalysis("CantCheckMemDepsAtRunTime", I) recordAnalysis("CantCheckMemDepsAtRunTime", I)
<< "cannot check memory dependencies at runtime"; << "cannot check memory dependencies at runtime";
LLVM_DEBUG(dbgs() << "LAA: Can't vectorize with memory checks\n"); LLVM_DEBUG(dbgs() << "LAA: Can't vectorize with memory checks\n");
CanVecMem = false; CanVecMem = false;
return; return;
} }
CanVecMem = true; CanVecMem = true;
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines case MemoryDepChecker::Dependence::BackwardVectorizableButPreventsForwarding:
break; break;
case MemoryDepChecker::Dependence::Unknown: case MemoryDepChecker::Dependence::Unknown:
R << "\nUnknown data dependence."; R << "\nUnknown data dependence.";
break; break;
} }
if (Instruction *I = Dep.getSource(*this)) { if (Instruction *I = Dep.getSource(*this)) {
DebugLoc SourceLoc = I->getDebugLoc(); DebugLoc SourceLoc = I->getDebugLoc();
if (auto *DD = dyn_cast_or_null<Instruction>(getPointerOperand(I))) if (auto *DD = dyn_cast_if_present<Instruction>(getPointerOperand(I)))
SourceLoc = DD->getDebugLoc(); SourceLoc = DD->getDebugLoc();
if (SourceLoc) if (SourceLoc)
R << " Memory location is the same as accessed at " R << " Memory location is the same as accessed at "
<< ore::NV("Location", SourceLoc); << ore::NV("Location", SourceLoc);
} }
} }
bool LoopAccessInfo::blockNeedsPredication(BasicBlock *BB, Loop *TheLoop, bool LoopAccessInfo::blockNeedsPredication(BasicBlock *BB, Loop *TheLoop,
▲ Show 20 Lines • Show All 222 Lines • Show Last 20 Lines

llvm/lib/Analysis/LoopCacheAnalysis.cpp

Show First 20 Lines • Show All 238 Lines • ▼ Show 20 LinesOptional<bool> IndexedReference::hasTemporalReuse(const IndexedReference &Other,
// Check the dependence distance at every loop level. There is temporal reuse // Check the dependence distance at every loop level. There is temporal reuse
// if the distance at the given loop's depth is small (|d| <= MaxDistance) and // if the distance at the given loop's depth is small (|d| <= MaxDistance) and
// it is zero at every other loop level. // it is zero at every other loop level.
int LoopDepth = L.getLoopDepth(); int LoopDepth = L.getLoopDepth();
int Levels = D->getLevels(); int Levels = D->getLevels();
for (int Level = 1; Level <= Levels; ++Level) { for (int Level = 1; Level <= Levels; ++Level) {
const SCEV *Distance = D->getDistance(Level); const SCEV *Distance = D->getDistance(Level);
const SCEVConstant *SCEVConst = dyn_cast_or_null<SCEVConstant>(Distance); const SCEVConstant *SCEVConst = dyn_cast_if_present<SCEVConstant>(Distance);
if (SCEVConst == nullptr) { if (SCEVConst == nullptr) {
LLVM_DEBUG(dbgs().indent(2) << "No temporal reuse: distance unknown\n"); LLVM_DEBUG(dbgs().indent(2) << "No temporal reuse: distance unknown\n");
return None; return None;
} }
const ConstantInt &CI = *SCEVConst->getValue(); const ConstantInt &CI = *SCEVConst->getValue();
if (Level != LoopDepth && !CI.isZero()) { if (Level != LoopDepth && !CI.isZero()) {
▲ Show 20 Lines • Show All 486 Lines • Show Last 20 Lines

llvm/lib/Analysis/LoopInfo.cpp

Show First 20 Lines • Show All 163 Lines • ▼ Show 20 Lines if (ConstantInt *CI =
return PN; return PN;
} }
return nullptr; return nullptr;
} }
/// Get the latch condition instruction. /// Get the latch condition instruction.
ICmpInst *Loop::getLatchCmpInst() const { ICmpInst *Loop::getLatchCmpInst() const {
if (BasicBlock *Latch = getLoopLatch()) if (BasicBlock *Latch = getLoopLatch())
if (BranchInst *BI = dyn_cast_or_null<BranchInst>(Latch->getTerminator())) if (BranchInst *BI =
dyn_cast_if_present<BranchInst>(Latch->getTerminator()))
if (BI->isConditional()) if (BI->isConditional())
return dyn_cast<ICmpInst>(BI->getCondition()); return dyn_cast<ICmpInst>(BI->getCondition());
return nullptr; return nullptr;
} }
/// Return the final value of the loop induction variable if found. /// Return the final value of the loop induction variable if found.
static Value *findFinalIVValue(const Loop &L, const PHINode &IndVar, static Value *findFinalIVValue(const Loop &L, const PHINode &IndVar,
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
} }
using Direction = Loop::LoopBounds::Direction; using Direction = Loop::LoopBounds::Direction;
ICmpInst::Predicate Loop::LoopBounds::getCanonicalPredicate() const { ICmpInst::Predicate Loop::LoopBounds::getCanonicalPredicate() const {
BasicBlock *Latch = L.getLoopLatch(); BasicBlock *Latch = L.getLoopLatch();
assert(Latch && "Expecting valid latch"); assert(Latch && "Expecting valid latch");
BranchInst *BI = dyn_cast_or_null<BranchInst>(Latch->getTerminator()); BranchInst *BI = dyn_cast_if_present<BranchInst>(Latch->getTerminator());
assert(BI && BI->isConditional() && "Expecting conditional latch branch"); assert(BI && BI->isConditional() && "Expecting conditional latch branch");
ICmpInst *LatchCmpInst = dyn_cast<ICmpInst>(BI->getCondition()); ICmpInst *LatchCmpInst = dyn_cast<ICmpInst>(BI->getCondition());
assert(LatchCmpInst && assert(LatchCmpInst &&
"Expecting the latch compare instruction to be a CmpInst"); "Expecting the latch compare instruction to be a CmpInst");
// Need to inverse the predicate when first successor is not the loop // Need to inverse the predicate when first successor is not the loop
// header // header
▲ Show 20 Lines • Show All 163 Lines • ▼ Show 20 Lines else
return nullptr; return nullptr;
} }
bool Loop::isCanonical(ScalarEvolution &SE) const { bool Loop::isCanonical(ScalarEvolution &SE) const {
InductionDescriptor IndDesc; InductionDescriptor IndDesc;
if (!getInductionDescriptor(SE, IndDesc)) if (!getInductionDescriptor(SE, IndDesc))
return false; return false;
ConstantInt *Init = dyn_cast_or_null<ConstantInt>(IndDesc.getStartValue()); ConstantInt *Init = dyn_cast_if_present<ConstantInt>(IndDesc.getStartValue());
if (!Init || !Init->isZero()) if (!Init || !Init->isZero())
return false; return false;
if (IndDesc.getInductionOpcode() != Instruction::Add) if (IndDesc.getInductionOpcode() != Instruction::Add)
return false; return false;
ConstantInt *Step = IndDesc.getConstIntStepValue(); ConstantInt *Step = IndDesc.getConstIntStepValue();
if (!Step || !Step->isOne()) if (!Step || !Step->isOne())
▲ Show 20 Lines • Show All 804 Lines • Show Last 20 Lines

llvm/lib/Analysis/MemoryDependenceAnalysis.cpp

Show First 20 Lines • Show All 894 Lines • ▼ Show 20 Lines
/// If we do a lookup, add the result to the cache. /// If we do a lookup, add the result to the cache.
MemDepResult MemoryDependenceResults::getNonLocalInfoForBlock( MemDepResult MemoryDependenceResults::getNonLocalInfoForBlock(
Instruction *QueryInst, const MemoryLocation &Loc, bool isLoad, Instruction *QueryInst, const MemoryLocation &Loc, bool isLoad,
BasicBlock *BB, NonLocalDepInfo *Cache, unsigned NumSortedEntries, BasicBlock *BB, NonLocalDepInfo *Cache, unsigned NumSortedEntries,
BatchAAResults &BatchAA) { BatchAAResults &BatchAA) {
bool isInvariantLoad = false; bool isInvariantLoad = false;
if (LoadInst *LI = dyn_cast_or_null<LoadInst>(QueryInst)) if (LoadInst *LI = dyn_cast_if_present<LoadInst>(QueryInst))
isInvariantLoad = LI->getMetadata(LLVMContext::MD_invariant_load); isInvariantLoad = LI->getMetadata(LLVMContext::MD_invariant_load);
// Do a binary search to see if we already have an entry for this block in // Do a binary search to see if we already have an entry for this block in
// the cache set. If so, find it. // the cache set. If so, find it.
NonLocalDepInfo::iterator Entry = std::upper_bound( NonLocalDepInfo::iterator Entry = std::upper_bound(
Cache->begin(), Cache->begin() + NumSortedEntries, NonLocalDepEntry(BB)); Cache->begin(), Cache->begin() + NumSortedEntries, NonLocalDepEntry(BB));
if (Entry != Cache->begin() && (Entry - 1)->getBB() == BB) if (Entry != Cache->begin() && (Entry - 1)->getBB() == BB)
--Entry; --Entry;
▲ Show 20 Lines • Show All 126 Lines • ▼ Show 20 Linesbool MemoryDependenceResults::getNonLocalPointerDepFromBB(
// CacheKey, this value will be inserted as the associated value. Otherwise, // CacheKey, this value will be inserted as the associated value. Otherwise,
// it'll be ignored, and we'll have to check to see if the cached size and // it'll be ignored, and we'll have to check to see if the cached size and
// aa tags are consistent with the current query. // aa tags are consistent with the current query.
NonLocalPointerInfo InitialNLPI; NonLocalPointerInfo InitialNLPI;
InitialNLPI.Size = Loc.Size; InitialNLPI.Size = Loc.Size;
InitialNLPI.AATags = Loc.AATags; InitialNLPI.AATags = Loc.AATags;
bool isInvariantLoad = false; bool isInvariantLoad = false;
if (LoadInst *LI = dyn_cast_or_null<LoadInst>(QueryInst)) if (LoadInst *LI = dyn_cast_if_present<LoadInst>(QueryInst))
isInvariantLoad = LI->getMetadata(LLVMContext::MD_invariant_load); isInvariantLoad = LI->getMetadata(LLVMContext::MD_invariant_load);
// Get the NLPI for CacheKey, inserting one into the map if it doesn't // Get the NLPI for CacheKey, inserting one into the map if it doesn't
// already have one. // already have one.
std::pair<CachedNonLocalPointerInfo::iterator, bool> Pair = std::pair<CachedNonLocalPointerInfo::iterator, bool> Pair =
NonLocalPointerDeps.insert(std::make_pair(CacheKey, InitialNLPI)); NonLocalPointerDeps.insert(std::make_pair(CacheKey, InitialNLPI));
NonLocalPointerInfo *CacheInfo = &Pair.first->second; NonLocalPointerInfo *CacheInfo = &Pair.first->second;
▲ Show 20 Lines • Show All 743 Lines • Show Last 20 Lines

llvm/lib/Analysis/MemorySSA.cpp

Show First 20 Lines • Show All 309 Lines • ▼ Show 20 Lines if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(DefInst)) {
case Intrinsic::dbg_label: case Intrinsic::dbg_label:
case Intrinsic::dbg_value: case Intrinsic::dbg_value:
llvm_unreachable("debuginfo shouldn't have associated defs!"); llvm_unreachable("debuginfo shouldn't have associated defs!");
default: default:
break; break;
} }
} }
if (auto *CB = dyn_cast_or_null<CallBase>(UseInst)) { if (auto *CB = dyn_cast_if_present<CallBase>(UseInst)) {
ModRefInfo I = AA.getModRefInfo(DefInst, CB); ModRefInfo I = AA.getModRefInfo(DefInst, CB);
return isModOrRefSet(I); return isModOrRefSet(I);
} }
if (auto *DefLoad = dyn_cast<LoadInst>(DefInst)) if (auto *DefLoad = dyn_cast<LoadInst>(DefInst))
if (auto *UseLoad = dyn_cast_or_null<LoadInst>(UseInst)) if (auto *UseLoad = dyn_cast_if_present<LoadInst>(UseInst))
return !areLoadsReorderable(UseLoad, DefLoad); return !areLoadsReorderable(UseLoad, DefLoad);
ModRefInfo I = AA.getModRefInfo(DefInst, UseLoc); ModRefInfo I = AA.getModRefInfo(DefInst, UseLoc);
return isModSet(I); return isModSet(I);
} }
template <typename AliasAnalysisType> template <typename AliasAnalysisType>
static bool instructionClobbersQuery(MemoryDef *MD, const MemoryUseOrDef *MU, static bool instructionClobbersQuery(MemoryDef *MD, const MemoryUseOrDef *MU,
▲ Show 20 Lines • Show All 2,327 Lines • Show Last 20 Lines

llvm/lib/Analysis/MemorySSAUpdater.cpp

Show First 20 Lines • Show All 80 Lines • ▼ Show 20 Lines for (auto *Pred : predecessors(BB)) {
UniqueIncomingAccess = false; UniqueIncomingAccess = false;
PhiOps.push_back(IncomingAccess); PhiOps.push_back(IncomingAccess);
} else } else
PhiOps.push_back(MSSA->getLiveOnEntryDef()); PhiOps.push_back(MSSA->getLiveOnEntryDef());
} }
// Now try to simplify the ops to avoid placing a phi. // Now try to simplify the ops to avoid placing a phi.
// This may return null if we never created a phi yet, that's okay // This may return null if we never created a phi yet, that's okay
MemoryPhi *Phi = dyn_cast_or_null<MemoryPhi>(MSSA->getMemoryAccess(BB)); MemoryPhi *Phi = dyn_cast_if_present<MemoryPhi>(MSSA->getMemoryAccess(BB));
// See if we can avoid the phi by simplifying it. // See if we can avoid the phi by simplifying it.
auto *Result = tryRemoveTrivialPhi(Phi, PhiOps); auto *Result = tryRemoveTrivialPhi(Phi, PhiOps);
// If we couldn't simplify, we may have to create a phi // If we couldn't simplify, we may have to create a phi
if (Result == Phi && UniqueIncomingAccess && SingleAccess) { if (Result == Phi && UniqueIncomingAccess && SingleAccess) {
// A concrete Phi only exists if we created an empty one to break a cycle. // A concrete Phi only exists if we created an empty one to break a cycle.
if (Phi) { if (Phi) {
assert(Phi->operands().empty() && "Expected empty Phi"); assert(Phi->operands().empty() && "Expected empty Phi");
▲ Show 20 Lines • Show All 342 Lines • ▼ Show 20 Lines if (RenameUses) {
// incoming value. // incoming value.
if (auto *MD = dyn_cast<MemoryDef>(FirstDef)) if (auto *MD = dyn_cast<MemoryDef>(FirstDef))
FirstDef = MD->getDefiningAccess(); FirstDef = MD->getDefiningAccess();
MSSA->renamePass(MD->getBlock(), FirstDef, Visited); MSSA->renamePass(MD->getBlock(), FirstDef, Visited);
// We just inserted a phi into this block, so the incoming value will become // We just inserted a phi into this block, so the incoming value will become
// the phi anyway, so it does not matter what we pass. // the phi anyway, so it does not matter what we pass.
for (auto &MP : InsertedPHIs) { for (auto &MP : InsertedPHIs) {
MemoryPhi *Phi = dyn_cast_or_null<MemoryPhi>(MP); MemoryPhi *Phi = dyn_cast_if_present<MemoryPhi>(MP);
if (Phi) if (Phi)
MSSA->renamePass(Phi->getBlock(), nullptr, Visited); MSSA->renamePass(Phi->getBlock(), nullptr, Visited);
} }
// Existing Phi blocks may need renaming too, if an access was previously // Existing Phi blocks may need renaming too, if an access was previously
// optimized and the inserted Defs "covers" the Optimized value. // optimized and the inserted Defs "covers" the Optimized value.
for (const auto &MP : ExistingPhis) { for (const auto &MP : ExistingPhis) {
MemoryPhi *Phi = dyn_cast_or_null<MemoryPhi>(MP); MemoryPhi *Phi = dyn_cast_if_present<MemoryPhi>(MP);
if (Phi) if (Phi)
MSSA->renamePass(Phi->getBlock(), nullptr, Visited); MSSA->renamePass(Phi->getBlock(), nullptr, Visited);
} }
} }
} }
void MemorySSAUpdater::fixupDefs(const SmallVectorImpl<WeakVH> &Vars) { void MemorySSAUpdater::fixupDefs(const SmallVectorImpl<WeakVH> &Vars) {
SmallPtrSet<const BasicBlock *, 8> Seen; SmallPtrSet<const BasicBlock *, 8> Seen;
SmallVector<const BasicBlock *, 16> Worklist; SmallVector<const BasicBlock *, 16> Worklist;
for (const auto &Var : Vars) { for (const auto &Var : Vars) {
MemoryAccess *NewDef = dyn_cast_or_null<MemoryAccess>(Var); MemoryAccess *NewDef = dyn_cast_if_present<MemoryAccess>(Var);
if (!NewDef) if (!NewDef)
continue; continue;
// First, see if there is a local def after the operand. // First, see if there is a local def after the operand.
auto *Defs = MSSA->getWritableBlockDefs(NewDef->getBlock()); auto *Defs = MSSA->getWritableBlockDefs(NewDef->getBlock());
auto DefIter = NewDef->getDefsIterator(); auto DefIter = NewDef->getDefsIterator();
// The temporary Phi is being fixed, unmark it for not to optimize. // The temporary Phi is being fixed, unmark it for not to optimize.
if (MemoryPhi *Phi = dyn_cast<MemoryPhi>(NewDef)) if (MemoryPhi *Phi = dyn_cast<MemoryPhi>(NewDef))
▲ Show 20 Lines • Show All 140 Lines • ▼ Show 20 Lines if (const MemoryUseOrDef *MUD = dyn_cast<MemoryUseOrDef>(&MA)) {
// Entry does not exist if the clone of the block did not clone all // Entry does not exist if the clone of the block did not clone all
// instructions. This occurs in LoopRotate when cloning instructions // instructions. This occurs in LoopRotate when cloning instructions
// from the old header to the old preheader. The cloned instruction may // from the old header to the old preheader. The cloned instruction may
// also be a simplified Value, not an Instruction (see LoopRotate). // also be a simplified Value, not an Instruction (see LoopRotate).
// Also in LoopRotate, even when it's an instruction, due to it being // Also in LoopRotate, even when it's an instruction, due to it being
// simplified, it may be a Use rather than a Def, so we cannot use MUD as // simplified, it may be a Use rather than a Def, so we cannot use MUD as
// template. Calls coming from updateForClonedBlockIntoPred, ensure this. // template. Calls coming from updateForClonedBlockIntoPred, ensure this.
if (Instruction *NewInsn = if (Instruction *NewInsn =
dyn_cast_or_null<Instruction>(VMap.lookup(Insn))) { dyn_cast_if_present<Instruction>(VMap.lookup(Insn))) {
MemoryAccess *NewUseOrDef = MSSA->createDefinedAccess( MemoryAccess *NewUseOrDef = MSSA->createDefinedAccess(
NewInsn, NewInsn,
getNewDefiningAccessForClone(MUD->getDefiningAccess(), VMap, getNewDefiningAccessForClone(MUD->getDefiningAccess(), VMap,
MPhiMap, CloneWasSimplified, MSSA), MPhiMap, CloneWasSimplified, MSSA),
/*Template=*/CloneWasSimplified ? nullptr : MUD, /*Template=*/CloneWasSimplified ? nullptr : MUD,
/*CreationMustSucceed=*/CloneWasSimplified ? false : true); /*CreationMustSucceed=*/CloneWasSimplified ? false : true);
if (NewUseOrDef) if (NewUseOrDef)
MSSA->insertIntoListsForBlock(NewUseOrDef, NewBB, MemorySSA::End); MSSA->insertIntoListsForBlock(NewUseOrDef, NewBB, MemorySSA::End);
▲ Show 20 Lines • Show All 824 Lines • Show Last 20 Lines

llvm/lib/Analysis/MustExecute.cpp

Show First 20 Lines • Show All 135 Lines • ▼ Show 20 Linesstatic bool CanProveNotTakenFirstIteration(const BasicBlock *ExitBlock,
// plumbing is currently missing to pass a pointer in from the pass // plumbing is currently missing to pass a pointer in from the pass
// Check for cmp (phi [x, preheader] ...), y where (pred x, y is known // Check for cmp (phi [x, preheader] ...), y where (pred x, y is known
auto *LHS = dyn_cast<PHINode>(Cond->getOperand(0)); auto *LHS = dyn_cast<PHINode>(Cond->getOperand(0));
auto *RHS = Cond->getOperand(1); auto *RHS = Cond->getOperand(1);
if (!LHS || LHS->getParent() != CurLoop->getHeader()) if (!LHS || LHS->getParent() != CurLoop->getHeader())
return false; return false;
auto DL = ExitBlock->getModule()->getDataLayout(); auto DL = ExitBlock->getModule()->getDataLayout();
auto *IVStart = LHS->getIncomingValueForBlock(CurLoop->getLoopPreheader()); auto *IVStart = LHS->getIncomingValueForBlock(CurLoop->getLoopPreheader());
auto *SimpleValOrNull = simplifyCmpInst(Cond->getPredicate(), auto *SimpleValOrNull =
IVStart, RHS, simplifyCmpInst(Cond->getPredicate(), IVStart, RHS,
{DL, /*TLI*/ nullptr, {DL, /*TLI*/ nullptr, DT, /*AC*/ nullptr, BI});
DT, /*AC*/ nullptr, BI}); auto *SimpleCst = dyn_cast_if_present<Constant>(SimpleValOrNull);
auto *SimpleCst = dyn_cast_or_null<Constant>(SimpleValOrNull);
if (!SimpleCst) if (!SimpleCst)
return false; return false;
if (ExitBlock == BI->getSuccessor(0)) if (ExitBlock == BI->getSuccessor(0))
return SimpleCst->isZeroValue(); return SimpleCst->isZeroValue();
assert(ExitBlock == BI->getSuccessor(1) && "implied by above"); assert(ExitBlock == BI->getSuccessor(1) && "implied by above");
return SimpleCst->isAllOnesValue(); return SimpleCst->isAllOnesValue();
} }
▲ Show 20 Lines • Show All 718 Lines • Show Last 20 Lines

llvm/lib/Analysis/PHITransAddr.cpp

Show First 20 Lines • Show All 319 Lines • ▼ Show 20 Lines if (DT && DT->isReachableFromEntry(PredBB))
Addr = Addr =
PHITranslateSubExpr(Addr, CurBB, PredBB, MustDominate ? DT : nullptr); PHITranslateSubExpr(Addr, CurBB, PredBB, MustDominate ? DT : nullptr);
else else
Addr = nullptr; Addr = nullptr;
assert(Verify() && "Invalid PHITransAddr!"); assert(Verify() && "Invalid PHITransAddr!");
if (MustDominate) if (MustDominate)
// Make sure the value is live in the predecessor. // Make sure the value is live in the predecessor.
if (Instruction *Inst = dyn_cast_or_null<Instruction>(Addr)) if (Instruction *Inst = dyn_cast_if_present<Instruction>(Addr))
if (!DT->dominates(Inst->getParent(), PredBB)) if (!DT->dominates(Inst->getParent(), PredBB))
Addr = nullptr; Addr = nullptr;
return Addr == nullptr; return Addr == nullptr;
} }
/// PHITranslateWithInsertion - PHI translate this value into the specified /// PHITranslateWithInsertion - PHI translate this value into the specified
/// predecessor block, inserting a computation of the value if it is /// predecessor block, inserting a computation of the value if it is
▲ Show 20 Lines • Show All 105 Lines • Show Last 20 Lines

llvm/lib/Analysis/ScalarEvolution.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 9,451 Lines • ▼ Show 20 Linesconst SCEV *ScalarEvolution::computeExitCountExhaustively(const Loop *L,
if (!CurrentIterVals.count(PN)) if (!CurrentIterVals.count(PN))
return getCouldNotCompute(); return getCouldNotCompute();
// Okay, we find a PHI node that defines the trip count of this loop. Execute // Okay, we find a PHI node that defines the trip count of this loop. Execute
// the loop symbolically to determine when the condition gets a value of // the loop symbolically to determine when the condition gets a value of
// "ExitWhen". // "ExitWhen".
unsigned MaxIterations = MaxBruteForceIterations; // Limit analysis. unsigned MaxIterations = MaxBruteForceIterations; // Limit analysis.
const DataLayout &DL = getDataLayout(); const DataLayout &DL = getDataLayout();
for (unsigned IterationNum = 0; IterationNum != MaxIterations;++IterationNum){ for (unsigned IterationNum = 0; IterationNum != MaxIterations;
auto *CondVal = dyn_cast_or_null<ConstantInt>( ++IterationNum) {
auto *CondVal = dyn_cast_if_present<ConstantInt>(
EvaluateExpression(Cond, L, CurrentIterVals, DL, &TLI)); EvaluateExpression(Cond, L, CurrentIterVals, DL, &TLI));
// Couldn't symbolically evaluate. // Couldn't symbolically evaluate.
if (!CondVal) return getCouldNotCompute(); if (!CondVal) return getCouldNotCompute();
if (CondVal->getValue() == uint64_t(ExitWhen)) { if (CondVal->getValue() == uint64_t(ExitWhen)) {
++NumBruteForceTripCountsComputed; ++NumBruteForceTripCountsComputed;
return getConstant(Type::getInt32Ty(getContext()), IterationNum); return getConstant(Type::getInt32Ty(getContext()), IterationNum);
▲ Show 20 Lines • Show All 5,388 Lines • Show Last 20 Lines

llvm/lib/Analysis/TypeBasedAliasAnalysis.cpp

Show First 20 Lines • Show All 161 Lines • ▼ Show 20 Linespublic:
/// getParent - Get this TBAANode's Alias tree parent. /// getParent - Get this TBAANode's Alias tree parent.
TBAANodeImpl<MDNodeTy> getParent() const { TBAANodeImpl<MDNodeTy> getParent() const {
if (isNewFormat()) if (isNewFormat())
return TBAANodeImpl(cast<MDNodeTy>(Node->getOperand(0))); return TBAANodeImpl(cast<MDNodeTy>(Node->getOperand(0)));
if (Node->getNumOperands() < 2) if (Node->getNumOperands() < 2)
return TBAANodeImpl<MDNodeTy>(); return TBAANodeImpl<MDNodeTy>();
MDNodeTy *P = dyn_cast_or_null<MDNodeTy>(Node->getOperand(1)); MDNodeTy *P = dyn_cast_if_present<MDNodeTy>(Node->getOperand(1));
if (!P) if (!P)
return TBAANodeImpl<MDNodeTy>(); return TBAANodeImpl<MDNodeTy>();
// Ok, this node has a valid parent. Return it. // Ok, this node has a valid parent. Return it.
return TBAANodeImpl<MDNodeTy>(P); return TBAANodeImpl<MDNodeTy>(P);
} }
/// Test if this TBAANode represents a type for objects which are /// Test if this TBAANode represents a type for objects which are
/// not modified (by any means) in the context where this /// not modified (by any means) in the context where this
Show All 36 Lines if (Node->getNumOperands() < 4)
return false; return false;
if (MDNodeTy *AccessType = getAccessType()) if (MDNodeTy *AccessType = getAccessType())
if (!TBAANodeImpl<MDNodeTy>(AccessType).isNewFormat()) if (!TBAANodeImpl<MDNodeTy>(AccessType).isNewFormat())
return false; return false;
return true; return true;
} }
MDNodeTy *getBaseType() const { MDNodeTy *getBaseType() const {
return dyn_cast_or_null<MDNode>(Node->getOperand(0)); return dyn_cast_if_present<MDNode>(Node->getOperand(0));
} }
MDNodeTy *getAccessType() const { MDNodeTy *getAccessType() const {
return dyn_cast_or_null<MDNode>(Node->getOperand(1)); return dyn_cast_if_present<MDNode>(Node->getOperand(1));
} }
uint64_t getOffset() const { uint64_t getOffset() const {
return mdconst::extract<ConstantInt>(Node->getOperand(2))->getZExtValue(); return mdconst::extract<ConstantInt>(Node->getOperand(2))->getZExtValue();
} }
uint64_t getSize() const { uint64_t getSize() const {
if (!isNewFormat()) if (!isNewFormat())
▲ Show 20 Lines • Show All 82 Lines • ▼ Show 20 Lines if (NewFormat) {
// Fast path for a scalar type node and a struct type node with a single // Fast path for a scalar type node and a struct type node with a single
// field. // field.
if (NumOperands <= 3) { if (NumOperands <= 3) {
uint64_t Cur = uint64_t Cur =
NumOperands == 2 NumOperands == 2
? 0 ? 0
: mdconst::extract<ConstantInt>(Operands[2])->getZExtValue(); : mdconst::extract<ConstantInt>(Operands[2])->getZExtValue();
Offset -= Cur; Offset -= Cur;
MDNode *P = dyn_cast_or_null<MDNode>(Operands[1]); MDNode *P = dyn_cast_if_present<MDNode>(Operands[1]);
if (!P) if (!P)
return TBAAStructTypeNode(); return TBAAStructTypeNode();
return TBAAStructTypeNode(P); return TBAAStructTypeNode(P);
} }
} }
// Assume the offsets are in order. We return the previous field if // Assume the offsets are in order. We return the previous field if
// the current offset is bigger than the given offset. // the current offset is bigger than the given offset.
Show All 13 Lines for (unsigned Idx = FirstFieldOpNo; Idx < NumOperands;
} }
} }
// Move along the last field. // Move along the last field.
if (TheIdx == 0) if (TheIdx == 0)
TheIdx = NumOperands - NumOpsPerField; TheIdx = NumOperands - NumOpsPerField;
uint64_t Cur = uint64_t Cur =
mdconst::extract<ConstantInt>(Operands[TheIdx + 1])->getZExtValue(); mdconst::extract<ConstantInt>(Operands[TheIdx + 1])->getZExtValue();
Offset -= Cur; Offset -= Cur;
MDNode *P = dyn_cast_or_null<MDNode>(Operands[TheIdx]); MDNode *P = dyn_cast_if_present<MDNode>(Operands[TheIdx]);
if (!P) if (!P)
return TBAAStructTypeNode(); return TBAAStructTypeNode();
return TBAAStructTypeNode(P); return TBAAStructTypeNode(P);
} }
}; };
} // end anonymous namespace } // end anonymous namespace
▲ Show 20 Lines • Show All 461 Lines • Show Last 20 Lines

llvm/lib/Analysis/ValueTracking.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 2,013 Lines • ▼ Show 20 Lines#endif
if (const auto *CV = dyn_cast<ConstantVector>(V)) { if (const auto *CV = dyn_cast<ConstantVector>(V)) {
// We know that CV must be a vector of integers. Take the intersection of // We know that CV must be a vector of integers. Take the intersection of
// each element. // each element.
Known.Zero.setAllBits(); Known.One.setAllBits(); Known.Zero.setAllBits(); Known.One.setAllBits();
for (unsigned i = 0, e = CV->getNumOperands(); i != e; ++i) { for (unsigned i = 0, e = CV->getNumOperands(); i != e; ++i) {
if (!DemandedElts[i]) if (!DemandedElts[i])
continue; continue;
Constant *Element = CV->getAggregateElement(i); Constant *Element = CV->getAggregateElement(i);
auto *ElementCI = dyn_cast_or_null<ConstantInt>(Element); auto *ElementCI = dyn_cast_if_present<ConstantInt>(Element);
if (!ElementCI) { if (!ElementCI) {
Known.resetAll(); Known.resetAll();
return; return;
} }
const APInt &Elt = ElementCI->getValue(); const APInt &Elt = ElementCI->getValue();
Known.Zero &= ~Elt; Known.Zero &= ~Elt;
Known.One &= Elt; Known.One &= Elt;
} }
▲ Show 20 Lines • Show All 1,033 Lines • ▼ Show 20 Lines if (!CV || !isa<FixedVectorType>(CV->getType()))
return 0; return 0;
unsigned MinSignBits = TyBits; unsigned MinSignBits = TyBits;
unsigned NumElts = cast<FixedVectorType>(CV->getType())->getNumElements(); unsigned NumElts = cast<FixedVectorType>(CV->getType())->getNumElements();
for (unsigned i = 0; i != NumElts; ++i) { for (unsigned i = 0; i != NumElts; ++i) {
if (!DemandedElts[i]) if (!DemandedElts[i])
continue; continue;
// If we find a non-ConstantInt, bail out. // If we find a non-ConstantInt, bail out.
auto *Elt = dyn_cast_or_null<ConstantInt>(CV->getAggregateElement(i)); auto *Elt = dyn_cast_if_present<ConstantInt>(CV->getAggregateElement(i));
if (!Elt) if (!Elt)
return 0; return 0;
MinSignBits = std::min(MinSignBits, Elt->getValue().getNumSignBits()); MinSignBits = std::min(MinSignBits, Elt->getValue().getNumSignBits());
} }
return MinSignBits; return MinSignBits;
} }
▲ Show 20 Lines • Show All 517 Lines • ▼ Show 20 Lines return !CFP->getValueAPF().isNegative() ||
(!SignBitOnly && CFP->getValueAPF().isZero()); (!SignBitOnly && CFP->getValueAPF().isZero());
} }
// Handle vector of constants. // Handle vector of constants.
if (auto *CV = dyn_cast<Constant>(V)) { if (auto *CV = dyn_cast<Constant>(V)) {
if (auto *CVFVTy = dyn_cast<FixedVectorType>(CV->getType())) { if (auto *CVFVTy = dyn_cast<FixedVectorType>(CV->getType())) {
unsigned NumElts = CVFVTy->getNumElements(); unsigned NumElts = CVFVTy->getNumElements();
for (unsigned i = 0; i != NumElts; ++i) { for (unsigned i = 0; i != NumElts; ++i) {
auto *CFP = dyn_cast_or_null<ConstantFP>(CV->getAggregateElement(i)); auto *CFP = dyn_cast_if_present<ConstantFP>(CV->getAggregateElement(i));
if (!CFP) if (!CFP)
return false; return false;
if (CFP->getValueAPF().isNegative() && if (CFP->getValueAPF().isNegative() &&
(SignBitOnly || !CFP->getValueAPF().isZero())) (SignBitOnly || !CFP->getValueAPF().isZero()))
return false; return false;
} }
// All non-negative ConstantFPs. // All non-negative ConstantFPs.
▲ Show 20 Lines • Show All 1,527 Lines • ▼ Show 20 Lines if (auto *C = dyn_cast<Constant>(Op->getOperand(1))) {
for (unsigned i = 0; i < NumElts; ++i) for (unsigned i = 0; i < NumElts; ++i)
ShiftAmounts.push_back(C->getAggregateElement(i)); ShiftAmounts.push_back(C->getAggregateElement(i));
} else if (isa<ScalableVectorType>(C->getType())) } else if (isa<ScalableVectorType>(C->getType()))
return true; // Can't tell, just return true to be safe return true; // Can't tell, just return true to be safe
else else
ShiftAmounts.push_back(C); ShiftAmounts.push_back(C);
bool Safe = llvm::all_of(ShiftAmounts, [](Constant *C) { bool Safe = llvm::all_of(ShiftAmounts, [](Constant *C) {
auto *CI = dyn_cast_or_null<ConstantInt>(C); auto *CI = dyn_cast_if_present<ConstantInt>(C);
return CI && CI->getValue().ult(C->getType()->getIntegerBitWidth()); return CI && CI->getValue().ult(C->getType()->getIntegerBitWidth());
}); });
return !Safe; return !Safe;
} }
return true; return true;
} }
case Instruction::FPToSI: case Instruction::FPToSI:
case Instruction::FPToUI: case Instruction::FPToUI:
▲ Show 20 Lines • Show All 232 Lines • ▼ Show 20 Linesstatic bool isGuaranteedNotToBeUndefOrPoison(const Value *V,
// br V, BB1, BB2 // br V, BB1, BB2
// BB1: // BB1:
// CtxI ; V cannot be undef or poison here // CtxI ; V cannot be undef or poison here
auto *Dominator = DNode->getIDom(); auto *Dominator = DNode->getIDom();
while (Dominator) { while (Dominator) {
auto *TI = Dominator->getBlock()->getTerminator(); auto *TI = Dominator->getBlock()->getTerminator();
Value *Cond = nullptr; Value *Cond = nullptr;
if (auto BI = dyn_cast_or_null<BranchInst>(TI)) { if (auto BI = dyn_cast_if_present<BranchInst>(TI)) {
if (BI->isConditional()) if (BI->isConditional())
Cond = BI->getCondition(); Cond = BI->getCondition();
} else if (auto SI = dyn_cast_or_null<SwitchInst>(TI)) { } else if (auto SI = dyn_cast_if_present<SwitchInst>(TI)) {
Cond = SI->getCondition(); Cond = SI->getCondition();
} }
if (Cond) { if (Cond) {
if (Cond == V) if (Cond == V)
return true; return true;
else if (PoisonOnly && isa<Operator>(Cond)) { else if (PoisonOnly && isa<Operator>(Cond)) {
// For poison, we can analyze further // For poison, we can analyze further
▲ Show 20 Lines • Show All 1,972 Lines • Show Last 20 Lines

llvm/lib/AsmParser/LLParser.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 3,069 Lines • ▼ Show 20 Lines return P.error(NameLoc, "multiple definition of local value named '" +
NameStr + "'"); NameStr + "'");
return false; return false;
} }
/// getBB - Get a basic block with the specified name or ID, creating a /// getBB - Get a basic block with the specified name or ID, creating a
/// forward reference record if needed. /// forward reference record if needed.
BasicBlock *LLParser::PerFunctionState::getBB(const std::string &Name, BasicBlock *LLParser::PerFunctionState::getBB(const std::string &Name,
LocTy Loc) { LocTy Loc) {
return dyn_cast_or_null<BasicBlock>( return dyn_cast_if_present<BasicBlock>(
getVal(Name, Type::getLabelTy(F.getContext()), Loc)); getVal(Name, Type::getLabelTy(F.getContext()), Loc));
} }
BasicBlock *LLParser::PerFunctionState::getBB(unsigned ID, LocTy Loc) { BasicBlock *LLParser::PerFunctionState::getBB(unsigned ID, LocTy Loc) {
return dyn_cast_or_null<BasicBlock>( return dyn_cast_if_present<BasicBlock>(
getVal(ID, Type::getLabelTy(F.getContext()), Loc)); getVal(ID, Type::getLabelTy(F.getContext()), Loc));
} }
/// defineBB - Define the specified basic block, which is either named or /// defineBB - Define the specified basic block, which is either named or
/// unnamed. If there is an error, this returns null otherwise it returns /// unnamed. If there is an error, this returns null otherwise it returns
/// the block being defined. /// the block being defined.
BasicBlock *LLParser::PerFunctionState::defineBB(const std::string &Name, BasicBlock *LLParser::PerFunctionState::defineBB(const std::string &Name,
int NameID, LocTy Loc) { int NameID, LocTy Loc) {
▲ Show 20 Lines • Show All 290 Lines • ▼ Show 20 Lines if (BlockAddressPFS && F == &BlockAddressPFS->getFunction()) {
else else
BB = BlockAddressPFS->getBB(Label.StrVal, Label.Loc); BB = BlockAddressPFS->getBB(Label.StrVal, Label.Loc);
if (!BB) if (!BB)
return error(Label.Loc, "referenced value is not a basic block"); return error(Label.Loc, "referenced value is not a basic block");
} else { } else {
if (Label.Kind == ValID::t_LocalID) if (Label.Kind == ValID::t_LocalID)
return error(Label.Loc, "cannot take address of numeric label after " return error(Label.Loc, "cannot take address of numeric label after "
"the function is defined"); "the function is defined");
BB = dyn_cast_or_null<BasicBlock>( BB = dyn_cast_if_present<BasicBlock>(
F->getValueSymbolTable()->lookup(Label.StrVal)); F->getValueSymbolTable()->lookup(Label.StrVal));
if (!BB) if (!BB)
return error(Label.Loc, "referenced value is not a basic block"); return error(Label.Loc, "referenced value is not a basic block");
} }
ID.ConstantVal = BlockAddress::get(F, BB); ID.ConstantVal = BlockAddress::get(F, BB);
ID.Kind = ValID::t_Constant; ID.Kind = ValID::t_Constant;
return false; return false;
▲ Show 20 Lines • Show All 6,099 Lines • Show Last 20 Lines

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 3,134 Lines • ▼ Show 20 Lines case bitc::CST_CODE_CE_GEP_WITH_INRANGE_INDEX: { // [ty, flags, n x
return error("Invalid gep with no operands"); return error("Invalid gep with no operands");
Type *BaseType = getTypeByID(BaseTypeID); Type *BaseType = getTypeByID(BaseTypeID);
if (isa<VectorType>(BaseType)) { if (isa<VectorType>(BaseType)) {
BaseTypeID = getContainedTypeID(BaseTypeID, 0); BaseTypeID = getContainedTypeID(BaseTypeID, 0);
BaseType = getTypeByID(BaseTypeID); BaseType = getTypeByID(BaseTypeID);
} }
PointerType *OrigPtrTy = dyn_cast_or_null<PointerType>(BaseType); PointerType *OrigPtrTy = dyn_cast_if_present<PointerType>(BaseType);
if (!OrigPtrTy) if (!OrigPtrTy)
return error("GEP base operand must be pointer or vector of pointer"); return error("GEP base operand must be pointer or vector of pointer");
if (!PointeeType) { if (!PointeeType) {
PointeeType = getPtrElementTypeByID(BaseTypeID); PointeeType = getPtrElementTypeByID(BaseTypeID);
if (!PointeeType) if (!PointeeType)
return error("Missing element type for old-style constant GEP"); return error("Missing element type for old-style constant GEP");
} else if (!OrigPtrTy->isOpaqueOrPointeeTypeMatches(PointeeType)) } else if (!OrigPtrTy->isOpaqueOrPointeeTypeMatches(PointeeType))
Show All 15 Lines case bitc::CST_CODE_CE_SELECT: { // CE_SELECT: [opval#, opval#, opval#]
{(unsigned)Record[0], (unsigned)Record[1], (unsigned)Record[2]}); {(unsigned)Record[0], (unsigned)Record[1], (unsigned)Record[2]});
break; break;
} }
case bitc::CST_CODE_CE_EXTRACTELT case bitc::CST_CODE_CE_EXTRACTELT
: { // CE_EXTRACTELT: [opty, opval, opty, opval] : { // CE_EXTRACTELT: [opty, opval, opty, opval]
if (Record.size() < 3) if (Record.size() < 3)
return error("Invalid extractelement constexpr record"); return error("Invalid extractelement constexpr record");
unsigned OpTyID = Record[0]; unsigned OpTyID = Record[0];
VectorType *OpTy = VectorType *OpTy = dyn_cast_if_present<VectorType>(getTypeByID(OpTyID));
dyn_cast_or_null<VectorType>(getTypeByID(OpTyID));
if (!OpTy) if (!OpTy)
return error("Invalid extractelement constexpr record"); return error("Invalid extractelement constexpr record");
unsigned IdxRecord; unsigned IdxRecord;
if (Record.size() == 4) { if (Record.size() == 4) {
unsigned IdxTyID = Record[2]; unsigned IdxTyID = Record[2];
Type *IdxTy = getTypeByID(IdxTyID); Type *IdxTy = getTypeByID(IdxTyID);
if (!IdxTy) if (!IdxTy)
return error("Invalid extractelement constexpr record"); return error("Invalid extractelement constexpr record");
Show All 34 Lines case bitc::CST_CODE_CE_SHUFFLEVEC: { // CE_SHUFFLEVEC: [opval, opval, opval]
V = BitcodeConstant::create( V = BitcodeConstant::create(
Alloc, CurTy, Instruction::ShuffleVector, Alloc, CurTy, Instruction::ShuffleVector,
{(unsigned)Record[0], (unsigned)Record[1], (unsigned)Record[2]}); {(unsigned)Record[0], (unsigned)Record[1], (unsigned)Record[2]});
break; break;
} }
case bitc::CST_CODE_CE_SHUFVEC_EX: { // [opty, opval, opval, opval] case bitc::CST_CODE_CE_SHUFVEC_EX: { // [opty, opval, opval, opval]
VectorType *RTy = dyn_cast<VectorType>(CurTy); VectorType *RTy = dyn_cast<VectorType>(CurTy);
VectorType *OpTy = VectorType *OpTy =
dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); dyn_cast_if_present<VectorType>(getTypeByID(Record[0]));
if (Record.size() < 4 || !RTy || !OpTy) if (Record.size() < 4 || !RTy || !OpTy)
return error("Invalid shufflevector constexpr record"); return error("Invalid shufflevector constexpr record");
V = BitcodeConstant::create( V = BitcodeConstant::create(
Alloc, CurTy, Instruction::ShuffleVector, Alloc, CurTy, Instruction::ShuffleVector,
{(unsigned)Record[1], (unsigned)Record[2], (unsigned)Record[3]}); {(unsigned)Record[1], (unsigned)Record[2], (unsigned)Record[3]});
break; break;
} }
case bitc::CST_CODE_CE_CMP: { // CE_CMP: [opty, opval, opval, pred] case bitc::CST_CODE_CE_CMP: { // CE_CMP: [opty, opval, opval, pred]
▲ Show 20 Lines • Show All 97 Lines • ▼ Show 20 Lines case bitc::CST_CODE_INLINEASM_OLD3: {
InlineAsm::AsmDialect(AsmDialect), CanThrow); InlineAsm::AsmDialect(AsmDialect), CanThrow);
break; break;
} }
// This version adds explicit function type. // This version adds explicit function type.
case bitc::CST_CODE_INLINEASM: { case bitc::CST_CODE_INLINEASM: {
if (Record.size() < 3) if (Record.size() < 3)
return error("Invalid inlineasm record"); return error("Invalid inlineasm record");
unsigned OpNum = 0; unsigned OpNum = 0;
auto *FnTy = dyn_cast_or_null<FunctionType>(getTypeByID(Record[OpNum])); auto *FnTy =
dyn_cast_if_present<FunctionType>(getTypeByID(Record[OpNum]));
++OpNum; ++OpNum;
if (!FnTy) if (!FnTy)
return error("Invalid inlineasm record"); return error("Invalid inlineasm record");
std::string AsmStr, ConstrStr; std::string AsmStr, ConstrStr;
bool HasSideEffects = Record[OpNum] & 1; bool HasSideEffects = Record[OpNum] & 1;
bool IsAlignStack = (Record[OpNum] >> 1) & 1; bool IsAlignStack = (Record[OpNum] >> 1) & 1;
unsigned AsmDialect = (Record[OpNum] >> 2) & 1; unsigned AsmDialect = (Record[OpNum] >> 2) & 1;
bool CanThrow = (Record[OpNum] >> 3) & 1; bool CanThrow = (Record[OpNum] >> 3) & 1;
▲ Show 20 Lines • Show All 1,286 Lines • ▼ Show 20 Lines case bitc::FUNC_CODE_DEBUG_LOC: { // DEBUG_LOC: [line, col, scope, ia]
return error("Invalid record"); return error("Invalid record");
unsigned Line = Record[0], Col = Record[1]; unsigned Line = Record[0], Col = Record[1];
unsigned ScopeID = Record[2], IAID = Record[3]; unsigned ScopeID = Record[2], IAID = Record[3];
bool isImplicitCode = Record.size() == 5 && Record[4]; bool isImplicitCode = Record.size() == 5 && Record[4];
MDNode *Scope = nullptr, *IA = nullptr; MDNode *Scope = nullptr, *IA = nullptr;
if (ScopeID) { if (ScopeID) {
Scope = dyn_cast_or_null<MDNode>( Scope = dyn_cast_if_present<MDNode>(
MDLoader->getMetadataFwdRefOrLoad(ScopeID - 1)); MDLoader->getMetadataFwdRefOrLoad(ScopeID - 1));
if (!Scope) if (!Scope)
return error("Invalid record"); return error("Invalid record");
} }
if (IAID) { if (IAID) {
IA = dyn_cast_or_null<MDNode>( IA = dyn_cast_if_present<MDNode>(
MDLoader->getMetadataFwdRefOrLoad(IAID - 1)); MDLoader->getMetadataFwdRefOrLoad(IAID - 1));
if (!IA) if (!IA)
return error("Invalid record"); return error("Invalid record");
} }
LastLoc = DILocation::get(Scope->getContext(), Line, Col, Scope, IA, LastLoc = DILocation::get(Scope->getContext(), Line, Col, Scope, IA,
isImplicitCode); isImplicitCode);
I->setDebugLoc(LastLoc); I->setDebugLoc(LastLoc);
I = nullptr; I = nullptr;
▲ Show 20 Lines • Show All 642 Lines • ▼ Show 20 Lines case bitc::FUNC_CODE_INST_SWITCH: { // SWITCH: [opty, op0, op1, ...]
Value *Cond = getValue(Record, 1, NextValueNo, OpTy, OpTyID, CurBB); Value *Cond = getValue(Record, 1, NextValueNo, OpTy, OpTyID, CurBB);
BasicBlock *Default = getBasicBlock(Record[2]); BasicBlock *Default = getBasicBlock(Record[2]);
if (!OpTy || !Cond || !Default) if (!OpTy || !Cond || !Default)
return error("Invalid record"); return error("Invalid record");
unsigned NumCases = (Record.size()-3)/2; unsigned NumCases = (Record.size()-3)/2;
SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases); SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases);
InstructionList.push_back(SI); InstructionList.push_back(SI);
for (unsigned i = 0, e = NumCases; i != e; ++i) { for (unsigned i = 0, e = NumCases; i != e; ++i) {
ConstantInt *CaseVal = dyn_cast_or_null<ConstantInt>( ConstantInt *CaseVal = dyn_cast_if_present<ConstantInt>(
getFnValueByID(Record[3+i*2], OpTy, OpTyID, nullptr)); getFnValueByID(Record[3 + i * 2], OpTy, OpTyID, nullptr));
BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]); BasicBlock *DestBB = getBasicBlock(Record[1 + 3 + i * 2]);
if (!CaseVal || !DestBB) { if (!CaseVal || !DestBB) {
delete SI; delete SI;
return error("Invalid record"); return error("Invalid record");
} }
SI->addCase(CaseVal, DestBB); SI->addCase(CaseVal, DestBB);
} }
I = SI; I = SI;
break; break;
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines case bitc::FUNC_CODE_INST_INVOKE: {
CurBB)) CurBB))
return error("Invalid record"); return error("Invalid record");
PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType()); PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType());
if (!CalleeTy) if (!CalleeTy)
return error("Callee is not a pointer"); return error("Callee is not a pointer");
if (!FTy) { if (!FTy) {
FTyID = getContainedTypeID(CalleeTypeID); FTyID = getContainedTypeID(CalleeTypeID);
FTy = dyn_cast_or_null<FunctionType>(getTypeByID(FTyID)); FTy = dyn_cast_if_present<FunctionType>(getTypeByID(FTyID));
if (!FTy) if (!FTy)
return error("Callee is not of pointer to function type"); return error("Callee is not of pointer to function type");
} else if (!CalleeTy->isOpaqueOrPointeeTypeMatches(FTy)) } else if (!CalleeTy->isOpaqueOrPointeeTypeMatches(FTy))
return error("Explicit invoke type does not match pointee type of " return error("Explicit invoke type does not match pointee type of "
"callee operand"); "callee operand");
if (Record.size() < FTy->getNumParams() + OpNum) if (Record.size() < FTy->getNumParams() + OpNum)
return error("Insufficient operands to call"); return error("Insufficient operands to call");
▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Lines case bitc::FUNC_CODE_INST_CALLBR: {
SmallVector<BasicBlock *, 16> IndirectDests; SmallVector<BasicBlock *, 16> IndirectDests;
for (unsigned i = 0, e = NumIndirectDests; i != e; ++i) for (unsigned i = 0, e = NumIndirectDests; i != e; ++i)
IndirectDests.push_back(getBasicBlock(Record[OpNum++])); IndirectDests.push_back(getBasicBlock(Record[OpNum++]));
unsigned FTyID = InvalidTypeID; unsigned FTyID = InvalidTypeID;
FunctionType *FTy = nullptr; FunctionType *FTy = nullptr;
if ((CCInfo >> bitc::CALL_EXPLICIT_TYPE) & 1) { if ((CCInfo >> bitc::CALL_EXPLICIT_TYPE) & 1) {
FTyID = Record[OpNum++]; FTyID = Record[OpNum++];
FTy = dyn_cast_or_null<FunctionType>(getTypeByID(FTyID)); FTy = dyn_cast_if_present<FunctionType>(getTypeByID(FTyID));
if (!FTy) if (!FTy)
return error("Explicit call type is not a function type"); return error("Explicit call type is not a function type");
} }
Value *Callee; Value *Callee;
unsigned CalleeTypeID; unsigned CalleeTypeID;
if (getValueTypePair(Record, OpNum, NextValueNo, Callee, CalleeTypeID, if (getValueTypePair(Record, OpNum, NextValueNo, Callee, CalleeTypeID,
CurBB)) CurBB))
return error("Invalid record"); return error("Invalid record");
PointerType *OpTy = dyn_cast<PointerType>(Callee->getType()); PointerType *OpTy = dyn_cast<PointerType>(Callee->getType());
if (!OpTy) if (!OpTy)
return error("Callee is not a pointer type"); return error("Callee is not a pointer type");
if (!FTy) { if (!FTy) {
FTyID = getContainedTypeID(CalleeTypeID); FTyID = getContainedTypeID(CalleeTypeID);
FTy = dyn_cast_or_null<FunctionType>(getTypeByID(FTyID)); FTy = dyn_cast_if_present<FunctionType>(getTypeByID(FTyID));
if (!FTy) if (!FTy)
return error("Callee is not of pointer to function type"); return error("Callee is not of pointer to function type");
} else if (!OpTy->isOpaqueOrPointeeTypeMatches(FTy)) } else if (!OpTy->isOpaqueOrPointeeTypeMatches(FTy))
return error("Explicit call type does not match pointee type of " return error("Explicit call type does not match pointee type of "
"callee operand"); "callee operand");
if (Record.size() < FTy->getNumParams() + OpNum) if (Record.size() < FTy->getNumParams() + OpNum)
return error("Insufficient operands to call"); return error("Insufficient operands to call");
▲ Show 20 Lines • Show All 677 Lines • ▼ Show 20 Lines case bitc::FUNC_CODE_INST_CALL: {
if (!FMF.any()) if (!FMF.any())
return error("Fast math flags indicator set for call with no FMF"); return error("Fast math flags indicator set for call with no FMF");
} }
unsigned FTyID = InvalidTypeID; unsigned FTyID = InvalidTypeID;
FunctionType *FTy = nullptr; FunctionType *FTy = nullptr;
if ((CCInfo >> bitc::CALL_EXPLICIT_TYPE) & 1) { if ((CCInfo >> bitc::CALL_EXPLICIT_TYPE) & 1) {
FTyID = Record[OpNum++]; FTyID = Record[OpNum++];
FTy = dyn_cast_or_null<FunctionType>(getTypeByID(FTyID)); FTy = dyn_cast_if_present<FunctionType>(getTypeByID(FTyID));
if (!FTy) if (!FTy)
return error("Explicit call type is not a function type"); return error("Explicit call type is not a function type");
} }
Value *Callee; Value *Callee;
unsigned CalleeTypeID; unsigned CalleeTypeID;
if (getValueTypePair(Record, OpNum, NextValueNo, Callee, CalleeTypeID, if (getValueTypePair(Record, OpNum, NextValueNo, Callee, CalleeTypeID,
CurBB)) CurBB))
return error("Invalid record"); return error("Invalid record");
PointerType *OpTy = dyn_cast<PointerType>(Callee->getType()); PointerType *OpTy = dyn_cast<PointerType>(Callee->getType());
if (!OpTy) if (!OpTy)
return error("Callee is not a pointer type"); return error("Callee is not a pointer type");
if (!FTy) { if (!FTy) {
FTyID = getContainedTypeID(CalleeTypeID); FTyID = getContainedTypeID(CalleeTypeID);
FTy = dyn_cast_or_null<FunctionType>(getTypeByID(FTyID)); FTy = dyn_cast_if_present<FunctionType>(getTypeByID(FTyID));
if (!FTy) if (!FTy)
return error("Callee is not of pointer to function type"); return error("Callee is not of pointer to function type");
} else if (!OpTy->isOpaqueOrPointeeTypeMatches(FTy)) } else if (!OpTy->isOpaqueOrPointeeTypeMatches(FTy))
return error("Explicit call type does not match pointee type of " return error("Explicit call type does not match pointee type of "
"callee operand"); "callee operand");
if (Record.size() < FTy->getNumParams() + OpNum) if (Record.size() < FTy->getNumParams() + OpNum)
return error("Insufficient operands to call"); return error("Insufficient operands to call");
▲ Show 20 Lines • Show All 144 Lines • ▼ Show 20 LinesOutOfRecordLoop:
if (!OperandBundles.empty()) if (!OperandBundles.empty())
return error("Operand bundles found with no consumer"); return error("Operand bundles found with no consumer");
// Check the function list for unresolved values. // Check the function list for unresolved values.
if (Argument *A = dyn_cast<Argument>(ValueList.back())) { if (Argument *A = dyn_cast<Argument>(ValueList.back())) {
if (!A->getParent()) { if (!A->getParent()) {
// We found at least one unresolved value. Nuke them all to avoid leaks. // We found at least one unresolved value. Nuke them all to avoid leaks.
for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e; ++i){ for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e; ++i){
if ((A = dyn_cast_or_null<Argument>(ValueList[i])) && !A->getParent()) { if ((A = dyn_cast_if_present<Argument>(ValueList[i])) &&
!A->getParent()) {
A->replaceAllUsesWith(PoisonValue::get(A->getType())); A->replaceAllUsesWith(PoisonValue::get(A->getType()));
delete A; delete A;
} }
} }
return error("Never resolved value found in function"); return error("Never resolved value found in function");
} }
} }
▲ Show 20 Lines • Show All 1,617 Lines • Show Last 20 Lines

llvm/lib/Bitcode/Reader/MetadataLoader.cpp

Show First 20 Lines • Show All 223 Lines • ▼ Show 20 LinesMetadata *BitcodeReaderMetadataList::getMetadataFwdRef(unsigned Idx) {
++NumMDNodeTemporary; ++NumMDNodeTemporary;
Metadata *MD = MDNode::getTemporary(Context, None).release(); Metadata *MD = MDNode::getTemporary(Context, None).release();
MetadataPtrs[Idx].reset(MD); MetadataPtrs[Idx].reset(MD);
return MD; return MD;
} }
Metadata *BitcodeReaderMetadataList::getMetadataIfResolved(unsigned Idx) { Metadata *BitcodeReaderMetadataList::getMetadataIfResolved(unsigned Idx) {
Metadata *MD = lookup(Idx); Metadata *MD = lookup(Idx);
if (auto *N = dyn_cast_or_null<MDNode>(MD)) if (auto *N = dyn_cast_if_present<MDNode>(MD))
if (!N->isResolved()) if (!N->isResolved())
return nullptr; return nullptr;
return MD; return MD;
} }
MDNode *BitcodeReaderMetadataList::getMDNodeFwdRefOrNull(unsigned Idx) { MDNode *BitcodeReaderMetadataList::getMDNodeFwdRefOrNull(unsigned Idx) {
return dyn_cast_or_null<MDNode>(getMetadataFwdRef(Idx)); return dyn_cast_if_present<MDNode>(getMetadataFwdRef(Idx));
} }
void BitcodeReaderMetadataList::tryToResolveCycles() { void BitcodeReaderMetadataList::tryToResolveCycles() {
if (!ForwardReference.empty()) if (!ForwardReference.empty())
// Still forward references... can't resolve cycles. // Still forward references... can't resolve cycles.
return; return;
// Give up on finding a full definition for any forward decls that remain. // Give up on finding a full definition for any forward decls that remain.
Show All 20 Linesvoid BitcodeReaderMetadataList::tryToResolveCycles() {
if (UnresolvedNodes.empty()) if (UnresolvedNodes.empty())
// Nothing to do. // Nothing to do.
return; return;
// Resolve any cycles. // Resolve any cycles.
for (unsigned I : UnresolvedNodes) { for (unsigned I : UnresolvedNodes) {
auto &MD = MetadataPtrs[I]; auto &MD = MetadataPtrs[I];
auto *N = dyn_cast_or_null<MDNode>(MD); auto *N = dyn_cast_if_present<MDNode>(MD);
if (!N) if (!N)
continue; continue;
assert(!N->isTemporary() && "Unexpected forward reference"); assert(!N->isTemporary() && "Unexpected forward reference");
N->resolveCycles(); N->resolveCycles();
} }
// Make sure we return early again until there's another unresolved ref. // Make sure we return early again until there's another unresolved ref.
UnresolvedNodes.clear(); UnresolvedNodes.clear();
} }
void BitcodeReaderMetadataList::addTypeRef(MDString &UUID, void BitcodeReaderMetadataList::addTypeRef(MDString &UUID,
DICompositeType &CT) { DICompositeType &CT) {
assert(CT.getRawIdentifier() == &UUID && "Mismatched UUID"); assert(CT.getRawIdentifier() == &UUID && "Mismatched UUID");
if (CT.isForwardDecl()) if (CT.isForwardDecl())
OldTypeRefs.FwdDecls.insert(std::make_pair(&UUID, &CT)); OldTypeRefs.FwdDecls.insert(std::make_pair(&UUID, &CT));
else else
OldTypeRefs.Final.insert(std::make_pair(&UUID, &CT)); OldTypeRefs.Final.insert(std::make_pair(&UUID, &CT));
} }
Metadata *BitcodeReaderMetadataList::upgradeTypeRef(Metadata *MaybeUUID) { Metadata *BitcodeReaderMetadataList::upgradeTypeRef(Metadata *MaybeUUID) {
auto *UUID = dyn_cast_or_null<MDString>(MaybeUUID); auto *UUID = dyn_cast_if_present<MDString>(MaybeUUID);
if (LLVM_LIKELY(!UUID)) if (LLVM_LIKELY(!UUID))
return MaybeUUID; return MaybeUUID;
if (auto *CT = OldTypeRefs.Final.lookup(UUID)) if (auto *CT = OldTypeRefs.Final.lookup(UUID))
return CT; return CT;
auto &Ref = OldTypeRefs.Unknown[UUID]; auto &Ref = OldTypeRefs.Unknown[UUID];
if (!Ref) if (!Ref)
Ref = MDNode::getTemporary(Context, None); Ref = MDNode::getTemporary(Context, None);
return Ref.get(); return Ref.get();
} }
Metadata *BitcodeReaderMetadataList::upgradeTypeRefArray(Metadata *MaybeTuple) { Metadata *BitcodeReaderMetadataList::upgradeTypeRefArray(Metadata *MaybeTuple) {
auto *Tuple = dyn_cast_or_null<MDTuple>(MaybeTuple); auto *Tuple = dyn_cast_if_present<MDTuple>(MaybeTuple);
if (!Tuple || Tuple->isDistinct()) if (!Tuple || Tuple->isDistinct())
return MaybeTuple; return MaybeTuple;
// Look through the array immediately if possible. // Look through the array immediately if possible.
if (!Tuple->isTemporary()) if (!Tuple->isTemporary())
return resolveTypeRefArray(Tuple); return resolveTypeRefArray(Tuple);
// Create and return a placeholder to use for now. Eventually // Create and return a placeholder to use for now. Eventually
// resolveTypeRefArrays() will be resolve this forward reference. // resolveTypeRefArrays() will be resolve this forward reference.
OldTypeRefs.Arrays.emplace_back( OldTypeRefs.Arrays.emplace_back(
std::piecewise_construct, std::forward_as_tuple(Tuple), std::piecewise_construct, std::forward_as_tuple(Tuple),
std::forward_as_tuple(MDTuple::getTemporary(Context, None))); std::forward_as_tuple(MDTuple::getTemporary(Context, None)));
return OldTypeRefs.Arrays.back().second.get(); return OldTypeRefs.Arrays.back().second.get();
} }
Metadata *BitcodeReaderMetadataList::resolveTypeRefArray(Metadata *MaybeTuple) { Metadata *BitcodeReaderMetadataList::resolveTypeRefArray(Metadata *MaybeTuple) {
auto *Tuple = dyn_cast_or_null<MDTuple>(MaybeTuple); auto *Tuple = dyn_cast_if_present<MDTuple>(MaybeTuple);
if (!Tuple || Tuple->isDistinct()) if (!Tuple || Tuple->isDistinct())
return MaybeTuple; return MaybeTuple;
// Look through the DITypeRefArray, upgrading each DIType *. // Look through the DITypeRefArray, upgrading each DIType *.
SmallVector<Metadata *, 32> Ops; SmallVector<Metadata *, 32> Ops;
Ops.reserve(Tuple->getNumOperands()); Ops.reserve(Tuple->getNumOperands());
for (Metadata *MD : Tuple->operands()) for (Metadata *MD : Tuple->operands())
Ops.push_back(upgradeTypeRef(MD)); Ops.push_back(upgradeTypeRef(MD));
Show All 23 Lines void getTemporaries(BitcodeReaderMetadataList &MetadataList,
DenseSet<unsigned> &Temporaries) { DenseSet<unsigned> &Temporaries) {
for (auto &PH : PHs) { for (auto &PH : PHs) {
auto ID = PH.getID(); auto ID = PH.getID();
auto *MD = MetadataList.lookup(ID); auto *MD = MetadataList.lookup(ID);
if (!MD) { if (!MD) {
Temporaries.insert(ID); Temporaries.insert(ID);
continue; continue;
} }
auto *N = dyn_cast_or_null<MDNode>(MD); auto *N = dyn_cast_if_present<MDNode>(MD);
if (N && N->isTemporary()) if (N && N->isTemporary())
Temporaries.insert(ID); Temporaries.insert(ID);
} }
} }
}; };
} // end anonymous namespace } // end anonymous namespace
▲ Show 20 Lines • Show All 98 Lines • ▼ Show 20 Lines Error parseGlobalObjectAttachment(GlobalObject &GO,
ArrayRef<uint64_t> Record); ArrayRef<uint64_t> Record);
Error parseMetadataKindRecord(SmallVectorImpl<uint64_t> &Record); Error parseMetadataKindRecord(SmallVectorImpl<uint64_t> &Record);
void resolveForwardRefsAndPlaceholders(PlaceholderQueue &Placeholders); void resolveForwardRefsAndPlaceholders(PlaceholderQueue &Placeholders);
/// Upgrade old-style CU <-> SP pointers to point from SP to CU. /// Upgrade old-style CU <-> SP pointers to point from SP to CU.
void upgradeCUSubprograms() { void upgradeCUSubprograms() {
for (auto CU_SP : CUSubprograms) for (auto CU_SP : CUSubprograms)
if (auto *SPs = dyn_cast_or_null<MDTuple>(CU_SP.second)) if (auto *SPs = dyn_cast_if_present<MDTuple>(CU_SP.second))
for (auto &Op : SPs->operands()) for (auto &Op : SPs->operands())
if (auto *SP = dyn_cast_or_null<DISubprogram>(Op)) if (auto *SP = dyn_cast_if_present<DISubprogram>(Op))
SP->replaceUnit(CU_SP.first); SP->replaceUnit(CU_SP.first);
CUSubprograms.clear(); CUSubprograms.clear();
} }
/// Upgrade old-style bare DIGlobalVariables to DIGlobalVariableExpressions. /// Upgrade old-style bare DIGlobalVariables to DIGlobalVariableExpressions.
void upgradeCUVariables() { void upgradeCUVariables() {
if (!NeedUpgradeToDIGlobalVariableExpression) if (!NeedUpgradeToDIGlobalVariableExpression)
return; return;
// Upgrade list of variables attached to the CUs. // Upgrade list of variables attached to the CUs.
if (NamedMDNode *CUNodes = TheModule.getNamedMetadata("llvm.dbg.cu")) if (NamedMDNode *CUNodes = TheModule.getNamedMetadata("llvm.dbg.cu"))
for (unsigned I = 0, E = CUNodes->getNumOperands(); I != E; ++I) { for (unsigned I = 0, E = CUNodes->getNumOperands(); I != E; ++I) {
auto *CU = cast<DICompileUnit>(CUNodes->getOperand(I)); auto *CU = cast<DICompileUnit>(CUNodes->getOperand(I));
if (auto *GVs = dyn_cast_or_null<MDTuple>(CU->getRawGlobalVariables())) if (auto *GVs =
dyn_cast_if_present<MDTuple>(CU->getRawGlobalVariables()))
for (unsigned I = 0; I < GVs->getNumOperands(); I++) for (unsigned I = 0; I < GVs->getNumOperands(); I++)
if (auto *GV = if (auto *GV =
dyn_cast_or_null<DIGlobalVariable>(GVs->getOperand(I))) { dyn_cast_if_present<DIGlobalVariable>(GVs->getOperand(I))) {
auto *DGVE = DIGlobalVariableExpression::getDistinct( auto *DGVE = DIGlobalVariableExpression::getDistinct(
Context, GV, DIExpression::get(Context, {})); Context, GV, DIExpression::get(Context, {}));
GVs->replaceOperandWith(I, DGVE); GVs->replaceOperandWith(I, DGVE);
} }
} }
// Upgrade variables attached to globals. // Upgrade variables attached to globals.
for (auto &GV : TheModule.globals()) { for (auto &GV : TheModule.globals()) {
▲ Show 20 Lines • Show All 1,238 Lines • ▼ Show 20 Lines DISubprogram *SP = GET_OR_DISTINCT(
HasTargetFuncName ? getMDString(Record[19 + OffsetB]) HasTargetFuncName ? getMDString(Record[19 + OffsetB])
: nullptr // targetFuncName : nullptr // targetFuncName
)); ));
MetadataList.assignValue(SP, NextMetadataNo); MetadataList.assignValue(SP, NextMetadataNo);
NextMetadataNo++; NextMetadataNo++;
// Upgrade sp->function mapping to function->sp mapping. // Upgrade sp->function mapping to function->sp mapping.
if (HasFn) { if (HasFn) {
if (auto *CMD = dyn_cast_or_null<ConstantAsMetadata>(CUorFn)) if (auto *CMD = dyn_cast_if_present<ConstantAsMetadata>(CUorFn))
if (auto *F = dyn_cast<Function>(CMD->getValue())) { if (auto *F = dyn_cast<Function>(CMD->getValue())) {
if (F->isMaterializable()) if (F->isMaterializable())
// Defer until materialized; unmaterialized functions may not have // Defer until materialized; unmaterialized functions may not have
// metadata. // metadata.
FunctionsWithSPs[F] = SP; FunctionsWithSPs[F] = SP;
else if (!F->empty()) else if (!F->empty())
F->setSubprogram(SP); F->setSubprogram(SP);
} }
▲ Show 20 Lines • Show All 158 Lines • ▼ Show 20 Lines if (Version == 2) {
Metadata *Expr = getMDOrNull(Record[9]); Metadata *Expr = getMDOrNull(Record[9]);
uint32_t AlignInBits = 0; uint32_t AlignInBits = 0;
if (Record.size() > 11) { if (Record.size() > 11) {
if (Record[11] > (uint64_t)std::numeric_limits<uint32_t>::max()) if (Record[11] > (uint64_t)std::numeric_limits<uint32_t>::max())
return error("Alignment value is too large"); return error("Alignment value is too large");
AlignInBits = Record[11]; AlignInBits = Record[11];
} }
GlobalVariable *Attach = nullptr; GlobalVariable *Attach = nullptr;
if (auto *CMD = dyn_cast_or_null<ConstantAsMetadata>(Expr)) { if (auto *CMD = dyn_cast_if_present<ConstantAsMetadata>(Expr)) {
if (auto *GV = dyn_cast<GlobalVariable>(CMD->getValue())) { if (auto *GV = dyn_cast<GlobalVariable>(CMD->getValue())) {
Attach = GV; Attach = GV;
Expr = nullptr; Expr = nullptr;
} else if (auto *CI = dyn_cast<ConstantInt>(CMD->getValue())) { } else if (auto *CI = dyn_cast<ConstantInt>(CMD->getValue())) {
Expr = DIExpression::get(Context, Expr = DIExpression::get(Context,
{dwarf::DW_OP_constu, CI->getZExtValue(), {dwarf::DW_OP_constu, CI->getZExtValue(),
dwarf::DW_OP_stack_value}); dwarf::DW_OP_stack_value});
} else { } else {
▲ Show 20 Lines • Show All 235 Lines • ▼ Show 20 Lines
Error MetadataLoader::MetadataLoaderImpl::parseGlobalObjectAttachment( Error MetadataLoader::MetadataLoaderImpl::parseGlobalObjectAttachment(
GlobalObject &GO, ArrayRef<uint64_t> Record) { GlobalObject &GO, ArrayRef<uint64_t> Record) {
assert(Record.size() % 2 == 0); assert(Record.size() % 2 == 0);
for (unsigned I = 0, E = Record.size(); I != E; I += 2) { for (unsigned I = 0, E = Record.size(); I != E; I += 2) {
auto K = MDKindMap.find(Record[I]); auto K = MDKindMap.find(Record[I]);
if (K == MDKindMap.end()) if (K == MDKindMap.end())
return error("Invalid ID"); return error("Invalid ID");
MDNode *MD = MDNode *MD =
dyn_cast_or_null<MDNode>(getMetadataFwdRefOrLoad(Record[I + 1])); dyn_cast_if_present<MDNode>(getMetadataFwdRefOrLoad(Record[I + 1]));
if (!MD) if (!MD)
return error("Invalid metadata attachment: expect fwd ref to MDNode"); return error("Invalid metadata attachment: expect fwd ref to MDNode");
GO.addMetadata(K->second, *MD); GO.addMetadata(K->second, *MD);
} }
return Error::success(); return Error::success();
} }
/// Parse metadata attachments. /// Parse metadata attachments.
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Lines case bitc::METADATA_ATTACHMENT: {
resolveForwardRefsAndPlaceholders(Placeholders); resolveForwardRefsAndPlaceholders(Placeholders);
} }
Metadata *Node = MetadataList.getMetadataFwdRef(Idx); Metadata *Node = MetadataList.getMetadataFwdRef(Idx);
if (isa<LocalAsMetadata>(Node)) if (isa<LocalAsMetadata>(Node))
// Drop the attachment. This used to be legal, but there's no // Drop the attachment. This used to be legal, but there's no
// upgrade path. // upgrade path.
break; break;
MDNode *MD = dyn_cast_or_null<MDNode>(Node); MDNode *MD = dyn_cast_if_present<MDNode>(Node);
if (!MD) if (!MD)
return error("Invalid metadata attachment"); return error("Invalid metadata attachment");
if (HasSeenOldLoopTags && I->second == LLVMContext::MD_loop) if (HasSeenOldLoopTags && I->second == LLVMContext::MD_loop)
MD = upgradeInstructionLoopAttachment(*MD); MD = upgradeInstructionLoopAttachment(*MD);
if (I->second == LLVMContext::MD_tbaa) { if (I->second == LLVMContext::MD_tbaa) {
assert(!MD->isTemporary() && "should load MDs before attachments"); assert(!MD->isTemporary() && "should load MDs before attachments");
▲ Show 20 Lines • Show All 119 Lines • Show Last 20 Lines

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

Show First 20 Lines • Show All 3,036 Lines • ▼ Show 20 Linesstatic void emitGlobalConstantVector(const DataLayout &DL,
if (ElementSizeInBits != ElementAllocSizeInBits) { if (ElementSizeInBits != ElementAllocSizeInBits) {
// If the allocation size of an element is different from the size in bits, // If the allocation size of an element is different from the size in bits,
// printing each element separately will insert incorrect padding. // printing each element separately will insert incorrect padding.
// //
// The general algorithm here is complicated; instead of writing it out // The general algorithm here is complicated; instead of writing it out
// here, just use the existing code in ConstantFolding. // here, just use the existing code in ConstantFolding.
Type *IntT = Type *IntT =
IntegerType::get(CV->getContext(), DL.getTypeSizeInBits(CV->getType())); IntegerType::get(CV->getContext(), DL.getTypeSizeInBits(CV->getType()));
ConstantInt *CI = dyn_cast_or_null<ConstantInt>(ConstantFoldConstant( ConstantInt *CI = dyn_cast_if_present<ConstantInt>(ConstantFoldConstant(
ConstantExpr::getBitCast(const_cast<ConstantVector *>(CV), IntT), DL)); ConstantExpr::getBitCast(const_cast<ConstantVector *>(CV), IntT), DL));
if (!CI) { if (!CI) {
report_fatal_error( report_fatal_error(
"Cannot lower vector global with unusual element type"); "Cannot lower vector global with unusual element type");
} }
emitGlobalAliasInline(AP, 0, AliasList); emitGlobalAliasInline(AP, 0, AliasList);
emitGlobalConstantLargeInt(CI, AP); emitGlobalConstantLargeInt(CI, AP);
EmittedSize = DL.getTypeStoreSize(CV->getType()); EmittedSize = DL.getTypeStoreSize(CV->getType());
▲ Show 20 Lines • Show All 180 Lines • ▼ Show 20 Linesstatic void handleIndirectSymViaGOTPCRel(AsmPrinter &AP, const MCExpr **ME,
if (!SymA) if (!SymA)
return; return;
// Check that GOT equivalent symbol is cached. // Check that GOT equivalent symbol is cached.
const MCSymbol *GOTEquivSym = &SymA->getSymbol(); const MCSymbol *GOTEquivSym = &SymA->getSymbol();
if (!AP.GlobalGOTEquivs.count(GOTEquivSym)) if (!AP.GlobalGOTEquivs.count(GOTEquivSym))
return; return;
const GlobalValue *BaseGV = dyn_cast_or_null<GlobalValue>(BaseCst); const GlobalValue *BaseGV = dyn_cast_if_present<GlobalValue>(BaseCst);
if (!BaseGV) if (!BaseGV)
return; return;
// Check for a valid base symbol // Check for a valid base symbol
const MCSymbol *BaseSym = AP.getSymbol(BaseGV); const MCSymbol *BaseSym = AP.getSymbol(BaseGV);
const MCSymbolRefExpr *SymB = MV.getSymB(); const MCSymbolRefExpr *SymB = MV.getSymB();
if (!SymB || BaseSym != &SymB->getSymbol()) if (!SymB || BaseSym != &SymB->getSymbol())
▲ Show 20 Lines • Show All 688 Lines • Show Last 20 Lines

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

Show First 20 Lines • Show All 390 Lines • ▼ Show 20 LinesTypeIndex CodeViewDebug::getFuncIdForSubprogram(const DISubprogram *SP) {
// The display name includes function template arguments. Drop them to match // The display name includes function template arguments. Drop them to match
// MSVC. We need to have the template arguments in the DISubprogram name // MSVC. We need to have the template arguments in the DISubprogram name
// because they are used in other symbol records, such as S_GPROC32_IDs. // because they are used in other symbol records, such as S_GPROC32_IDs.
StringRef DisplayName = removeTemplateArgs(SP->getName()); StringRef DisplayName = removeTemplateArgs(SP->getName());
const DIScope *Scope = SP->getScope(); const DIScope *Scope = SP->getScope();
TypeIndex TI; TypeIndex TI;
if (const auto *Class = dyn_cast_or_null<DICompositeType>(Scope)) { if (const auto *Class = dyn_cast_if_present<DICompositeType>(Scope)) {
// If the scope is a DICompositeType, then this must be a method. Member // If the scope is a DICompositeType, then this must be a method. Member
// function types take some special handling, and require access to the // function types take some special handling, and require access to the
// subprogram. // subprogram.
TypeIndex ClassType = getTypeIndex(Class); TypeIndex ClassType = getTypeIndex(Class);
MemberFuncIdRecord MFuncId(ClassType, getMemberFunctionType(SP, Class), MemberFuncIdRecord MFuncId(ClassType, getMemberFunctionType(SP, Class),
DisplayName); DisplayName);
TI = TypeTable.writeLeafType(MFuncId); TI = TypeTable.writeLeafType(MFuncId);
} else { } else {
Show All 18 LinesgetFunctionOptions(const DISubroutineType *Ty,
const DIType *ReturnTy = nullptr; const DIType *ReturnTy = nullptr;
if (auto TypeArray = Ty->getTypeArray()) { if (auto TypeArray = Ty->getTypeArray()) {
if (TypeArray.size()) if (TypeArray.size())
ReturnTy = TypeArray[0]; ReturnTy = TypeArray[0];
} }
// Add CxxReturnUdt option to functions that return nontrivial record types // Add CxxReturnUdt option to functions that return nontrivial record types
// or methods that return record types. // or methods that return record types.
if (auto *ReturnDCTy = dyn_cast_or_null<DICompositeType>(ReturnTy)) if (auto *ReturnDCTy = dyn_cast_if_present<DICompositeType>(ReturnTy))
if (isNonTrivial(ReturnDCTy) || ClassTy) if (isNonTrivial(ReturnDCTy) || ClassTy)
FO |= FunctionOptions::CxxReturnUdt; FO |= FunctionOptions::CxxReturnUdt;
// DISubroutineType is unnamed. Use DISubprogram's i.e. SPName in comparison. // DISubroutineType is unnamed. Use DISubprogram's i.e. SPName in comparison.
if (ClassTy && isNonTrivial(ClassTy) && SPName == ClassTy->getName()) { if (ClassTy && isNonTrivial(ClassTy) && SPName == ClassTy->getName()) {
FO |= FunctionOptions::Constructor; FO |= FunctionOptions::Constructor;
// TODO: put the FunctionOptions::ConstructorWithVirtualBases flag. // TODO: put the FunctionOptions::ConstructorWithVirtualBases flag.
▲ Show 20 Lines • Show All 1,616 Lines • ▼ Show 20 LinesTypeIndex CodeViewDebug::lowerTypeMemberFunction(const DISubroutineType *Ty,
} }
// If the first argument is a pointer type and this isn't a static method, // If the first argument is a pointer type and this isn't a static method,
// treat it as the special 'this' parameter, which is encoded separately from // treat it as the special 'this' parameter, which is encoded separately from
// the arguments. // the arguments.
TypeIndex ThisTypeIndex; TypeIndex ThisTypeIndex;
if (!IsStaticMethod && ReturnAndArgs.size() > Index) { if (!IsStaticMethod && ReturnAndArgs.size() > Index) {
if (const DIDerivedType *PtrTy = if (const DIDerivedType *PtrTy =
dyn_cast_or_null<DIDerivedType>(ReturnAndArgs[Index])) { dyn_cast_if_present<DIDerivedType>(ReturnAndArgs[Index])) {
if (PtrTy->getTag() == dwarf::DW_TAG_pointer_type) { if (PtrTy->getTag() == dwarf::DW_TAG_pointer_type) {
ThisTypeIndex = getTypeIndexForThisPtr(PtrTy, Ty); ThisTypeIndex = getTypeIndexForThisPtr(PtrTy, Ty);
Index++; Index++;
} }
} }
} }
while (Index < ReturnAndArgs.size()) while (Index < ReturnAndArgs.size())
▲ Show 20 Lines • Show All 141 Lines • ▼ Show 20 LinesTypeIndex CodeViewDebug::lowerTypeEnum(const DICompositeType *Ty) {
if (Ty->isForwardDecl()) { if (Ty->isForwardDecl()) {
CO |= ClassOptions::ForwardReference; CO |= ClassOptions::ForwardReference;
} else { } else {
ContinuationRecordBuilder ContinuationBuilder; ContinuationRecordBuilder ContinuationBuilder;
ContinuationBuilder.begin(ContinuationRecordKind::FieldList); ContinuationBuilder.begin(ContinuationRecordKind::FieldList);
for (const DINode *Element : Ty->getElements()) { for (const DINode *Element : Ty->getElements()) {
// We assume that the frontend provides all members in source declaration // We assume that the frontend provides all members in source declaration
// order, which is what MSVC does. // order, which is what MSVC does.
if (auto *Enumerator = dyn_cast_or_null<DIEnumerator>(Element)) { if (auto *Enumerator = dyn_cast_if_present<DIEnumerator>(Element)) {
// FIXME: Is it correct to always emit these as unsigned here? // FIXME: Is it correct to always emit these as unsigned here?
EnumeratorRecord ER(MemberAccess::Public, EnumeratorRecord ER(MemberAccess::Public,
APSInt(Enumerator->getValue(), true), APSInt(Enumerator->getValue(), true),
Enumerator->getName()); Enumerator->getName());
ContinuationBuilder.writeMemberType(ER); ContinuationBuilder.writeMemberType(ER);
EnumeratorCount++; EnumeratorCount++;
} }
} }
▲ Show 20 Lines • Show All 310 Lines • ▼ Show 20 Lines if ((Member->getFlags() & DINode::FlagArtificial) &&
continue; continue;
} }
// Data member. // Data member.
uint64_t MemberOffsetInBits = uint64_t MemberOffsetInBits =
Member->getOffsetInBits() + MemberInfo.BaseOffset; Member->getOffsetInBits() + MemberInfo.BaseOffset;
if (Member->isBitField()) { if (Member->isBitField()) {
uint64_t StartBitOffset = MemberOffsetInBits; uint64_t StartBitOffset = MemberOffsetInBits;
if (const auto *CI = if (const auto *CI = dyn_cast_if_present<ConstantInt>(
dyn_cast_or_null<ConstantInt>(Member->getStorageOffsetInBits())) { Member->getStorageOffsetInBits())) {
MemberOffsetInBits = CI->getZExtValue() + MemberInfo.BaseOffset; MemberOffsetInBits = CI->getZExtValue() + MemberInfo.BaseOffset;
} }
StartBitOffset -= MemberOffsetInBits; StartBitOffset -= MemberOffsetInBits;
BitFieldRecord BFR(MemberBaseType, Member->getSizeInBits(), BitFieldRecord BFR(MemberBaseType, Member->getSizeInBits(),
StartBitOffset); StartBitOffset);
MemberBaseType = TypeTable.writeLeafType(BFR); MemberBaseType = TypeTable.writeLeafType(BFR);
} }
uint64_t MemberOffsetInBytes = MemberOffsetInBits / 8; uint64_t MemberOffsetInBytes = MemberOffsetInBits / 8;
▲ Show 20 Lines • Show All 742 Lines • ▼ Show 20 Lines
} }
void CodeViewDebug::emitStaticConstMemberList() { void CodeViewDebug::emitStaticConstMemberList() {
for (const DIDerivedType *DTy : StaticConstMembers) { for (const DIDerivedType *DTy : StaticConstMembers) {
const DIScope *Scope = DTy->getScope(); const DIScope *Scope = DTy->getScope();
APSInt Value; APSInt Value;
if (const ConstantInt *CI = if (const ConstantInt *CI =
dyn_cast_or_null<ConstantInt>(DTy->getConstant())) dyn_cast_if_present<ConstantInt>(DTy->getConstant()))
Value = APSInt(CI->getValue(), Value = APSInt(CI->getValue(),
DebugHandlerBase::isUnsignedDIType(DTy->getBaseType())); DebugHandlerBase::isUnsignedDIType(DTy->getBaseType()));
else if (const ConstantFP *CFP = else if (const ConstantFP *CFP =
dyn_cast_or_null<ConstantFP>(DTy->getConstant())) dyn_cast_if_present<ConstantFP>(DTy->getConstant()))
Value = APSInt(CFP->getValueAPF().bitcastToAPInt(), true); Value = APSInt(CFP->getValueAPF().bitcastToAPInt(), true);
else else
llvm_unreachable("cannot emit a constant without a value"); llvm_unreachable("cannot emit a constant without a value");
emitConstantSymbolRecord(DTy->getBaseType(), Value, emitConstantSymbolRecord(DTy->getBaseType(), Value,
getFullyQualifiedName(Scope, DTy->getName())); getFullyQualifiedName(Scope, DTy->getName()));
} }
} }
Show All 17 Linesstatic bool isFloatDIType(const DIType *Ty) {
return (BTy->getEncoding() == dwarf::DW_ATE_float); return (BTy->getEncoding() == dwarf::DW_ATE_float);
} }
void CodeViewDebug::emitDebugInfoForGlobal(const CVGlobalVariable &CVGV) { void CodeViewDebug::emitDebugInfoForGlobal(const CVGlobalVariable &CVGV) {
const DIGlobalVariable *DIGV = CVGV.DIGV; const DIGlobalVariable *DIGV = CVGV.DIGV;
const DIScope *Scope = DIGV->getScope(); const DIScope *Scope = DIGV->getScope();
// For static data members, get the scope from the declaration. // For static data members, get the scope from the declaration.
if (const auto *MemberDecl = dyn_cast_or_null<DIDerivedType>( if (const auto *MemberDecl = dyn_cast_if_present<DIDerivedType>(
DIGV->getRawStaticDataMemberDeclaration())) DIGV->getRawStaticDataMemberDeclaration()))
Scope = MemberDecl->getScope(); Scope = MemberDecl->getScope();
// For static local variables and Fortran, the scoping portion is elided // For static local variables and Fortran, the scoping portion is elided
// in its name so that we can reference the variable in the command line // in its name so that we can reference the variable in the command line
// of the VS debugger. // of the VS debugger.
std::string QualifiedName = std::string QualifiedName =
(moduleIsInFortran() || isa<DILocalScope>(Scope)) (moduleIsInFortran() || isa<DILocalScope>(Scope))
? std::string(DIGV->getName()) ? std::string(DIGV->getName())
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp

Show First 20 Lines • Show All 920 Lines • ▼ Show 20 Lines for (const auto *Element : Elements) {
DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer); DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
addType(ElemDie, DDTy->getBaseType(), dwarf::DW_AT_friend); addType(ElemDie, DDTy->getBaseType(), dwarf::DW_AT_friend);
} else if (DDTy->isStaticMember()) { } else if (DDTy->isStaticMember()) {
getOrCreateStaticMemberDIE(DDTy); getOrCreateStaticMemberDIE(DDTy);
} else if (Tag == dwarf::DW_TAG_variant_part) { } else if (Tag == dwarf::DW_TAG_variant_part) {
// When emitting a variant part, wrap each member in // When emitting a variant part, wrap each member in
// DW_TAG_variant. // DW_TAG_variant.
DIE &Variant = createAndAddDIE(dwarf::DW_TAG_variant, Buffer); DIE &Variant = createAndAddDIE(dwarf::DW_TAG_variant, Buffer);
if (const ConstantInt *CI = if (const ConstantInt *CI = dyn_cast_if_present<ConstantInt>(
dyn_cast_or_null<ConstantInt>(DDTy->getDiscriminantValue())) { DDTy->getDiscriminantValue())) {
if (DD->isUnsignedDIType(Discriminator->getBaseType())) if (DD->isUnsignedDIType(Discriminator->getBaseType()))
addUInt(Variant, dwarf::DW_AT_discr_value, None, CI->getZExtValue()); addUInt(Variant, dwarf::DW_AT_discr_value, None,
CI->getZExtValue());
else else
addSInt(Variant, dwarf::DW_AT_discr_value, None, CI->getSExtValue()); addSInt(Variant, dwarf::DW_AT_discr_value, None,
CI->getSExtValue());
} }
constructMemberDIE(Variant, DDTy); constructMemberDIE(Variant, DDTy);
} else { } else {
constructMemberDIE(Buffer, DDTy); constructMemberDIE(Buffer, DDTy);
} }
} else if (auto *Property = dyn_cast<DIObjCProperty>(Element)) { } else if (auto *Property = dyn_cast<DIObjCProperty>(Element)) {
DIE &ElemDie = createAndAddDIE(Property->getTag(), Buffer); DIE &ElemDie = createAndAddDIE(Property->getTag(), Buffer);
StringRef PropertyName = Property->getName(); StringRef PropertyName = Property->getName();
▲ Show 20 Lines • Show All 590 Lines • ▼ Show 20 Linesvoid DwarfUnit::constructArrayTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
// FIXME: This type should be passed down from the front end // FIXME: This type should be passed down from the front end
// as different languages may have different sizes for indexes. // as different languages may have different sizes for indexes.
DIE *IdxTy = getIndexTyDie(); DIE *IdxTy = getIndexTyDie();
// Add subranges to array type. // Add subranges to array type.
DINodeArray Elements = CTy->getElements(); DINodeArray Elements = CTy->getElements();
for (DINode *E : Elements) { for (DINode *E : Elements) {
// FIXME: Should this really be such a loose cast? // FIXME: Should this really be such a loose cast?
if (auto *Element = dyn_cast_or_null<DINode>(E)) { if (auto *Element = dyn_cast_if_present<DINode>(E)) {
if (Element->getTag() == dwarf::DW_TAG_subrange_type) if (Element->getTag() == dwarf::DW_TAG_subrange_type)
constructSubrangeDIE(Buffer, cast<DISubrange>(Element), IdxTy); constructSubrangeDIE(Buffer, cast<DISubrange>(Element), IdxTy);
else if (Element->getTag() == dwarf::DW_TAG_generic_subrange) else if (Element->getTag() == dwarf::DW_TAG_generic_subrange)
constructGenericSubrangeDIE(Buffer, cast<DIGenericSubrange>(Element), constructGenericSubrangeDIE(Buffer, cast<DIGenericSubrange>(Element),
IdxTy); IdxTy);
} }
} }
} }
Show All 10 Linesvoid DwarfUnit::constructEnumTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
auto *Context = CTy->getScope(); auto *Context = CTy->getScope();
bool IndexEnumerators = !Context || isa<DICompileUnit>(Context) || isa<DIFile>(Context) || bool IndexEnumerators = !Context || isa<DICompileUnit>(Context) || isa<DIFile>(Context) ||
isa<DINamespace>(Context) || isa<DICommonBlock>(Context); isa<DINamespace>(Context) || isa<DICommonBlock>(Context);
DINodeArray Elements = CTy->getElements(); DINodeArray Elements = CTy->getElements();
// Add enumerators to enumeration type. // Add enumerators to enumeration type.
for (const DINode *E : Elements) { for (const DINode *E : Elements) {
auto *Enum = dyn_cast_or_null<DIEnumerator>(E); auto *Enum = dyn_cast_if_present<DIEnumerator>(E);
if (Enum) { if (Enum) {
DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer); DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
StringRef Name = Enum->getName(); StringRef Name = Enum->getName();
addString(Enumerator, dwarf::DW_AT_name, Name); addString(Enumerator, dwarf::DW_AT_name, Name);
addConstantValue(Enumerator, Enum->getValue(), IsUnsigned); addConstantValue(Enumerator, Enum->getValue(), IsUnsigned);
if (IndexEnumerators) if (IndexEnumerators)
addGlobalName(Name, Enumerator, Context); addGlobalName(Name, Enumerator, Context);
} }
▲ Show 20 Lines • Show All 147 Lines • ▼ Show 20 LinesDIE *DwarfUnit::getOrCreateStaticMemberDIE(const DIDerivedType *DT) {
addSourceLine(StaticMemberDIE, DT); addSourceLine(StaticMemberDIE, DT);
addFlag(StaticMemberDIE, dwarf::DW_AT_external); addFlag(StaticMemberDIE, dwarf::DW_AT_external);
addFlag(StaticMemberDIE, dwarf::DW_AT_declaration); addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
// FIXME: We could omit private if the parent is a class_type, and // FIXME: We could omit private if the parent is a class_type, and
// public if the parent is something else. // public if the parent is something else.
addAccess(StaticMemberDIE, DT->getFlags()); addAccess(StaticMemberDIE, DT->getFlags());
if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT->getConstant())) if (const ConstantInt *CI =
dyn_cast_if_present<ConstantInt>(DT->getConstant()))
addConstantValue(StaticMemberDIE, CI, Ty); addConstantValue(StaticMemberDIE, CI, Ty);
if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT->getConstant())) if (const ConstantFP *CFP =
dyn_cast_if_present<ConstantFP>(DT->getConstant()))
addConstantFPValue(StaticMemberDIE, CFP); addConstantFPValue(StaticMemberDIE, CFP);
if (uint32_t AlignInBytes = DT->getAlignInBytes()) if (uint32_t AlignInBytes = DT->getAlignInBytes())
addUInt(StaticMemberDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata, addUInt(StaticMemberDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
AlignInBytes); AlignInBytes);
return &StaticMemberDIE; return &StaticMemberDIE;
} }
▲ Show 20 Lines • Show All 107 Lines • Show Last 20 Lines

llvm/lib/CodeGen/CodeGenPrepare.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 5,387 Lines • ▼ Show 20 Lines if (!ResultPtr && !AddrMode.BaseReg && !AddrMode.Scale &&
SunkAddr = Builder.CreatePointerCast(SunkAddr, Addr->getType()); SunkAddr = Builder.CreatePointerCast(SunkAddr, Addr->getType());
} }
} }
} else { } else {
// We'd require a ptrtoint/inttoptr down the line, which we can't do for // We'd require a ptrtoint/inttoptr down the line, which we can't do for
// non-integral pointers, so in that case bail out now. // non-integral pointers, so in that case bail out now.
Type *BaseTy = AddrMode.BaseReg ? AddrMode.BaseReg->getType() : nullptr; Type *BaseTy = AddrMode.BaseReg ? AddrMode.BaseReg->getType() : nullptr;
Type *ScaleTy = AddrMode.Scale ? AddrMode.ScaledReg->getType() : nullptr; Type *ScaleTy = AddrMode.Scale ? AddrMode.ScaledReg->getType() : nullptr;
PointerType *BasePtrTy = dyn_cast_or_null<PointerType>(BaseTy); PointerType *BasePtrTy = dyn_cast_if_present<PointerType>(BaseTy);
PointerType *ScalePtrTy = dyn_cast_or_null<PointerType>(ScaleTy); PointerType *ScalePtrTy = dyn_cast_if_present<PointerType>(ScaleTy);
if (DL->isNonIntegralPointerType(Addr->getType()) || if (DL->isNonIntegralPointerType(Addr->getType()) ||
(BasePtrTy && DL->isNonIntegralPointerType(BasePtrTy)) || (BasePtrTy && DL->isNonIntegralPointerType(BasePtrTy)) ||
(ScalePtrTy && DL->isNonIntegralPointerType(ScalePtrTy)) || (ScalePtrTy && DL->isNonIntegralPointerType(ScalePtrTy)) ||
(AddrMode.BaseGV && (AddrMode.BaseGV &&
DL->isNonIntegralPointerType(AddrMode.BaseGV->getType()))) DL->isNonIntegralPointerType(AddrMode.BaseGV->getType())))
return Modified; return Modified;
LLVM_DEBUG(dbgs() << "CGP: SINKING nonlocal addrmode: " << AddrMode LLVM_DEBUG(dbgs() << "CGP: SINKING nonlocal addrmode: " << AddrMode
Show All 26 Lines if (AddrMode.Scale) {
cast<IntegerType>(V->getType())->getBitWidth()) { cast<IntegerType>(V->getType())->getBitWidth()) {
V = Builder.CreateTrunc(V, IntPtrTy, "sunkaddr"); V = Builder.CreateTrunc(V, IntPtrTy, "sunkaddr");
} else { } else {
// It is only safe to sign extend the BaseReg if we know that the math // It is only safe to sign extend the BaseReg if we know that the math
// required to create it did not overflow before we extend it. Since // required to create it did not overflow before we extend it. Since
// the original IR value was tossed in favor of a constant back when // the original IR value was tossed in favor of a constant back when
// the AddrMode was created we need to bail out gracefully if widths // the AddrMode was created we need to bail out gracefully if widths
// do not match instead of extending it. // do not match instead of extending it.
Instruction *I = dyn_cast_or_null<Instruction>(Result); Instruction *I = dyn_cast_if_present<Instruction>(Result);
if (I && (Result != AddrMode.BaseReg)) if (I && (Result != AddrMode.BaseReg))
I->eraseFromParent(); I->eraseFromParent();
return Modified; return Modified;
} }
if (AddrMode.Scale != 1) if (AddrMode.Scale != 1)
V = Builder.CreateMul(V, ConstantInt::get(IntPtrTy, AddrMode.Scale), V = Builder.CreateMul(V, ConstantInt::get(IntPtrTy, AddrMode.Scale),
"sunkaddr"); "sunkaddr");
if (Result) if (Result)
▲ Show 20 Lines • Show All 92 Lines • ▼ Show 20 Lines if (const auto *GEP = dyn_cast<GetElementPtrInst>(Ptr)) {
// FIXME: This isn't strictly required. All that's required is that they are // FIXME: This isn't strictly required. All that's required is that they are
// all scalars or splats. // all scalars or splats.
for (unsigned i = 1; i < FinalIndex; ++i) { for (unsigned i = 1; i < FinalIndex; ++i) {
auto *C = dyn_cast<Constant>(Ops[i]); auto *C = dyn_cast<Constant>(Ops[i]);
if (!C) if (!C)
return false; return false;
if (isa<VectorType>(C->getType())) if (isa<VectorType>(C->getType()))
C = C->getSplatValue(); C = C->getSplatValue();
auto *CI = dyn_cast_or_null<ConstantInt>(C); auto *CI = dyn_cast_if_present<ConstantInt>(C);
if (!CI || !CI->isZero()) if (!CI || !CI->isZero())
return false; return false;
// Scalarize the index if needed. // Scalarize the index if needed.
Ops[i] = CI; Ops[i] = CI;
} }
// Try to scalarize the final index. // Try to scalarize the final index.
if (Ops[FinalIndex]->getType()->isVectorTy()) { if (Ops[FinalIndex]->getType()->isVectorTy()) {
▲ Show 20 Lines • Show All 2,590 Lines • ▼ Show 20 Linesbool CodeGenPrepare::placeDbgValues(Function &F) {
for (BasicBlock &BB : F) { for (BasicBlock &BB : F) {
for (Instruction &Insn : llvm::make_early_inc_range(BB)) { for (Instruction &Insn : llvm::make_early_inc_range(BB)) {
DbgValueInst *DVI = dyn_cast<DbgValueInst>(&Insn); DbgValueInst *DVI = dyn_cast<DbgValueInst>(&Insn);
if (!DVI) if (!DVI)
continue; continue;
SmallVector<Instruction *, 4> VIs; SmallVector<Instruction *, 4> VIs;
for (Value *V : DVI->getValues()) for (Value *V : DVI->getValues())
if (Instruction *VI = dyn_cast_or_null<Instruction>(V)) if (Instruction *VI = dyn_cast_if_present<Instruction>(V))
VIs.push_back(VI); VIs.push_back(VI);
// This DVI may depend on multiple instructions, complicating any // This DVI may depend on multiple instructions, complicating any
// potential sink. This block takes the defensive approach, opting to // potential sink. This block takes the defensive approach, opting to
// "undef" the DVI if it has more than one instruction and any of them do // "undef" the DVI if it has more than one instruction and any of them do
// not dominate DVI. // not dominate DVI.
for (Instruction *VI : VIs) { for (Instruction *VI : VIs) {
if (VI->isTerminator()) if (VI->isTerminator())
▲ Show 20 Lines • Show All 266 Lines • Show Last 20 Lines

llvm/lib/CodeGen/GlobalISel/CombinerHelper.cpp

Show First 20 Lines • Show All 4,917 Lines • ▼ Show 20 Lines if (LI) {
if (!isLegalOrBeforeLegalizer( if (!isLegalOrBeforeLegalizer(
{TargetOpcode::G_ICMP, {TargetOpcode::G_ICMP,
{DstTy.isVector() ? DstTy.changeElementSize(1) : LLT::scalar(1), {DstTy.isVector() ? DstTy.changeElementSize(1) : LLT::scalar(1),
DstTy}})) DstTy}}))
return false; return false;
} }
auto CheckEltValue = [&](const Constant *C) { auto CheckEltValue = [&](const Constant *C) {
if (auto *CI = dyn_cast_or_null<ConstantInt>(C)) if (auto *CI = dyn_cast_if_present<ConstantInt>(C))
return !CI->isZero(); return !CI->isZero();
return false; return false;
}; };
return matchUnaryPredicate(MRI, RHS, CheckEltValue); return matchUnaryPredicate(MRI, RHS, CheckEltValue);
} }
void CombinerHelper::applyUDivByConst(MachineInstr &MI) { void CombinerHelper::applyUDivByConst(MachineInstr &MI) {
auto *NewMI = buildUDivUsingMul(MI); auto *NewMI = buildUDivUsingMul(MI);
▲ Show 20 Lines • Show All 747 Lines • Show Last 20 Lines

llvm/lib/CodeGen/GlobalISel/LegalizerHelper.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 5,704 Lines • ▼ Show 20 Lines
// Check that (every element of) Reg is undef or not an exact multiple of BW. // Check that (every element of) Reg is undef or not an exact multiple of BW.
static bool isNonZeroModBitWidthOrUndef(const MachineRegisterInfo &MRI, static bool isNonZeroModBitWidthOrUndef(const MachineRegisterInfo &MRI,
Register Reg, unsigned BW) { Register Reg, unsigned BW) {
return matchUnaryPredicate( return matchUnaryPredicate(
MRI, Reg, MRI, Reg,
[=](const Constant *C) { [=](const Constant *C) {
// Null constant here means an undef. // Null constant here means an undef.
const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(C); const ConstantInt *CI = dyn_cast_if_present<ConstantInt>(C);
return !CI || CI->getValue().urem(BW) != 0; return !CI || CI->getValue().urem(BW) != 0;
}, },
/*AllowUndefs*/ true); /*AllowUndefs*/ true);
} }
LegalizerHelper::LegalizeResult LegalizerHelper::LegalizeResult
LegalizerHelper::lowerFunnelShiftWithInverse(MachineInstr &MI) { LegalizerHelper::lowerFunnelShiftWithInverse(MachineInstr &MI) {
Register Dst = MI.getOperand(0).getReg(); Register Dst = MI.getOperand(0).getReg();
▲ Show 20 Lines • Show All 2,157 Lines • Show Last 20 Lines

llvm/lib/CodeGen/GlobalISel/Utils.cpp

Show First 20 Lines • Show All 691 Lines • ▼ Show 20 Linesbool llvm::isKnownNeverNaN(Register Val, const MachineRegisterInfo &MRI,
} }
return false; return false;
} }
Align llvm::inferAlignFromPtrInfo(MachineFunction &MF, Align llvm::inferAlignFromPtrInfo(MachineFunction &MF,
const MachinePointerInfo &MPO) { const MachinePointerInfo &MPO) {
auto PSV = MPO.V.dyn_cast<const PseudoSourceValue *>(); auto PSV = MPO.V.dyn_cast<const PseudoSourceValue *>();
if (auto FSPV = dyn_cast_or_null<FixedStackPseudoSourceValue>(PSV)) { if (auto FSPV = dyn_cast_if_present<FixedStackPseudoSourceValue>(PSV)) {
MachineFrameInfo &MFI = MF.getFrameInfo(); MachineFrameInfo &MFI = MF.getFrameInfo();
return commonAlignment(MFI.getObjectAlign(FSPV->getFrameIndex()), return commonAlignment(MFI.getObjectAlign(FSPV->getFrameIndex()),
MPO.Offset); MPO.Offset);
} }
if (const Value *V = MPO.V.dyn_cast<const Value *>()) { if (const Value *V = MPO.V.dyn_cast<const Value *>()) {
const Module *M = MF.getFunction().getParent(); const Module *M = MF.getFunction().getParent();
return V->getPointerAlignment(M->getDataLayout()); return V->getPointerAlignment(M->getDataLayout());
▲ Show 20 Lines • Show All 643 Lines • Show Last 20 Lines

llvm/lib/CodeGen/LowerEmuTLS.cpp

Show First 20 Lines • Show All 128 Lines • ▼ Show 20 Linesbool LowerEmuTLS::addEmuTlsVar(Module &M, const GlobalVariable *GV) {
Type *GVType = GV->getValueType(); Type *GVType = GV->getValueType();
Align GVAlignment = DL.getValueOrABITypeAlignment(GV->getAlign(), GVType); Align GVAlignment = DL.getValueOrABITypeAlignment(GV->getAlign(), GVType);
// Define "__emutls_t.*" if there is InitValue // Define "__emutls_t.*" if there is InitValue
GlobalVariable *EmuTlsTmplVar = nullptr; GlobalVariable *EmuTlsTmplVar = nullptr;
if (InitValue) { if (InitValue) {
std::string EmuTlsTmplName = ("__emutls_t." + GV->getName()).str(); std::string EmuTlsTmplName = ("__emutls_t." + GV->getName()).str();
EmuTlsTmplVar = dyn_cast_or_null<GlobalVariable>( EmuTlsTmplVar = dyn_cast_if_present<GlobalVariable>(
M.getOrInsertGlobal(EmuTlsTmplName, GVType)); M.getOrInsertGlobal(EmuTlsTmplName, GVType));
assert(EmuTlsTmplVar && "Failed to create emualted TLS initializer"); assert(EmuTlsTmplVar && "Failed to create emualted TLS initializer");
EmuTlsTmplVar->setConstant(true); EmuTlsTmplVar->setConstant(true);
EmuTlsTmplVar->setInitializer(const_cast<Constant*>(InitValue)); EmuTlsTmplVar->setInitializer(const_cast<Constant*>(InitValue));
EmuTlsTmplVar->setAlignment(GVAlignment); EmuTlsTmplVar->setAlignment(GVAlignment);
copyLinkageVisibility(M, GV, EmuTlsTmplVar); copyLinkageVisibility(M, GV, EmuTlsTmplVar);
} }
Show All 13 Lines

llvm/lib/CodeGen/MIRParser/MIParser.cpp

Show First 20 Lines • Show All 722 Lines • ▼ Show 20 Lines if (consumeIfPresent(MIToken::lparen)) {
} while (consumeIfPresent(MIToken::comma)); } while (consumeIfPresent(MIToken::comma));
if (expectAndConsume(MIToken::rparen)) if (expectAndConsume(MIToken::rparen))
return true; return true;
} }
if (expectAndConsume(MIToken::colon)) if (expectAndConsume(MIToken::colon))
return true; return true;
if (!Name.empty()) { if (!Name.empty()) {
BB = dyn_cast_or_null<BasicBlock>( BB = dyn_cast_if_present<BasicBlock>(
MF.getFunction().getValueSymbolTable()->lookup(Name)); MF.getFunction().getValueSymbolTable()->lookup(Name));
if (!BB) if (!BB)
return error(Loc, Twine("basic block '") + Name + return error(Loc, Twine("basic block '") + Name +
"' is not defined in the function '" + "' is not defined in the function '" +
MF.getName() + "'"); MF.getName() + "'");
} }
auto *MBB = MF.CreateMachineBasicBlock(BB); auto *MBB = MF.CreateMachineBasicBlock(BB);
MF.insert(MF.end(), MBB); MF.insert(MF.end(), MBB);
▲ Show 20 Lines • Show All 1,794 Lines • ▼ Show 20 Linesbool MIParser::parseCFIOperand(MachineOperand &Dest) {
} }
Dest = MachineOperand::CreateCFIIndex(CFIIndex); Dest = MachineOperand::CreateCFIIndex(CFIIndex);
return false; return false;
} }
bool MIParser::parseIRBlock(BasicBlock *&BB, const Function &F) { bool MIParser::parseIRBlock(BasicBlock *&BB, const Function &F) {
switch (Token.kind()) { switch (Token.kind()) {
case MIToken::NamedIRBlock: { case MIToken::NamedIRBlock: {
BB = dyn_cast_or_null<BasicBlock>( BB = dyn_cast_if_present<BasicBlock>(
F.getValueSymbolTable()->lookup(Token.stringValue())); F.getValueSymbolTable()->lookup(Token.stringValue()));
if (!BB) if (!BB)
return error(Twine("use of undefined IR block '") + Token.range() + "'"); return error(Twine("use of undefined IR block '") + Token.range() + "'");
break; break;
} }
case MIToken::IRBlock: { case MIToken::IRBlock: {
unsigned SlotNumber = 0; unsigned SlotNumber = 0;
if (getUnsigned(SlotNumber)) if (getUnsigned(SlotNumber))
▲ Show 20 Lines • Show All 983 Lines • Show Last 20 Lines

llvm/lib/CodeGen/MIRParser/MIRParser.cpp

Show First 20 Lines • Show All 237 Lines • ▼ Show 20 Lines if (auto LayoutOverride = DataLayoutCallback(M->getTargetTriple()))
M->setDataLayout(*LayoutOverride); M->setDataLayout(*LayoutOverride);
return M; return M;
} }
std::unique_ptr<Module> M; std::unique_ptr<Module> M;
// Parse the block scalar manually so that we can return unique pointer // Parse the block scalar manually so that we can return unique pointer
// without having to go trough YAML traits. // without having to go trough YAML traits.
if (const auto *BSN = if (const auto *BSN =
dyn_cast_or_null<yaml::BlockScalarNode>(In.getCurrentNode())) { dyn_cast_if_present<yaml::BlockScalarNode>(In.getCurrentNode())) {
SMDiagnostic Error; SMDiagnostic Error;
M = parseAssembly(MemoryBufferRef(BSN->getValue(), Filename), Error, M = parseAssembly(MemoryBufferRef(BSN->getValue(), Filename), Error,
Context, &IRSlots, DataLayoutCallback); Context, &IRSlots, DataLayoutCallback);
if (!M) { if (!M) {
reportDiagnostic(diagFromBlockStringDiag(Error, BSN->getSourceRange())); reportDiagnostic(diagFromBlockStringDiag(Error, BSN->getSourceRange()));
return nullptr; return nullptr;
} }
In.nextDocument(); In.nextDocument();
▲ Show 20 Lines • Show All 524 Lines • ▼ Show 20 Linesbool MIRParserImpl::initializeFrameInfo(PerFunctionMIParsingState &PFS,
} }
// Initialize the ordinary frame objects. // Initialize the ordinary frame objects.
for (const auto &Object : YamlMF.StackObjects) { for (const auto &Object : YamlMF.StackObjects) {
int ObjectIdx; int ObjectIdx;
const AllocaInst *Alloca = nullptr; const AllocaInst *Alloca = nullptr;
const yaml::StringValue &Name = Object.Name; const yaml::StringValue &Name = Object.Name;
if (!Name.Value.empty()) { if (!Name.Value.empty()) {
Alloca = dyn_cast_or_null<AllocaInst>( Alloca = dyn_cast_if_present<AllocaInst>(
F.getValueSymbolTable()->lookup(Name.Value)); F.getValueSymbolTable()->lookup(Name.Value));
if (!Alloca) if (!Alloca)
return error(Name.SourceRange.Start, return error(Name.SourceRange.Start,
"alloca instruction named '" + Name.Value + "alloca instruction named '" + Name.Value +
"' isn't defined in the function '" + F.getName() + "' isn't defined in the function '" + F.getName() +
"'"); "'");
} }
if (!TFI->isSupportedStackID(Object.StackID)) if (!TFI->isSupportedStackID(Object.StackID))
▲ Show 20 Lines • Show All 116 Lines • ▼ Show 20 Linesbool MIRParserImpl::initializeConstantPool(PerFunctionMIParsingState &PFS,
const MachineFunction &MF = PFS.MF; const MachineFunction &MF = PFS.MF;
const auto &M = *MF.getFunction().getParent(); const auto &M = *MF.getFunction().getParent();
SMDiagnostic Error; SMDiagnostic Error;
for (const auto &YamlConstant : YamlMF.Constants) { for (const auto &YamlConstant : YamlMF.Constants) {
if (YamlConstant.IsTargetSpecific) if (YamlConstant.IsTargetSpecific)
// FIXME: Support target-specific constant pools // FIXME: Support target-specific constant pools
return error(YamlConstant.Value.SourceRange.Start, return error(YamlConstant.Value.SourceRange.Start,
"Can't parse target-specific constant pool entries yet"); "Can't parse target-specific constant pool entries yet");
const Constant *Value = dyn_cast_or_null<Constant>( const Constant *Value = dyn_cast_if_present<Constant>(
parseConstantValue(YamlConstant.Value.Value, Error, M)); parseConstantValue(YamlConstant.Value.Value, Error, M));
if (!Value) if (!Value)
return error(Error, YamlConstant.Value.SourceRange); return error(Error, YamlConstant.Value.SourceRange);
const Align PrefTypeAlign = const Align PrefTypeAlign =
M.getDataLayout().getPrefTypeAlign(Value->getType()); M.getDataLayout().getPrefTypeAlign(Value->getType());
const Align Alignment = YamlConstant.Alignment.value_or(PrefTypeAlign); const Align Alignment = YamlConstant.Alignment.value_or(PrefTypeAlign);
unsigned Index = ConstantPool.getConstantPoolIndex(Value, Alignment); unsigned Index = ConstantPool.getConstantPoolIndex(Value, Alignment);
if (!ConstantPoolSlots.insert(std::make_pair(YamlConstant.ID.Value, Index)) if (!ConstantPoolSlots.insert(std::make_pair(YamlConstant.ID.Value, Index))
▲ Show 20 Lines • Show All 151 Lines • Show Last 20 Lines

llvm/lib/CodeGen/MachineFunction.cpp

Show First 20 Lines • Show All 106 Lines • ▼ Show 20 Linesstatic const char *getPropertyName(MachineFunctionProperties::Property Prop) {
llvm_unreachable("Invalid machine function property"); llvm_unreachable("Invalid machine function property");
} }
void setUnsafeStackSize(const Function &F, MachineFrameInfo &FrameInfo) { void setUnsafeStackSize(const Function &F, MachineFrameInfo &FrameInfo) {
if (!F.hasFnAttribute(Attribute::SafeStack)) if (!F.hasFnAttribute(Attribute::SafeStack))
return; return;
auto *Existing = auto *Existing =
dyn_cast_or_null<MDTuple>(F.getMetadata(LLVMContext::MD_annotation)); dyn_cast_if_present<MDTuple>(F.getMetadata(LLVMContext::MD_annotation));
if (!Existing || Existing->getNumOperands() != 2) if (!Existing || Existing->getNumOperands() != 2)
return; return;
auto *MetadataName = "unsafe-stack-size"; auto *MetadataName = "unsafe-stack-size";
if (auto &N = Existing->getOperand(0)) { if (auto &N = Existing->getOperand(0)) {
if (cast<MDString>(N.get())->getString() == MetadataName) { if (cast<MDString>(N.get())->getString() == MetadataName) {
if (auto &Op = Existing->getOperand(1)) { if (auto &Op = Existing->getOperand(1)) {
▲ Show 20 Lines • Show All 1,408 Lines • Show Last 20 Lines

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 11,630 Lines • ▼ Show 20 Linesbool BuildVectorSDNode::getRepeatedSequence(SmallVectorImpl<SDValue> &Sequence,
BitVector *UndefElements) const { BitVector *UndefElements) const {
APInt DemandedElts = APInt::getAllOnes(getNumOperands()); APInt DemandedElts = APInt::getAllOnes(getNumOperands());
return getRepeatedSequence(DemandedElts, Sequence, UndefElements); return getRepeatedSequence(DemandedElts, Sequence, UndefElements);
} }
ConstantSDNode * ConstantSDNode *
BuildVectorSDNode::getConstantSplatNode(const APInt &DemandedElts, BuildVectorSDNode::getConstantSplatNode(const APInt &DemandedElts,
BitVector *UndefElements) const { BitVector *UndefElements) const {
return dyn_cast_or_null<ConstantSDNode>( return dyn_cast_if_present<ConstantSDNode>(
getSplatValue(DemandedElts, UndefElements)); getSplatValue(DemandedElts, UndefElements));
} }
ConstantSDNode * ConstantSDNode *
BuildVectorSDNode::getConstantSplatNode(BitVector *UndefElements) const { BuildVectorSDNode::getConstantSplatNode(BitVector *UndefElements) const {
return dyn_cast_or_null<ConstantSDNode>(getSplatValue(UndefElements)); return dyn_cast_if_present<ConstantSDNode>(getSplatValue(UndefElements));
} }
ConstantFPSDNode * ConstantFPSDNode *
BuildVectorSDNode::getConstantFPSplatNode(const APInt &DemandedElts, BuildVectorSDNode::getConstantFPSplatNode(const APInt &DemandedElts,
BitVector *UndefElements) const { BitVector *UndefElements) const {
return dyn_cast_or_null<ConstantFPSDNode>( return dyn_cast_if_present<ConstantFPSDNode>(
getSplatValue(DemandedElts, UndefElements)); getSplatValue(DemandedElts, UndefElements));
} }
ConstantFPSDNode * ConstantFPSDNode *
BuildVectorSDNode::getConstantFPSplatNode(BitVector *UndefElements) const { BuildVectorSDNode::getConstantFPSplatNode(BitVector *UndefElements) const {
return dyn_cast_or_null<ConstantFPSDNode>(getSplatValue(UndefElements)); return dyn_cast_if_present<ConstantFPSDNode>(getSplatValue(UndefElements));
} }
int32_t int32_t
BuildVectorSDNode::getConstantFPSplatPow2ToLog2Int(BitVector *UndefElements, BuildVectorSDNode::getConstantFPSplatPow2ToLog2Int(BitVector *UndefElements,
uint32_t BitWidth) const { uint32_t BitWidth) const {
if (ConstantFPSDNode *CN = if (ConstantFPSDNode *CN =
dyn_cast_or_null<ConstantFPSDNode>(getSplatValue(UndefElements))) { dyn_cast_if_present<ConstantFPSDNode>(getSplatValue(UndefElements))) {
bool IsExact; bool IsExact;
APSInt IntVal(BitWidth); APSInt IntVal(BitWidth);
const APFloat &APF = CN->getValueAPF(); const APFloat &APF = CN->getValueAPF();
if (APF.convertToInteger(IntVal, APFloat::rmTowardZero, &IsExact) != if (APF.convertToInteger(IntVal, APFloat::rmTowardZero, &IsExact) !=
APFloat::opOK || APFloat::opOK ||
!IsExact) !IsExact)
return -1; return -1;
▲ Show 20 Lines • Show All 307 Lines • Show Last 20 Lines

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 294 Lines • ▼ Show 20 Lines if (PartEVT == MVT::x86mmx && ValueVT.isInteger() &&
return DAG.getNode(ISD::TRUNCATE, DL, ValueVT, Val); return DAG.getNode(ISD::TRUNCATE, DL, ValueVT, Val);
} }
report_fatal_error("Unknown mismatch in getCopyFromParts!"); report_fatal_error("Unknown mismatch in getCopyFromParts!");
} }
static void diagnosePossiblyInvalidConstraint(LLVMContext &Ctx, const Value *V, static void diagnosePossiblyInvalidConstraint(LLVMContext &Ctx, const Value *V,
const Twine &ErrMsg) { const Twine &ErrMsg) {
const Instruction *I = dyn_cast_or_null<Instruction>(V); const Instruction *I = dyn_cast_if_present<Instruction>(V);
if (!V) if (!V)
return Ctx.emitError(ErrMsg); return Ctx.emitError(ErrMsg);
const char *AsmError = ", possible invalid constraint for vector type"; const char *AsmError = ", possible invalid constraint for vector type";
if (const CallInst *CI = dyn_cast<CallInst>(I)) if (const CallInst *CI = dyn_cast<CallInst>(I))
if (CI->isInlineAsm()) if (CI->isInlineAsm())
return Ctx.emitError(I, ErrMsg + AsmError); return Ctx.emitError(I, ErrMsg + AsmError);
▲ Show 20 Lines • Show All 3,591 Lines • ▼ Show 20 Lines if (StructType *StTy = GTI.getStructTypeOrNull()) {
bool ElementScalable = ElementSize.isScalable(); bool ElementScalable = ElementSize.isScalable();
// If this is a scalar constant or a splat vector of constants, // If this is a scalar constant or a splat vector of constants,
// handle it quickly. // handle it quickly.
const auto *C = dyn_cast<Constant>(Idx); const auto *C = dyn_cast<Constant>(Idx);
if (C && isa<VectorType>(C->getType())) if (C && isa<VectorType>(C->getType()))
C = C->getSplatValue(); C = C->getSplatValue();
const auto *CI = dyn_cast_or_null<ConstantInt>(C); const auto *CI = dyn_cast_if_present<ConstantInt>(C);
if (CI && CI->isZero()) if (CI && CI->isZero())
continue; continue;
if (CI && !ElementScalable) { if (CI && !ElementScalable) {
APInt Offs = ElementMul * CI->getValue().sextOrTrunc(IdxSize); APInt Offs = ElementMul * CI->getValue().sextOrTrunc(IdxSize);
LLVMContext &Context = *DAG.getContext(); LLVMContext &Context = *DAG.getContext();
SDValue OffsVal; SDValue OffsVal;
if (IsVectorGEP) if (IsVectorGEP)
OffsVal = DAG.getConstant( OffsVal = DAG.getConstant(
▲ Show 20 Lines • Show All 2,953 Lines • ▼ Show 20 Lines case Intrinsic::lifetime_end: {
const int64_t ObjectSize = const int64_t ObjectSize =
cast<ConstantInt>(I.getArgOperand(0))->getSExtValue(); cast<ConstantInt>(I.getArgOperand(0))->getSExtValue();
Value *const ObjectPtr = I.getArgOperand(1); Value *const ObjectPtr = I.getArgOperand(1);
SmallVector<const Value *, 4> Allocas; SmallVector<const Value *, 4> Allocas;
getUnderlyingObjects(ObjectPtr, Allocas); getUnderlyingObjects(ObjectPtr, Allocas);
for (const Value *Alloca : Allocas) { for (const Value *Alloca : Allocas) {
const AllocaInst *LifetimeObject = dyn_cast_or_null<AllocaInst>(Alloca); const AllocaInst *LifetimeObject =
dyn_cast_if_present<AllocaInst>(Alloca);
// Could not find an Alloca. // Could not find an Alloca.
if (!LifetimeObject) if (!LifetimeObject)
continue; continue;
// First check that the Alloca is static, otherwise it won't have a // First check that the Alloca is static, otherwise it won't have a
// valid frame index. // valid frame index.
auto SI = FuncInfo.StaticAllocaMap.find(LifetimeObject); auto SI = FuncInfo.StaticAllocaMap.find(LifetimeObject);
▲ Show 20 Lines • Show All 4,490 Lines • Show Last 20 Lines

llvm/lib/CodeGen/SelectionDAG/StatepointLowering.cpp

Show First 20 Lines • Show All 570 Lines • ▼ Show 20 Lines#endif
// Decide which deriver pointers will go on VRegs // Decide which deriver pointers will go on VRegs
unsigned MaxVRegPtrs = MaxRegistersForGCPointers.getValue(); unsigned MaxVRegPtrs = MaxRegistersForGCPointers.getValue();
// Pointers used on exceptional path of invoke statepoint. // Pointers used on exceptional path of invoke statepoint.
// We cannot assing them to VRegs. // We cannot assing them to VRegs.
SmallSet<SDValue, 8> LPadPointers; SmallSet<SDValue, 8> LPadPointers;
if (!UseRegistersForGCPointersInLandingPad) if (!UseRegistersForGCPointersInLandingPad)
if (const auto *StInvoke = if (const auto *StInvoke =
dyn_cast_or_null<InvokeInst>(SI.StatepointInstr)) { dyn_cast_if_present<InvokeInst>(SI.StatepointInstr)) {
LandingPadInst *LPI = StInvoke->getLandingPadInst(); LandingPadInst *LPI = StInvoke->getLandingPadInst();
for (const auto *Relocate : SI.GCRelocates) for (const auto *Relocate : SI.GCRelocates)
if (Relocate->getOperand(0) == LPI) { if (Relocate->getOperand(0) == LPI) {
LPadPointers.insert(Builder.getValue(Relocate->getBasePtr())); LPadPointers.insert(Builder.getValue(Relocate->getBasePtr()));
LPadPointers.insert(Builder.getValue(Relocate->getDerivedPtr())); LPadPointers.insert(Builder.getValue(Relocate->getDerivedPtr()));
} }
} }
▲ Show 20 Lines • Show All 760 Lines • Show Last 20 Lines

llvm/lib/CodeGen/StackColoring.cpp

Show First 20 Lines • Show All 1,016 Lines • ▼ Show 20 Lines for (MachineInstr &I : BB) {
if (I.getOpcode() == TargetOpcode::LIFETIME_START || if (I.getOpcode() == TargetOpcode::LIFETIME_START ||
I.getOpcode() == TargetOpcode::LIFETIME_END) I.getOpcode() == TargetOpcode::LIFETIME_END)
continue; continue;
// Update the MachineMemOperand to use the new alloca. // Update the MachineMemOperand to use the new alloca.
for (MachineMemOperand *MMO : I.memoperands()) { for (MachineMemOperand *MMO : I.memoperands()) {
// We've replaced IR-level uses of the remapped allocas, so we only // We've replaced IR-level uses of the remapped allocas, so we only
// need to replace direct uses here. // need to replace direct uses here.
const AllocaInst *AI = dyn_cast_or_null<AllocaInst>(MMO->getValue()); const AllocaInst *AI = dyn_cast_if_present<AllocaInst>(MMO->getValue());
if (!AI) if (!AI)
continue; continue;
if (!Allocas.count(AI)) if (!Allocas.count(AI))
continue; continue;
MMO->setValue(Allocas[AI]); MMO->setValue(Allocas[AI]);
FixedMemOp++; FixedMemOp++;
Show All 39 Lines#endif
} }
// We adjust AliasAnalysis information for merged stack slots. // We adjust AliasAnalysis information for merged stack slots.
SmallVector<MachineMemOperand *, 2> NewMMOs; SmallVector<MachineMemOperand *, 2> NewMMOs;
bool ReplaceMemOps = false; bool ReplaceMemOps = false;
for (MachineMemOperand *MMO : I.memoperands()) { for (MachineMemOperand *MMO : I.memoperands()) {
// Collect MachineMemOperands which reference // Collect MachineMemOperands which reference
// FixedStackPseudoSourceValues with old frame indices. // FixedStackPseudoSourceValues with old frame indices.
if (const auto *FSV = dyn_cast_or_null<FixedStackPseudoSourceValue>( if (const auto *FSV = dyn_cast_if_present<FixedStackPseudoSourceValue>(
MMO->getPseudoValue())) { MMO->getPseudoValue())) {
int FI = FSV->getFrameIndex(); int FI = FSV->getFrameIndex();
auto To = SlotRemap.find(FI); auto To = SlotRemap.find(FI);
if (To != SlotRemap.end()) if (To != SlotRemap.end())
SSRefs[FI].push_back(MMO); SSRefs[FI].push_back(MMO);
} }
// If this memory location can be a slot remapped here, // If this memory location can be a slot remapped here,
// we remove AA information. // we remove AA information.
bool MayHaveConflictingAAMD = false; bool MayHaveConflictingAAMD = false;
if (MMO->getAAInfo()) { if (MMO->getAAInfo()) {
if (const Value *MMOV = MMO->getValue()) { if (const Value *MMOV = MMO->getValue()) {
SmallVector<Value *, 4> Objs; SmallVector<Value *, 4> Objs;
getUnderlyingObjectsForCodeGen(MMOV, Objs); getUnderlyingObjectsForCodeGen(MMOV, Objs);
if (Objs.empty()) if (Objs.empty())
MayHaveConflictingAAMD = true; MayHaveConflictingAAMD = true;
else else
for (Value *V : Objs) { for (Value *V : Objs) {
// If this memory location comes from a known stack slot // If this memory location comes from a known stack slot
// that is not remapped, we continue checking. // that is not remapped, we continue checking.
// Otherwise, we need to invalidate AA infomation. // Otherwise, we need to invalidate AA infomation.
const AllocaInst *AI = dyn_cast_or_null<AllocaInst>(V); const AllocaInst *AI = dyn_cast_if_present<AllocaInst>(V);
if (AI && MergedAllocas.count(AI)) { if (AI && MergedAllocas.count(AI)) {
MayHaveConflictingAAMD = true; MayHaveConflictingAAMD = true;
break; break;
} }
} }
} }
} }
if (MayHaveConflictingAAMD) { if (MayHaveConflictingAAMD) {
▲ Show 20 Lines • Show All 266 Lines • Show Last 20 Lines

llvm/lib/CodeGen/StackSlotColoring.cpp

Show First 20 Lines • Show All 170 Lines • ▼ Show 20 Lines for (MachineInstr &MI : MBB) {
li.incrementWeight( li.incrementWeight(
LiveIntervals::getSpillWeight(false, true, MBFI, MI)); LiveIntervals::getSpillWeight(false, true, MBFI, MI));
} }
for (MachineInstr::mmo_iterator MMOI = MI.memoperands_begin(), for (MachineInstr::mmo_iterator MMOI = MI.memoperands_begin(),
EE = MI.memoperands_end(); EE = MI.memoperands_end();
MMOI != EE; ++MMOI) { MMOI != EE; ++MMOI) {
MachineMemOperand *MMO = *MMOI; MachineMemOperand *MMO = *MMOI;
if (const FixedStackPseudoSourceValue *FSV = if (const FixedStackPseudoSourceValue *FSV =
dyn_cast_or_null<FixedStackPseudoSourceValue>( dyn_cast_if_present<FixedStackPseudoSourceValue>(
MMO->getPseudoValue())) { MMO->getPseudoValue())) {
int FI = FSV->getFrameIndex(); int FI = FSV->getFrameIndex();
if (FI >= 0) if (FI >= 0)
SSRefs[FI].push_back(MMO); SSRefs[FI].push_back(MMO);
} }
} }
} }
} }
} }
▲ Show 20 Lines • Show All 335 Lines • Show Last 20 Lines

llvm/lib/CodeGen/TargetLoweringBase.cpp

Show First 20 Lines • Show All 1,845 Lines • ▼ Show 20 Lines
Value * Value *
TargetLoweringBase::getDefaultSafeStackPointerLocation(IRBuilderBase &IRB, TargetLoweringBase::getDefaultSafeStackPointerLocation(IRBuilderBase &IRB,
bool UseTLS) const { bool UseTLS) const {
// compiler-rt provides a variable with a magic name. Targets that do not // compiler-rt provides a variable with a magic name. Targets that do not
// link with compiler-rt may also provide such a variable. // link with compiler-rt may also provide such a variable.
Module *M = IRB.GetInsertBlock()->getParent()->getParent(); Module *M = IRB.GetInsertBlock()->getParent()->getParent();
const char *UnsafeStackPtrVar = "__safestack_unsafe_stack_ptr"; const char *UnsafeStackPtrVar = "__safestack_unsafe_stack_ptr";
auto UnsafeStackPtr = auto UnsafeStackPtr =
dyn_cast_or_null<GlobalVariable>(M->getNamedValue(UnsafeStackPtrVar)); dyn_cast_if_present<GlobalVariable>(M->getNamedValue(UnsafeStackPtrVar));
Type *StackPtrTy = Type::getInt8PtrTy(M->getContext()); Type *StackPtrTy = Type::getInt8PtrTy(M->getContext());
if (!UnsafeStackPtr) { if (!UnsafeStackPtr) {
auto TLSModel = UseTLS ? auto TLSModel = UseTLS ?
GlobalValue::InitialExecTLSModel : GlobalValue::InitialExecTLSModel :
GlobalValue::NotThreadLocal; GlobalValue::NotThreadLocal;
// The global variable is not defined yet, define it ourselves. // The global variable is not defined yet, define it ourselves.
▲ Show 20 Lines • Show All 74 Lines • ▼ Show 20 Lines
// For OpenBSD return its special guard variable. Otherwise return nullptr, // For OpenBSD return its special guard variable. Otherwise return nullptr,
// so that SelectionDAG handle SSP. // so that SelectionDAG handle SSP.
Value *TargetLoweringBase::getIRStackGuard(IRBuilderBase &IRB) const { Value *TargetLoweringBase::getIRStackGuard(IRBuilderBase &IRB) const {
if (getTargetMachine().getTargetTriple().isOSOpenBSD()) { if (getTargetMachine().getTargetTriple().isOSOpenBSD()) {
Module &M = *IRB.GetInsertBlock()->getParent()->getParent(); Module &M = *IRB.GetInsertBlock()->getParent()->getParent();
PointerType *PtrTy = Type::getInt8PtrTy(M.getContext()); PointerType *PtrTy = Type::getInt8PtrTy(M.getContext());
Constant *C = M.getOrInsertGlobal("__guard_local", PtrTy); Constant *C = M.getOrInsertGlobal("__guard_local", PtrTy);
if (GlobalVariable *G = dyn_cast_or_null<GlobalVariable>(C)) if (GlobalVariable *G = dyn_cast_if_present<GlobalVariable>(C))
G->setVisibility(GlobalValue::HiddenVisibility); G->setVisibility(GlobalValue::HiddenVisibility);
return C; return C;
} }
return nullptr; return nullptr;
} }
// Currently only support "standard" __stack_chk_guard. // Currently only support "standard" __stack_chk_guard.
// TODO: add LOAD_STACK_GUARD support. // TODO: add LOAD_STACK_GUARD support.
▲ Show 20 Lines • Show All 369 Lines • Show Last 20 Lines

llvm/lib/CodeGen/WinEHPrepare.cpp

Show First 20 Lines • Show All 941 Lines • ▼ Show 20 Lines
void WinEHPrepare::removeImplausibleInstructions(Function &F) { void WinEHPrepare::removeImplausibleInstructions(Function &F) {
// Remove implausible terminators and replace them with UnreachableInst. // Remove implausible terminators and replace them with UnreachableInst.
for (auto &Funclet : FuncletBlocks) { for (auto &Funclet : FuncletBlocks) {
BasicBlock *FuncletPadBB = Funclet.first; BasicBlock *FuncletPadBB = Funclet.first;
std::vector<BasicBlock *> &BlocksInFunclet = Funclet.second; std::vector<BasicBlock *> &BlocksInFunclet = Funclet.second;
Instruction *FirstNonPHI = FuncletPadBB->getFirstNonPHI(); Instruction *FirstNonPHI = FuncletPadBB->getFirstNonPHI();
auto *FuncletPad = dyn_cast<FuncletPadInst>(FirstNonPHI); auto *FuncletPad = dyn_cast<FuncletPadInst>(FirstNonPHI);
auto *CatchPad = dyn_cast_or_null<CatchPadInst>(FuncletPad); auto *CatchPad = dyn_cast_if_present<CatchPadInst>(FuncletPad);
auto *CleanupPad = dyn_cast_or_null<CleanupPadInst>(FuncletPad); auto *CleanupPad = dyn_cast_if_present<CleanupPadInst>(FuncletPad);
for (BasicBlock *BB : BlocksInFunclet) { for (BasicBlock *BB : BlocksInFunclet) {
for (Instruction &I : *BB) { for (Instruction &I : *BB) {
auto *CB = dyn_cast<CallBase>(&I); auto *CB = dyn_cast<CallBase>(&I);
if (!CB) if (!CB)
continue; continue;
Value *FuncletBundleOperand = nullptr; Value *FuncletBundleOperand = nullptr;
▲ Show 20 Lines • Show All 297 Lines • Show Last 20 Lines

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

Show First 20 Lines • Show All 699 Lines • ▼ Show 20 Lines
} }
DWARFTypeUnit *DWARFContext::getTypeUnitForHash(uint16_t Version, uint64_t Hash, DWARFTypeUnit *DWARFContext::getTypeUnitForHash(uint16_t Version, uint64_t Hash,
bool IsDWO) { bool IsDWO) {
parseDWOUnits(LazyParse); parseDWOUnits(LazyParse);
if (const auto &TUI = getTUIndex()) { if (const auto &TUI = getTUIndex()) {
if (const auto *R = TUI.getFromHash(Hash)) if (const auto *R = TUI.getFromHash(Hash))
return dyn_cast_or_null<DWARFTypeUnit>( return dyn_cast_if_present<DWARFTypeUnit>(
DWOUnits.getUnitForIndexEntry(*R)); DWOUnits.getUnitForIndexEntry(*R));
return nullptr; return nullptr;
} }
struct UnitContainers { struct UnitContainers {
const DWARFUnitVector &Units; const DWARFUnitVector &Units;
Optional<DenseMap<uint64_t, DWARFTypeUnit *>> &Map; Optional<DenseMap<uint64_t, DWARFTypeUnit *>> &Map;
}; };
Show All 10 LinesDWARFTypeUnit *DWARFContext::getTypeUnitForHash(uint16_t Version, uint64_t Hash,
return (*Units.Map)[Hash]; return (*Units.Map)[Hash];
} }
DWARFCompileUnit *DWARFContext::getDWOCompileUnitForHash(uint64_t Hash) { DWARFCompileUnit *DWARFContext::getDWOCompileUnitForHash(uint64_t Hash) {
parseDWOUnits(LazyParse); parseDWOUnits(LazyParse);
if (const auto &CUI = getCUIndex()) { if (const auto &CUI = getCUIndex()) {
if (const auto *R = CUI.getFromHash(Hash)) if (const auto *R = CUI.getFromHash(Hash))
return dyn_cast_or_null<DWARFCompileUnit>( return dyn_cast_if_present<DWARFCompileUnit>(
DWOUnits.getUnitForIndexEntry(*R)); DWOUnits.getUnitForIndexEntry(*R));
return nullptr; return nullptr;
} }
// If there's no index, just search through the CUs in the DWO - there's // If there's no index, just search through the CUs in the DWO - there's
// probably only one unless this is something like LTO - though an in-process // probably only one unless this is something like LTO - though an in-process
// built/cached lookup table could be used in that case to improve repeated // built/cached lookup table could be used in that case to improve repeated
// lookups of different CUs in the DWO. // lookups of different CUs in the DWO.
▲ Show 20 Lines • Show All 296 Lines • ▼ Show 20 Linesvoid DWARFContext::parseDWOUnits(bool Lazy) {
DWOUnits.finishedInfoUnits(); DWOUnits.finishedInfoUnits();
DObj->forEachTypesDWOSections([&](const DWARFSection &S) { DObj->forEachTypesDWOSections([&](const DWARFSection &S) {
DWOUnits.addUnitsForDWOSection(*this, S, DW_SECT_EXT_TYPES, Lazy); DWOUnits.addUnitsForDWOSection(*this, S, DW_SECT_EXT_TYPES, Lazy);
}); });
} }
DWARFCompileUnit *DWARFContext::getCompileUnitForOffset(uint64_t Offset) { DWARFCompileUnit *DWARFContext::getCompileUnitForOffset(uint64_t Offset) {
parseNormalUnits(); parseNormalUnits();
return dyn_cast_or_null<DWARFCompileUnit>( return dyn_cast_if_present<DWARFCompileUnit>(
NormalUnits.getUnitForOffset(Offset)); NormalUnits.getUnitForOffset(Offset));
} }
DWARFCompileUnit *DWARFContext::getCompileUnitForAddress(uint64_t Address) { DWARFCompileUnit *DWARFContext::getCompileUnitForAddress(uint64_t Address) {
// First, get the offset of the compile unit. // First, get the offset of the compile unit.
uint64_t CUOffset = getDebugAranges()->findAddress(Address); uint64_t CUOffset = getDebugAranges()->findAddress(Address);
// Retrieve the compile unit. // Retrieve the compile unit.
if (DWARFCompileUnit *OffsetCU = getCompileUnitForOffset(CUOffset)) if (DWARFCompileUnit *OffsetCU = getCompileUnitForOffset(CUOffset))
▲ Show 20 Lines • Show All 991 Lines • Show Last 20 Lines

llvm/lib/DebugInfo/PDB/PDBContext.cpp

Show All 34 Lines
DILineInfo PDBContext::getLineInfoForAddress(object::SectionedAddress Address, DILineInfo PDBContext::getLineInfoForAddress(object::SectionedAddress Address,
DILineInfoSpecifier Specifier) { DILineInfoSpecifier Specifier) {
DILineInfo Result; DILineInfo Result;
Result.FunctionName = getFunctionName(Address.Address, Specifier.FNKind); Result.FunctionName = getFunctionName(Address.Address, Specifier.FNKind);
uint32_t Length = 1; uint32_t Length = 1;
std::unique_ptr<PDBSymbol> Symbol = std::unique_ptr<PDBSymbol> Symbol =
Session->findSymbolByAddress(Address.Address, PDB_SymType::None); Session->findSymbolByAddress(Address.Address, PDB_SymType::None);
if (auto Func = dyn_cast_or_null<PDBSymbolFunc>(Symbol.get())) { if (auto Func = dyn_cast_if_present<PDBSymbolFunc>(Symbol.get())) {
Length = Func->getLength(); Length = Func->getLength();
} else if (auto Data = dyn_cast_or_null<PDBSymbolData>(Symbol.get())) { } else if (auto Data = dyn_cast_if_present<PDBSymbolData>(Symbol.get())) {
Length = Data->getLength(); Length = Data->getLength();
} }
// If we couldn't find a symbol, then just assume 1 byte, so that we get // If we couldn't find a symbol, then just assume 1 byte, so that we get
// only the line number of the first instruction. // only the line number of the first instruction.
auto LineNumbers = Session->findLineNumbersByAddress(Address.Address, Length); auto LineNumbers = Session->findLineNumbersByAddress(Address.Address, Length);
if (!LineNumbers || LineNumbers->getChildCount() == 0) if (!LineNumbers || LineNumbers->getChildCount() == 0)
return Result; return Result;
▲ Show 20 Lines • Show All 88 Lines • ▼ Show 20 Lines
std::string PDBContext::getFunctionName(uint64_t Address, std::string PDBContext::getFunctionName(uint64_t Address,
DINameKind NameKind) const { DINameKind NameKind) const {
if (NameKind == DINameKind::None) if (NameKind == DINameKind::None)
return std::string(); return std::string();
std::unique_ptr<PDBSymbol> FuncSymbol = std::unique_ptr<PDBSymbol> FuncSymbol =
Session->findSymbolByAddress(Address, PDB_SymType::Function); Session->findSymbolByAddress(Address, PDB_SymType::Function);
auto *Func = dyn_cast_or_null<PDBSymbolFunc>(FuncSymbol.get()); auto *Func = dyn_cast_if_present<PDBSymbolFunc>(FuncSymbol.get());
if (NameKind == DINameKind::LinkageName) { if (NameKind == DINameKind::LinkageName) {
// It is not possible to get the mangled linkage name through a // It is not possible to get the mangled linkage name through a
// PDBSymbolFunc. For that we have to specifically request a // PDBSymbolFunc. For that we have to specifically request a
// PDBSymbolPublicSymbol. // PDBSymbolPublicSymbol.
auto PublicSym = auto PublicSym =
Session->findSymbolByAddress(Address, PDB_SymType::PublicSymbol); Session->findSymbolByAddress(Address, PDB_SymType::PublicSymbol);
if (auto *PS = dyn_cast_or_null<PDBSymbolPublicSymbol>(PublicSym.get())) { if (auto *PS =
dyn_cast_if_present<PDBSymbolPublicSymbol>(PublicSym.get())) {
// If we also have a function symbol, prefer the use of public symbol name // If we also have a function symbol, prefer the use of public symbol name
// only if it refers to the same address. The public symbol uses the // only if it refers to the same address. The public symbol uses the
// linkage name while the function does not. // linkage name while the function does not.
if (!Func || Func->getVirtualAddress() == PS->getVirtualAddress()) if (!Func || Func->getVirtualAddress() == PS->getVirtualAddress())
return PS->getName(); return PS->getName();
} }
} }
return Func ? Func->getName() : std::string(); return Func ? Func->getName() : std::string();
} }

llvm/lib/DebugInfo/PDB/PDBSymbolTypeFunctionSig.cpp

Show First 20 Lines • Show All 76 Lines • ▼ Show 20 Lines
bool PDBSymbolTypeFunctionSig::isCVarArgs() const { bool PDBSymbolTypeFunctionSig::isCVarArgs() const {
auto SigArguments = getArguments(); auto SigArguments = getArguments();
if (!SigArguments) if (!SigArguments)
return false; return false;
uint32_t NumArgs = SigArguments->getChildCount(); uint32_t NumArgs = SigArguments->getChildCount();
if (NumArgs == 0) if (NumArgs == 0)
return false; return false;
auto Last = SigArguments->getChildAtIndex(NumArgs - 1); auto Last = SigArguments->getChildAtIndex(NumArgs - 1);
if (auto Builtin = llvm::dyn_cast_or_null<PDBSymbolTypeBuiltin>(Last.get())) { if (auto Builtin =
llvm::dyn_cast_if_present<PDBSymbolTypeBuiltin>(Last.get())) {
if (Builtin->getBuiltinType() == PDB_BuiltinType::None) if (Builtin->getBuiltinType() == PDB_BuiltinType::None)
return true; return true;
} }
// Note that for a variadic template signature, this method always returns // Note that for a variadic template signature, this method always returns
// false since the parameters of the template are specialized. // false since the parameters of the template are specialized.
return false; return false;
} }

llvm/lib/DebugInfo/Symbolize/Symbolize.cpp

Show First 20 Lines • Show All 553 Lines • ▼ Show 20 Lines if (!Pair.second) {
LRUBinaries.push_back(CachedBin); LRUBinaries.push_back(CachedBin);
CacheSize += CachedBin.size(); CacheSize += CachedBin.size();
Bin = CachedBin->getBinary(); Bin = CachedBin->getBinary();
} }
if (!Bin) if (!Bin)
return static_cast<ObjectFile *>(nullptr); return static_cast<ObjectFile *>(nullptr);
if (MachOUniversalBinary *UB = dyn_cast_or_null<MachOUniversalBinary>(Bin)) { if (MachOUniversalBinary *UB =
dyn_cast_if_present<MachOUniversalBinary>(Bin)) {
auto I = ObjectForUBPathAndArch.find(std::make_pair(Path, ArchName)); auto I = ObjectForUBPathAndArch.find(std::make_pair(Path, ArchName));
if (I != ObjectForUBPathAndArch.end()) if (I != ObjectForUBPathAndArch.end())
return I->second.get(); return I->second.get();
Expected<std::unique_ptr<ObjectFile>> ObjOrErr = Expected<std::unique_ptr<ObjectFile>> ObjOrErr =
UB->getMachOObjectForArch(ArchName); UB->getMachOObjectForArch(ArchName);
if (!ObjOrErr) { if (!ObjOrErr) {
ObjectForUBPathAndArch.emplace(std::make_pair(Path, ArchName), ObjectForUBPathAndArch.emplace(std::make_pair(Path, ArchName),
▲ Show 20 Lines • Show All 210 Lines • Show Last 20 Lines

llvm/lib/ExecutionEngine/Orc/ExecutionUtils.cpp

Show All 18 Lines
#include "llvm/Support/FormatVariadic.h" #include "llvm/Support/FormatVariadic.h"
#include "llvm/Target/TargetMachine.h" #include "llvm/Target/TargetMachine.h"
#include <string> #include <string>
namespace llvm { namespace llvm {
namespace orc { namespace orc {
CtorDtorIterator::CtorDtorIterator(const GlobalVariable *GV, bool End) CtorDtorIterator::CtorDtorIterator(const GlobalVariable *GV, bool End)
: InitList( : InitList(GV ? dyn_cast_if_present<ConstantArray>(GV->getInitializer())
GV ? dyn_cast_or_null<ConstantArray>(GV->getInitializer()) : nullptr), : nullptr),
I((InitList && End) ? InitList->getNumOperands() : 0) { I((InitList && End) ? InitList->getNumOperands() : 0) {}
}
bool CtorDtorIterator::operator==(const CtorDtorIterator &Other) const { bool CtorDtorIterator::operator==(const CtorDtorIterator &Other) const {
assert(InitList == Other.InitList && "Incomparable iterators."); assert(InitList == Other.InitList && "Incomparable iterators.");
return I == Other.I; return I == Other.I;
} }
bool CtorDtorIterator::operator!=(const CtorDtorIterator &Other) const { bool CtorDtorIterator::operator!=(const CtorDtorIterator &Other) const {
return !(*this == Other); return !(*this == Other);
} }
CtorDtorIterator& CtorDtorIterator::operator++() { CtorDtorIterator &CtorDtorIterator::operator++() {
++I; ++I;
return *this; return *this;
} }
CtorDtorIterator CtorDtorIterator::operator++(int) { CtorDtorIterator CtorDtorIterator::operator++(int) {
CtorDtorIterator Temp = *this; CtorDtorIterator Temp = *this;
++I; ++I;
return Temp; return Temp;
} }
CtorDtorIterator::Element CtorDtorIterator::operator*() const { CtorDtorIterator::Element CtorDtorIterator::operator*() const {
ConstantStruct *CS = dyn_cast<ConstantStruct>(InitList->getOperand(I)); ConstantStruct *CS = dyn_cast<ConstantStruct>(InitList->getOperand(I));
assert(CS && "Unrecognized type in llvm.global_ctors/llvm.global_dtors"); assert(CS && "Unrecognized type in llvm.global_ctors/llvm.global_dtors");
Constant *FuncC = CS->getOperand(1); Constant *FuncC = CS->getOperand(1);
Function *Func = nullptr; Function *Func = nullptr;
// Extract function pointer, pulling off any casts. // Extract function pointer, pulling off any casts.
while (FuncC) { while (FuncC) {
if (Function *F = dyn_cast_or_null<Function>(FuncC)) { if (Function *F = dyn_cast_if_present<Function>(FuncC)) {
Func = F; Func = F;
break; break;
} else if (ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(FuncC)) { } else if (ConstantExpr *CE = dyn_cast_if_present<ConstantExpr>(FuncC)) {
if (CE->isCast()) if (CE->isCast())
FuncC = CE->getOperand(0); FuncC = CE->getOperand(0);
else else
break; break;
} else { } else {
// This isn't anything we recognize. Bail out with Func left set to null. // This isn't anything we recognize. Bail out with Func left set to null.
break; break;
} }
▲ Show 20 Lines • Show All 90 Lines • ▼ Show 20 Lines if (auto CtorDtorMap = ES.lookup(
} }
CtorDtorsByPriority.clear(); CtorDtorsByPriority.clear();
return Error::success(); return Error::success();
} else } else
return CtorDtorMap.takeError(); return CtorDtorMap.takeError();
} }
void LocalCXXRuntimeOverridesBase::runDestructors() { void LocalCXXRuntimeOverridesBase::runDestructors() {
auto& CXXDestructorDataPairs = DSOHandleOverride; auto &CXXDestructorDataPairs = DSOHandleOverride;
for (auto &P : CXXDestructorDataPairs) for (auto &P : CXXDestructorDataPairs)
P.first(P.second); P.first(P.second);
CXXDestructorDataPairs.clear(); CXXDestructorDataPairs.clear();
} }
int LocalCXXRuntimeOverridesBase::CXAAtExitOverride(DestructorPtr Destructor, int LocalCXXRuntimeOverridesBase::CXAAtExitOverride(DestructorPtr Destructor,
void *Arg, void *Arg,
void *DSOHandle) { void *DSOHandle) {
auto& CXXDestructorDataPairs = auto &CXXDestructorDataPairs =
*reinterpret_cast<CXXDestructorDataPairList*>(DSOHandle); *reinterpret_cast<CXXDestructorDataPairList *>(DSOHandle);
CXXDestructorDataPairs.push_back(std::make_pair(Destructor, Arg)); CXXDestructorDataPairs.push_back(std::make_pair(Destructor, Arg));
return 0; return 0;
} }
Error LocalCXXRuntimeOverrides::enable(JITDylib &JD, Error LocalCXXRuntimeOverrides::enable(JITDylib &JD,
MangleAndInterner &Mangle) { MangleAndInterner &Mangle) {
SymbolMap RuntimeInterposes; SymbolMap RuntimeInterposes;
RuntimeInterposes[Mangle("__dso_handle")] = RuntimeInterposes[Mangle("__dso_handle")] = JITEvaluatedSymbol(
JITEvaluatedSymbol(toTargetAddress(&DSOHandleOverride), toTargetAddress(&DSOHandleOverride), JITSymbolFlags::Exported);
JITSymbolFlags::Exported); RuntimeInterposes[Mangle("__cxa_atexit")] = JITEvaluatedSymbol(
RuntimeInterposes[Mangle("__cxa_atexit")] = toTargetAddress(&CXAAtExitOverride), JITSymbolFlags::Exported);
JITEvaluatedSymbol(toTargetAddress(&CXAAtExitOverride),
JITSymbolFlags::Exported);
return JD.define(absoluteSymbols(std::move(RuntimeInterposes))); return JD.define(absoluteSymbols(std::move(RuntimeInterposes)));
} }
void ItaniumCXAAtExitSupport::registerAtExit(void (*F)(void *), void *Ctx, void ItaniumCXAAtExitSupport::registerAtExit(void (*F)(void *), void *Ctx,
void *DSOHandle) { void *DSOHandle) {
std::lock_guard<std::mutex> Lock(AtExitsMutex); std::lock_guard<std::mutex> Lock(AtExitsMutex);
AtExitRecords[DSOHandle].push_back({F, Ctx}); AtExitRecords[DSOHandle].push_back({F, Ctx});
▲ Show 20 Lines • Show All 348 Lines • Show Last 20 Lines

llvm/lib/IR/AsmWriter.cpp

Show First 20 Lines • Show All 1,090 Lines • ▼ Show 20 Lines
} }
void SlotTracker::processInstructionMetadata(const Instruction &I) { void SlotTracker::processInstructionMetadata(const Instruction &I) {
// Process metadata used directly by intrinsics. // Process metadata used directly by intrinsics.
if (const CallInst *CI = dyn_cast<CallInst>(&I)) if (const CallInst *CI = dyn_cast<CallInst>(&I))
if (Function *F = CI->getCalledFunction()) if (Function *F = CI->getCalledFunction())
if (F->isIntrinsic()) if (F->isIntrinsic())
for (auto &Op : I.operands()) for (auto &Op : I.operands())
if (auto *V = dyn_cast_or_null<MetadataAsValue>(Op)) if (auto *V = dyn_cast_if_present<MetadataAsValue>(Op))
if (MDNode *N = dyn_cast<MDNode>(V->getMetadata())) if (MDNode *N = dyn_cast<MDNode>(V->getMetadata()))
CreateMetadataSlot(N); CreateMetadataSlot(N);
// Process metadata attached to this instruction. // Process metadata attached to this instruction.
SmallVector<std::pair<unsigned, MDNode *>, 4> MDs; SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
I.getAllMetadata(MDs); I.getAllMetadata(MDs);
for (auto &MD : MDs) for (auto &MD : MDs)
CreateMetadataSlot(MD.second); CreateMetadataSlot(MD.second);
▲ Show 20 Lines • Show All 133 Lines • ▼ Show 20 Linesvoid SlotTracker::CreateMetadataSlot(const MDNode *N) {
unsigned DestSlot = mdnNext; unsigned DestSlot = mdnNext;
if (!mdnMap.insert(std::make_pair(N, DestSlot)).second) if (!mdnMap.insert(std::make_pair(N, DestSlot)).second)
return; return;
++mdnNext; ++mdnNext;
// Recursively add any MDNodes referenced by operands. // Recursively add any MDNodes referenced by operands.
for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i)
if (const MDNode *Op = dyn_cast_or_null<MDNode>(N->getOperand(i))) if (const MDNode *Op = dyn_cast_if_present<MDNode>(N->getOperand(i)))
CreateMetadataSlot(Op); CreateMetadataSlot(Op);
} }
void SlotTracker::CreateAttributeSetSlot(AttributeSet AS) { void SlotTracker::CreateAttributeSetSlot(AttributeSet AS) {
assert(AS.hasAttributes() && "Doesn't need a slot!"); assert(AS.hasAttributes() && "Doesn't need a slot!");
as_iterator I = asMap.find(AS); as_iterator I = asMap.find(AS);
if (I != asMap.end()) if (I != asMap.end())
▲ Show 20 Lines • Show All 602 Lines • ▼ Show 20 Lines
} }
static void writeDISubrange(raw_ostream &Out, const DISubrange *N, static void writeDISubrange(raw_ostream &Out, const DISubrange *N,
AsmWriterContext &WriterCtx) { AsmWriterContext &WriterCtx) {
Out << "!DISubrange("; Out << "!DISubrange(";
MDFieldPrinter Printer(Out, WriterCtx); MDFieldPrinter Printer(Out, WriterCtx);
auto *Count = N->getRawCountNode(); auto *Count = N->getRawCountNode();
if (auto *CE = dyn_cast_or_null<ConstantAsMetadata>(Count)) { if (auto *CE = dyn_cast_if_present<ConstantAsMetadata>(Count)) {
auto *CV = cast<ConstantInt>(CE->getValue()); auto *CV = cast<ConstantInt>(CE->getValue());
Printer.printInt("count", CV->getSExtValue(), Printer.printInt("count", CV->getSExtValue(),
/* ShouldSkipZero */ false); /* ShouldSkipZero */ false);
} else } else
Printer.printMetadata("count", Count, /*ShouldSkipNull */ true); Printer.printMetadata("count", Count, /*ShouldSkipNull */ true);
// A lowerBound of constant 0 should not be skipped, since it is different // A lowerBound of constant 0 should not be skipped, since it is different
// from an unspecified lower bound (= nullptr). // from an unspecified lower bound (= nullptr).
auto *LBound = N->getRawLowerBound(); auto *LBound = N->getRawLowerBound();
if (auto *LE = dyn_cast_or_null<ConstantAsMetadata>(LBound)) { if (auto *LE = dyn_cast_if_present<ConstantAsMetadata>(LBound)) {
auto *LV = cast<ConstantInt>(LE->getValue()); auto *LV = cast<ConstantInt>(LE->getValue());
Printer.printInt("lowerBound", LV->getSExtValue(), Printer.printInt("lowerBound", LV->getSExtValue(),
/* ShouldSkipZero */ false); /* ShouldSkipZero */ false);
} else } else
Printer.printMetadata("lowerBound", LBound, /*ShouldSkipNull */ true); Printer.printMetadata("lowerBound", LBound, /*ShouldSkipNull */ true);
auto *UBound = N->getRawUpperBound(); auto *UBound = N->getRawUpperBound();
if (auto *UE = dyn_cast_or_null<ConstantAsMetadata>(UBound)) { if (auto *UE = dyn_cast_if_present<ConstantAsMetadata>(UBound)) {
auto *UV = cast<ConstantInt>(UE->getValue()); auto *UV = cast<ConstantInt>(UE->getValue());
Printer.printInt("upperBound", UV->getSExtValue(), Printer.printInt("upperBound", UV->getSExtValue(),
/* ShouldSkipZero */ false); /* ShouldSkipZero */ false);
} else } else
Printer.printMetadata("upperBound", UBound, /*ShouldSkipNull */ true); Printer.printMetadata("upperBound", UBound, /*ShouldSkipNull */ true);
auto *Stride = N->getRawStride(); auto *Stride = N->getRawStride();
if (auto *SE = dyn_cast_or_null<ConstantAsMetadata>(Stride)) { if (auto *SE = dyn_cast_if_present<ConstantAsMetadata>(Stride)) {
auto *SV = cast<ConstantInt>(SE->getValue()); auto *SV = cast<ConstantInt>(SE->getValue());
Printer.printInt("stride", SV->getSExtValue(), /* ShouldSkipZero */ false); Printer.printInt("stride", SV->getSExtValue(), /* ShouldSkipZero */ false);
} else } else
Printer.printMetadata("stride", Stride, /*ShouldSkipNull */ true); Printer.printMetadata("stride", Stride, /*ShouldSkipNull */ true);
Out << ")"; Out << ")";
} }
static void writeDIGenericSubrange(raw_ostream &Out, const DIGenericSubrange *N, static void writeDIGenericSubrange(raw_ostream &Out, const DIGenericSubrange *N,
AsmWriterContext &WriterCtx) { AsmWriterContext &WriterCtx) {
Out << "!DIGenericSubrange("; Out << "!DIGenericSubrange(";
MDFieldPrinter Printer(Out, WriterCtx); MDFieldPrinter Printer(Out, WriterCtx);
auto IsConstant = [&](Metadata *Bound) -> bool { auto IsConstant = [&](Metadata *Bound) -> bool {
if (auto *BE = dyn_cast_or_null<DIExpression>(Bound)) { if (auto *BE = dyn_cast_if_present<DIExpression>(Bound)) {
return BE->isConstant() && return BE->isConstant() &&
DIExpression::SignedOrUnsignedConstant::SignedConstant == DIExpression::SignedOrUnsignedConstant::SignedConstant ==
*BE->isConstant(); *BE->isConstant();
} }
return false; return false;
}; };
auto GetConstant = [&](Metadata *Bound) -> int64_t { auto GetConstant = [&](Metadata *Bound) -> int64_t {
assert(IsConstant(Bound) && "Expected constant"); assert(IsConstant(Bound) && "Expected constant");
auto *BE = dyn_cast_or_null<DIExpression>(Bound); auto *BE = dyn_cast_if_present<DIExpression>(Bound);
return static_cast<int64_t>(BE->getElement(1)); return static_cast<int64_t>(BE->getElement(1));
}; };
auto *Count = N->getRawCountNode(); auto *Count = N->getRawCountNode();
if (IsConstant(Count)) if (IsConstant(Count))
Printer.printInt("count", GetConstant(Count), Printer.printInt("count", GetConstant(Count),
/* ShouldSkipZero */ false); /* ShouldSkipZero */ false);
else else
▲ Show 20 Lines • Show All 2,646 Lines • ▼ Show 20 Lines if (StructType *STy = dyn_cast<StructType>(const_cast<Type*>(this)))
} }
} }
static bool isReferencingMDNode(const Instruction &I) { static bool isReferencingMDNode(const Instruction &I) {
if (const auto *CI = dyn_cast<CallInst>(&I)) if (const auto *CI = dyn_cast<CallInst>(&I))
if (Function *F = CI->getCalledFunction()) if (Function *F = CI->getCalledFunction())
if (F->isIntrinsic()) if (F->isIntrinsic())
for (auto &Op : I.operands()) for (auto &Op : I.operands())
if (auto *V = dyn_cast_or_null<MetadataAsValue>(Op)) if (auto *V = dyn_cast_if_present<MetadataAsValue>(Op))
if (isa<MDNode>(V->getMetadata())) if (isa<MDNode>(V->getMetadata()))
return true; return true;
return false; return false;
} }
void Value::print(raw_ostream &ROS, bool IsForDebug) const { void Value::print(raw_ostream &ROS, bool IsForDebug) const {
bool ShouldInitializeAllMetadata = false; bool ShouldInitializeAllMetadata = false;
if (auto *I = dyn_cast<Instruction>(this)) if (auto *I = dyn_cast<Instruction>(this))
▲ Show 20 Lines • Show All 283 Lines • Show Last 20 Lines

llvm/lib/IR/AutoUpgrade.cpp

Show First 20 Lines • Show All 3,911 Lines • ▼ Show 20 Lines
case Intrinsic::convert_from_fp16: case Intrinsic::convert_from_fp16:
NewCall = Builder.CreateCall(NewFn, {CI->getArgOperand(0)}); NewCall = Builder.CreateCall(NewFn, {CI->getArgOperand(0)});
break; break;
case Intrinsic::dbg_value: case Intrinsic::dbg_value:
// Upgrade from the old version that had an extra offset argument. // Upgrade from the old version that had an extra offset argument.
assert(CI->arg_size() == 4); assert(CI->arg_size() == 4);
// Drop nonzero offsets instead of attempting to upgrade them. // Drop nonzero offsets instead of attempting to upgrade them.
if (auto *Offset = dyn_cast_or_null<Constant>(CI->getArgOperand(1))) if (auto *Offset = dyn_cast_if_present<Constant>(CI->getArgOperand(1)))
if (Offset->isZeroValue()) { if (Offset->isZeroValue()) {
NewCall = Builder.CreateCall( NewCall = Builder.CreateCall(
NewFn, NewFn,
{CI->getArgOperand(0), CI->getArgOperand(2), CI->getArgOperand(3)}); {CI->getArgOperand(0), CI->getArgOperand(2), CI->getArgOperand(3)});
break; break;
} }
CI->eraseFromParent(); CI->eraseFromParent();
return; return;
▲ Show 20 Lines • Show All 300 Lines • ▼ Show 20 Lines
/// returns true if module is modified. /// returns true if module is modified.
static bool UpgradeRetainReleaseMarker(Module &M) { static bool UpgradeRetainReleaseMarker(Module &M) {
bool Changed = false; bool Changed = false;
const char *MarkerKey = "clang.arc.retainAutoreleasedReturnValueMarker"; const char *MarkerKey = "clang.arc.retainAutoreleasedReturnValueMarker";
NamedMDNode *ModRetainReleaseMarker = M.getNamedMetadata(MarkerKey); NamedMDNode *ModRetainReleaseMarker = M.getNamedMetadata(MarkerKey);
if (ModRetainReleaseMarker) { if (ModRetainReleaseMarker) {
MDNode *Op = ModRetainReleaseMarker->getOperand(0); MDNode *Op = ModRetainReleaseMarker->getOperand(0);
if (Op) { if (Op) {
MDString *ID = dyn_cast_or_null<MDString>(Op->getOperand(0)); MDString *ID = dyn_cast_if_present<MDString>(Op->getOperand(0));
if (ID) { if (ID) {
SmallVector<StringRef, 4> ValueComp; SmallVector<StringRef, 4> ValueComp;
ID->getString().split(ValueComp, "#"); ID->getString().split(ValueComp, "#");
if (ValueComp.size() == 2) { if (ValueComp.size() == 2) {
std::string NewValue = ValueComp[0].str() + ";" + ValueComp[1].str(); std::string NewValue = ValueComp[0].str() + ";" + ValueComp[1].str();
ID = MDString::get(M.getContext(), NewValue); ID = MDString::get(M.getContext(), NewValue);
} }
M.addModuleFlag(Module::Error, MarkerKey, ID); M.addModuleFlag(Module::Error, MarkerKey, ID);
▲ Show 20 Lines • Show All 137 Lines • ▼ Show 20 Linesbool llvm::UpgradeModuleFlags(Module &M) {
uint32_t SwiftABIVersion; uint32_t SwiftABIVersion;
auto Int8Ty = Type::getInt8Ty(M.getContext()); auto Int8Ty = Type::getInt8Ty(M.getContext());
auto Int32Ty = Type::getInt32Ty(M.getContext()); auto Int32Ty = Type::getInt32Ty(M.getContext());
for (unsigned I = 0, E = ModFlags->getNumOperands(); I != E; ++I) { for (unsigned I = 0, E = ModFlags->getNumOperands(); I != E; ++I) {
MDNode *Op = ModFlags->getOperand(I); MDNode *Op = ModFlags->getOperand(I);
if (Op->getNumOperands() != 3) if (Op->getNumOperands() != 3)
continue; continue;
MDString *ID = dyn_cast_or_null<MDString>(Op->getOperand(1)); MDString *ID = dyn_cast_if_present<MDString>(Op->getOperand(1));
if (!ID) if (!ID)
continue; continue;
auto SetBehavior = [&](Module::ModFlagBehavior B) { auto SetBehavior = [&](Module::ModFlagBehavior B) {
Metadata *Ops[3] = {ConstantAsMetadata::get(ConstantInt::get( Metadata *Ops[3] = {ConstantAsMetadata::get(ConstantInt::get(
Type::getInt32Ty(M.getContext()), B)), Type::getInt32Ty(M.getContext()), B)),
MDString::get(M.getContext(), ID->getString()), MDString::get(M.getContext(), ID->getString()),
Op->getOperand(2)}; Op->getOperand(2)};
ModFlags->setOperand(I, MDNode::get(M.getContext(), Ops)); ModFlags->setOperand(I, MDNode::get(M.getContext(), Ops));
Show All 36 Lines if (ID->getString() == "branch-target-enforcement" ||
} }
} }
} }
// Upgrade Objective-C Image Info Section. Removed the whitespce in the // Upgrade Objective-C Image Info Section. Removed the whitespce in the
// section name so that llvm-lto will not complain about mismatching // section name so that llvm-lto will not complain about mismatching
// module flags that is functionally the same. // module flags that is functionally the same.
if (ID->getString() == "Objective-C Image Info Section") { if (ID->getString() == "Objective-C Image Info Section") {
if (auto *Value = dyn_cast_or_null<MDString>(Op->getOperand(2))) { if (auto *Value = dyn_cast_if_present<MDString>(Op->getOperand(2))) {
SmallVector<StringRef, 4> ValueComp; SmallVector<StringRef, 4> ValueComp;
Value->getString().split(ValueComp, " "); Value->getString().split(ValueComp, " ");
if (ValueComp.size() != 1) { if (ValueComp.size() != 1) {
std::string NewValue; std::string NewValue;
for (auto &S : ValueComp) for (auto &S : ValueComp)
NewValue += S.str(); NewValue += S.str();
Metadata *Ops[3] = {Op->getOperand(0), Op->getOperand(1), Metadata *Ops[3] = {Op->getOperand(0), Op->getOperand(1),
MDString::get(M.getContext(), NewValue)}; MDString::get(M.getContext(), NewValue)};
▲ Show 20 Lines • Show All 120 Lines • ▼ Show 20 Linesvoid llvm::UpgradeFunctionAttributes(Function &F) {
// Remove all incompatibile attributes from function. // Remove all incompatibile attributes from function.
F.removeRetAttrs(AttributeFuncs::typeIncompatible(F.getReturnType())); F.removeRetAttrs(AttributeFuncs::typeIncompatible(F.getReturnType()));
for (auto &Arg : F.args()) for (auto &Arg : F.args())
Arg.removeAttrs(AttributeFuncs::typeIncompatible(Arg.getType())); Arg.removeAttrs(AttributeFuncs::typeIncompatible(Arg.getType()));
} }
static bool isOldLoopArgument(Metadata *MD) { static bool isOldLoopArgument(Metadata *MD) {
auto *T = dyn_cast_or_null<MDTuple>(MD); auto *T = dyn_cast_if_present<MDTuple>(MD);
if (!T) if (!T)
return false; return false;
if (T->getNumOperands() < 1) if (T->getNumOperands() < 1)
return false; return false;
auto *S = dyn_cast_or_null<MDString>(T->getOperand(0)); auto *S = dyn_cast_if_present<MDString>(T->getOperand(0));
if (!S) if (!S)
return false; return false;
return S->getString().startswith("llvm.vectorizer."); return S->getString().startswith("llvm.vectorizer.");
} }
static MDString *upgradeLoopTag(LLVMContext &C, StringRef OldTag) { static MDString *upgradeLoopTag(LLVMContext &C, StringRef OldTag) {
StringRef OldPrefix = "llvm.vectorizer."; StringRef OldPrefix = "llvm.vectorizer.";
assert(OldTag.startswith(OldPrefix) && "Expected old prefix"); assert(OldTag.startswith(OldPrefix) && "Expected old prefix");
if (OldTag == "llvm.vectorizer.unroll") if (OldTag == "llvm.vectorizer.unroll")
return MDString::get(C, "llvm.loop.interleave.count"); return MDString::get(C, "llvm.loop.interleave.count");
return MDString::get( return MDString::get(
C, (Twine("llvm.loop.vectorize.") + OldTag.drop_front(OldPrefix.size())) C, (Twine("llvm.loop.vectorize.") + OldTag.drop_front(OldPrefix.size()))
.str()); .str());
} }
static Metadata *upgradeLoopArgument(Metadata *MD) { static Metadata *upgradeLoopArgument(Metadata *MD) {
auto *T = dyn_cast_or_null<MDTuple>(MD); auto *T = dyn_cast_if_present<MDTuple>(MD);
if (!T) if (!T)
return MD; return MD;
if (T->getNumOperands() < 1) if (T->getNumOperands() < 1)
return MD; return MD;
auto *OldTag = dyn_cast_or_null<MDString>(T->getOperand(0)); auto *OldTag = dyn_cast_if_present<MDString>(T->getOperand(0));
if (!OldTag) if (!OldTag)
return MD; return MD;
if (!OldTag->getString().startswith("llvm.vectorizer.")) if (!OldTag->getString().startswith("llvm.vectorizer."))
return MD; return MD;
// This has an old tag. Upgrade it. // This has an old tag. Upgrade it.
SmallVector<Metadata *, 8> Ops; SmallVector<Metadata *, 8> Ops;
Ops.reserve(T->getNumOperands()); Ops.reserve(T->getNumOperands());
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

llvm/lib/IR/BasicBlock.cpp

Show First 20 Lines • Show All 180 Lines • ▼ Show 20 Lines
const CallInst *BasicBlock::getTerminatingDeoptimizeCall() const { const CallInst *BasicBlock::getTerminatingDeoptimizeCall() const {
if (InstList.empty()) if (InstList.empty())
return nullptr; return nullptr;
auto *RI = dyn_cast<ReturnInst>(&InstList.back()); auto *RI = dyn_cast<ReturnInst>(&InstList.back());
if (!RI || RI == &InstList.front()) if (!RI || RI == &InstList.front())
return nullptr; return nullptr;
if (auto *CI = dyn_cast_or_null<CallInst>(RI->getPrevNode())) if (auto *CI = dyn_cast_if_present<CallInst>(RI->getPrevNode()))
if (Function *F = CI->getCalledFunction()) if (Function *F = CI->getCalledFunction())
if (F->getIntrinsicID() == Intrinsic::experimental_deoptimize) if (F->getIntrinsicID() == Intrinsic::experimental_deoptimize)
return CI; return CI;
return nullptr; return nullptr;
} }
const CallInst *BasicBlock::getPostdominatingDeoptimizeCall() const { const CallInst *BasicBlock::getPostdominatingDeoptimizeCall() const {
▲ Show 20 Lines • Show All 325 Lines • Show Last 20 Lines

llvm/lib/IR/ConstantFold.cpp

Show First 20 Lines • Show All 1,921 Lines • ▼ Show 20 Linesstatic bool isInBoundsIndices(ArrayRef<IndexTy> Idxs) {
// If the first index is one and all the rest are zero, it's in bounds, // If the first index is one and all the rest are zero, it's in bounds,
// by the one-past-the-end rule. // by the one-past-the-end rule.
if (auto *CI = dyn_cast<ConstantInt>(Idxs[0])) { if (auto *CI = dyn_cast<ConstantInt>(Idxs[0])) {
if (!CI->isOne()) if (!CI->isOne())
return false; return false;
} else { } else {
auto *CV = cast<ConstantDataVector>(Idxs[0]); auto *CV = cast<ConstantDataVector>(Idxs[0]);
CI = dyn_cast_or_null<ConstantInt>(CV->getSplatValue()); CI = dyn_cast_if_present<ConstantInt>(CV->getSplatValue());
if (!CI || !CI->isOne()) if (!CI || !CI->isOne())
return false; return false;
} }
for (unsigned i = 1, e = Idxs.size(); i != e; ++i) for (unsigned i = 1, e = Idxs.size(); i != e; ++i)
if (!cast<Constant>(Idxs[i])->isNullValue()) if (!cast<Constant>(Idxs[i])->isNullValue())
return false; return false;
return true; return true;
▲ Show 20 Lines • Show All 343 Lines • Show Last 20 Lines

llvm/lib/IR/Constants.cpp

Show All 40 Lines
bool Constant::isNegativeZeroValue() const { bool Constant::isNegativeZeroValue() const {
// Floating point values have an explicit -0.0 value. // Floating point values have an explicit -0.0 value.
if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this)) if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this))
return CFP->isZero() && CFP->isNegative(); return CFP->isZero() && CFP->isNegative();
// Equivalent for a vector of -0.0's. // Equivalent for a vector of -0.0's.
if (getType()->isVectorTy()) if (getType()->isVectorTy())
if (const auto *SplatCFP = dyn_cast_or_null<ConstantFP>(getSplatValue())) if (const auto *SplatCFP = dyn_cast_if_present<ConstantFP>(getSplatValue()))
return SplatCFP->isNegativeZeroValue(); return SplatCFP->isNegativeZeroValue();
// We've already handled true FP case; any other FP vectors can't represent -0.0. // We've already handled true FP case; any other FP vectors can't represent -0.0.
if (getType()->isFPOrFPVectorTy()) if (getType()->isFPOrFPVectorTy())
return false; return false;
// Otherwise, just use +0.0. // Otherwise, just use +0.0.
return isNullValue(); return isNullValue();
} }
// Return true iff this constant is positive zero (floating point), negative // Return true iff this constant is positive zero (floating point), negative
// zero (floating point), or a null value. // zero (floating point), or a null value.
bool Constant::isZeroValue() const { bool Constant::isZeroValue() const {
// Floating point values have an explicit -0.0 value. // Floating point values have an explicit -0.0 value.
if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this)) if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this))
return CFP->isZero(); return CFP->isZero();
// Check for constant splat vectors of 1 values. // Check for constant splat vectors of 1 values.
if (getType()->isVectorTy()) if (getType()->isVectorTy())
if (const auto *SplatCFP = dyn_cast_or_null<ConstantFP>(getSplatValue())) if (const auto *SplatCFP = dyn_cast_if_present<ConstantFP>(getSplatValue()))
return SplatCFP->isZero(); return SplatCFP->isZero();
// Otherwise, just use +0.0. // Otherwise, just use +0.0.
return isNullValue(); return isNullValue();
} }
bool Constant::isNullValue() const { bool Constant::isNullValue() const {
// 0 is null. // 0 is null.
▲ Show 20 Lines • Show All 120 Lines • ▼ Show 20 Lines
} }
bool Constant::isFiniteNonZeroFP() const { bool Constant::isFiniteNonZeroFP() const {
if (auto *CFP = dyn_cast<ConstantFP>(this)) if (auto *CFP = dyn_cast<ConstantFP>(this))
return CFP->getValueAPF().isFiniteNonZero(); return CFP->getValueAPF().isFiniteNonZero();
if (auto *VTy = dyn_cast<FixedVectorType>(getType())) { if (auto *VTy = dyn_cast<FixedVectorType>(getType())) {
for (unsigned I = 0, E = VTy->getNumElements(); I != E; ++I) { for (unsigned I = 0, E = VTy->getNumElements(); I != E; ++I) {
auto *CFP = dyn_cast_or_null<ConstantFP>(getAggregateElement(I)); auto *CFP = dyn_cast_if_present<ConstantFP>(getAggregateElement(I));
if (!CFP || !CFP->getValueAPF().isFiniteNonZero()) if (!CFP || !CFP->getValueAPF().isFiniteNonZero())
return false; return false;
} }
return true; return true;
} }
if (getType()->isVectorTy()) if (getType()->isVectorTy())
if (const auto *SplatCFP = dyn_cast_or_null<ConstantFP>(getSplatValue())) if (const auto *SplatCFP = dyn_cast_if_present<ConstantFP>(getSplatValue()))
return SplatCFP->isFiniteNonZeroFP(); return SplatCFP->isFiniteNonZeroFP();
// It *may* contain finite non-zero, we can't tell. // It *may* contain finite non-zero, we can't tell.
return false; return false;
} }
bool Constant::isNormalFP() const { bool Constant::isNormalFP() const {
if (auto *CFP = dyn_cast<ConstantFP>(this)) if (auto *CFP = dyn_cast<ConstantFP>(this))
return CFP->getValueAPF().isNormal(); return CFP->getValueAPF().isNormal();
if (auto *VTy = dyn_cast<FixedVectorType>(getType())) { if (auto *VTy = dyn_cast<FixedVectorType>(getType())) {
for (unsigned I = 0, E = VTy->getNumElements(); I != E; ++I) { for (unsigned I = 0, E = VTy->getNumElements(); I != E; ++I) {
auto *CFP = dyn_cast_or_null<ConstantFP>(getAggregateElement(I)); auto *CFP = dyn_cast_if_present<ConstantFP>(getAggregateElement(I));
if (!CFP || !CFP->getValueAPF().isNormal()) if (!CFP || !CFP->getValueAPF().isNormal())
return false; return false;
} }
return true; return true;
} }
if (getType()->isVectorTy()) if (getType()->isVectorTy())
if (const auto *SplatCFP = dyn_cast_or_null<ConstantFP>(getSplatValue())) if (const auto *SplatCFP = dyn_cast_if_present<ConstantFP>(getSplatValue()))
return SplatCFP->isNormalFP(); return SplatCFP->isNormalFP();
// It *may* contain a normal fp value, we can't tell. // It *may* contain a normal fp value, we can't tell.
return false; return false;
} }
bool Constant::hasExactInverseFP() const { bool Constant::hasExactInverseFP() const {
if (auto *CFP = dyn_cast<ConstantFP>(this)) if (auto *CFP = dyn_cast<ConstantFP>(this))
return CFP->getValueAPF().getExactInverse(nullptr); return CFP->getValueAPF().getExactInverse(nullptr);
if (auto *VTy = dyn_cast<FixedVectorType>(getType())) { if (auto *VTy = dyn_cast<FixedVectorType>(getType())) {
for (unsigned I = 0, E = VTy->getNumElements(); I != E; ++I) { for (unsigned I = 0, E = VTy->getNumElements(); I != E; ++I) {
auto *CFP = dyn_cast_or_null<ConstantFP>(getAggregateElement(I)); auto *CFP = dyn_cast_if_present<ConstantFP>(getAggregateElement(I));
if (!CFP || !CFP->getValueAPF().getExactInverse(nullptr)) if (!CFP || !CFP->getValueAPF().getExactInverse(nullptr))
return false; return false;
} }
return true; return true;
} }
if (getType()->isVectorTy()) if (getType()->isVectorTy())
if (const auto *SplatCFP = dyn_cast_or_null<ConstantFP>(getSplatValue())) if (const auto *SplatCFP = dyn_cast_if_present<ConstantFP>(getSplatValue()))
return SplatCFP->hasExactInverseFP(); return SplatCFP->hasExactInverseFP();
// It *may* have an exact inverse fp value, we can't tell. // It *may* have an exact inverse fp value, we can't tell.
return false; return false;
} }
bool Constant::isNaN() const { bool Constant::isNaN() const {
if (auto *CFP = dyn_cast<ConstantFP>(this)) if (auto *CFP = dyn_cast<ConstantFP>(this))
return CFP->isNaN(); return CFP->isNaN();
if (auto *VTy = dyn_cast<FixedVectorType>(getType())) { if (auto *VTy = dyn_cast<FixedVectorType>(getType())) {
for (unsigned I = 0, E = VTy->getNumElements(); I != E; ++I) { for (unsigned I = 0, E = VTy->getNumElements(); I != E; ++I) {
auto *CFP = dyn_cast_or_null<ConstantFP>(getAggregateElement(I)); auto *CFP = dyn_cast_if_present<ConstantFP>(getAggregateElement(I));
if (!CFP || !CFP->isNaN()) if (!CFP || !CFP->isNaN())
return false; return false;
} }
return true; return true;
} }
if (getType()->isVectorTy()) if (getType()->isVectorTy())
if (const auto *SplatCFP = dyn_cast_or_null<ConstantFP>(getSplatValue())) if (const auto *SplatCFP = dyn_cast_if_present<ConstantFP>(getSplatValue()))
return SplatCFP->isNaN(); return SplatCFP->isNaN();
// It *may* be NaN, we can't tell. // It *may* be NaN, we can't tell.
return false; return false;
} }
bool Constant::isElementWiseEqual(Value *Y) const { bool Constant::isElementWiseEqual(Value *Y) const {
// Are they fully identical? // Are they fully identical?
▲ Show 20 Lines • Show All 3,205 Lines • Show Last 20 Lines

llvm/lib/IR/Core.cpp

Show First 20 Lines • Show All 980 Lines • ▼ Show 20 LinesLLVMInstructionGetAllMetadataOtherThanDebugLoc(LLVMValueRef Value,
return llvm_getMetadata(NumEntries, [&Value](MetadataEntries &Entries) { return llvm_getMetadata(NumEntries, [&Value](MetadataEntries &Entries) {
Entries.clear(); Entries.clear();
unwrap<Instruction>(Value)->getAllMetadata(Entries); unwrap<Instruction>(Value)->getAllMetadata(Entries);
}); });
} }
/*--.. Conversion functions ................................................--*/ /*--.. Conversion functions ................................................--*/
#define LLVM_DEFINE_VALUE_CAST(name) \ #define LLVM_DEFINE_VALUE_CAST(name) \
LLVMValueRef LLVMIsA##name(LLVMValueRef Val) { \ LLVMValueRef LLVMIsA##name(LLVMValueRef Val) { \
return wrap(static_cast<Value*>(dyn_cast_or_null<name>(unwrap(Val)))); \ return wrap(static_cast<Value *>(dyn_cast_if_present<name>(unwrap(Val)))); \
} }
LLVM_FOR_EACH_VALUE_SUBCLASS(LLVM_DEFINE_VALUE_CAST) LLVM_FOR_EACH_VALUE_SUBCLASS(LLVM_DEFINE_VALUE_CAST)
LLVMValueRef LLVMIsAMDNode(LLVMValueRef Val) { LLVMValueRef LLVMIsAMDNode(LLVMValueRef Val) {
if (auto *MD = dyn_cast_or_null<MetadataAsValue>(unwrap(Val))) if (auto *MD = dyn_cast_if_present<MetadataAsValue>(unwrap(Val)))
if (isa<MDNode>(MD->getMetadata()) || if (isa<MDNode>(MD->getMetadata()) ||
isa<ValueAsMetadata>(MD->getMetadata())) isa<ValueAsMetadata>(MD->getMetadata()))
return Val; return Val;
return nullptr; return nullptr;
} }
LLVMValueRef LLVMIsAMDString(LLVMValueRef Val) { LLVMValueRef LLVMIsAMDString(LLVMValueRef Val) {
if (auto *MD = dyn_cast_or_null<MetadataAsValue>(unwrap(Val))) if (auto *MD = dyn_cast_if_present<MetadataAsValue>(unwrap(Val)))
if (isa<MDString>(MD->getMetadata())) if (isa<MDString>(MD->getMetadata()))
return Val; return Val;
return nullptr; return nullptr;
} }
/*--.. Operations on Uses ..................................................--*/ /*--.. Operations on Uses ..................................................--*/
LLVMUseRef LLVMGetFirstUse(LLVMValueRef Val) { LLVMUseRef LLVMGetFirstUse(LLVMValueRef Val) {
Value *V = unwrap(Val); Value *V = unwrap(Val);
▲ Show 20 Lines • Show All 3,189 Lines • Show Last 20 Lines

llvm/lib/IR/DIBuilder.cpp

Show First 20 Lines • Show All 721 Lines • ▼ Show 20 LinesDIGenericSubrange *DIBuilder::getOrCreateGenericSubrange(
return DIGenericSubrange::get(VMContext, ConvToMetadata(CountNode), return DIGenericSubrange::get(VMContext, ConvToMetadata(CountNode),
ConvToMetadata(LB), ConvToMetadata(UB), ConvToMetadata(LB), ConvToMetadata(UB),
ConvToMetadata(Stride)); ConvToMetadata(Stride));
} }
static void checkGlobalVariableScope(DIScope *Context) { static void checkGlobalVariableScope(DIScope *Context) {
#ifndef NDEBUG #ifndef NDEBUG
if (auto *CT = if (auto *CT =
dyn_cast_or_null<DICompositeType>(getNonCompileUnitScope(Context))) dyn_cast_if_present<DICompositeType>(getNonCompileUnitScope(Context)))
assert(CT->getIdentifier().empty() && assert(CT->getIdentifier().empty() &&
"Context of a global variable should not be a type with identifier"); "Context of a global variable should not be a type with identifier");
#endif #endif
} }
DIGlobalVariableExpression *DIBuilder::createGlobalVariableExpression( DIGlobalVariableExpression *DIBuilder::createGlobalVariableExpression(
DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *F, DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *F,
unsigned LineNumber, DIType *Ty, bool IsLocalToUnit, bool isDefined, unsigned LineNumber, DIType *Ty, bool IsLocalToUnit, bool isDefined,
▲ Show 20 Lines • Show All 384 Lines • ▼ Show 20 Linesvoid DIBuilder::replaceVTableHolder(DICompositeType *&T, DIType *VTableHolder) {
// If this didn't create a self-reference, just return. // If this didn't create a self-reference, just return.
if (T != VTableHolder) if (T != VTableHolder)
return; return;
// Look for unresolved operands. T will drop RAUW support, orphaning any // Look for unresolved operands. T will drop RAUW support, orphaning any
// cycles underneath it. // cycles underneath it.
if (T->isResolved()) if (T->isResolved())
for (const MDOperand &O : T->operands()) for (const MDOperand &O : T->operands())
if (auto *N = dyn_cast_or_null<MDNode>(O)) if (auto *N = dyn_cast_if_present<MDNode>(O))
trackIfUnresolved(N); trackIfUnresolved(N);
} }
void DIBuilder::replaceArrays(DICompositeType *&T, DINodeArray Elements, void DIBuilder::replaceArrays(DICompositeType *&T, DINodeArray Elements,
DINodeArray TParams) { DINodeArray TParams) {
{ {
TypedTrackingMDRef<DICompositeType> N(T); TypedTrackingMDRef<DICompositeType> N(T);
if (Elements) if (Elements)
Show All 18 Lines

llvm/lib/IR/DebugInfo.cpp

Show First 20 Lines • Show All 120 Lines • ▼ Show 20 Lines for (Metadata *AL : L->getAllArgListUsers()) {
if (EncounteredDbgValues.insert(DII).second) if (EncounteredDbgValues.insert(DII).second)
DbgUsers.push_back(DII); DbgUsers.push_back(DII);
} }
} }
} }
} }
DISubprogram *llvm::getDISubprogram(const MDNode *Scope) { DISubprogram *llvm::getDISubprogram(const MDNode *Scope) {
if (auto *LocalScope = dyn_cast_or_null<DILocalScope>(Scope)) if (auto *LocalScope = dyn_cast_if_present<DILocalScope>(Scope))
return LocalScope->getSubprogram(); return LocalScope->getSubprogram();
return nullptr; return nullptr;
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// DebugInfoFinder implementations. // DebugInfoFinder implementations.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 241 Lines • ▼ Show 20 Linesvoid llvm::updateLoopMetadataDebugLocations(
I.setMetadata(LLVMContext::MD_loop, NewLoopID); I.setMetadata(LLVMContext::MD_loop, NewLoopID);
} }
/// Return true if a node is a DILocation or if a DILocation is /// Return true if a node is a DILocation or if a DILocation is
/// indirectly referenced by one of the node's children. /// indirectly referenced by one of the node's children.
static bool isDILocationReachable(SmallPtrSetImpl<Metadata *> &Visited, static bool isDILocationReachable(SmallPtrSetImpl<Metadata *> &Visited,
SmallPtrSetImpl<Metadata *> &Reachable, SmallPtrSetImpl<Metadata *> &Reachable,
Metadata *MD) { Metadata *MD) {
MDNode *N = dyn_cast_or_null<MDNode>(MD); MDNode *N = dyn_cast_if_present<MDNode>(MD);
if (!N) if (!N)
return false; return false;
if (isa<DILocation>(N) || Reachable.count(N)) if (isa<DILocation>(N) || Reachable.count(N))
return true; return true;
if (!Visited.insert(N).second) if (!Visited.insert(N).second)
return false; return false;
for (auto &OpIt : N->operands()) { for (auto &OpIt : N->operands()) {
Metadata *Op = OpIt.get(); Metadata *Op = OpIt.get();
▲ Show 20 Lines • Show All 133 Lines • ▼ Show 20 Lines Metadata *map(Metadata *M) {
if (!M) if (!M)
return nullptr; return nullptr;
auto Replacement = Replacements.find(M); auto Replacement = Replacements.find(M);
if (Replacement != Replacements.end()) if (Replacement != Replacements.end())
return Replacement->second; return Replacement->second;
return M; return M;
} }
MDNode *mapNode(Metadata *N) { return dyn_cast_or_null<MDNode>(map(N)); } MDNode *mapNode(Metadata *N) { return dyn_cast_if_present<MDNode>(map(N)); }
/// Recursively remap N and all its referenced children. Does a DF post-order /// Recursively remap N and all its referenced children. Does a DF post-order
/// traversal, so as to remap bottoms up. /// traversal, so as to remap bottoms up.
void traverseAndRemap(MDNode *N) { traverse(N); } void traverseAndRemap(MDNode *N) { traverse(N); }
private: private:
// Create a new DISubprogram, to replace the one given. // Create a new DISubprogram, to replace the one given.
DISubprogram *getReplacementSubprogram(DISubprogram *MDS) { DISubprogram *getReplacementSubprogram(DISubprogram *MDS) {
▲ Show 20 Lines • Show All 147 Lines • ▼ Show 20 Lines while (!ToVisit.empty()) {
auto *N = ToVisit.back(); auto *N = ToVisit.back();
if (!Opened.insert(N).second) { if (!Opened.insert(N).second) {
// Close it. // Close it.
remap(N); remap(N);
ToVisit.pop_back(); ToVisit.pop_back();
continue; continue;
} }
for (auto &I : N->operands()) for (auto &I : N->operands())
if (auto *MDN = dyn_cast_or_null<MDNode>(I)) if (auto *MDN = dyn_cast_if_present<MDNode>(I))
if (!Opened.count(MDN) && !Replacements.count(MDN) && !prune(N, MDN) && if (!Opened.count(MDN) && !Replacements.count(MDN) && !prune(N, MDN) &&
!isa<DICompileUnit>(MDN)) !isa<DICompileUnit>(MDN))
ToVisit.push_back(MDN); ToVisit.push_back(MDN);
} }
} }
bool llvm::stripNonLineTableDebugInfo(Module &M) { bool llvm::stripNonLineTableDebugInfo(Module &M) {
bool Changed = false; bool Changed = false;
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Lines for (auto &BB : F) {
Scope, InlinedAt); Scope, InlinedAt);
}; };
if (I.getDebugLoc() != DebugLoc()) if (I.getDebugLoc() != DebugLoc())
I.setDebugLoc(remapDebugLoc(I.getDebugLoc())); I.setDebugLoc(remapDebugLoc(I.getDebugLoc()));
// Remap DILocations in llvm.loop attachments. // Remap DILocations in llvm.loop attachments.
updateLoopMetadataDebugLocations(I, [&](Metadata *MD) -> Metadata * { updateLoopMetadataDebugLocations(I, [&](Metadata *MD) -> Metadata * {
if (auto *Loc = dyn_cast_or_null<DILocation>(MD)) if (auto *Loc = dyn_cast_if_present<DILocation>(MD))
return remapDebugLoc(Loc).get(); return remapDebugLoc(Loc).get();
return MD; return MD;
}); });
// Strip heapallocsite attachments, they point into the DIType system. // Strip heapallocsite attachments, they point into the DIType system.
if (I.hasMetadataOtherThanDebugLoc()) if (I.hasMetadataOtherThanDebugLoc())
I.setMetadata("heapallocsite", nullptr); I.setMetadata("heapallocsite", nullptr);
} }
▲ Show 20 Lines • Show All 833 Lines • Show Last 20 Lines

llvm/lib/IR/DebugInfoMetadata.cpp

Show First 20 Lines • Show All 600 Lines • ▼ Show 20 Lines
} }
DIType *DIDerivedType::getClassType() const { DIType *DIDerivedType::getClassType() const {
assert(getTag() == dwarf::DW_TAG_ptr_to_member_type); assert(getTag() == dwarf::DW_TAG_ptr_to_member_type);
return cast_or_null<DIType>(getExtraData()); return cast_or_null<DIType>(getExtraData());
} }
uint32_t DIDerivedType::getVBPtrOffset() const { uint32_t DIDerivedType::getVBPtrOffset() const {
assert(getTag() == dwarf::DW_TAG_inheritance); assert(getTag() == dwarf::DW_TAG_inheritance);
if (auto *CM = cast_or_null<ConstantAsMetadata>(getExtraData())) if (auto *CM = cast_or_null<ConstantAsMetadata>(getExtraData()))
if (auto *CI = dyn_cast_or_null<ConstantInt>(CM->getValue())) if (auto *CI = dyn_cast_if_present<ConstantInt>(CM->getValue()))
return static_cast<uint32_t>(CI->getZExtValue()); return static_cast<uint32_t>(CI->getZExtValue());
return 0; return 0;
} }
Constant *DIDerivedType::getStorageOffsetInBits() const { Constant *DIDerivedType::getStorageOffsetInBits() const {
assert(getTag() == dwarf::DW_TAG_member && isBitField()); assert(getTag() == dwarf::DW_TAG_member && isBitField());
if (auto *C = cast_or_null<ConstantAsMetadata>(getExtraData())) if (auto *C = cast_or_null<ConstantAsMetadata>(getExtraData()))
return C->getValue(); return C->getValue();
return nullptr; return nullptr;
▲ Show 20 Lines • Show All 1,226 Lines • Show Last 20 Lines

llvm/lib/IR/LLVMContextImpl.h

Show First 20 Lines • Show All 325 Lines • ▼ Show 20 Lines MDNodeKeyImpl(const DISubrange *N)
: CountNode(N->getRawCountNode()), LowerBound(N->getRawLowerBound()), : CountNode(N->getRawCountNode()), LowerBound(N->getRawLowerBound()),
UpperBound(N->getRawUpperBound()), Stride(N->getRawStride()) {} UpperBound(N->getRawUpperBound()), Stride(N->getRawStride()) {}
bool isKeyOf(const DISubrange *RHS) const { bool isKeyOf(const DISubrange *RHS) const {
auto BoundsEqual = [=](Metadata *Node1, Metadata *Node2) -> bool { auto BoundsEqual = [=](Metadata *Node1, Metadata *Node2) -> bool {
if (Node1 == Node2) if (Node1 == Node2)
return true; return true;
ConstantAsMetadata *MD1 = dyn_cast_or_null<ConstantAsMetadata>(Node1); ConstantAsMetadata *MD1 = dyn_cast_if_present<ConstantAsMetadata>(Node1);
ConstantAsMetadata *MD2 = dyn_cast_or_null<ConstantAsMetadata>(Node2); ConstantAsMetadata *MD2 = dyn_cast_if_present<ConstantAsMetadata>(Node2);
if (MD1 && MD2) { if (MD1 && MD2) {
ConstantInt *CV1 = cast<ConstantInt>(MD1->getValue()); ConstantInt *CV1 = cast<ConstantInt>(MD1->getValue());
ConstantInt *CV2 = cast<ConstantInt>(MD2->getValue()); ConstantInt *CV2 = cast<ConstantInt>(MD2->getValue());
if (CV1->getSExtValue() == CV2->getSExtValue()) if (CV1->getSExtValue() == CV2->getSExtValue())
return true; return true;
} }
return false; return false;
}; };
Show All 30 Linestemplate <> struct MDNodeKeyImpl<DIGenericSubrange> {
bool isKeyOf(const DIGenericSubrange *RHS) const { bool isKeyOf(const DIGenericSubrange *RHS) const {
return (CountNode == RHS->getRawCountNode()) && return (CountNode == RHS->getRawCountNode()) &&
(LowerBound == RHS->getRawLowerBound()) && (LowerBound == RHS->getRawLowerBound()) &&
(UpperBound == RHS->getRawUpperBound()) && (UpperBound == RHS->getRawUpperBound()) &&
(Stride == RHS->getRawStride()); (Stride == RHS->getRawStride());
} }
unsigned getHashValue() const { unsigned getHashValue() const {
auto *MD = dyn_cast_or_null<ConstantAsMetadata>(CountNode); auto *MD = dyn_cast_if_present<ConstantAsMetadata>(CountNode);
if (CountNode && MD) if (CountNode && MD)
return hash_combine(cast<ConstantInt>(MD->getValue())->getSExtValue(), return hash_combine(cast<ConstantInt>(MD->getValue())->getSExtValue(),
LowerBound, UpperBound, Stride); LowerBound, UpperBound, Stride);
return hash_combine(CountNode, LowerBound, UpperBound, Stride); return hash_combine(CountNode, LowerBound, UpperBound, Stride);
} }
}; };
template <> struct MDNodeKeyImpl<DIEnumerator> { template <> struct MDNodeKeyImpl<DIEnumerator> {
▲ Show 20 Lines • Show All 125 Lines • ▼ Show 20 Lines return Tag == RHS->getTag() && Name == RHS->getRawName() &&
Annotations == RHS->getRawAnnotations(); Annotations == RHS->getRawAnnotations();
} }
unsigned getHashValue() const { unsigned getHashValue() const {
// If this is a member inside an ODR type, only hash the type and the name. // If this is a member inside an ODR type, only hash the type and the name.
// Otherwise the hash will be stronger than // Otherwise the hash will be stronger than
// MDNodeSubsetEqualImpl::isODRMember(). // MDNodeSubsetEqualImpl::isODRMember().
if (Tag == dwarf::DW_TAG_member && Name) if (Tag == dwarf::DW_TAG_member && Name)
if (auto *CT = dyn_cast_or_null<DICompositeType>(Scope)) if (auto *CT = dyn_cast_if_present<DICompositeType>(Scope))
if (CT->getRawIdentifier()) if (CT->getRawIdentifier())
return hash_combine(Name, Scope); return hash_combine(Name, Scope);
// Intentionally computes the hash on a subset of the operands for // Intentionally computes the hash on a subset of the operands for
// performance reason. The subset has to be significant enough to avoid // performance reason. The subset has to be significant enough to avoid
// collision "most of the time". There is no correctness issue in case of // collision "most of the time". There is no correctness issue in case of
// collision because of the full check above. // collision because of the full check above.
return hash_combine(Tag, Name, File, Line, Scope, BaseType, Flags); return hash_combine(Tag, Name, File, Line, Scope, BaseType, Flags);
Show All 16 Linestemplate <> struct MDNodeSubsetEqualImpl<DIDerivedType> {
/// Subprograms compare equal if they declare the same function in an ODR /// Subprograms compare equal if they declare the same function in an ODR
/// type. /// type.
static bool isODRMember(unsigned Tag, const Metadata *Scope, static bool isODRMember(unsigned Tag, const Metadata *Scope,
const MDString *Name, const DIDerivedType *RHS) { const MDString *Name, const DIDerivedType *RHS) {
// Check whether the LHS is eligible. // Check whether the LHS is eligible.
if (Tag != dwarf::DW_TAG_member || !Name) if (Tag != dwarf::DW_TAG_member || !Name)
return false; return false;
auto *CT = dyn_cast_or_null<DICompositeType>(Scope); auto *CT = dyn_cast_if_present<DICompositeType>(Scope);
if (!CT || !CT->getRawIdentifier()) if (!CT || !CT->getRawIdentifier())
return false; return false;
// Compare to the RHS. // Compare to the RHS.
return Tag == RHS->getTag() && Name == RHS->getRawName() && return Tag == RHS->getTag() && Name == RHS->getRawName() &&
Scope == RHS->getRawScope(); Scope == RHS->getRawScope();
} }
}; };
▲ Show 20 Lines • Show All 197 Lines • ▼ Show 20 Linestemplate <> struct MDNodeKeyImpl<DISubprogram> {
bool isDefinition() const { return SPFlags & DISubprogram::SPFlagDefinition; } bool isDefinition() const { return SPFlags & DISubprogram::SPFlagDefinition; }
unsigned getHashValue() const { unsigned getHashValue() const {
// If this is a declaration inside an ODR type, only hash the type and the // If this is a declaration inside an ODR type, only hash the type and the
// name. Otherwise the hash will be stronger than // name. Otherwise the hash will be stronger than
// MDNodeSubsetEqualImpl::isDeclarationOfODRMember(). // MDNodeSubsetEqualImpl::isDeclarationOfODRMember().
if (!isDefinition() && LinkageName) if (!isDefinition() && LinkageName)
if (auto *CT = dyn_cast_or_null<DICompositeType>(Scope)) if (auto *CT = dyn_cast_if_present<DICompositeType>(Scope))
if (CT->getRawIdentifier()) if (CT->getRawIdentifier())
return hash_combine(LinkageName, Scope); return hash_combine(LinkageName, Scope);
// Intentionally computes the hash on a subset of the operands for // Intentionally computes the hash on a subset of the operands for
// performance reason. The subset has to be significant enough to avoid // performance reason. The subset has to be significant enough to avoid
// collision "most of the time". There is no correctness issue in case of // collision "most of the time". There is no correctness issue in case of
// collision because of the full check above. // collision because of the full check above.
return hash_combine(Name, Scope, File, Type, Line); return hash_combine(Name, Scope, File, Type, Line);
Show All 19 Linestemplate <> struct MDNodeSubsetEqualImpl<DISubprogram> {
static bool isDeclarationOfODRMember(bool IsDefinition, const Metadata *Scope, static bool isDeclarationOfODRMember(bool IsDefinition, const Metadata *Scope,
const MDString *LinkageName, const MDString *LinkageName,
const Metadata *TemplateParams, const Metadata *TemplateParams,
const DISubprogram *RHS) { const DISubprogram *RHS) {
// Check whether the LHS is eligible. // Check whether the LHS is eligible.
if (IsDefinition || !Scope || !LinkageName) if (IsDefinition || !Scope || !LinkageName)
return false; return false;
auto *CT = dyn_cast_or_null<DICompositeType>(Scope); auto *CT = dyn_cast_if_present<DICompositeType>(Scope);
if (!CT || !CT->getRawIdentifier()) if (!CT || !CT->getRawIdentifier())
return false; return false;
// Compare to the RHS. // Compare to the RHS.
// FIXME: We need to compare template parameters here to avoid incorrect // FIXME: We need to compare template parameters here to avoid incorrect
// collisions in mapMetadata when RF_ReuseAndMutateDistinctMDs and a // collisions in mapMetadata when RF_ReuseAndMutateDistinctMDs and a
// ODR-DISubprogram has a non-ODR template parameter (i.e., a // ODR-DISubprogram has a non-ODR template parameter (i.e., a
// DICompositeType that does not have an identifier). Eventually we should // DICompositeType that does not have an identifier). Eventually we should
▲ Show 20 Lines • Show All 767 Lines • Show Last 20 Lines

llvm/lib/IR/Mangler.cpp

Show First 20 Lines • Show All 138 Lines • ▼ Show 20 Lines if (!GV->hasName()) {
return; return;
} }
StringRef Name = GV->getName(); StringRef Name = GV->getName();
char Prefix = DL.getGlobalPrefix(); char Prefix = DL.getGlobalPrefix();
// Mangle functions with Microsoft calling conventions specially. Only do // Mangle functions with Microsoft calling conventions specially. Only do
// this mangling for x86_64 vectorcall and 32-bit x86. // this mangling for x86_64 vectorcall and 32-bit x86.
const Function *MSFunc = dyn_cast_or_null<Function>(GV->getAliaseeObject()); const Function *MSFunc =
dyn_cast_if_present<Function>(GV->getAliaseeObject());
// Don't add byte count suffixes when '\01' or '?' are in the first // Don't add byte count suffixes when '\01' or '?' are in the first
// character. // character.
if (Name.startswith("\01") || if (Name.startswith("\01") ||
(DL.doNotMangleLeadingQuestionMark() && Name.startswith("?"))) (DL.doNotMangleLeadingQuestionMark() && Name.startswith("?")))
MSFunc = nullptr; MSFunc = nullptr;
CallingConv::ID CC = CallingConv::ID CC =
▲ Show 20 Lines • Show All 125 Lines • Show Last 20 Lines

llvm/lib/IR/Metadata.cpp

Show First 20 Lines • Show All 636 Lines • ▼ Show 20 Linesvoid MDNode::Header::resizeSmallToLarge(size_t NumOps) {
NewOps.resize(NumOps); NewOps.resize(NumOps);
llvm::move(operands(), NewOps.begin()); llvm::move(operands(), NewOps.begin());
resizeSmall(0); resizeSmall(0);
new (getLargePtr()) LargeStorageVector(std::move(NewOps)); new (getLargePtr()) LargeStorageVector(std::move(NewOps));
IsLarge = true; IsLarge = true;
} }
static bool isOperandUnresolved(Metadata *Op) { static bool isOperandUnresolved(Metadata *Op) {
if (auto *N = dyn_cast_or_null<MDNode>(Op)) if (auto *N = dyn_cast_if_present<MDNode>(Op))
return !N->isResolved(); return !N->isResolved();
return false; return false;
} }
void MDNode::countUnresolvedOperands() { void MDNode::countUnresolvedOperands() {
assert(getNumUnresolved() == 0 && "Expected unresolved ops to be uncounted"); assert(getNumUnresolved() == 0 && "Expected unresolved ops to be uncounted");
assert(isUniqued() && "Expected this to be uniqued"); assert(isUniqued() && "Expected this to be uniqued");
setNumUnresolved(count_if(operands(), isOperandUnresolved)); setNumUnresolved(count_if(operands(), isOperandUnresolved));
▲ Show 20 Lines • Show All 80 Lines • ▼ Show 20 Linesvoid MDNode::resolveCycles() {
if (isResolved()) if (isResolved())
return; return;
// Resolve this node immediately. // Resolve this node immediately.
resolve(); resolve();
// Resolve all operands. // Resolve all operands.
for (const auto &Op : operands()) { for (const auto &Op : operands()) {
auto *N = dyn_cast_or_null<MDNode>(Op); auto *N = dyn_cast_if_present<MDNode>(Op);
if (!N) if (!N)
continue; continue;
assert(!N->isTemporary() && assert(!N->isTemporary() &&
"Expected all forward declarations to be resolved"); "Expected all forward declarations to be resolved");
if (!N->isResolved()) if (!N->isResolved())
N->resolveCycles(); N->resolveCycles();
} }
▲ Show 20 Lines • Show All 236 Lines • ▼ Show 20 Lines
/// ///
/// Special handling for finding self-references, for use by \a /// Special handling for finding self-references, for use by \a
/// MDNode::concatenate() and \a MDNode::intersect() to maintain behaviour from /// MDNode::concatenate() and \a MDNode::intersect() to maintain behaviour from
/// when self-referencing nodes were still uniqued. If the first operand has /// when self-referencing nodes were still uniqued. If the first operand has
/// the same operands as \c Ops, return the first operand instead. /// the same operands as \c Ops, return the first operand instead.
static MDNode *getOrSelfReference(LLVMContext &Context, static MDNode *getOrSelfReference(LLVMContext &Context,
ArrayRef<Metadata *> Ops) { ArrayRef<Metadata *> Ops) {
if (!Ops.empty()) if (!Ops.empty())
if (MDNode *N = dyn_cast_or_null<MDNode>(Ops[0])) if (MDNode *N = dyn_cast_if_present<MDNode>(Ops[0]))
if (N->getNumOperands() == Ops.size() && N == N->getOperand(0)) { if (N->getNumOperands() == Ops.size() && N == N->getOperand(0)) {
for (unsigned I = 1, E = Ops.size(); I != E; ++I) for (unsigned I = 1, E = Ops.size(); I != E; ++I)
if (Ops[I] != N->getOperand(I)) if (Ops[I] != N->getOperand(I))
return MDNode::get(Context, Ops); return MDNode::get(Context, Ops);
return N; return N;
} }
return MDNode::get(Context, Ops); return MDNode::get(Context, Ops);
▲ Show 20 Lines • Show All 603 Lines • Show Last 20 Lines

llvm/lib/IR/Module.cpp

Show First 20 Lines • Show All 167 Lines • ▼ Show 20 Lines
FunctionCallee Module::getOrInsertFunction(StringRef Name, FunctionType *Ty) { FunctionCallee Module::getOrInsertFunction(StringRef Name, FunctionType *Ty) {
return getOrInsertFunction(Name, Ty, AttributeList()); return getOrInsertFunction(Name, Ty, AttributeList());
} }
// getFunction - Look up the specified function in the module symbol table. // getFunction - Look up the specified function in the module symbol table.
// If it does not exist, return null. // If it does not exist, return null.
// //
Function *Module::getFunction(StringRef Name) const { Function *Module::getFunction(StringRef Name) const {
return dyn_cast_or_null<Function>(getNamedValue(Name)); return dyn_cast_if_present<Function>(getNamedValue(Name));
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Methods for easy access to the global variables in the module. // Methods for easy access to the global variables in the module.
// //
/// getGlobalVariable - Look up the specified global variable in the module /// getGlobalVariable - Look up the specified global variable in the module
/// symbol table. If it does not exist, return null. The type argument /// symbol table. If it does not exist, return null. The type argument
/// should be the underlying type of the global, i.e., it should not have /// should be the underlying type of the global, i.e., it should not have
/// the top-level PointerType, which represents the address of the global. /// the top-level PointerType, which represents the address of the global.
/// If AllowLocal is set to true, this function will return types that /// If AllowLocal is set to true, this function will return types that
/// have an local. By default, these types are not returned. /// have an local. By default, these types are not returned.
/// ///
GlobalVariable *Module::getGlobalVariable(StringRef Name, GlobalVariable *Module::getGlobalVariable(StringRef Name,
bool AllowLocal) const { bool AllowLocal) const {
if (GlobalVariable *Result = if (GlobalVariable *Result =
dyn_cast_or_null<GlobalVariable>(getNamedValue(Name))) dyn_cast_if_present<GlobalVariable>(getNamedValue(Name)))
if (AllowLocal || !Result->hasLocalLinkage()) if (AllowLocal || !Result->hasLocalLinkage())
return Result; return Result;
return nullptr; return nullptr;
} }
/// getOrInsertGlobal - Look up the specified global in the module symbol table. /// getOrInsertGlobal - Look up the specified global in the module symbol table.
/// 1. If it does not exist, add a declaration of the global and return it. /// 1. If it does not exist, add a declaration of the global and return it.
/// 2. Else, the global exists but has the wrong type: return the function /// 2. Else, the global exists but has the wrong type: return the function
/// with a constantexpr cast to the right type. /// with a constantexpr cast to the right type.
/// 3. Finally, if the existing global is the correct declaration, return the /// 3. Finally, if the existing global is the correct declaration, return the
/// existing global. /// existing global.
Constant *Module::getOrInsertGlobal( Constant *Module::getOrInsertGlobal(
StringRef Name, Type *Ty, StringRef Name, Type *Ty,
function_ref<GlobalVariable *()> CreateGlobalCallback) { function_ref<GlobalVariable *()> CreateGlobalCallback) {
// See if we have a definition for the specified global already. // See if we have a definition for the specified global already.
GlobalVariable *GV = dyn_cast_or_null<GlobalVariable>(getNamedValue(Name)); GlobalVariable *GV = dyn_cast_if_present<GlobalVariable>(getNamedValue(Name));
if (!GV) if (!GV)
GV = CreateGlobalCallback(); GV = CreateGlobalCallback();
assert(GV && "The CreateGlobalCallback is expected to create a global"); assert(GV && "The CreateGlobalCallback is expected to create a global");
// If the variable exists but has the wrong type, return a bitcast to the // If the variable exists but has the wrong type, return a bitcast to the
// right type. // right type.
Type *GVTy = GV->getType(); Type *GVTy = GV->getType();
PointerType *PTy = PointerType::get(Ty, GVTy->getPointerAddressSpace()); PointerType *PTy = PointerType::get(Ty, GVTy->getPointerAddressSpace());
Show All 15 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Methods for easy access to the global variables in the module. // Methods for easy access to the global variables in the module.
// //
// getNamedAlias - Look up the specified global in the module symbol table. // getNamedAlias - Look up the specified global in the module symbol table.
// If it does not exist, return null. // If it does not exist, return null.
// //
GlobalAlias *Module::getNamedAlias(StringRef Name) const { GlobalAlias *Module::getNamedAlias(StringRef Name) const {
return dyn_cast_or_null<GlobalAlias>(getNamedValue(Name)); return dyn_cast_if_present<GlobalAlias>(getNamedValue(Name));
} }
GlobalIFunc *Module::getNamedIFunc(StringRef Name) const { GlobalIFunc *Module::getNamedIFunc(StringRef Name) const {
return dyn_cast_or_null<GlobalIFunc>(getNamedValue(Name)); return dyn_cast_if_present<GlobalIFunc>(getNamedValue(Name));
} }
/// getNamedMetadata - Return the first NamedMDNode in the module with the /// getNamedMetadata - Return the first NamedMDNode in the module with the
/// specified name. This method returns null if a NamedMDNode with the /// specified name. This method returns null if a NamedMDNode with the
/// specified name is not found. /// specified name is not found.
NamedMDNode *Module::getNamedMetadata(const Twine &Name) const { NamedMDNode *Module::getNamedMetadata(const Twine &Name) const {
SmallString<256> NameData; SmallString<256> NameData;
StringRef NameRef = Name.toStringRef(NameData); StringRef NameRef = Name.toStringRef(NameData);
Show All 32 Lines
} }
bool Module::isValidModuleFlag(const MDNode &ModFlag, ModFlagBehavior &MFB, bool Module::isValidModuleFlag(const MDNode &ModFlag, ModFlagBehavior &MFB,
MDString *&Key, Metadata *&Val) { MDString *&Key, Metadata *&Val) {
if (ModFlag.getNumOperands() < 3) if (ModFlag.getNumOperands() < 3)
return false; return false;
if (!isValidModFlagBehavior(ModFlag.getOperand(0), MFB)) if (!isValidModFlagBehavior(ModFlag.getOperand(0), MFB))
return false; return false;
MDString *K = dyn_cast_or_null<MDString>(ModFlag.getOperand(1)); MDString *K = dyn_cast_if_present<MDString>(ModFlag.getOperand(1));
if (!K) if (!K)
return false; return false;
Key = K; Key = K;
Val = ModFlag.getOperand(2); Val = ModFlag.getOperand(2);
return true; return true;
} }
/// getModuleFlagsMetadata - Returns the module flags in the provided vector. /// getModuleFlagsMetadata - Returns the module flags in the provided vector.
▲ Show 20 Lines • Show All 386 Lines • ▼ Show 20 Lines
} }
void Module::setFramePointer(FramePointerKind Kind) { void Module::setFramePointer(FramePointerKind Kind) {
addModuleFlag(ModFlagBehavior::Max, "frame-pointer", static_cast<int>(Kind)); addModuleFlag(ModFlagBehavior::Max, "frame-pointer", static_cast<int>(Kind));
} }
StringRef Module::getStackProtectorGuard() const { StringRef Module::getStackProtectorGuard() const {
Metadata *MD = getModuleFlag("stack-protector-guard"); Metadata *MD = getModuleFlag("stack-protector-guard");
if (auto *MDS = dyn_cast_or_null<MDString>(MD)) if (auto *MDS = dyn_cast_if_present<MDString>(MD))
return MDS->getString(); return MDS->getString();
return {}; return {};
} }
void Module::setStackProtectorGuard(StringRef Kind) { void Module::setStackProtectorGuard(StringRef Kind) {
MDString *ID = MDString::get(getContext(), Kind); MDString *ID = MDString::get(getContext(), Kind);
addModuleFlag(ModFlagBehavior::Error, "stack-protector-guard", ID); addModuleFlag(ModFlagBehavior::Error, "stack-protector-guard", ID);
} }
StringRef Module::getStackProtectorGuardReg() const { StringRef Module::getStackProtectorGuardReg() const {
Metadata *MD = getModuleFlag("stack-protector-guard-reg"); Metadata *MD = getModuleFlag("stack-protector-guard-reg");
if (auto *MDS = dyn_cast_or_null<MDString>(MD)) if (auto *MDS = dyn_cast_if_present<MDString>(MD))
return MDS->getString(); return MDS->getString();
return {}; return {};
} }
void Module::setStackProtectorGuardReg(StringRef Reg) { void Module::setStackProtectorGuardReg(StringRef Reg) {
MDString *ID = MDString::get(getContext(), Reg); MDString *ID = MDString::get(getContext(), Reg);
addModuleFlag(ModFlagBehavior::Error, "stack-protector-guard-reg", ID); addModuleFlag(ModFlagBehavior::Error, "stack-protector-guard-reg", ID);
} }
StringRef Module::getStackProtectorGuardSymbol() const { StringRef Module::getStackProtectorGuardSymbol() const {
Metadata *MD = getModuleFlag("stack-protector-guard-symbol"); Metadata *MD = getModuleFlag("stack-protector-guard-symbol");
if (auto *MDS = dyn_cast_or_null<MDString>(MD)) if (auto *MDS = dyn_cast_if_present<MDString>(MD))
return MDS->getString(); return MDS->getString();
return {}; return {};
} }
void Module::setStackProtectorGuardSymbol(StringRef Symbol) { void Module::setStackProtectorGuardSymbol(StringRef Symbol) {
MDString *ID = MDString::get(getContext(), Symbol); MDString *ID = MDString::get(getContext(), Symbol);
addModuleFlag(ModFlagBehavior::Error, "stack-protector-guard-symbol", ID); addModuleFlag(ModFlagBehavior::Error, "stack-protector-guard-symbol", ID);
} }
Show All 34 Lines M.addModuleFlag(Module::ModFlagBehavior::Warning, Name,
ConstantDataArray::get(M.getContext(), Entries)); ConstantDataArray::get(M.getContext(), Entries));
} }
void Module::setSDKVersion(const VersionTuple &V) { void Module::setSDKVersion(const VersionTuple &V) {
addSDKVersionMD(V, *this, "SDK Version"); addSDKVersionMD(V, *this, "SDK Version");
} }
static VersionTuple getSDKVersionMD(Metadata *MD) { static VersionTuple getSDKVersionMD(Metadata *MD) {
auto *CM = dyn_cast_or_null<ConstantAsMetadata>(MD); auto *CM = dyn_cast_if_present<ConstantAsMetadata>(MD);
if (!CM) if (!CM)
return {}; return {};
auto *Arr = dyn_cast_or_null<ConstantDataArray>(CM->getValue()); auto *Arr = dyn_cast_if_present<ConstantDataArray>(CM->getValue());
if (!Arr) if (!Arr)
return {}; return {};
auto getVersionComponent = [&](unsigned Index) -> Optional<unsigned> { auto getVersionComponent = [&](unsigned Index) -> Optional<unsigned> {
if (Index >= Arr->getNumElements()) if (Index >= Arr->getNumElements())
return None; return None;
return (unsigned)Arr->getElementAsInteger(Index); return (unsigned)Arr->getElementAsInteger(Index);
}; };
auto Major = getVersionComponent(0); auto Major = getVersionComponent(0);
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

llvm/lib/IR/ModuleSummaryIndex.cpp

Show First 20 Lines • Show All 148 Lines • ▼ Show 20 Lines
// Collect for the given module the list of function it defines // Collect for the given module the list of function it defines
// (GUID -> Summary). // (GUID -> Summary).
void ModuleSummaryIndex::collectDefinedFunctionsForModule( void ModuleSummaryIndex::collectDefinedFunctionsForModule(
StringRef ModulePath, GVSummaryMapTy &GVSummaryMap) const { StringRef ModulePath, GVSummaryMapTy &GVSummaryMap) const {
for (auto &GlobalList : *this) { for (auto &GlobalList : *this) {
auto GUID = GlobalList.first; auto GUID = GlobalList.first;
for (auto &GlobSummary : GlobalList.second.SummaryList) { for (auto &GlobSummary : GlobalList.second.SummaryList) {
auto *Summary = dyn_cast_or_null<FunctionSummary>(GlobSummary.get()); auto *Summary = dyn_cast_if_present<FunctionSummary>(GlobSummary.get());
if (!Summary) if (!Summary)
// Ignore global variable, focus on functions // Ignore global variable, focus on functions
continue; continue;
// Ignore summaries from other modules. // Ignore summaries from other modules.
if (Summary->modulePath() != ModulePath) if (Summary->modulePath() != ModulePath)
continue; continue;
GVSummaryMap[GUID] = Summary; GVSummaryMap[GUID] = Summary;
} }
▲ Show 20 Lines • Show All 298 Lines • ▼ Show 20 Lines char FlagRep[] = {FlagValue(F.ReadNone),
FlagValue(F.MustBeUnreachable), FlagValue(F.MustBeUnreachable),
0}; 0};
return FlagRep; return FlagRep;
} }
// Get string representation of function instruction count and flags. // Get string representation of function instruction count and flags.
static std::string getSummaryAttributes(GlobalValueSummary* GVS) { static std::string getSummaryAttributes(GlobalValueSummary* GVS) {
auto *FS = dyn_cast_or_null<FunctionSummary>(GVS); auto *FS = dyn_cast_if_present<FunctionSummary>(GVS);
if (!FS) if (!FS)
return ""; return "";
return std::string("inst: ") + std::to_string(FS->instCount()) + return std::string("inst: ") + std::to_string(FS->instCount()) +
", ffl: " + fflagsToString(FS->fflags()); ", ffl: " + fflagsToString(FS->fflags());
} }
static std::string getNodeVisualName(GlobalValue::GUID Id) { static std::string getNodeVisualName(GlobalValue::GUID Id) {
▲ Show 20 Lines • Show All 154 Lines • ▼ Show 20 Lines for (auto &ModIt : ModuleToDefinedGVS) {
OS << " // Edges:\n"; OS << " // Edges:\n";
for (auto &SummaryIt : GVSMap) { for (auto &SummaryIt : GVSMap) {
auto *GVS = SummaryIt.second; auto *GVS = SummaryIt.second;
for (auto &R : GVS->refs()) for (auto &R : GVS->refs())
Draw(SummaryIt.first, R.getGUID(), Draw(SummaryIt.first, R.getGUID(),
R.isWriteOnly() ? -1 : (R.isReadOnly() ? -2 : -3)); R.isWriteOnly() ? -1 : (R.isReadOnly() ? -2 : -3));
if (auto *AS = dyn_cast_or_null<AliasSummary>(SummaryIt.second)) { if (auto *AS = dyn_cast_if_present<AliasSummary>(SummaryIt.second)) {
Draw(SummaryIt.first, AS->getAliaseeGUID(), -4); Draw(SummaryIt.first, AS->getAliaseeGUID(), -4);
continue; continue;
} }
if (auto *FS = dyn_cast_or_null<FunctionSummary>(SummaryIt.second)) if (auto *FS = dyn_cast_if_present<FunctionSummary>(SummaryIt.second))
for (auto &CGEdge : FS->calls()) for (auto &CGEdge : FS->calls())
Draw(SummaryIt.first, CGEdge.first.getGUID(), Draw(SummaryIt.first, CGEdge.first.getGUID(),
static_cast<int>(CGEdge.second.Hotness)); static_cast<int>(CGEdge.second.Hotness));
} }
OS << " }\n"; OS << " }\n";
} }
OS << " // Cross-module edges:\n"; OS << " // Cross-module edges:\n";
Show All 20 Lines

llvm/lib/IR/ProfileSummary.cpp

Show First 20 Lines • Show All 186 Lines • ▼ Show 20 Lines if (getVal(dyn_cast<MDTuple>(Tuple->getOperand(Idx)), Key, Value)) {
// last, the next entry in the tuple operand array must exist. // last, the next entry in the tuple operand array must exist.
return Idx < Tuple->getNumOperands(); return Idx < Tuple->getNumOperands();
} }
// It was absent, keep going. // It was absent, keep going.
return true; return true;
} }
ProfileSummary *ProfileSummary::getFromMD(Metadata *MD) { ProfileSummary *ProfileSummary::getFromMD(Metadata *MD) {
MDTuple *Tuple = dyn_cast_or_null<MDTuple>(MD); MDTuple *Tuple = dyn_cast_if_present<MDTuple>(MD);
if (!Tuple || Tuple->getNumOperands() < 8 || Tuple->getNumOperands() > 10) if (!Tuple || Tuple->getNumOperands() < 8 || Tuple->getNumOperands() > 10)
return nullptr; return nullptr;
unsigned I = 0; unsigned I = 0;
auto &FormatMD = Tuple->getOperand(I++); auto &FormatMD = Tuple->getOperand(I++);
ProfileSummary::Kind SummaryKind; ProfileSummary::Kind SummaryKind;
if (isKeyValuePair(dyn_cast_or_null<MDTuple>(FormatMD), "ProfileFormat", if (isKeyValuePair(dyn_cast_if_present<MDTuple>(FormatMD), "ProfileFormat",
"SampleProfile")) "SampleProfile"))
SummaryKind = PSK_Sample; SummaryKind = PSK_Sample;
else if (isKeyValuePair(dyn_cast_or_null<MDTuple>(FormatMD), "ProfileFormat", else if (isKeyValuePair(dyn_cast_if_present<MDTuple>(FormatMD),
"InstrProf")) "ProfileFormat", "InstrProf"))
SummaryKind = PSK_Instr; SummaryKind = PSK_Instr;
else if (isKeyValuePair(dyn_cast_or_null<MDTuple>(FormatMD), "ProfileFormat", else if (isKeyValuePair(dyn_cast_if_present<MDTuple>(FormatMD),
"CSInstrProf")) "ProfileFormat", "CSInstrProf"))
SummaryKind = PSK_CSInstr; SummaryKind = PSK_CSInstr;
else else
return nullptr; return nullptr;
uint64_t NumCounts, TotalCount, NumFunctions, MaxFunctionCount, MaxCount, uint64_t NumCounts, TotalCount, NumFunctions, MaxFunctionCount, MaxCount,
MaxInternalCount; MaxInternalCount;
if (!getVal(dyn_cast<MDTuple>(Tuple->getOperand(I++)), "TotalCount", if (!getVal(dyn_cast<MDTuple>(Tuple->getOperand(I++)), "TotalCount",
TotalCount)) TotalCount))
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

llvm/lib/IR/Type.cpp

Show First 20 Lines • Show All 610 Lines • ▼ Show 20 Linesbool StructType::indexValid(const Value *V) const {
// vector case all of the indices must be equal. // vector case all of the indices must be equal.
if (!V->getType()->isIntOrIntVectorTy(32)) if (!V->getType()->isIntOrIntVectorTy(32))
return false; return false;
if (isa<ScalableVectorType>(V->getType())) if (isa<ScalableVectorType>(V->getType()))
return false; return false;
const Constant *C = dyn_cast<Constant>(V); const Constant *C = dyn_cast<Constant>(V);
if (C && V->getType()->isVectorTy()) if (C && V->getType()->isVectorTy())
C = C->getSplatValue(); C = C->getSplatValue();
const ConstantInt *CU = dyn_cast_or_null<ConstantInt>(C); const ConstantInt *CU = dyn_cast_if_present<ConstantInt>(C);
return CU && CU->getZExtValue() < getNumElements(); return CU && CU->getZExtValue() < getNumElements();
} }
StructType *StructType::getTypeByName(LLVMContext &C, StringRef Name) { StructType *StructType::getTypeByName(LLVMContext &C, StringRef Name) {
return C.pImpl->NamedStructTypes.lookup(Name); return C.pImpl->NamedStructTypes.lookup(Name);
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 159 Lines • Show Last 20 Lines

llvm/lib/IR/User.cpp

Show All 27 Linesbool User::replaceUsesOfWith(Value *From, Value *To) {
for (unsigned i = 0, E = getNumOperands(); i != E; ++i) for (unsigned i = 0, E = getNumOperands(); i != E; ++i)
if (getOperand(i) == From) { // Is This operand is pointing to oldval? if (getOperand(i) == From) { // Is This operand is pointing to oldval?
// The side effects of this setOperand call include linking to // The side effects of this setOperand call include linking to
// "To", adding "this" to the uses list of To, and // "To", adding "this" to the uses list of To, and
// most importantly, removing "this" from the use list of "From". // most importantly, removing "this" from the use list of "From".
setOperand(i, To); setOperand(i, To);
Changed = true; Changed = true;
} }
if (auto DVI = dyn_cast_or_null<DbgVariableIntrinsic>(this)) { if (auto DVI = dyn_cast_if_present<DbgVariableIntrinsic>(this)) {
if (is_contained(DVI->location_ops(), From)) { if (is_contained(DVI->location_ops(), From)) {
DVI->replaceVariableLocationOp(From, To); DVI->replaceVariableLocationOp(From, To);
Changed = true; Changed = true;
} }
} }
return Changed; return Changed;
} }
▲ Show 20 Lines • Show All 162 Lines • Show Last 20 Lines

llvm/lib/IR/Value.cpp

Show First 20 Lines • Show All 963 Lines • ▼ Show 20 Lines if (auto *GO = dyn_cast<GlobalObject>(this)) {
if (MDNode *MD = LI->getMetadata(LLVMContext::MD_align)) { if (MDNode *MD = LI->getMetadata(LLVMContext::MD_align)) {
ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0)); ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0));
return Align(CI->getLimitedValue()); return Align(CI->getLimitedValue());
} }
} else if (auto *CstPtr = dyn_cast<Constant>(this)) { } else if (auto *CstPtr = dyn_cast<Constant>(this)) {
// Strip pointer casts to avoid creating unnecessary ptrtoint expression // Strip pointer casts to avoid creating unnecessary ptrtoint expression
// if the only "reduction" is combining a bitcast + ptrtoint. // if the only "reduction" is combining a bitcast + ptrtoint.
CstPtr = CstPtr->stripPointerCasts(); CstPtr = CstPtr->stripPointerCasts();
if (auto *CstInt = dyn_cast_or_null<ConstantInt>(ConstantExpr::getPtrToInt( if (auto *CstInt =
dyn_cast_if_present<ConstantInt>(ConstantExpr::getPtrToInt(
const_cast<Constant *>(CstPtr), DL.getIntPtrType(getType()), const_cast<Constant *>(CstPtr), DL.getIntPtrType(getType()),
/*OnlyIfReduced=*/true))) { /*OnlyIfReduced=*/true))) {
size_t TrailingZeros = CstInt->getValue().countTrailingZeros(); size_t TrailingZeros = CstInt->getValue().countTrailingZeros();
// While the actual alignment may be large, elsewhere we have // While the actual alignment may be large, elsewhere we have
// an arbitrary upper alignmet limit, so let's clamp to it. // an arbitrary upper alignmet limit, so let's clamp to it.
return Align(TrailingZeros < Value::MaxAlignmentExponent return Align(TrailingZeros < Value::MaxAlignmentExponent
? uint64_t(1) << TrailingZeros ? uint64_t(1) << TrailingZeros
: Value::MaximumAlignment); : Value::MaximumAlignment);
} }
} }
▲ Show 20 Lines • Show All 265 Lines • Show Last 20 Lines

llvm/lib/IR/Verifier.cpp

Show First 20 Lines • Show All 1,092 Lines • ▼ Show 20 Lines CheckDI(N.getTag() == dwarf::DW_TAG_typedef ||
"invalid tag", &N); "invalid tag", &N);
if (N.getTag() == dwarf::DW_TAG_ptr_to_member_type) { if (N.getTag() == dwarf::DW_TAG_ptr_to_member_type) {
CheckDI(isType(N.getRawExtraData()), "invalid pointer to member type", &N, CheckDI(isType(N.getRawExtraData()), "invalid pointer to member type", &N,
N.getRawExtraData()); N.getRawExtraData());
} }
if (N.getTag() == dwarf::DW_TAG_set_type) { if (N.getTag() == dwarf::DW_TAG_set_type) {
if (auto *T = N.getRawBaseType()) { if (auto *T = N.getRawBaseType()) {
auto *Enum = dyn_cast_or_null<DICompositeType>(T); auto *Enum = dyn_cast_if_present<DICompositeType>(T);
auto *Basic = dyn_cast_or_null<DIBasicType>(T); auto *Basic = dyn_cast_if_present<DIBasicType>(T);
CheckDI( CheckDI(
(Enum && Enum->getTag() == dwarf::DW_TAG_enumeration_type) || (Enum && Enum->getTag() == dwarf::DW_TAG_enumeration_type) ||
(Basic && (Basic->getEncoding() == dwarf::DW_ATE_unsigned || (Basic && (Basic->getEncoding() == dwarf::DW_ATE_unsigned ||
Basic->getEncoding() == dwarf::DW_ATE_signed || Basic->getEncoding() == dwarf::DW_ATE_signed ||
Basic->getEncoding() == dwarf::DW_ATE_unsigned_char || Basic->getEncoding() == dwarf::DW_ATE_unsigned_char ||
Basic->getEncoding() == dwarf::DW_ATE_signed_char || Basic->getEncoding() == dwarf::DW_ATE_signed_char ||
Basic->getEncoding() == dwarf::DW_ATE_boolean)), Basic->getEncoding() == dwarf::DW_ATE_boolean)),
"invalid set base type", &N, T); "invalid set base type", &N, T);
▲ Show 20 Lines • Show All 145 Lines • ▼ Show 20 Linesvoid Verifier::visitDICompileUnit(const DICompileUnit &N) {
verifySourceDebugInfo(N, *N.getFile()); verifySourceDebugInfo(N, *N.getFile());
CheckDI((N.getEmissionKind() <= DICompileUnit::LastEmissionKind), CheckDI((N.getEmissionKind() <= DICompileUnit::LastEmissionKind),
"invalid emission kind", &N); "invalid emission kind", &N);
if (auto *Array = N.getRawEnumTypes()) { if (auto *Array = N.getRawEnumTypes()) {
CheckDI(isa<MDTuple>(Array), "invalid enum list", &N, Array); CheckDI(isa<MDTuple>(Array), "invalid enum list", &N, Array);
for (Metadata *Op : N.getEnumTypes()->operands()) { for (Metadata *Op : N.getEnumTypes()->operands()) {
auto *Enum = dyn_cast_or_null<DICompositeType>(Op); auto *Enum = dyn_cast_if_present<DICompositeType>(Op);
CheckDI(Enum && Enum->getTag() == dwarf::DW_TAG_enumeration_type, CheckDI(Enum && Enum->getTag() == dwarf::DW_TAG_enumeration_type,
"invalid enum type", &N, N.getEnumTypes(), Op); "invalid enum type", &N, N.getEnumTypes(), Op);
} }
} }
if (auto *Array = N.getRawRetainedTypes()) { if (auto *Array = N.getRawRetainedTypes()) {
CheckDI(isa<MDTuple>(Array), "invalid retained type list", &N, Array); CheckDI(isa<MDTuple>(Array), "invalid retained type list", &N, Array);
for (Metadata *Op : N.getRetainedTypes()->operands()) { for (Metadata *Op : N.getRetainedTypes()->operands()) {
CheckDI( CheckDI(
▲ Show 20 Lines • Show All 262 Lines • ▼ Show 20 Linesvoid Verifier::visitModuleIdents() {
if (!Idents) if (!Idents)
return; return;
// llvm.ident takes a list of metadata entry. Each entry has only one string. // llvm.ident takes a list of metadata entry. Each entry has only one string.
// Scan each llvm.ident entry and make sure that this requirement is met. // Scan each llvm.ident entry and make sure that this requirement is met.
for (const MDNode *N : Idents->operands()) { for (const MDNode *N : Idents->operands()) {
Check(N->getNumOperands() == 1, Check(N->getNumOperands() == 1,
"incorrect number of operands in llvm.ident metadata", N); "incorrect number of operands in llvm.ident metadata", N);
Check(dyn_cast_or_null<MDString>(N->getOperand(0)), Check(dyn_cast_if_present<MDString>(N->getOperand(0)),
("invalid value for llvm.ident metadata entry operand" ("invalid value for llvm.ident metadata entry operand"
"(the operand should be a string)"), "(the operand should be a string)"),
N->getOperand(0)); N->getOperand(0));
} }
} }
void Verifier::visitModuleCommandLines() { void Verifier::visitModuleCommandLines() {
const NamedMDNode *CommandLines = M.getNamedMetadata("llvm.commandline"); const NamedMDNode *CommandLines = M.getNamedMetadata("llvm.commandline");
if (!CommandLines) if (!CommandLines)
return; return;
// llvm.commandline takes a list of metadata entry. Each entry has only one // llvm.commandline takes a list of metadata entry. Each entry has only one
// string. Scan each llvm.commandline entry and make sure that this // string. Scan each llvm.commandline entry and make sure that this
// requirement is met. // requirement is met.
for (const MDNode *N : CommandLines->operands()) { for (const MDNode *N : CommandLines->operands()) {
Check(N->getNumOperands() == 1, Check(N->getNumOperands() == 1,
"incorrect number of operands in llvm.commandline metadata", N); "incorrect number of operands in llvm.commandline metadata", N);
Check(dyn_cast_or_null<MDString>(N->getOperand(0)), Check(dyn_cast_if_present<MDString>(N->getOperand(0)),
("invalid value for llvm.commandline metadata entry operand" ("invalid value for llvm.commandline metadata entry operand"
"(the operand should be a string)"), "(the operand should be a string)"),
N->getOperand(0)); N->getOperand(0));
} }
} }
void Verifier::visitModuleFlags() { void Verifier::visitModuleFlags() {
const NamedMDNode *Flags = M.getModuleFlagsMetadata(); const NamedMDNode *Flags = M.getModuleFlagsMetadata();
Show All 38 LinesVerifier::visitModuleFlag(const MDNode *Op,
if (!Module::isValidModFlagBehavior(Op->getOperand(0), MFB)) { if (!Module::isValidModFlagBehavior(Op->getOperand(0), MFB)) {
Check(mdconst::dyn_extract_or_null<ConstantInt>(Op->getOperand(0)), Check(mdconst::dyn_extract_or_null<ConstantInt>(Op->getOperand(0)),
"invalid behavior operand in module flag (expected constant integer)", "invalid behavior operand in module flag (expected constant integer)",
Op->getOperand(0)); Op->getOperand(0));
Check(false, Check(false,
"invalid behavior operand in module flag (unexpected constant)", "invalid behavior operand in module flag (unexpected constant)",
Op->getOperand(0)); Op->getOperand(0));
} }
MDString *ID = dyn_cast_or_null<MDString>(Op->getOperand(1)); MDString *ID = dyn_cast_if_present<MDString>(Op->getOperand(1));
Check(ID, "invalid ID operand in module flag (expected metadata string)", Check(ID, "invalid ID operand in module flag (expected metadata string)",
Op->getOperand(1)); Op->getOperand(1));
// Check the values for behaviors with additional requirements. // Check the values for behaviors with additional requirements.
switch (MFB) { switch (MFB) {
case Module::Error: case Module::Error:
case Module::Warning: case Module::Warning:
case Module::Override: case Module::Override:
▲ Show 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
void Verifier::visitModuleFlagCGProfileEntry(const MDOperand &MDO) { void Verifier::visitModuleFlagCGProfileEntry(const MDOperand &MDO) {
auto CheckFunction = [&](const MDOperand &FuncMDO) { auto CheckFunction = [&](const MDOperand &FuncMDO) {
if (!FuncMDO) if (!FuncMDO)
return; return;
auto F = dyn_cast<ValueAsMetadata>(FuncMDO); auto F = dyn_cast<ValueAsMetadata>(FuncMDO);
Check(F && isa<Function>(F->getValue()->stripPointerCasts()), Check(F && isa<Function>(F->getValue()->stripPointerCasts()),
"expected a Function or null", FuncMDO); "expected a Function or null", FuncMDO);
}; };
auto Node = dyn_cast_or_null<MDNode>(MDO); auto Node = dyn_cast_if_present<MDNode>(MDO);
Check(Node && Node->getNumOperands() == 3, "expected a MDNode triple", MDO); Check(Node && Node->getNumOperands() == 3, "expected a MDNode triple", MDO);
CheckFunction(Node->getOperand(0)); CheckFunction(Node->getOperand(0));
CheckFunction(Node->getOperand(1)); CheckFunction(Node->getOperand(1));
auto Count = dyn_cast_or_null<ConstantAsMetadata>(Node->getOperand(2)); auto Count = dyn_cast_if_present<ConstantAsMetadata>(Node->getOperand(2));
Check(Count && Count->getType()->isIntegerTy(), Check(Count && Count->getType()->isIntegerTy(),
"expected an integer constant", Node->getOperand(2)); "expected an integer constant", Node->getOperand(2));
} }
void Verifier::verifyAttributeTypes(AttributeSet Attrs, const Value *V) { void Verifier::verifyAttributeTypes(AttributeSet Attrs, const Value *V) {
for (Attribute A : Attrs) { for (Attribute A : Attrs) {
if (A.isStringAttribute()) { if (A.isStringAttribute()) {
▲ Show 20 Lines • Show All 988 Lines • ▼ Show 20 Linesvoid Verifier::visitFunction(const Function &F) {
// Check that all !dbg attachments lead to back to N. // Check that all !dbg attachments lead to back to N.
// //
// FIXME: Check this incrementally while visiting !dbg attachments. // FIXME: Check this incrementally while visiting !dbg attachments.
// FIXME: Only check when N is the canonical subprogram for F. // FIXME: Only check when N is the canonical subprogram for F.
SmallPtrSet<const MDNode *, 32> Seen; SmallPtrSet<const MDNode *, 32> Seen;
auto VisitDebugLoc = [&](const Instruction &I, const MDNode *Node) { auto VisitDebugLoc = [&](const Instruction &I, const MDNode *Node) {
// Be careful about using DILocation here since we might be dealing with // Be careful about using DILocation here since we might be dealing with
// broken code (this is the Verifier after all). // broken code (this is the Verifier after all).
const DILocation *DL = dyn_cast_or_null<DILocation>(Node); const DILocation *DL = dyn_cast_if_present<DILocation>(Node);
if (!DL) if (!DL)
return; return;
if (!Seen.insert(DL).second) if (!Seen.insert(DL).second)
return; return;
Metadata *Parent = DL->getRawScope(); Metadata *Parent = DL->getRawScope();
CheckDI(Parent && isa<DILocalScope>(Parent), CheckDI(Parent && isa<DILocalScope>(Parent),
"DILocation's scope must be a DILocalScope", N, &F, &I, DL, Parent); "DILocation's scope must be a DILocalScope", N, &F, &I, DL, Parent);
Show All 16 Lines CheckDI(SP->describes(&F),
&I, DL, Scope, SP); &I, DL, Scope, SP);
}; };
for (auto &BB : F) for (auto &BB : F)
for (auto &I : BB) { for (auto &I : BB) {
VisitDebugLoc(I, I.getDebugLoc().getAsMDNode()); VisitDebugLoc(I, I.getDebugLoc().getAsMDNode());
// The llvm.loop annotations also contain two DILocations. // The llvm.loop annotations also contain two DILocations.
if (auto MD = I.getMetadata(LLVMContext::MD_loop)) if (auto MD = I.getMetadata(LLVMContext::MD_loop))
for (unsigned i = 1; i < MD->getNumOperands(); ++i) for (unsigned i = 1; i < MD->getNumOperands(); ++i)
VisitDebugLoc(I, dyn_cast_or_null<MDNode>(MD->getOperand(i))); VisitDebugLoc(I, dyn_cast_if_present<MDNode>(MD->getOperand(i)));
if (BrokenDebugInfo) if (BrokenDebugInfo)
return; return;
} }
} }
// verifyBasicBlock - Verify that a basic block is well formed... // verifyBasicBlock - Verify that a basic block is well formed...
// //
void Verifier::visitBasicBlock(BasicBlock &BB) { void Verifier::visitBasicBlock(BasicBlock &BB) {
▲ Show 20 Lines • Show All 755 Lines • ▼ Show 20 Linesvoid Verifier::verifyMustTailCall(CallInst &CI) {
// - The call must immediately precede a :ref:`ret <i_ret>` instruction, // - The call must immediately precede a :ref:`ret <i_ret>` instruction,
// or a pointer bitcast followed by a ret instruction. // or a pointer bitcast followed by a ret instruction.
// - The ret instruction must return the (possibly bitcasted) value // - The ret instruction must return the (possibly bitcasted) value
// produced by the call or void. // produced by the call or void.
Value *RetVal = &CI; Value *RetVal = &CI;
Instruction *Next = CI.getNextNode(); Instruction *Next = CI.getNextNode();
// Handle the optional bitcast. // Handle the optional bitcast.
if (BitCastInst *BI = dyn_cast_or_null<BitCastInst>(Next)) { if (BitCastInst *BI = dyn_cast_if_present<BitCastInst>(Next)) {
Check(BI->getOperand(0) == RetVal, Check(BI->getOperand(0) == RetVal,
"bitcast following musttail call must use the call", BI); "bitcast following musttail call must use the call", BI);
RetVal = BI; RetVal = BI;
Next = BI->getNextNode(); Next = BI->getNextNode();
} }
// Check the return. // Check the return.
ReturnInst *Ret = dyn_cast_or_null<ReturnInst>(Next); ReturnInst *Ret = dyn_cast_if_present<ReturnInst>(Next);
Check(Ret, "musttail call must precede a ret with an optional bitcast", &CI); Check(Ret, "musttail call must precede a ret with an optional bitcast", &CI);
Check(!Ret->getReturnValue() || Ret->getReturnValue() == RetVal || Check(!Ret->getReturnValue() || Ret->getReturnValue() == RetVal ||
isa<UndefValue>(Ret->getReturnValue()), isa<UndefValue>(Ret->getReturnValue()),
"musttail call result must be returned", Ret); "musttail call result must be returned", Ret);
AttributeList CallerAttrs = F->getAttributes(); AttributeList CallerAttrs = F->getAttributes();
AttributeList CalleeAttrs = CI.getAttributes(); AttributeList CalleeAttrs = CI.getAttributes();
if (CI.getCallingConv() == CallingConv::SwiftTail || if (CI.getCallingConv() == CallingConv::SwiftTail ||
▲ Show 20 Lines • Show All 2,465 Lines • ▼ Show 20 Linesvoid Verifier::visitDbgLabelIntrinsic(StringRef Kind, DbgLabelInst &DLI) {
CheckDI(LabelSP == LocSP, CheckDI(LabelSP == LocSP,
"mismatched subprogram between llvm.dbg." + Kind + "mismatched subprogram between llvm.dbg." + Kind +
" label and !dbg attachment", " label and !dbg attachment",
&DLI, BB, F, Label, Label->getScope()->getSubprogram(), Loc, &DLI, BB, F, Label, Label->getScope()->getSubprogram(), Loc,
Loc->getScope()->getSubprogram()); Loc->getScope()->getSubprogram());
} }
void Verifier::verifyFragmentExpression(const DbgVariableIntrinsic &I) { void Verifier::verifyFragmentExpression(const DbgVariableIntrinsic &I) {
DILocalVariable *V = dyn_cast_or_null<DILocalVariable>(I.getRawVariable()); DILocalVariable *V = dyn_cast_if_present<DILocalVariable>(I.getRawVariable());
DIExpression *E = dyn_cast_or_null<DIExpression>(I.getRawExpression()); DIExpression *E = dyn_cast_if_present<DIExpression>(I.getRawExpression());
// We don't know whether this intrinsic verified correctly. // We don't know whether this intrinsic verified correctly.
if (!V || !E || !E->isValid()) if (!V || !E || !E->isValid())
return; return;
// Nothing to do if this isn't a DW_OP_LLVM_fragment expression. // Nothing to do if this isn't a DW_OP_LLVM_fragment expression.
auto Fragment = E->getFragmentInfo(); auto Fragment = E->getFragmentInfo();
if (!Fragment) if (!Fragment)
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Linesvoid Verifier::verifyFnArgs(const DbgVariableIntrinsic &I) {
auto *Prev = DebugFnArgs[ArgNo - 1]; auto *Prev = DebugFnArgs[ArgNo - 1];
DebugFnArgs[ArgNo - 1] = Var; DebugFnArgs[ArgNo - 1] = Var;
CheckDI(!Prev || (Prev == Var), "conflicting debug info for argument", &I, CheckDI(!Prev || (Prev == Var), "conflicting debug info for argument", &I,
Prev, Var); Prev, Var);
} }
void Verifier::verifyNotEntryValue(const DbgVariableIntrinsic &I) { void Verifier::verifyNotEntryValue(const DbgVariableIntrinsic &I) {
DIExpression *E = dyn_cast_or_null<DIExpression>(I.getRawExpression()); DIExpression *E = dyn_cast_if_present<DIExpression>(I.getRawExpression());
// We don't know whether this intrinsic verified correctly. // We don't know whether this intrinsic verified correctly.
if (!E || !E->isValid()) if (!E || !E->isValid())
return; return;
CheckDI(!E->isEntryValue(), "Entry values are only allowed in MIR", &I); CheckDI(!E->isEntryValue(), "Entry values are only allowed in MIR", &I);
} }
▲ Show 20 Lines • Show All 375 Lines • ▼ Show 20 Lines if (!isa<MDString>(MD->getOperand(0)))
return false; return false;
if (MD->getNumOperands() == 3) { if (MD->getNumOperands() == 3) {
auto *Offset = mdconst::dyn_extract<ConstantInt>(MD->getOperand(2)); auto *Offset = mdconst::dyn_extract<ConstantInt>(MD->getOperand(2));
if (!(Offset && Offset->isZero() && isa<MDString>(MD->getOperand(0)))) if (!(Offset && Offset->isZero() && isa<MDString>(MD->getOperand(0))))
return false; return false;
} }
auto *Parent = dyn_cast_or_null<MDNode>(MD->getOperand(1)); auto *Parent = dyn_cast_if_present<MDNode>(MD->getOperand(1));
return Parent && Visited.insert(Parent).second && return Parent && Visited.insert(Parent).second &&
(IsRootTBAANode(Parent) || IsScalarTBAANodeImpl(Parent, Visited)); (IsRootTBAANode(Parent) || IsScalarTBAANodeImpl(Parent, Visited));
} }
bool TBAAVerifier::isValidScalarTBAANode(const MDNode *MD) { bool TBAAVerifier::isValidScalarTBAANode(const MDNode *MD) {
auto ResultIt = TBAAScalarNodes.find(MD); auto ResultIt = TBAAScalarNodes.find(MD);
if (ResultIt != TBAAScalarNodes.end()) if (ResultIt != TBAAScalarNodes.end())
return ResultIt->second; return ResultIt->second;
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Linesbool TBAAVerifier::visitTBAAMetadata(Instruction &I, const MDNode *MD) {
bool IsStructPathTBAA = bool IsStructPathTBAA =
isa<MDNode>(MD->getOperand(0)) && MD->getNumOperands() >= 3; isa<MDNode>(MD->getOperand(0)) && MD->getNumOperands() >= 3;
CheckTBAA(IsStructPathTBAA, CheckTBAA(IsStructPathTBAA,
"Old-style TBAA is no longer allowed, use struct-path TBAA instead", "Old-style TBAA is no longer allowed, use struct-path TBAA instead",
&I); &I);
MDNode *BaseNode = dyn_cast_or_null<MDNode>(MD->getOperand(0)); MDNode *BaseNode = dyn_cast_if_present<MDNode>(MD->getOperand(0));
MDNode *AccessType = dyn_cast_or_null<MDNode>(MD->getOperand(1)); MDNode *AccessType = dyn_cast_if_present<MDNode>(MD->getOperand(1));
bool IsNewFormat = isNewFormatTBAATypeNode(AccessType); bool IsNewFormat = isNewFormatTBAATypeNode(AccessType);
if (IsNewFormat) { if (IsNewFormat) {
CheckTBAA(MD->getNumOperands() == 4 || MD->getNumOperands() == 5, CheckTBAA(MD->getNumOperands() == 4 || MD->getNumOperands() == 5,
"Access tag metadata must have either 4 or 5 operands", &I, MD); "Access tag metadata must have either 4 or 5 operands", &I, MD);
} else { } else {
CheckTBAA(MD->getNumOperands() < 5, CheckTBAA(MD->getNumOperands() < 5,
▲ Show 20 Lines • Show All 117 Lines • Show Last 20 Lines

llvm/lib/LTO/LTO.cpp

Show First 20 Lines • Show All 248 Lines • ▼ Show 20 Lines#endif
// Imported functions may introduce new uses of type identifier resolutions, // Imported functions may introduce new uses of type identifier resolutions,
// so we need to collect their used resolutions as well. // so we need to collect their used resolutions as well.
for (auto &ImpM : ImportList) for (auto &ImpM : ImportList)
for (auto &ImpF : ImpM.second) { for (auto &ImpF : ImpM.second) {
GlobalValueSummary *S = Index.findSummaryInModule(ImpF, ImpM.first()); GlobalValueSummary *S = Index.findSummaryInModule(ImpF, ImpM.first());
AddUsedThings(S); AddUsedThings(S);
// If this is an alias, we also care about any types/etc. that the aliasee // If this is an alias, we also care about any types/etc. that the aliasee
// may reference. // may reference.
if (auto *AS = dyn_cast_or_null<AliasSummary>(S)) if (auto *AS = dyn_cast_if_present<AliasSummary>(S))
AddUsedThings(AS->getBaseObject()); AddUsedThings(AS->getBaseObject());
} }
auto AddTypeIdSummary = [&](StringRef TId, const TypeIdSummary &S) { auto AddTypeIdSummary = [&](StringRef TId, const TypeIdSummary &S) {
AddString(TId); AddString(TId);
AddUnsigned(S.TTRes.TheKind); AddUnsigned(S.TTRes.TheKind);
AddUnsigned(S.TTRes.SizeM1BitWidth); AddUnsigned(S.TTRes.SizeM1BitWidth);
▲ Show 20 Lines • Show All 1,396 Lines • Show Last 20 Lines

llvm/lib/Linker/LinkModules.cpp

Show First 20 Lines • Show All 125 Lines • ▼ Show 20 Lines if (A == GlobalValue::ProtectedVisibility ||
B == GlobalValue::ProtectedVisibility) B == GlobalValue::ProtectedVisibility)
return GlobalValue::ProtectedVisibility; return GlobalValue::ProtectedVisibility;
return GlobalValue::DefaultVisibility; return GlobalValue::DefaultVisibility;
} }
bool ModuleLinker::getComdatLeader(Module &M, StringRef ComdatName, bool ModuleLinker::getComdatLeader(Module &M, StringRef ComdatName,
const GlobalVariable *&GVar) { const GlobalVariable *&GVar) {
const GlobalValue *GVal = M.getNamedValue(ComdatName); const GlobalValue *GVal = M.getNamedValue(ComdatName);
if (const auto *GA = dyn_cast_or_null<GlobalAlias>(GVal)) { if (const auto *GA = dyn_cast_if_present<GlobalAlias>(GVal)) {
GVal = GA->getAliaseeObject(); GVal = GA->getAliaseeObject();
if (!GVal) if (!GVal)
// We cannot resolve the size of the aliasee yet. // We cannot resolve the size of the aliasee yet.
return emitError("Linking COMDATs named '" + ComdatName + return emitError("Linking COMDATs named '" + ComdatName +
"': COMDAT key involves incomputable alias size."); "': COMDAT key involves incomputable alias size.");
} }
GVar = dyn_cast_or_null<GlobalVariable>(GVal); GVar = dyn_cast_if_present<GlobalVariable>(GVal);
if (!GVar) if (!GVar)
return emitError( return emitError(
"Linking COMDATs named '" + ComdatName + "Linking COMDATs named '" + ComdatName +
"': GlobalVariable required for data dependent selection!"); "': GlobalVariable required for data dependent selection!");
return false; return false;
} }
▲ Show 20 Lines • Show All 480 Lines • Show Last 20 Lines

llvm/lib/MC/MCObjectStreamer.cpp

Show First 20 Lines • Show All 217 Lines • ▼ Show 20 Lines if (Assembler.isBundlingEnabled())
return Assembler.getRelaxAll(); return Assembler.getRelaxAll();
// If the subtarget is changed mid fragment we start a new fragment to record // If the subtarget is changed mid fragment we start a new fragment to record
// the new STI. // the new STI.
return !STI || F.getSubtargetInfo() == STI; return !STI || F.getSubtargetInfo() == STI;
} }
MCDataFragment * MCDataFragment *
MCObjectStreamer::getOrCreateDataFragment(const MCSubtargetInfo *STI) { MCObjectStreamer::getOrCreateDataFragment(const MCSubtargetInfo *STI) {
MCDataFragment *F = dyn_cast_or_null<MCDataFragment>(getCurrentFragment()); MCDataFragment *F = dyn_cast_if_present<MCDataFragment>(getCurrentFragment());
if (!F || !canReuseDataFragment(*F, *Assembler, STI)) { if (!F || !canReuseDataFragment(*F, *Assembler, STI)) {
F = new MCDataFragment(); F = new MCDataFragment();
insert(F); insert(F);
} }
return F; return F;
} }
void MCObjectStreamer::visitUsedSymbol(const MCSymbol &Sym) { void MCObjectStreamer::visitUsedSymbol(const MCSymbol &Sym) {
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Lines
void MCObjectStreamer::emitLabel(MCSymbol *Symbol, SMLoc Loc) { void MCObjectStreamer::emitLabel(MCSymbol *Symbol, SMLoc Loc) {
MCStreamer::emitLabel(Symbol, Loc); MCStreamer::emitLabel(Symbol, Loc);
getAssembler().registerSymbol(*Symbol); getAssembler().registerSymbol(*Symbol);
// If there is a current fragment, mark the symbol as pointing into it. // If there is a current fragment, mark the symbol as pointing into it.
// Otherwise queue the label and set its fragment pointer when we emit the // Otherwise queue the label and set its fragment pointer when we emit the
// next fragment. // next fragment.
auto *F = dyn_cast_or_null<MCDataFragment>(getCurrentFragment()); auto *F = dyn_cast_if_present<MCDataFragment>(getCurrentFragment());
if (F && !(getAssembler().isBundlingEnabled() && if (F && !(getAssembler().isBundlingEnabled() &&
getAssembler().getRelaxAll())) { getAssembler().getRelaxAll())) {
Symbol->setFragment(F); Symbol->setFragment(F);
Symbol->setOffset(F->getContents().size()); Symbol->setOffset(F->getContents().size());
} else { } else {
// Assign all pending labels to offset 0 within the dummy "pending" // Assign all pending labels to offset 0 within the dummy "pending"
// fragment. (They will all be reassigned to a real fragment in // fragment. (They will all be reassigned to a real fragment in
// flushPendingLabels()) // flushPendingLabels())
Show All 17 Lines
// Emit a label at a previously emitted fragment/offset position. This must be // Emit a label at a previously emitted fragment/offset position. This must be
// within the currently-active section. // within the currently-active section.
void MCObjectStreamer::emitLabelAtPos(MCSymbol *Symbol, SMLoc Loc, void MCObjectStreamer::emitLabelAtPos(MCSymbol *Symbol, SMLoc Loc,
MCFragment *F, uint64_t Offset) { MCFragment *F, uint64_t Offset) {
assert(F->getParent() == getCurrentSectionOnly()); assert(F->getParent() == getCurrentSectionOnly());
MCStreamer::emitLabel(Symbol, Loc); MCStreamer::emitLabel(Symbol, Loc);
getAssembler().registerSymbol(*Symbol); getAssembler().registerSymbol(*Symbol);
auto *DF = dyn_cast_or_null<MCDataFragment>(F); auto *DF = dyn_cast_if_present<MCDataFragment>(F);
Symbol->setOffset(Offset); Symbol->setOffset(Offset);
if (DF) { if (DF) {
Symbol->setFragment(F); Symbol->setFragment(F);
} else { } else {
assert(isa<MCDummyFragment>(F) && assert(isa<MCDummyFragment>(F) &&
"F must either be an MCDataFragment or the pending MCDummyFragment"); "F must either be an MCDataFragment or the pending MCDummyFragment");
assert(Offset == 0); assert(Offset == 0);
addPendingLabel(Symbol); addPendingLabel(Symbol);
▲ Show 20 Lines • Show All 601 Lines • Show Last 20 Lines

llvm/lib/MC/MCParser/ELFAsmParser.cpp

Show First 20 Lines • Show All 466 Lines • ▼ Show 20 Linesbool ELFAsmParser::parseLinkedToSym(MCSymbolELF *&LinkedToSym) {
if (getParser().parseIdentifier(Name)) { if (getParser().parseIdentifier(Name)) {
if (getParser().getTok().getString() == "0") { if (getParser().getTok().getString() == "0") {
getParser().Lex(); getParser().Lex();
LinkedToSym = nullptr; LinkedToSym = nullptr;
return false; return false;
} }
return TokError("invalid linked-to symbol"); return TokError("invalid linked-to symbol");
} }
LinkedToSym = dyn_cast_or_null<MCSymbolELF>(getContext().lookupSymbol(Name)); LinkedToSym =
dyn_cast_if_present<MCSymbolELF>(getContext().lookupSymbol(Name));
if (!LinkedToSym || !LinkedToSym->isInSection()) if (!LinkedToSym || !LinkedToSym->isInSection())
return Error(StartLoc, "linked-to symbol is not in a section: " + Name); return Error(StartLoc, "linked-to symbol is not in a section: " + Name);
return false; return false;
} }
bool ELFAsmParser::maybeParseUniqueID(int64_t &UniqueID) { bool ELFAsmParser::maybeParseUniqueID(int64_t &UniqueID) {
MCAsmLexer &L = getLexer(); MCAsmLexer &L = getLexer();
if (L.isNot(AsmToken::Comma)) if (L.isNot(AsmToken::Comma))
▲ Show 20 Lines • Show All 445 Lines • Show Last 20 Lines

llvm/lib/MC/MCParser/MasmParser.cpp

Show First 20 Lines • Show All 3,509 Lines • ▼ Show 20 Lines if (!Expr->evaluateAsAbsolute(Value, getStreamer().getAssemblerPtr())) {
Var.Redefinable = Variable::REDEFINABLE; Var.Redefinable = Variable::REDEFINABLE;
return false; return false;
} }
MCSymbol *Sym = getContext().getOrCreateSymbol(Var.Name); MCSymbol *Sym = getContext().getOrCreateSymbol(Var.Name);
const MCConstantExpr *PrevValue = const MCConstantExpr *PrevValue =
Sym->isVariable() ? dyn_cast_or_null<MCConstantExpr>( Sym->isVariable() ? dyn_cast_if_present<MCConstantExpr>(
Sym->getVariableValue(/*SetUsed=*/false)) Sym->getVariableValue(/*SetUsed=*/false))
: nullptr; : nullptr;
if (Var.IsText || !PrevValue || PrevValue->getValue() != Value) { if (Var.IsText || !PrevValue || PrevValue->getValue() != Value) {
switch (Var.Redefinable) { switch (Var.Redefinable) {
case Variable::NOT_REDEFINABLE: case Variable::NOT_REDEFINABLE:
return Error(getTok().getLoc(), "invalid variable redefinition"); return Error(getTok().getLoc(), "invalid variable redefinition");
case Variable::WARN_ON_REDEFINITION: case Variable::WARN_ON_REDEFINITION:
if (Warning(NameLoc, "redefining '" + Name + if (Warning(NameLoc, "redefining '" + Name +
▲ Show 20 Lines • Show All 4,202 Lines • Show Last 20 Lines

llvm/lib/MC/MachObjectWriter.cpp

Show First 20 Lines • Show All 772 Lines • ▼ Show 20 Linesuint64_t MachObjectWriter::writeObject(MCAssembler &Asm,
// Compute symbol table information and bind symbol indices. // Compute symbol table information and bind symbol indices.
computeSymbolTable(Asm, LocalSymbolData, ExternalSymbolData, computeSymbolTable(Asm, LocalSymbolData, ExternalSymbolData,
UndefinedSymbolData); UndefinedSymbolData);
if (!Asm.CGProfile.empty()) { if (!Asm.CGProfile.empty()) {
MCSection *CGProfileSection = Asm.getContext().getMachOSection( MCSection *CGProfileSection = Asm.getContext().getMachOSection(
"__LLVM", "__cg_profile", 0, SectionKind::getMetadata()); "__LLVM", "__cg_profile", 0, SectionKind::getMetadata());
MCDataFragment *Frag = dyn_cast_or_null<MCDataFragment>( MCDataFragment *Frag = dyn_cast_if_present<MCDataFragment>(
&*CGProfileSection->getFragmentList().begin()); &*CGProfileSection->getFragmentList().begin());
assert(Frag && "call graph profile section not reserved"); assert(Frag && "call graph profile section not reserved");
Frag->getContents().clear(); Frag->getContents().clear();
raw_svector_ostream OS(Frag->getContents()); raw_svector_ostream OS(Frag->getContents());
for (const MCAssembler::CGProfileEntry &CGPE : Asm.CGProfile) { for (const MCAssembler::CGProfileEntry &CGPE : Asm.CGProfile) {
uint32_t FromIndex = CGPE.From->getSymbol().getIndex(); uint32_t FromIndex = CGPE.From->getSymbol().getIndex();
uint32_t ToIndex = CGPE.To->getSymbol().getIndex(); uint32_t ToIndex = CGPE.To->getSymbol().getIndex();
support::endian::write(OS, FromIndex, W.Endian); support::endian::write(OS, FromIndex, W.Endian);
▲ Show 20 Lines • Show All 312 Lines • Show Last 20 Lines

llvm/lib/ObjectYAML/ELFEmitter.cpp

Show First 20 Lines • Show All 973 Lines • ▼ Show 20 Linesvoid ELFState<ELFT>::initSymtabSectionHeader(Elf_Shdr &SHeader,
bool IsStatic = STType == SymtabType::Static; bool IsStatic = STType == SymtabType::Static;
ArrayRef<ELFYAML::Symbol> Symbols; ArrayRef<ELFYAML::Symbol> Symbols;
if (IsStatic && Doc.Symbols) if (IsStatic && Doc.Symbols)
Symbols = *Doc.Symbols; Symbols = *Doc.Symbols;
else if (!IsStatic && Doc.DynamicSymbols) else if (!IsStatic && Doc.DynamicSymbols)
Symbols = *Doc.DynamicSymbols; Symbols = *Doc.DynamicSymbols;
ELFYAML::RawContentSection *RawSec = ELFYAML::RawContentSection *RawSec =
dyn_cast_or_null<ELFYAML::RawContentSection>(YAMLSec); dyn_cast_if_present<ELFYAML::RawContentSection>(YAMLSec);
if (RawSec && (RawSec->Content || RawSec->Size)) { if (RawSec && (RawSec->Content || RawSec->Size)) {
bool HasSymbolsDescription = bool HasSymbolsDescription =
(IsStatic && Doc.Symbols) || (!IsStatic && Doc.DynamicSymbols); (IsStatic && Doc.Symbols) || (!IsStatic && Doc.DynamicSymbols);
if (HasSymbolsDescription) { if (HasSymbolsDescription) {
StringRef Property = (IsStatic ? "`Symbols`" : "`DynamicSymbols`"); StringRef Property = (IsStatic ? "`Symbols`" : "`DynamicSymbols`");
if (RawSec->Content) if (RawSec->Content)
reportError("cannot specify both `Content` and " + Property + reportError("cannot specify both `Content` and " + Property +
" for symbol table section '" + RawSec->Name + "'"); " for symbol table section '" + RawSec->Name + "'");
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Linesvoid ELFState<ELFT>::initStrtabSectionHeader(Elf_Shdr &SHeader, StringRef Name,
StringTableBuilder &STB, StringTableBuilder &STB,
ContiguousBlobAccumulator &CBA, ContiguousBlobAccumulator &CBA,
ELFYAML::Section *YAMLSec) { ELFYAML::Section *YAMLSec) {
SHeader.sh_name = getSectionNameOffset(ELFYAML::dropUniqueSuffix(Name)); SHeader.sh_name = getSectionNameOffset(ELFYAML::dropUniqueSuffix(Name));
SHeader.sh_type = YAMLSec ? YAMLSec->Type : ELF::SHT_STRTAB; SHeader.sh_type = YAMLSec ? YAMLSec->Type : ELF::SHT_STRTAB;
SHeader.sh_addralign = YAMLSec ? (uint64_t)YAMLSec->AddressAlign : 1; SHeader.sh_addralign = YAMLSec ? (uint64_t)YAMLSec->AddressAlign : 1;
ELFYAML::RawContentSection *RawSec = ELFYAML::RawContentSection *RawSec =
dyn_cast_or_null<ELFYAML::RawContentSection>(YAMLSec); dyn_cast_if_present<ELFYAML::RawContentSection>(YAMLSec);
SHeader.sh_offset = alignToOffset(CBA, SHeader.sh_addralign, SHeader.sh_offset = alignToOffset(CBA, SHeader.sh_addralign,
YAMLSec ? YAMLSec->Offset : None); YAMLSec ? YAMLSec->Offset : None);
if (RawSec && (RawSec->Content || RawSec->Size)) { if (RawSec && (RawSec->Content || RawSec->Size)) {
SHeader.sh_size = writeContent(CBA, RawSec->Content, RawSec->Size); SHeader.sh_size = writeContent(CBA, RawSec->Content, RawSec->Size);
} else { } else {
if (raw_ostream *OS = CBA.getRawOS(STB.getSize())) if (raw_ostream *OS = CBA.getRawOS(STB.getSize()))
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Linesvoid ELFState<ELFT>::initDWARFSectionHeader(Elf_Shdr &SHeader, StringRef Name,
ELFYAML::Section *YAMLSec) { ELFYAML::Section *YAMLSec) {
SHeader.sh_name = getSectionNameOffset(ELFYAML::dropUniqueSuffix(Name)); SHeader.sh_name = getSectionNameOffset(ELFYAML::dropUniqueSuffix(Name));
SHeader.sh_type = YAMLSec ? YAMLSec->Type : ELF::SHT_PROGBITS; SHeader.sh_type = YAMLSec ? YAMLSec->Type : ELF::SHT_PROGBITS;
SHeader.sh_addralign = YAMLSec ? (uint64_t)YAMLSec->AddressAlign : 1; SHeader.sh_addralign = YAMLSec ? (uint64_t)YAMLSec->AddressAlign : 1;
SHeader.sh_offset = alignToOffset(CBA, SHeader.sh_addralign, SHeader.sh_offset = alignToOffset(CBA, SHeader.sh_addralign,
YAMLSec ? YAMLSec->Offset : None); YAMLSec ? YAMLSec->Offset : None);
ELFYAML::RawContentSection *RawSec = ELFYAML::RawContentSection *RawSec =
dyn_cast_or_null<ELFYAML::RawContentSection>(YAMLSec); dyn_cast_if_present<ELFYAML::RawContentSection>(YAMLSec);
if (Doc.DWARF && shouldEmitDWARF(*Doc.DWARF, Name)) { if (Doc.DWARF && shouldEmitDWARF(*Doc.DWARF, Name)) {
if (RawSec && (RawSec->Content || RawSec->Size)) if (RawSec && (RawSec->Content || RawSec->Size))
reportError("cannot specify section '" + Name + reportError("cannot specify section '" + Name +
"' contents in the 'DWARF' entry and the 'Content' " "' contents in the 'DWARF' entry and the 'Content' "
"or 'Size' in the 'Sections' entry at the same time"); "or 'Size' in the 'Sections' entry at the same time");
else { else {
if (Expected<uint64_t> ShSizeOrErr = if (Expected<uint64_t> ShSizeOrErr =
emitDWARF<ELFT>(SHeader, Name, *Doc.DWARF, CBA)) emitDWARF<ELFT>(SHeader, Name, *Doc.DWARF, CBA))
▲ Show 20 Lines • Show All 887 Lines • Show Last 20 Lines

llvm/lib/ProfileData/InstrProf.cpp

Show First 20 Lines • Show All 1,166 Lines • ▼ Show 20 Linesbool isIRPGOFlagSet(const Module *M) {
// have the decl. // have the decl.
if (IRInstrVar->isDeclaration()) if (IRInstrVar->isDeclaration())
return true; return true;
// Check if the flag is set. // Check if the flag is set.
if (!IRInstrVar->hasInitializer()) if (!IRInstrVar->hasInitializer())
return false; return false;
auto *InitVal = dyn_cast_or_null<ConstantInt>(IRInstrVar->getInitializer()); auto *InitVal =
dyn_cast_if_present<ConstantInt>(IRInstrVar->getInitializer());
if (!InitVal) if (!InitVal)
return false; return false;
return (InitVal->getZExtValue() & VARIANT_MASK_IR_PROF) != 0; return (InitVal->getZExtValue() & VARIANT_MASK_IR_PROF) != 0;
} }
// Check if we can safely rename this Comdat function. // Check if we can safely rename this Comdat function.
bool canRenameComdatFunc(const Function &F, bool CheckAddressTaken) { bool canRenameComdatFunc(const Function &F, bool CheckAddressTaken) {
if (F.getName().empty()) if (F.getName().empty())
▲ Show 20 Lines • Show All 223 Lines • Show Last 20 Lines

llvm/lib/Support/YAMLTraits.cpp

Show First 20 Lines • Show All 127 Lines • ▼ Show 20 Linesbool Input::mapTag(StringRef Tag, bool Default) {
// Return true iff found tag matches supplied tag. // Return true iff found tag matches supplied tag.
return Tag.equals(foundTag); return Tag.equals(foundTag);
} }
void Input::beginMapping() { void Input::beginMapping() {
if (EC) if (EC)
return; return;
// CurrentNode can be null if the document is empty. // CurrentNode can be null if the document is empty.
MapHNode *MN = dyn_cast_or_null<MapHNode>(CurrentNode); MapHNode *MN = dyn_cast_if_present<MapHNode>(CurrentNode);
if (MN) { if (MN) {
MN->ValidKeys.clear(); MN->ValidKeys.clear();
} }
} }
std::vector<StringRef> Input::keys() { std::vector<StringRef> Input::keys() {
MapHNode *MN = dyn_cast<MapHNode>(CurrentNode); MapHNode *MN = dyn_cast<MapHNode>(CurrentNode);
std::vector<StringRef> Ret; std::vector<StringRef> Ret;
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
void Input::postflightKey(void *saveInfo) { void Input::postflightKey(void *saveInfo) {
CurrentNode = reinterpret_cast<HNode *>(saveInfo); CurrentNode = reinterpret_cast<HNode *>(saveInfo);
} }
void Input::endMapping() { void Input::endMapping() {
if (EC) if (EC)
return; return;
// CurrentNode can be null if the document is empty. // CurrentNode can be null if the document is empty.
MapHNode *MN = dyn_cast_or_null<MapHNode>(CurrentNode); MapHNode *MN = dyn_cast_if_present<MapHNode>(CurrentNode);
if (!MN) if (!MN)
return; return;
for (const auto &NN : MN->Mapping) { for (const auto &NN : MN->Mapping) {
if (!is_contained(MN->ValidKeys, NN.first())) { if (!is_contained(MN->ValidKeys, NN.first())) {
const SMRange &ReportLoc = NN.second.second; const SMRange &ReportLoc = NN.second.second;
if (!AllowUnknownKeys) { if (!AllowUnknownKeys) {
setError(ReportLoc, Twine("unknown key '") + NN.first() + "'"); setError(ReportLoc, Twine("unknown key '") + NN.first() + "'");
break; break;
▲ Show 20 Lines • Show All 208 Lines • ▼ Show 20 Lines for (Node &SN : *SQ) {
break; break;
SQHNode->Entries.push_back(std::move(Entry)); SQHNode->Entries.push_back(std::move(Entry));
} }
return std::move(SQHNode); return std::move(SQHNode);
} else if (MappingNode *Map = dyn_cast<MappingNode>(N)) { } else if (MappingNode *Map = dyn_cast<MappingNode>(N)) {
auto mapHNode = std::make_unique<MapHNode>(N); auto mapHNode = std::make_unique<MapHNode>(N);
for (KeyValueNode &KVN : *Map) { for (KeyValueNode &KVN : *Map) {
Node *KeyNode = KVN.getKey(); Node *KeyNode = KVN.getKey();
ScalarNode *Key = dyn_cast_or_null<ScalarNode>(KeyNode); ScalarNode *Key = dyn_cast_if_present<ScalarNode>(KeyNode);
Node *Value = KVN.getValue(); Node *Value = KVN.getValue();
if (!Key || !Value) { if (!Key || !Value) {
if (!Key) if (!Key)
setError(KeyNode, "Map key must be a scalar"); setError(KeyNode, "Map key must be a scalar");
if (!Value) if (!Value)
setError(KeyNode, "Map value must not be empty"); setError(KeyNode, "Map value must not be empty");
break; break;
} }
▲ Show 20 Lines • Show All 693 Lines • Show Last 20 Lines

llvm/lib/TableGen/Error.cpp

Show First 20 Lines • Show All 151 Lines • ▼ Show 20 Linesvoid PrintFatalError(const RecordVal *RecVal, const Twine &Msg) {
// The following call runs the file cleanup handlers. // The following call runs the file cleanup handlers.
sys::RunInterruptHandlers(); sys::RunInterruptHandlers();
std::exit(1); std::exit(1);
} }
// Check an assertion: Obtain the condition value and be sure it is true. // Check an assertion: Obtain the condition value and be sure it is true.
// If not, print a nonfatal error along with the message. // If not, print a nonfatal error along with the message.
void CheckAssert(SMLoc Loc, Init *Condition, Init *Message) { void CheckAssert(SMLoc Loc, Init *Condition, Init *Message) {
auto *CondValue = dyn_cast_or_null<IntInit>(Condition->convertInitializerTo( auto *CondValue =
dyn_cast_if_present<IntInit>(Condition->convertInitializerTo(
IntRecTy::get(Condition->getRecordKeeper()))); IntRecTy::get(Condition->getRecordKeeper())));
if (!CondValue) if (!CondValue)
PrintError(Loc, "assert condition must of type bit, bits, or int."); PrintError(Loc, "assert condition must of type bit, bits, or int.");
else if (!CondValue->getValue()) { else if (!CondValue->getValue()) {
PrintError(Loc, "assertion failed"); PrintError(Loc, "assertion failed");
if (auto *MessageInit = dyn_cast<StringInit>(Message)) if (auto *MessageInit = dyn_cast<StringInit>(Message))
PrintNote(MessageInit->getValue()); PrintNote(MessageInit->getValue());
else else
PrintNote("(assert message is not a string)"); PrintNote("(assert message is not a string)");
} }
} }
} // end namespace llvm } // end namespace llvm

llvm/lib/TableGen/Record.cpp

Show First 20 Lines • Show All 779 Lines • ▼ Show 20 LinesInit *UnOpInit::Fold(Record *CurRec, bool IsFinal) const {
case CAST: case CAST:
if (isa<StringRecTy>(getType())) { if (isa<StringRecTy>(getType())) {
if (StringInit *LHSs = dyn_cast<StringInit>(LHS)) if (StringInit *LHSs = dyn_cast<StringInit>(LHS))
return LHSs; return LHSs;
if (DefInit *LHSd = dyn_cast<DefInit>(LHS)) if (DefInit *LHSd = dyn_cast<DefInit>(LHS))
return StringInit::get(RK, LHSd->getAsString()); return StringInit::get(RK, LHSd->getAsString());
if (IntInit *LHSi = dyn_cast_or_null<IntInit>( if (IntInit *LHSi = dyn_cast_if_present<IntInit>(
LHS->convertInitializerTo(IntRecTy::get(RK)))) LHS->convertInitializerTo(IntRecTy::get(RK))))
return StringInit::get(RK, LHSi->getAsString()); return StringInit::get(RK, LHSi->getAsString());
} else if (isa<RecordRecTy>(getType())) { } else if (isa<RecordRecTy>(getType())) {
if (StringInit *Name = dyn_cast<StringInit>(LHS)) { if (StringInit *Name = dyn_cast<StringInit>(LHS)) {
if (!CurRec && !IsFinal) if (!CurRec && !IsFinal)
break; break;
assert(CurRec && "NULL pointer"); assert(CurRec && "NULL pointer");
Show All 30 Lines if (isa<StringRecTy>(getType())) {
} }
} }
if (Init *NewInit = LHS->convertInitializerTo(getType())) if (Init *NewInit = LHS->convertInitializerTo(getType()))
return NewInit; return NewInit;
break; break;
case NOT: case NOT:
if (IntInit *LHSi = dyn_cast_or_null<IntInit>( if (IntInit *LHSi = dyn_cast_if_present<IntInit>(
LHS->convertInitializerTo(IntRecTy::get(RK)))) LHS->convertInitializerTo(IntRecTy::get(RK))))
return IntInit::get(RK, LHSi->getValue() ? 0 : 1); return IntInit::get(RK, LHSi->getValue() ? 0 : 1);
break; break;
case HEAD: case HEAD:
if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) { if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) {
assert(!LHSl->empty() && "Empty list in head"); assert(!LHSl->empty() && "Empty list in head");
return LHSl->getElement(0); return LHSl->getElement(0);
▲ Show 20 Lines • Show All 125 Lines • ▼ Show 20 Linesstatic StringInit *interleaveStringList(const ListInit *List,
return StringInit::get(List->getRecordKeeper(), Result, Fmt); return StringInit::get(List->getRecordKeeper(), Result, Fmt);
} }
static StringInit *interleaveIntList(const ListInit *List, static StringInit *interleaveIntList(const ListInit *List,
const StringInit *Delim) { const StringInit *Delim) {
RecordKeeper &RK = List->getRecordKeeper(); RecordKeeper &RK = List->getRecordKeeper();
if (List->size() == 0) if (List->size() == 0)
return StringInit::get(RK, ""); return StringInit::get(RK, "");
IntInit *Element = dyn_cast_or_null<IntInit>( IntInit *Element = dyn_cast_if_present<IntInit>(
List->getElement(0)->convertInitializerTo(IntRecTy::get(RK))); List->getElement(0)->convertInitializerTo(IntRecTy::get(RK)));
if (!Element) if (!Element)
return nullptr; return nullptr;
SmallString<80> Result(Element->getAsString()); SmallString<80> Result(Element->getAsString());
for (unsigned I = 1, E = List->size(); I < E; ++I) { for (unsigned I = 1, E = List->size(); I < E; ++I) {
Result.append(Delim->getValue()); Result.append(Delim->getValue());
IntInit *Element = dyn_cast_or_null<IntInit>( IntInit *Element = dyn_cast_if_present<IntInit>(
List->getElement(I)->convertInitializerTo(IntRecTy::get(RK))); List->getElement(I)->convertInitializerTo(IntRecTy::get(RK)));
if (!Element) if (!Element)
return nullptr; return nullptr;
Result.append(Element->getAsString()); Result.append(Element->getAsString());
} }
return StringInit::get(RK, Result); return StringInit::get(RK, Result);
} }
▲ Show 20 Lines • Show All 101 Lines • ▼ Show 20 LinesInit *BinOpInit::Fold(Record *CurRec) const {
} }
case EQ: case EQ:
case NE: case NE:
case LE: case LE:
case LT: case LT:
case GE: case GE:
case GT: { case GT: {
// First see if we have two bit, bits, or int. // First see if we have two bit, bits, or int.
IntInit *LHSi = dyn_cast_or_null<IntInit>( IntInit *LHSi = dyn_cast_if_present<IntInit>(
LHS->convertInitializerTo(IntRecTy::get(getRecordKeeper()))); LHS->convertInitializerTo(IntRecTy::get(getRecordKeeper())));
IntInit *RHSi = dyn_cast_or_null<IntInit>( IntInit *RHSi = dyn_cast_if_present<IntInit>(
RHS->convertInitializerTo(IntRecTy::get(getRecordKeeper()))); RHS->convertInitializerTo(IntRecTy::get(getRecordKeeper())));
if (LHSi && RHSi) { if (LHSi && RHSi) {
bool Result; bool Result;
switch (getOpcode()) { switch (getOpcode()) {
case EQ: Result = LHSi->getValue() == RHSi->getValue(); break; case EQ: Result = LHSi->getValue() == RHSi->getValue(); break;
case NE: Result = LHSi->getValue() != RHSi->getValue(); break; case NE: Result = LHSi->getValue() != RHSi->getValue(); break;
case LE: Result = LHSi->getValue() <= RHSi->getValue(); break; case LE: Result = LHSi->getValue() <= RHSi->getValue(); break;
▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 LinesInit *BinOpInit::Fold(Record *CurRec) const {
case SUB: case SUB:
case MUL: case MUL:
case AND: case AND:
case OR: case OR:
case XOR: case XOR:
case SHL: case SHL:
case SRA: case SRA:
case SRL: { case SRL: {
IntInit *LHSi = dyn_cast_or_null<IntInit>( IntInit *LHSi = dyn_cast_if_present<IntInit>(
LHS->convertInitializerTo(IntRecTy::get(getRecordKeeper()))); LHS->convertInitializerTo(IntRecTy::get(getRecordKeeper())));
IntInit *RHSi = dyn_cast_or_null<IntInit>( IntInit *RHSi = dyn_cast_if_present<IntInit>(
RHS->convertInitializerTo(IntRecTy::get(getRecordKeeper()))); RHS->convertInitializerTo(IntRecTy::get(getRecordKeeper())));
if (LHSi && RHSi) { if (LHSi && RHSi) {
int64_t LHSv = LHSi->getValue(), RHSv = RHSi->getValue(); int64_t LHSv = LHSi->getValue(), RHSv = RHSi->getValue();
int64_t Result; int64_t Result;
switch (getOpcode()) { switch (getOpcode()) {
default: llvm_unreachable("Bad opcode!"); default: llvm_unreachable("Bad opcode!");
case ADD: Result = LHSv + RHSv; break; case ADD: Result = LHSv + RHSv; break;
case SUB: Result = LHSv - RHSv; break; case SUB: Result = LHSv - RHSv; break;
▲ Show 20 Lines • Show All 141 Lines • ▼ Show 20 Linesstatic Init *FilterHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,
if (ListInit *MHSl = dyn_cast<ListInit>(MHS)) { if (ListInit *MHSl = dyn_cast<ListInit>(MHS)) {
SmallVector<Init *, 8> NewList; SmallVector<Init *, 8> NewList;
for (Init *Item : MHSl->getValues()) { for (Init *Item : MHSl->getValues()) {
Init *Include = ItemApply(LHS, Item, RHS, CurRec); Init *Include = ItemApply(LHS, Item, RHS, CurRec);
if (!Include) if (!Include)
return nullptr; return nullptr;
if (IntInit *IncludeInt = if (IntInit *IncludeInt =
dyn_cast_or_null<IntInit>(Include->convertInitializerTo( dyn_cast_if_present<IntInit>(Include->convertInitializerTo(
IntRecTy::get(LHS->getRecordKeeper())))) { IntRecTy::get(LHS->getRecordKeeper())))) {
if (IncludeInt->getValue()) if (IncludeInt->getValue())
NewList.push_back(Item); NewList.push_back(Item);
} else { } else {
return nullptr; return nullptr;
} }
} }
return ListInit::get(NewList, cast<ListRecTy>(Type)->getElementType()); return ListInit::get(NewList, cast<ListRecTy>(Type)->getElementType());
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 LinesInit *TernOpInit::Fold(Record *CurRec) const {
case FILTER: { case FILTER: {
if (Init *Result = FilterHelper(LHS, MHS, RHS, getType(), CurRec)) if (Init *Result = FilterHelper(LHS, MHS, RHS, getType(), CurRec))
return Result; return Result;
break; break;
} }
case IF: { case IF: {
if (IntInit *LHSi = dyn_cast_or_null<IntInit>( if (IntInit *LHSi = dyn_cast_if_present<IntInit>(
LHS->convertInitializerTo(IntRecTy::get(RK)))) { LHS->convertInitializerTo(IntRecTy::get(RK)))) {
if (LHSi->getValue()) if (LHSi->getValue())
return MHS; return MHS;
return RHS; return RHS;
} }
break; break;
} }
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 LinesInit *TernOpInit::Fold(Record *CurRec) const {
return const_cast<TernOpInit *>(this); return const_cast<TernOpInit *>(this);
} }
Init *TernOpInit::resolveReferences(Resolver &R) const { Init *TernOpInit::resolveReferences(Resolver &R) const {
Init *lhs = LHS->resolveReferences(R); Init *lhs = LHS->resolveReferences(R);
if (getOpcode() == IF && lhs != LHS) { if (getOpcode() == IF && lhs != LHS) {
if (IntInit *Value = dyn_cast_or_null<IntInit>( if (IntInit *Value = dyn_cast_if_present<IntInit>(
lhs->convertInitializerTo(IntRecTy::get(getRecordKeeper())))) { lhs->convertInitializerTo(IntRecTy::get(getRecordKeeper())))) {
// Short-circuit // Short-circuit
if (Value->getValue()) if (Value->getValue())
return MHS->resolveReferences(R); return MHS->resolveReferences(R);
return RHS->resolveReferences(R); return RHS->resolveReferences(R);
} }
} }
▲ Show 20 Lines • Show All 661 Lines • ▼ Show 20 Lines
} }
Init *CondOpInit::Fold(Record *CurRec) const { Init *CondOpInit::Fold(Record *CurRec) const {
RecordKeeper &RK = getRecordKeeper(); RecordKeeper &RK = getRecordKeeper();
for ( unsigned i = 0; i < NumConds; ++i) { for ( unsigned i = 0; i < NumConds; ++i) {
Init *Cond = getCond(i); Init *Cond = getCond(i);
Init *Val = getVal(i); Init *Val = getVal(i);
if (IntInit *CondI = dyn_cast_or_null<IntInit>( if (IntInit *CondI = dyn_cast_if_present<IntInit>(
Cond->convertInitializerTo(IntRecTy::get(RK)))) { Cond->convertInitializerTo(IntRecTy::get(RK)))) {
if (CondI->getValue()) if (CondI->getValue())
return Val->convertInitializerTo(getValType()); return Val->convertInitializerTo(getValType());
} else { } else {
return const_cast<CondOpInit *>(this); return const_cast<CondOpInit *>(this);
} }
} }
▲ Show 20 Lines • Show All 806 Lines • Show Last 20 Lines

llvm/lib/TableGen/TGParser.cpp

Show First 20 Lines • Show All 689 Lines • ▼ Show 20 Lines
/// RangePiece ::= INTVAL INTVAL /// RangePiece ::= INTVAL INTVAL
// The last two forms are deprecated. // The last two forms are deprecated.
bool TGParser::ParseRangePiece(SmallVectorImpl<unsigned> &Ranges, bool TGParser::ParseRangePiece(SmallVectorImpl<unsigned> &Ranges,
TypedInit *FirstItem) { TypedInit *FirstItem) {
Init *CurVal = FirstItem; Init *CurVal = FirstItem;
if (!CurVal) if (!CurVal)
CurVal = ParseValue(nullptr); CurVal = ParseValue(nullptr);
IntInit *II = dyn_cast_or_null<IntInit>(CurVal); IntInit *II = dyn_cast_if_present<IntInit>(CurVal);
if (!II) if (!II)
return TokError("expected integer or bitrange"); return TokError("expected integer or bitrange");
int64_t Start = II->getValue(); int64_t Start = II->getValue();
int64_t End; int64_t End;
if (Start < 0) if (Start < 0)
return TokError("invalid range, cannot be negative"); return TokError("invalid range, cannot be negative");
switch (Lex.getCode()) { switch (Lex.getCode()) {
default: default:
Ranges.push_back(Start); Ranges.push_back(Start);
return false; return false;
case tgtok::dotdotdot: case tgtok::dotdotdot:
case tgtok::minus: { case tgtok::minus: {
Lex.Lex(); // eat Lex.Lex(); // eat
Init *I_End = ParseValue(nullptr); Init *I_End = ParseValue(nullptr);
IntInit *II_End = dyn_cast_or_null<IntInit>(I_End); IntInit *II_End = dyn_cast_if_present<IntInit>(I_End);
if (!II_End) { if (!II_End) {
TokError("expected integer value as end of range"); TokError("expected integer value as end of range");
return true; return true;
} }
End = II_End->getValue(); End = II_End->getValue();
break; break;
} }
▲ Show 20 Lines • Show All 3,136 Lines • Show Last 20 Lines

llvm/lib/Target/AArch64/AArch64ISelLowering.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 4,849 Lines • ▼ Show 20 LinesSDValue AArch64TargetLowering::LowerINTRINSIC_WO_CHAIN(SDValue Op,
case Intrinsic::eh_recoverfp: { case Intrinsic::eh_recoverfp: {
// FIXME: This needs to be implemented to correctly handle highly aligned // FIXME: This needs to be implemented to correctly handle highly aligned
// stack objects. For now we simply return the incoming FP. Refer D53541 // stack objects. For now we simply return the incoming FP. Refer D53541
// for more details. // for more details.
SDValue FnOp = Op.getOperand(1); SDValue FnOp = Op.getOperand(1);
SDValue IncomingFPOp = Op.getOperand(2); SDValue IncomingFPOp = Op.getOperand(2);
GlobalAddressSDNode *GSD = dyn_cast<GlobalAddressSDNode>(FnOp); GlobalAddressSDNode *GSD = dyn_cast<GlobalAddressSDNode>(FnOp);
auto *Fn = dyn_cast_or_null<Function>(GSD ? GSD->getGlobal() : nullptr); auto *Fn = dyn_cast_if_present<Function>(GSD ? GSD->getGlobal() : nullptr);
if (!Fn) if (!Fn)
report_fatal_error( report_fatal_error(
"llvm.eh.recoverfp must take a function as the first argument"); "llvm.eh.recoverfp must take a function as the first argument");
return IncomingFPOp; return IncomingFPOp;
} }
case Intrinsic::aarch64_neon_vsri: case Intrinsic::aarch64_neon_vsri:
case Intrinsic::aarch64_neon_vsli: { case Intrinsic::aarch64_neon_vsli: {
▲ Show 20 Lines • Show All 13,014 Lines • ▼ Show 20 Lines if (Index.getOpcode() == ISD::STEP_VECTOR) {
Stride = cast<ConstantSDNode>(Index.getOperand(0))->getSExtValue(); Stride = cast<ConstantSDNode>(Index.getOperand(0))->getSExtValue();
} }
// Match: // Match:
// Index = step(const) << shift(const) // Index = step(const) << shift(const)
else if (Index.getOpcode() == ISD::SHL && else if (Index.getOpcode() == ISD::SHL &&
Index.getOperand(0).getOpcode() == ISD::STEP_VECTOR) { Index.getOperand(0).getOpcode() == ISD::STEP_VECTOR) {
SDValue RHS = Index.getOperand(1); SDValue RHS = Index.getOperand(1);
if (auto *Shift = if (auto *Shift =
dyn_cast_or_null<ConstantSDNode>(DAG.getSplatValue(RHS))) { dyn_cast_if_present<ConstantSDNode>(DAG.getSplatValue(RHS))) {
int64_t Step = (int64_t)Index.getOperand(0).getConstantOperandVal(1); int64_t Step = (int64_t)Index.getOperand(0).getConstantOperandVal(1);
Stride = Step << Shift->getZExtValue(); Stride = Step << Shift->getZExtValue();
} }
} }
// Return early because no supported pattern is found. // Return early because no supported pattern is found.
if (Stride == 0) if (Stride == 0)
return Changed; return Changed;
▲ Show 20 Lines • Show All 4,335 Lines • Show Last 20 Lines

llvm/lib/Target/AArch64/AArch64TargetTransformInfo.cpp

Show First 20 Lines • Show All 700 Lines • ▼ Show 20 Linesstatic Optional<Instruction *> instCombineSVECmpNE(InstCombiner &IC,
const auto PTruePattern = const auto PTruePattern =
cast<ConstantInt>(Pg->getOperand(0))->getZExtValue(); cast<ConstantInt>(Pg->getOperand(0))->getZExtValue();
if (PTruePattern != AArch64SVEPredPattern::all) if (PTruePattern != AArch64SVEPredPattern::all)
return None; return None;
// Check that we have a compare of zero.. // Check that we have a compare of zero..
auto *SplatValue = auto *SplatValue =
dyn_cast_or_null<ConstantInt>(getSplatValue(II.getArgOperand(2))); dyn_cast_if_present<ConstantInt>(getSplatValue(II.getArgOperand(2)));
if (!SplatValue || !SplatValue->isZero()) if (!SplatValue || !SplatValue->isZero())
return None; return None;
// ..against a dupq // ..against a dupq
auto *DupQLane = dyn_cast<IntrinsicInst>(II.getArgOperand(1)); auto *DupQLane = dyn_cast<IntrinsicInst>(II.getArgOperand(1));
if (!DupQLane || if (!DupQLane ||
DupQLane->getIntrinsicID() != Intrinsic::aarch64_sve_dupq_lane) DupQLane->getIntrinsicID() != Intrinsic::aarch64_sve_dupq_lane)
return None; return None;
▲ Show 20 Lines • Show All 456 Lines • ▼ Show 20 Lines
static Optional<Instruction *> instCombineSVETBL(InstCombiner &IC, static Optional<Instruction *> instCombineSVETBL(InstCombiner &IC,
IntrinsicInst &II) { IntrinsicInst &II) {
auto *OpVal = II.getOperand(0); auto *OpVal = II.getOperand(0);
auto *OpIndices = II.getOperand(1); auto *OpIndices = II.getOperand(1);
VectorType *VTy = cast<VectorType>(II.getType()); VectorType *VTy = cast<VectorType>(II.getType());
// Check whether OpIndices is a constant splat value < minimal element count // Check whether OpIndices is a constant splat value < minimal element count
// of result. // of result.
auto *SplatValue = dyn_cast_or_null<ConstantInt>(getSplatValue(OpIndices)); auto *SplatValue = dyn_cast_if_present<ConstantInt>(getSplatValue(OpIndices));
if (!SplatValue || if (!SplatValue ||
SplatValue->getValue().uge(VTy->getElementCount().getKnownMinValue())) SplatValue->getValue().uge(VTy->getElementCount().getKnownMinValue()))
return None; return None;
// Convert sve_tbl(OpVal sve_dup_x(SplatValue)) to // Convert sve_tbl(OpVal sve_dup_x(SplatValue)) to
// splat_vector(extractelement(OpVal, SplatValue)) for further optimization. // splat_vector(extractelement(OpVal, SplatValue)) for further optimization.
IRBuilder<> Builder(II.getContext()); IRBuilder<> Builder(II.getContext());
Builder.SetInsertPoint(&II); Builder.SetInsertPoint(&II);
▲ Show 20 Lines • Show All 117 Lines • ▼ Show 20 Linesstatic Optional<Instruction *> instCombineSVESDIV(InstCombiner &IC,
IRBuilder<> Builder(II.getContext()); IRBuilder<> Builder(II.getContext());
Builder.SetInsertPoint(&II); Builder.SetInsertPoint(&II);
Type *Int32Ty = Builder.getInt32Ty(); Type *Int32Ty = Builder.getInt32Ty();
Value *Pred = II.getOperand(0); Value *Pred = II.getOperand(0);
Value *Vec = II.getOperand(1); Value *Vec = II.getOperand(1);
Value *DivVec = II.getOperand(2); Value *DivVec = II.getOperand(2);
Value *SplatValue = getSplatValue(DivVec); Value *SplatValue = getSplatValue(DivVec);
ConstantInt *SplatConstantInt = dyn_cast_or_null<ConstantInt>(SplatValue); ConstantInt *SplatConstantInt = dyn_cast_if_present<ConstantInt>(SplatValue);
if (!SplatConstantInt) if (!SplatConstantInt)
return None; return None;
APInt Divisor = SplatConstantInt->getValue(); APInt Divisor = SplatConstantInt->getValue();
if (Divisor.isPowerOf2()) { if (Divisor.isPowerOf2()) {
Constant *DivisorLog2 = ConstantInt::get(Int32Ty, Divisor.logBase2()); Constant *DivisorLog2 = ConstantInt::get(Int32Ty, Divisor.logBase2());
auto ASRD = Builder.CreateIntrinsic( auto ASRD = Builder.CreateIntrinsic(
Intrinsic::aarch64_sve_asrd, {II.getType()}, {Pred, Vec, DivisorLog2}); Intrinsic::aarch64_sve_asrd, {II.getType()}, {Pred, Vec, DivisorLog2});
▲ Show 20 Lines • Show All 1,767 Lines • Show Last 20 Lines

llvm/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp

Show First 20 Lines • Show All 4,415 Lines • ▼ Show 20 Linesbool AArch64AsmParser::parseOperand(OperandVector &Operands, bool isCondCode,
} }
} }
bool AArch64AsmParser::parseImmExpr(int64_t &Out) { bool AArch64AsmParser::parseImmExpr(int64_t &Out) {
const MCExpr *Expr = nullptr; const MCExpr *Expr = nullptr;
SMLoc L = getLoc(); SMLoc L = getLoc();
if (check(getParser().parseExpression(Expr), L, "expected expression")) if (check(getParser().parseExpression(Expr), L, "expected expression"))
return true; return true;
const MCConstantExpr *Value = dyn_cast_or_null<MCConstantExpr>(Expr); const MCConstantExpr *Value = dyn_cast_if_present<MCConstantExpr>(Expr);
if (check(!Value, L, "expected constant expression")) if (check(!Value, L, "expected constant expression"))
return true; return true;
Out = Value->getValue(); Out = Value->getValue();
return false; return false;
} }
bool AArch64AsmParser::parseComma() { bool AArch64AsmParser::parseComma() {
if (check(getTok().isNot(AsmToken::Comma), getLoc(), "expected comma")) if (check(getTok().isNot(AsmToken::Comma), getLoc(), "expected comma"))
▲ Show 20 Lines • Show All 1,906 Lines • ▼ Show 20 Linesbool AArch64AsmParser::parseDirectiveInst(SMLoc Loc) {
if (getLexer().is(AsmToken::EndOfStatement)) if (getLexer().is(AsmToken::EndOfStatement))
return Error(Loc, "expected expression following '.inst' directive"); return Error(Loc, "expected expression following '.inst' directive");
auto parseOp = [&]() -> bool { auto parseOp = [&]() -> bool {
SMLoc L = getLoc(); SMLoc L = getLoc();
const MCExpr *Expr = nullptr; const MCExpr *Expr = nullptr;
if (check(getParser().parseExpression(Expr), L, "expected expression")) if (check(getParser().parseExpression(Expr), L, "expected expression"))
return true; return true;
const MCConstantExpr *Value = dyn_cast_or_null<MCConstantExpr>(Expr); const MCConstantExpr *Value = dyn_cast_if_present<MCConstantExpr>(Expr);
if (check(!Value, L, "expected constant expression")) if (check(!Value, L, "expected constant expression"))
return true; return true;
getTargetStreamer().emitInst(Value->getValue()); getTargetStreamer().emitInst(Value->getValue());
return false; return false;
}; };
return parseMany(parseOp); return parseMany(parseOp);
} }
▲ Show 20 Lines • Show All 740 Lines • Show Last 20 Lines

llvm/lib/Target/AMDGPU/AMDGPULibCalls.cpp

Show First 20 Lines • Show All 820 Lines • ▼ Show 20 Lines if (getVecSize(FInfo) == 1) {
CINT = dyn_cast<ConstantInt>(opr1); CINT = dyn_cast<ConstantInt>(opr1);
} else { } else {
VectorType *VTy = dyn_cast<VectorType>(opr0->getType()); VectorType *VTy = dyn_cast<VectorType>(opr0->getType());
assert(VTy && "Oprand of vector function should be of vectortype"); assert(VTy && "Oprand of vector function should be of vectortype");
eltType = VTy->getElementType(); eltType = VTy->getElementType();
ConstantDataVector *CDV = dyn_cast<ConstantDataVector>(opr1); ConstantDataVector *CDV = dyn_cast<ConstantDataVector>(opr1);
// Now, only Handle vector const whose elements have the same value. // Now, only Handle vector const whose elements have the same value.
CF = CDV ? dyn_cast_or_null<ConstantFP>(CDV->getSplatValue()) : nullptr; CF = CDV ? dyn_cast_if_present<ConstantFP>(CDV->getSplatValue()) : nullptr;
CINT = CDV ? dyn_cast_or_null<ConstantInt>(CDV->getSplatValue()) : nullptr; CINT =
CDV ? dyn_cast_if_present<ConstantInt>(CDV->getSplatValue()) : nullptr;
} }
// No unsafe math , no constant argument, do nothing // No unsafe math , no constant argument, do nothing
if (!isUnsafeMath(CI) && !CF && !CINT && !CZero) if (!isUnsafeMath(CI) && !CF && !CINT && !CZero)
return false; return false;
// 0x1111111 means that we don't do anything for this call. // 0x1111111 means that we don't do anything for this call.
int ci_opr1 = (CINT ? (int)CINT->getSExtValue() : 0x1111111); int ci_opr1 = (CINT ? (int)CINT->getSExtValue() : 0x1111111);
▲ Show 20 Lines • Show All 404 Lines • ▼ Show 20 Linesbool AMDGPULibCalls::fold_sincos(CallInst *CI, IRBuilder<> &B,
} }
Module *M = CI->getModule(); Module *M = CI->getModule();
fInfo.setId(isSin ? AMDGPULibFunc::EI_COS : AMDGPULibFunc::EI_SIN); fInfo.setId(isSin ? AMDGPULibFunc::EI_COS : AMDGPULibFunc::EI_SIN);
std::string const PairName = fInfo.mangle(); std::string const PairName = fInfo.mangle();
CallInst *UI = nullptr; CallInst *UI = nullptr;
for (User* U : CArgVal->users()) { for (User* U : CArgVal->users()) {
CallInst *XI = dyn_cast_or_null<CallInst>(U); CallInst *XI = dyn_cast_if_present<CallInst>(U);
if (!XI || XI == CI || XI->getParent() != CBB) if (!XI || XI == CI || XI->getParent() != CBB)
continue; continue;
Function *UCallee = XI->getCalledFunction(); Function *UCallee = XI->getCalledFunction();
if (!UCallee || !UCallee->getName().equals(PairName)) if (!UCallee || !UCallee->getName().equals(PairName))
continue; continue;
BasicBlock::iterator BBI = CI->getIterator(); BasicBlock::iterator BBI = CI->getIterator();
▲ Show 20 Lines • Show All 102 Lines • ▼ Show 20 Lines
bool AMDGPULibCalls::evaluateScalarMathFunc(const FuncInfo &FInfo, bool AMDGPULibCalls::evaluateScalarMathFunc(const FuncInfo &FInfo,
double& Res0, double& Res1, double& Res0, double& Res1,
Constant *copr0, Constant *copr1, Constant *copr0, Constant *copr1,
Constant *copr2) { Constant *copr2) {
// By default, opr0/opr1/opr3 holds values of float/double type. // By default, opr0/opr1/opr3 holds values of float/double type.
// If they are not float/double, each function has to its // If they are not float/double, each function has to its
// operand separately. // operand separately.
double opr0=0.0, opr1=0.0, opr2=0.0; double opr0 = 0.0, opr1 = 0.0, opr2 = 0.0;
ConstantFP *fpopr0 = dyn_cast_or_null<ConstantFP>(copr0); ConstantFP *fpopr0 = dyn_cast_if_present<ConstantFP>(copr0);
ConstantFP *fpopr1 = dyn_cast_or_null<ConstantFP>(copr1); ConstantFP *fpopr1 = dyn_cast_if_present<ConstantFP>(copr1);
ConstantFP *fpopr2 = dyn_cast_or_null<ConstantFP>(copr2); ConstantFP *fpopr2 = dyn_cast_if_present<ConstantFP>(copr2);
if (fpopr0) { if (fpopr0) {
opr0 = (getArgType(FInfo) == AMDGPULibFunc::F64) opr0 = (getArgType(FInfo) == AMDGPULibFunc::F64)
? fpopr0->getValueAPF().convertToDouble() ? fpopr0->getValueAPF().convertToDouble()
: (double)fpopr0->getValueAPF().convertToFloat(); : (double)fpopr0->getValueAPF().convertToFloat();
} }
if (fpopr1) { if (fpopr1) {
opr1 = (getArgType(FInfo) == AMDGPULibFunc::F64) opr1 = (getArgType(FInfo) == AMDGPULibFunc::F64)
? fpopr1->getValueAPF().convertToDouble() ? fpopr1->getValueAPF().convertToDouble()
: (double)fpopr1->getValueAPF().convertToFloat(); : (double)fpopr1->getValueAPF().convertToFloat();
} }
if (fpopr2) { if (fpopr2) {
opr2 = (getArgType(FInfo) == AMDGPULibFunc::F64) opr2 = (getArgType(FInfo) == AMDGPULibFunc::F64)
? fpopr2->getValueAPF().convertToDouble() ? fpopr2->getValueAPF().convertToDouble()
: (double)fpopr2->getValueAPF().convertToFloat(); : (double)fpopr2->getValueAPF().convertToFloat();
} }
▲ Show 20 Lines • Show All 125 Lines • ▼ Show 20 Lines case AMDGPULibFunc::EI_DIVIDE:
return true; return true;
case AMDGPULibFunc::EI_POW: case AMDGPULibFunc::EI_POW:
case AMDGPULibFunc::EI_POWR: case AMDGPULibFunc::EI_POWR:
Res0 = pow(opr0, opr1); Res0 = pow(opr0, opr1);
return true; return true;
case AMDGPULibFunc::EI_POWN: { case AMDGPULibFunc::EI_POWN: {
if (ConstantInt *iopr1 = dyn_cast_or_null<ConstantInt>(copr1)) { if (ConstantInt *iopr1 = dyn_cast_if_present<ConstantInt>(copr1)) {
double val = (double)iopr1->getSExtValue(); double val = (double)iopr1->getSExtValue();
Res0 = pow(opr0, val); Res0 = pow(opr0, val);
return true; return true;
} }
return false; return false;
} }
case AMDGPULibFunc::EI_ROOTN: { case AMDGPULibFunc::EI_ROOTN: {
if (ConstantInt *iopr1 = dyn_cast_or_null<ConstantInt>(copr1)) { if (ConstantInt *iopr1 = dyn_cast_if_present<ConstantInt>(copr1)) {
double val = (double)iopr1->getSExtValue(); double val = (double)iopr1->getSExtValue();
Res0 = pow(opr0, 1.0 / val); Res0 = pow(opr0, 1.0 / val);
return true; return true;
} }
return false; return false;
} }
// with ptr arg // with ptr arg
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Linesbool AMDGPULibCalls::evaluateCall(CallInst *aCI, const FuncInfo &FInfo) {
int FuncVecSize = getVecSize(FInfo); int FuncVecSize = getVecSize(FInfo);
bool hasTwoResults = (FInfo.getId() == AMDGPULibFunc::EI_SINCOS); bool hasTwoResults = (FInfo.getId() == AMDGPULibFunc::EI_SINCOS);
if (FuncVecSize == 1) { if (FuncVecSize == 1) {
if (!evaluateScalarMathFunc(FInfo, DVal0[0], if (!evaluateScalarMathFunc(FInfo, DVal0[0],
DVal1[0], copr0, copr1, copr2)) { DVal1[0], copr0, copr1, copr2)) {
return false; return false;
} }
} else { } else {
ConstantDataVector *CDV0 = dyn_cast_or_null<ConstantDataVector>(copr0); ConstantDataVector *CDV0 = dyn_cast_if_present<ConstantDataVector>(copr0);
ConstantDataVector *CDV1 = dyn_cast_or_null<ConstantDataVector>(copr1); ConstantDataVector *CDV1 = dyn_cast_if_present<ConstantDataVector>(copr1);
ConstantDataVector *CDV2 = dyn_cast_or_null<ConstantDataVector>(copr2); ConstantDataVector *CDV2 = dyn_cast_if_present<ConstantDataVector>(copr2);
for (int i = 0; i < FuncVecSize; ++i) { for (int i = 0; i < FuncVecSize; ++i) {
Constant *celt0 = CDV0 ? CDV0->getElementAsConstant(i) : nullptr; Constant *celt0 = CDV0 ? CDV0->getElementAsConstant(i) : nullptr;
Constant *celt1 = CDV1 ? CDV1->getElementAsConstant(i) : nullptr; Constant *celt1 = CDV1 ? CDV1->getElementAsConstant(i) : nullptr;
Constant *celt2 = CDV2 ? CDV2->getElementAsConstant(i) : nullptr; Constant *celt2 = CDV2 ? CDV2->getElementAsConstant(i) : nullptr;
if (!evaluateScalarMathFunc(FInfo, DVal0[i], if (!evaluateScalarMathFunc(FInfo, DVal0[i], DVal1[i], celt0, celt1,
DVal1[i], celt0, celt1, celt2)) { celt2)) {
return false; return false;
} }
} }
} }
LLVMContext &context = CI->getParent()->getParent()->getContext(); LLVMContext &context = CI->getParent()->getParent()->getContext();
Constant *nval0, *nval1; Constant *nval0, *nval1;
if (FuncVecSize == 1) { if (FuncVecSize == 1) {
▲ Show 20 Lines • Show All 165 Lines • Show Last 20 Lines

llvm/lib/Target/AMDGPU/AMDGPULibFunc.cpp

Show First 20 Lines • Show All 940 Lines • ▼ Show 20 Linesstd::string AMDGPUMangledLibFunc::getName() const {
SmallString<128> Buf; SmallString<128> Buf;
raw_svector_ostream OS(Buf); raw_svector_ostream OS(Buf);
writeName(OS); writeName(OS);
return std::string(OS.str()); return std::string(OS.str());
} }
Function *AMDGPULibFunc::getFunction(Module *M, const AMDGPULibFunc &fInfo) { Function *AMDGPULibFunc::getFunction(Module *M, const AMDGPULibFunc &fInfo) {
std::string FuncName = fInfo.mangle(); std::string FuncName = fInfo.mangle();
Function *F = dyn_cast_or_null<Function>( Function *F =
M->getValueSymbolTable().lookup(FuncName)); dyn_cast_if_present<Function>(M->getValueSymbolTable().lookup(FuncName));
// check formal with actual types conformance // check formal with actual types conformance
if (F && !F->isDeclaration() if (F && !F->isDeclaration()
&& !F->isVarArg() && !F->isVarArg()
&& F->arg_size() == fInfo.getNumArgs()) { && F->arg_size() == fInfo.getNumArgs()) {
return F; return F;
} }
return nullptr; return nullptr;
} }
FunctionCallee AMDGPULibFunc::getOrInsertFunction(Module *M, FunctionCallee AMDGPULibFunc::getOrInsertFunction(Module *M,
const AMDGPULibFunc &fInfo) { const AMDGPULibFunc &fInfo) {
std::string const FuncName = fInfo.mangle(); std::string const FuncName = fInfo.mangle();
Function *F = dyn_cast_or_null<Function>( Function *F =
M->getValueSymbolTable().lookup(FuncName)); dyn_cast_if_present<Function>(M->getValueSymbolTable().lookup(FuncName));
// check formal with actual types conformance // check formal with actual types conformance
if (F && !F->isDeclaration() if (F && !F->isDeclaration()
&& !F->isVarArg() && !F->isVarArg()
&& F->arg_size() == fInfo.getNumArgs()) { && F->arg_size() == fInfo.getNumArgs()) {
return F; return F;
} }
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

llvm/lib/Target/AMDGPU/AMDGPUPerfHintAnalysis.cpp

Show First 20 Lines • Show All 252 Lines • ▼ Show 20 Lines for (auto &I : B) {
FI.MemInstCost += Loc->second.MemInstCost; FI.MemInstCost += Loc->second.MemInstCost;
FI.InstCost += Loc->second.InstCost; FI.InstCost += Loc->second.InstCost;
FI.IAMInstCost += Loc->second.IAMInstCost; FI.IAMInstCost += Loc->second.IAMInstCost;
FI.LSMInstCost += Loc->second.LSMInstCost; FI.LSMInstCost += Loc->second.LSMInstCost;
} else if (auto *GEP = dyn_cast<GetElementPtrInst>(&I)) { } else if (auto *GEP = dyn_cast<GetElementPtrInst>(&I)) {
TargetLoweringBase::AddrMode AM; TargetLoweringBase::AddrMode AM;
auto *Ptr = GetPointerBaseWithConstantOffset(GEP, AM.BaseOffs, *DL); auto *Ptr = GetPointerBaseWithConstantOffset(GEP, AM.BaseOffs, *DL);
AM.BaseGV = dyn_cast_or_null<GlobalValue>(const_cast<Value *>(Ptr)); AM.BaseGV = dyn_cast_if_present<GlobalValue>(const_cast<Value *>(Ptr));
AM.HasBaseReg = !AM.BaseGV; AM.HasBaseReg = !AM.BaseGV;
if (TLI->isLegalAddressingMode(*DL, AM, GEP->getResultElementType(), if (TLI->isLegalAddressingMode(*DL, AM, GEP->getResultElementType(),
GEP->getPointerAddressSpace())) GEP->getPointerAddressSpace()))
// Offset will likely be folded into load or store // Offset will likely be folded into load or store
continue; continue;
++FI.InstCost; ++FI.InstCost;
} else { } else {
++FI.InstCost; ++FI.InstCost;
▲ Show 20 Lines • Show All 161 Lines • Show Last 20 Lines

llvm/lib/Target/AMDGPU/AMDGPUTargetTransformInfo.cpp

Show First 20 Lines • Show All 729 Lines • ▼ Show 20 LinesInstructionCost GCNTTIImpl::getCFInstrCost(unsigned Opcode,
assert((I == nullptr || I->getOpcode() == Opcode) && assert((I == nullptr || I->getOpcode() == Opcode) &&
"Opcode should reflect passed instruction."); "Opcode should reflect passed instruction.");
const bool SCost = const bool SCost =
(CostKind == TTI::TCK_CodeSize || CostKind == TTI::TCK_SizeAndLatency); (CostKind == TTI::TCK_CodeSize || CostKind == TTI::TCK_SizeAndLatency);
const int CBrCost = SCost ? 5 : 7; const int CBrCost = SCost ? 5 : 7;
switch (Opcode) { switch (Opcode) {
case Instruction::Br: { case Instruction::Br: {
// Branch instruction takes about 4 slots on gfx900. // Branch instruction takes about 4 slots on gfx900.
auto BI = dyn_cast_or_null<BranchInst>(I); auto BI = dyn_cast_if_present<BranchInst>(I);
if (BI && BI->isUnconditional()) if (BI && BI->isUnconditional())
return SCost ? 1 : 4; return SCost ? 1 : 4;
// Suppose conditional branch takes additional 3 exec manipulations // Suppose conditional branch takes additional 3 exec manipulations
// instructions in average. // instructions in average.
return CBrCost; return CBrCost;
} }
case Instruction::Switch: { case Instruction::Switch: {
auto SI = dyn_cast_or_null<SwitchInst>(I); auto SI = dyn_cast_if_present<SwitchInst>(I);
// Each case (including default) takes 1 cmp + 1 cbr instructions in // Each case (including default) takes 1 cmp + 1 cbr instructions in
// average. // average.
return (SI ? (SI->getNumCases() + 1) : 4) * (CBrCost + 1); return (SI ? (SI->getNumCases() + 1) : 4) * (CBrCost + 1);
} }
case Instruction::Ret: case Instruction::Ret:
return SCost ? 1 : 10; return SCost ? 1 : 10;
} }
return BaseT::getCFInstrCost(Opcode, CostKind, I); return BaseT::getCFInstrCost(Opcode, CostKind, I);
▲ Show 20 Lines • Show All 457 Lines • Show Last 20 Lines

llvm/lib/Target/AMDGPU/R600OpenCLImageTypeLoweringPass.cpp

Show First 20 Lines • Show All 83 Lines • ▼ Show 20 LinesGetFunctionFromMDNode(MDNode *Node) {
auto F = mdconst::dyn_extract<Function>(Node->getOperand(0)); auto F = mdconst::dyn_extract<Function>(Node->getOperand(0));
if (!F) if (!F)
return nullptr; return nullptr;
// Validation checks. // Validation checks.
size_t ExpectNumArgNodeOps = F->arg_size() + 1; size_t ExpectNumArgNodeOps = F->arg_size() + 1;
for (size_t i = 0; i < NumKernelArgMDNodes; ++i) { for (size_t i = 0; i < NumKernelArgMDNodes; ++i) {
MDNode *ArgNode = dyn_cast_or_null<MDNode>(Node->getOperand(i + 1)); MDNode *ArgNode = dyn_cast_if_present<MDNode>(Node->getOperand(i + 1));
if (ArgNode->getNumOperands() != ExpectNumArgNodeOps) if (ArgNode->getNumOperands() != ExpectNumArgNodeOps)
return nullptr; return nullptr;
if (!ArgNode->getOperand(0)) if (!ArgNode->getOperand(0))
return nullptr; return nullptr;
// FIXME: It should be possible to do image lowering when some metadata // FIXME: It should be possible to do image lowering when some metadata
// args missing or not in the expected order. // args missing or not in the expected order.
MDString *StringNode = dyn_cast<MDString>(ArgNode->getOperand(0)); MDString *StringNode = dyn_cast<MDString>(ArgNode->getOperand(0));
▲ Show 20 Lines • Show All 274 Lines • Show Last 20 Lines

llvm/lib/Target/ARM/ARMConstantPoolValue.cpp

Show First 20 Lines • Show All 175 Lines • ▼ Show 20 LinesARMConstantPoolConstant::Create(const Constant *C, unsigned ID,
ARMCP::ARMCPKind Kind, unsigned char PCAdj, ARMCP::ARMCPKind Kind, unsigned char PCAdj,
ARMCP::ARMCPModifier Modifier, ARMCP::ARMCPModifier Modifier,
bool AddCurrentAddress) { bool AddCurrentAddress) {
return new ARMConstantPoolConstant(C, ID, Kind, PCAdj, Modifier, return new ARMConstantPoolConstant(C, ID, Kind, PCAdj, Modifier,
AddCurrentAddress); AddCurrentAddress);
} }
const GlobalValue *ARMConstantPoolConstant::getGV() const { const GlobalValue *ARMConstantPoolConstant::getGV() const {
return dyn_cast_or_null<GlobalValue>(CVal); return dyn_cast_if_present<GlobalValue>(CVal);
} }
const BlockAddress *ARMConstantPoolConstant::getBlockAddress() const { const BlockAddress *ARMConstantPoolConstant::getBlockAddress() const {
return dyn_cast_or_null<BlockAddress>(CVal); return dyn_cast_if_present<BlockAddress>(CVal);
} }
int ARMConstantPoolConstant::getExistingMachineCPValue(MachineConstantPool *CP, int ARMConstantPoolConstant::getExistingMachineCPValue(MachineConstantPool *CP,
Align Alignment) { Align Alignment) {
int index = int index =
getExistingMachineCPValueImpl<ARMConstantPoolConstant>(CP, Alignment); getExistingMachineCPValueImpl<ARMConstantPoolConstant>(CP, Alignment);
if (index != -1) { if (index != -1) {
auto *CPV = static_cast<ARMConstantPoolValue*>( auto *CPV = static_cast<ARMConstantPoolValue*>(
▲ Show 20 Lines • Show All 102 Lines • Show Last 20 Lines

llvm/lib/Target/ARM/ARMTargetTransformInfo.cpp

Show First 20 Lines • Show All 1,005 Lines • ▼ Show 20 Lines if (ST->hasNEON() && ValTy->isVectorTy() && ISD == ISD::SELECT && CondTy) {
std::pair<InstructionCost, MVT> LT = getTypeLegalizationCost(ValTy); std::pair<InstructionCost, MVT> LT = getTypeLegalizationCost(ValTy);
return LT.first; return LT.first;
} }
if (ST->hasMVEIntegerOps() && ValTy->isVectorTy() && if (ST->hasMVEIntegerOps() && ValTy->isVectorTy() &&
(Opcode == Instruction::ICmp || Opcode == Instruction::FCmp) && (Opcode == Instruction::ICmp || Opcode == Instruction::FCmp) &&
cast<FixedVectorType>(ValTy)->getNumElements() > 1) { cast<FixedVectorType>(ValTy)->getNumElements() > 1) {
FixedVectorType *VecValTy = cast<FixedVectorType>(ValTy); FixedVectorType *VecValTy = cast<FixedVectorType>(ValTy);
FixedVectorType *VecCondTy = dyn_cast_or_null<FixedVectorType>(CondTy); FixedVectorType *VecCondTy = dyn_cast_if_present<FixedVectorType>(CondTy);
if (!VecCondTy) if (!VecCondTy)
VecCondTy = cast<FixedVectorType>(CmpInst::makeCmpResultType(VecValTy)); VecCondTy = cast<FixedVectorType>(CmpInst::makeCmpResultType(VecValTy));
// If we don't have mve.fp any fp operations will need to be scalarized. // If we don't have mve.fp any fp operations will need to be scalarized.
if (Opcode == Instruction::FCmp && !ST->hasMVEFloatOps()) { if (Opcode == Instruction::FCmp && !ST->hasMVEFloatOps()) {
// One scalaization insert, one scalarization extract and the cost of the // One scalaization insert, one scalarization extract and the cost of the
// fcmps. // fcmps.
return BaseT::getScalarizationOverhead(VecValTy, false, true) + return BaseT::getScalarizationOverhead(VecValTy, false, true) +
▲ Show 20 Lines • Show All 1,410 Lines • Show Last 20 Lines

llvm/lib/Target/ARM/AsmParser/ARMAsmParser.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 6,328 Lines • ▼ Show 20 Linesbool ARMAsmParser::parseOperand(OperandVector &Operands, StringRef Mnemonic) {
} }
} }
bool ARMAsmParser::parseImmExpr(int64_t &Out) { bool ARMAsmParser::parseImmExpr(int64_t &Out) {
const MCExpr *Expr = nullptr; const MCExpr *Expr = nullptr;
SMLoc L = getParser().getTok().getLoc(); SMLoc L = getParser().getTok().getLoc();
if (check(getParser().parseExpression(Expr), L, "expected expression")) if (check(getParser().parseExpression(Expr), L, "expected expression"))
return true; return true;
const MCConstantExpr *Value = dyn_cast_or_null<MCConstantExpr>(Expr); const MCConstantExpr *Value = dyn_cast_if_present<MCConstantExpr>(Expr);
if (check(!Value, L, "expected constant expression")) if (check(!Value, L, "expected constant expression"))
return true; return true;
Out = Value->getValue(); Out = Value->getValue();
return false; return false;
} }
// parsePrefix - Parse ARM 16-bit relocations expression prefix, i.e. // parsePrefix - Parse ARM 16-bit relocations expression prefix, i.e.
// :lower16: and :upper16:. // :lower16: and :upper16:.
▲ Show 20 Lines • Show All 5,422 Lines • ▼ Show 20 Lines if (isThumb()) {
if (Suffix) if (Suffix)
return Error(Loc, "width suffixes are invalid in ARM mode"); return Error(Loc, "width suffixes are invalid in ARM mode");
} }
auto parseOne = [&]() -> bool { auto parseOne = [&]() -> bool {
const MCExpr *Expr; const MCExpr *Expr;
if (getParser().parseExpression(Expr)) if (getParser().parseExpression(Expr))
return true; return true;
const MCConstantExpr *Value = dyn_cast_or_null<MCConstantExpr>(Expr); const MCConstantExpr *Value = dyn_cast_if_present<MCConstantExpr>(Expr);
if (!Value) { if (!Value) {
return Error(Loc, "expected constant expression"); return Error(Loc, "expected constant expression");
} }
char CurSuffix = Suffix; char CurSuffix = Suffix;
switch (Width) { switch (Width) {
case 2: case 2:
if (Value->getValue() > 0xffff) if (Value->getValue() > 0xffff)
▲ Show 20 Lines • Show All 901 Lines • Show Last 20 Lines

llvm/lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp

Show First 20 Lines • Show All 557 Lines • ▼ Show 20 Lines void FlushPendingMappingSymbol() {
EmitMappingSymbol("$d", EMS->Loc, EMS->F, EMS->Offset); EmitMappingSymbol("$d", EMS->Loc, EMS->F, EMS->Offset);
EMS->resetInfo(); EMS->resetInfo();
} }
/// This is one of the functions used to emit data into an ELF section, so the /// This is one of the functions used to emit data into an ELF section, so the
/// ARM streamer overrides it to add the appropriate mapping symbol ($d) if /// ARM streamer overrides it to add the appropriate mapping symbol ($d) if
/// necessary. /// necessary.
void emitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc) override { void emitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc) override {
if (const MCSymbolRefExpr *SRE = dyn_cast_or_null<MCSymbolRefExpr>(Value)) { if (const MCSymbolRefExpr *SRE =
dyn_cast_if_present<MCSymbolRefExpr>(Value)) {
if (SRE->getKind() == MCSymbolRefExpr::VK_ARM_SBREL && !(Size == 4)) { if (SRE->getKind() == MCSymbolRefExpr::VK_ARM_SBREL && !(Size == 4)) {
getContext().reportError(Loc, "relocated expression must be 32-bit"); getContext().reportError(Loc, "relocated expression must be 32-bit");
return; return;
} }
getOrCreateDataFragment(); getOrCreateDataFragment();
} }
emitDataMappingSymbol(); emitDataMappingSymbol();
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Linesprivate:
void emitDataMappingSymbol() { void emitDataMappingSymbol() {
if (LastEMSInfo->State == EMS_Data) if (LastEMSInfo->State == EMS_Data)
return; return;
else if (LastEMSInfo->State == EMS_None) { else if (LastEMSInfo->State == EMS_None) {
// This is a tentative symbol, it won't really be emitted until it's // This is a tentative symbol, it won't really be emitted until it's
// actually needed. // actually needed.
ElfMappingSymbolInfo *EMS = LastEMSInfo.get(); ElfMappingSymbolInfo *EMS = LastEMSInfo.get();
auto *DF = dyn_cast_or_null<MCDataFragment>(getCurrentFragment()); auto *DF = dyn_cast_if_present<MCDataFragment>(getCurrentFragment());
if (!DF) if (!DF)
return; return;
EMS->Loc = SMLoc(); EMS->Loc = SMLoc();
EMS->F = getCurrentFragment(); EMS->F = getCurrentFragment();
EMS->Offset = DF->getContents().size(); EMS->Offset = DF->getContents().size();
LastEMSInfo->State = EMS_Data; LastEMSInfo->State = EMS_Data;
return; return;
} }
▲ Show 20 Lines • Show All 850 Lines • Show Last 20 Lines

llvm/lib/Target/BPF/BPFAbstractMemberAccess.cpp

Show First 20 Lines • Show All 329 Lines • ▼ Show 20 Linesstatic const DIType * stripQualifiers(const DIType *Ty) {
} }
return Ty; return Ty;
} }
static uint32_t calcArraySize(const DICompositeType *CTy, uint32_t StartDim) { static uint32_t calcArraySize(const DICompositeType *CTy, uint32_t StartDim) {
DINodeArray Elements = CTy->getElements(); DINodeArray Elements = CTy->getElements();
uint32_t DimSize = 1; uint32_t DimSize = 1;
for (uint32_t I = StartDim; I < Elements.size(); ++I) { for (uint32_t I = StartDim; I < Elements.size(); ++I) {
if (auto *Element = dyn_cast_or_null<DINode>(Elements[I])) if (auto *Element = dyn_cast_if_present<DINode>(Elements[I]))
if (Element->getTag() == dwarf::DW_TAG_subrange_type) { if (Element->getTag() == dwarf::DW_TAG_subrange_type) {
const DISubrange *SR = cast<DISubrange>(Element); const DISubrange *SR = cast<DISubrange>(Element);
auto *CI = SR->getCount().dyn_cast<ConstantInt *>(); auto *CI = SR->getCount().dyn_cast<ConstantInt *>();
DimSize *= CI->getSExtValue(); DimSize *= CI->getSExtValue();
} }
} }
return DimSize; return DimSize;
▲ Show 20 Lines • Show All 874 Lines • Show Last 20 Lines

llvm/lib/Target/BPF/BTFDebug.cpp

Show First 20 Lines • Show All 675 Lines • ▼ Show 20 Linesvoid BTFDebug::visitArrayType(const DICompositeType *CTy, uint32_t &TypeId) {
// Visit array element type. // Visit array element type.
uint32_t ElemTypeId; uint32_t ElemTypeId;
const DIType *ElemType = CTy->getBaseType(); const DIType *ElemType = CTy->getBaseType();
visitTypeEntry(ElemType, ElemTypeId, false, false); visitTypeEntry(ElemType, ElemTypeId, false, false);
// Visit array dimensions. // Visit array dimensions.
DINodeArray Elements = CTy->getElements(); DINodeArray Elements = CTy->getElements();
for (int I = Elements.size() - 1; I >= 0; --I) { for (int I = Elements.size() - 1; I >= 0; --I) {
if (auto *Element = dyn_cast_or_null<DINode>(Elements[I])) if (auto *Element = dyn_cast_if_present<DINode>(Elements[I]))
if (Element->getTag() == dwarf::DW_TAG_subrange_type) { if (Element->getTag() == dwarf::DW_TAG_subrange_type) {
const DISubrange *SR = cast<DISubrange>(Element); const DISubrange *SR = cast<DISubrange>(Element);
auto *CI = SR->getCount().dyn_cast<ConstantInt *>(); auto *CI = SR->getCount().dyn_cast<ConstantInt *>();
int64_t Count = CI->getSExtValue(); int64_t Count = CI->getSExtValue();
// For struct s { int b; char c[]; }, the c[] will be represented // For struct s { int b; char c[]; }, the c[] will be represented
// as an array with Count = -1. // as an array with Count = -1.
auto TypeEntry = auto TypeEntry =
std::make_unique<BTFTypeArray>(ElemTypeId, std::make_unique<BTFTypeArray>(ElemTypeId, Count >= 0 ? Count : 0);
Count >= 0 ? Count : 0);
if (I == 0) if (I == 0)
ElemTypeId = addType(std::move(TypeEntry), CTy); ElemTypeId = addType(std::move(TypeEntry), CTy);
else else
ElemTypeId = addType(std::move(TypeEntry)); ElemTypeId = addType(std::move(TypeEntry));
} }
} }
// The array TypeId is the type id of the outermost dimension. // The array TypeId is the type id of the outermost dimension.
▲ Show 20 Lines • Show All 907 Lines • Show Last 20 Lines

llvm/lib/Target/DirectX/PointerTypeAnalysis.cpp

Show First 20 Lines • Show All 64 Lines • ▼ Show 20 Lines
void classifyFunctionType(const Function &F, PointerTypeMap &Map) { void classifyFunctionType(const Function &F, PointerTypeMap &Map) {
SmallVector<Type *, 8> NewArgs; SmallVector<Type *, 8> NewArgs;
bool HasOpaqueTy = false; bool HasOpaqueTy = false;
Type *RetTy = F.getReturnType(); Type *RetTy = F.getReturnType();
if (RetTy->isOpaquePointerTy()) { if (RetTy->isOpaquePointerTy()) {
RetTy = nullptr; RetTy = nullptr;
for (const auto &B : F) { for (const auto &B : F) {
for (const auto &I : B) { for (const auto &I : B) {
if (const auto *RetInst = dyn_cast_or_null<ReturnInst>(&I)) { if (const auto *RetInst = dyn_cast_if_present<ReturnInst>(&I)) {
Type *NewRetTy = classifyPointerType(RetInst->getReturnValue()); Type *NewRetTy = classifyPointerType(RetInst->getReturnValue());
if (!RetTy) if (!RetTy)
RetTy = NewRetTy; RetTy = NewRetTy;
else if (RetTy != NewRetTy) else if (RetTy != NewRetTy)
RetTy = TypedPointerType::get( RetTy = TypedPointerType::get(
Type::getInt8Ty(I.getContext()), Type::getInt8Ty(I.getContext()),
F.getReturnType()->getPointerAddressSpace()); F.getReturnType()->getPointerAddressSpace());
} }
Show All 38 Lines

llvm/lib/Target/Hexagon/HexagonFrameLowering.cpp

Show First 20 Lines • Show All 1,543 Lines • ▼ Show 20 Linesvoid HexagonFrameLowering::processFunctionBeforeFrameFinalized(
if (!DealignSlots.empty()) { if (!DealignSlots.empty()) {
for (MachineBasicBlock &BB : MF) { for (MachineBasicBlock &BB : MF) {
for (MachineInstr &MI : BB) { for (MachineInstr &MI : BB) {
bool KeepOld = true; bool KeepOld = true;
ArrayRef<MachineMemOperand*> memops = MI.memoperands(); ArrayRef<MachineMemOperand*> memops = MI.memoperands();
SmallVector<MachineMemOperand*,1> new_memops; SmallVector<MachineMemOperand*,1> new_memops;
for (MachineMemOperand *MMO : memops) { for (MachineMemOperand *MMO : memops) {
auto *PV = MMO->getPseudoValue(); auto *PV = MMO->getPseudoValue();
if (auto *FS = dyn_cast_or_null<FixedStackPseudoSourceValue>(PV)) { if (auto *FS = dyn_cast_if_present<FixedStackPseudoSourceValue>(PV)) {
int FI = FS->getFrameIndex(); int FI = FS->getFrameIndex();
if (DealignSlots.count(FI)) { if (DealignSlots.count(FI)) {
auto *NewMMO = MF.getMachineMemOperand( auto *NewMMO = MF.getMachineMemOperand(
MMO->getPointerInfo(), MMO->getFlags(), MMO->getSize(), MMO->getPointerInfo(), MMO->getFlags(), MMO->getSize(),
MFI.getObjectAlign(FI), MMO->getAAInfo(), MMO->getRanges(), MFI.getObjectAlign(FI), MMO->getAAInfo(), MMO->getRanges(),
MMO->getSyncScopeID(), MMO->getSuccessOrdering(), MMO->getSyncScopeID(), MMO->getSuccessOrdering(),
MMO->getFailureOrdering()); MMO->getFailureOrdering());
new_memops.push_back(NewMMO); new_memops.push_back(NewMMO);
▲ Show 20 Lines • Show All 1,179 Lines • Show Last 20 Lines

llvm/lib/Target/Hexagon/HexagonISelLowering.cpp

Show First 20 Lines • Show All 3,602 Lines • ▼ Show 20 Lines if (!TargetLoweringBase::shouldReduceLoadWidth(Load, ExtTy, NewVT))
return false; return false;
auto *L = cast<LoadSDNode>(Load); auto *L = cast<LoadSDNode>(Load);
std::pair<SDValue,int> BO = getBaseAndOffset(L->getBasePtr()); std::pair<SDValue,int> BO = getBaseAndOffset(L->getBasePtr());
// Small-data object, do not shrink. // Small-data object, do not shrink.
if (BO.first.getOpcode() == HexagonISD::CONST32_GP) if (BO.first.getOpcode() == HexagonISD::CONST32_GP)
return false; return false;
if (GlobalAddressSDNode *GA = dyn_cast<GlobalAddressSDNode>(BO.first)) { if (GlobalAddressSDNode *GA = dyn_cast<GlobalAddressSDNode>(BO.first)) {
auto &HTM = static_cast<const HexagonTargetMachine&>(getTargetMachine()); auto &HTM = static_cast<const HexagonTargetMachine &>(getTargetMachine());
const auto *GO = dyn_cast_or_null<const GlobalObject>(GA->getGlobal()); const auto *GO = dyn_cast_if_present<const GlobalObject>(GA->getGlobal());
return !GO || !HTM.getObjFileLowering()->isGlobalInSmallSection(GO, HTM); return !GO || !HTM.getObjFileLowering()->isGlobalInSmallSection(GO, HTM);
} }
return true; return true;
} }
Value *HexagonTargetLowering::emitLoadLinked(IRBuilderBase &Builder, Value *HexagonTargetLowering::emitLoadLinked(IRBuilderBase &Builder,
Type *ValueTy, Value *Addr, Type *ValueTy, Value *Addr,
AtomicOrdering Ord) const { AtomicOrdering Ord) const {
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

llvm/lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp

Show First 20 Lines • Show All 1,859 Lines • ▼ Show 20 Lines if (!PV.Left) {
Simplifier PostSimp; Simplifier PostSimp;
setupPostSimplifier(PostSimp); setupPostSimplifier(PostSimp);
for (Instruction &In : *LoopB) { for (Instruction &In : *LoopB) {
SelectInst *SI = dyn_cast<SelectInst>(&In); SelectInst *SI = dyn_cast<SelectInst>(&In);
if (!SI || !FeedsPHI(SI)) if (!SI || !FeedsPHI(SI))
continue; continue;
Simplifier::Context C(SI); Simplifier::Context C(SI);
Value *T = PostSimp.simplify(C); Value *T = PostSimp.simplify(C);
SelectInst *SelI = dyn_cast_or_null<SelectInst>(T); SelectInst *SelI = dyn_cast_if_present<SelectInst>(T);
if (SelI != SI) { if (SelI != SI) {
Value *NewSel = C.materialize(LoopB, SI->getIterator()); Value *NewSel = C.materialize(LoopB, SI->getIterator());
SI->replaceAllUsesWith(NewSel); SI->replaceAllUsesWith(NewSel);
RecursivelyDeleteTriviallyDeadInstructions(SI, &TLI); RecursivelyDeleteTriviallyDeadInstructions(SI, &TLI);
} }
break; break;
} }
▲ Show 20 Lines • Show All 593 Lines • Show Last 20 Lines

llvm/lib/Target/LoongArch/LoongArchTargetMachine.cpp

Show First 20 Lines • Show All 69 Lines • ▼ Show 20 LinesLoongArchTargetMachine::getSubtargetImpl(const Function &F) const {
std::string Key = CPU + TuneCPU + FS; std::string Key = CPU + TuneCPU + FS;
auto &I = SubtargetMap[Key]; auto &I = SubtargetMap[Key];
if (!I) { if (!I) {
// This needs to be done before we create a new subtarget since any // This needs to be done before we create a new subtarget since any
// creation will depend on the TM and the code generation flags on the // creation will depend on the TM and the code generation flags on the
// function that reside in TargetOptions. // function that reside in TargetOptions.
resetTargetOptions(F); resetTargetOptions(F);
auto ABIName = Options.MCOptions.getABIName(); auto ABIName = Options.MCOptions.getABIName();
if (const MDString *ModuleTargetABI = dyn_cast_or_null<MDString>( if (const MDString *ModuleTargetABI = dyn_cast_if_present<MDString>(
F.getParent()->getModuleFlag("target-abi"))) { F.getParent()->getModuleFlag("target-abi"))) {
auto TargetABI = LoongArchABI::getTargetABI(ABIName); auto TargetABI = LoongArchABI::getTargetABI(ABIName);
if (TargetABI != LoongArchABI::ABI_Unknown && if (TargetABI != LoongArchABI::ABI_Unknown &&
ModuleTargetABI->getString() != ABIName) { ModuleTargetABI->getString() != ABIName) {
report_fatal_error("-target-abi option != target-abi module flag"); report_fatal_error("-target-abi option != target-abi module flag");
} }
ABIName = ModuleTargetABI->getString(); ABIName = ModuleTargetABI->getString();
} }
Show All 37 Lines

llvm/lib/Target/M68k/M68kISelDAGToDAG.cpp

Show First 20 Lines • Show All 128 Lines • ▼ Show 20 Linesstruct M68kISelAddressMode {
bool isDisp8() const { return getDispSize() == 8; } bool isDisp8() const { return getDispSize() == 8; }
bool isDisp16() const { return getDispSize() == 16; } bool isDisp16() const { return getDispSize() == 16; }
bool isDisp32() const { return getDispSize() == 32; } bool isDisp32() const { return getDispSize() == 32; }
/// Return true if this addressing mode is already PC-relative. /// Return true if this addressing mode is already PC-relative.
bool isPCRelative() const { bool isPCRelative() const {
if (BaseType != Base::RegBase) if (BaseType != Base::RegBase)
return false; return false;
if (auto *RegNode = dyn_cast_or_null<RegisterSDNode>(BaseReg.getNode())) if (auto *RegNode = dyn_cast_if_present<RegisterSDNode>(BaseReg.getNode()))
return RegNode->getReg() == M68k::PC; return RegNode->getReg() == M68k::PC;
return false; return false;
} }
void setBaseReg(SDValue Reg) { void setBaseReg(SDValue Reg) {
BaseType = Base::RegBase; BaseType = Base::RegBase;
BaseReg = Reg; BaseReg = Reg;
} }
▲ Show 20 Lines • Show All 782 Lines • Show Last 20 Lines

llvm/lib/Target/M68k/M68kSubtarget.cpp

Show First 20 Lines • Show All 242 Lines • ▼ Show 20 LinesM68kSubtarget::classifyGlobalFunctionReference(const GlobalValue *GV,
const Module &M) const { const Module &M) const {
// local always use pc-rel referencing // local always use pc-rel referencing
if (TM.shouldAssumeDSOLocal(M, GV)) if (TM.shouldAssumeDSOLocal(M, GV))
return M68kII::MO_NO_FLAG; return M68kII::MO_NO_FLAG;
// If the function is marked as non-lazy, generate an indirect call // If the function is marked as non-lazy, generate an indirect call
// which loads from the GOT directly. This avoids run-time overhead // which loads from the GOT directly. This avoids run-time overhead
// at the cost of eager binding. // at the cost of eager binding.
auto *F = dyn_cast_or_null<Function>(GV); auto *F = dyn_cast_if_present<Function>(GV);
if (F && F->hasFnAttribute(Attribute::NonLazyBind)) { if (F && F->hasFnAttribute(Attribute::NonLazyBind)) {
return M68kII::MO_GOTPCREL; return M68kII::MO_GOTPCREL;
} }
// otherwise linker will figure this out // otherwise linker will figure this out
return M68kII::MO_PLT; return M68kII::MO_PLT;
} }

llvm/lib/Target/Mips/MipsISelLowering.cpp

Show First 20 Lines • Show All 3,116 Lines • ▼ Show 20 Lines case Mips::TAILCALLREG_MMR6: {
return; return;
} }
// We are after the callee address, set by LowerCall(). // We are after the callee address, set by LowerCall().
// If added to MI, asm printer will emit .reloc R_MIPS_JALR for the // If added to MI, asm printer will emit .reloc R_MIPS_JALR for the
// symbol. // symbol.
const SDValue TargetAddr = Node->getOperand(0).getOperand(1); const SDValue TargetAddr = Node->getOperand(0).getOperand(1);
StringRef Sym; StringRef Sym;
if (const GlobalAddressSDNode *G = if (const GlobalAddressSDNode *G =
dyn_cast_or_null<const GlobalAddressSDNode>(TargetAddr)) { dyn_cast_if_present<const GlobalAddressSDNode>(TargetAddr)) {
// We must not emit the R_MIPS_JALR relocation against data symbols // We must not emit the R_MIPS_JALR relocation against data symbols
// since this will cause run-time crashes if the linker replaces the // since this will cause run-time crashes if the linker replaces the
// call instruction with a relative branch to the data symbol. // call instruction with a relative branch to the data symbol.
if (!isa<Function>(G->getGlobal())) { if (!isa<Function>(G->getGlobal())) {
LLVM_DEBUG(dbgs() << "Not adding R_MIPS_JALR against data symbol " LLVM_DEBUG(dbgs() << "Not adding R_MIPS_JALR against data symbol "
<< G->getGlobal()->getName() << "\n"); << G->getGlobal()->getName() << "\n");
return; return;
} }
Sym = G->getGlobal()->getName(); Sym = G->getGlobal()->getName();
} } else if (const ExternalSymbolSDNode *ES =
else if (const ExternalSymbolSDNode *ES = dyn_cast_if_present<const ExternalSymbolSDNode>(
dyn_cast_or_null<const ExternalSymbolSDNode>(TargetAddr)) { TargetAddr)) {
Sym = ES->getSymbol(); Sym = ES->getSymbol();
} }
if (Sym.empty()) if (Sym.empty())
return; return;
MachineFunction *MF = MI.getParent()->getParent(); MachineFunction *MF = MI.getParent()->getParent();
MCSymbol *S = MF->getContext().getOrCreateSymbol(Sym); MCSymbol *S = MF->getContext().getOrCreateSymbol(Sym);
Show All 27 LinesMipsTargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI,
// Analyze operands of the call, assigning locations to each operand. // Analyze operands of the call, assigning locations to each operand.
SmallVector<CCValAssign, 16> ArgLocs; SmallVector<CCValAssign, 16> ArgLocs;
MipsCCState CCInfo( MipsCCState CCInfo(
CallConv, IsVarArg, DAG.getMachineFunction(), ArgLocs, *DAG.getContext(), CallConv, IsVarArg, DAG.getMachineFunction(), ArgLocs, *DAG.getContext(),
MipsCCState::getSpecialCallingConvForCallee(Callee.getNode(), Subtarget)); MipsCCState::getSpecialCallingConvForCallee(Callee.getNode(), Subtarget));
const ExternalSymbolSDNode *ES = const ExternalSymbolSDNode *ES =
dyn_cast_or_null<const ExternalSymbolSDNode>(Callee.getNode()); dyn_cast_if_present<const ExternalSymbolSDNode>(Callee.getNode());
// There is one case where CALLSEQ_START..CALLSEQ_END can be nested, which // There is one case where CALLSEQ_START..CALLSEQ_END can be nested, which
// is during the lowering of a call with a byval argument which produces // is during the lowering of a call with a byval argument which produces
// a call to memcpy. For the O32 case, this causes the caller to allocate // a call to memcpy. For the O32 case, this causes the caller to allocate
// stack space for the reserved argument area for the callee, then recursively // stack space for the reserved argument area for the callee, then recursively
// again for the memcpy call. In the NEWABI case, this doesn't occur as those // again for the memcpy call. In the NEWABI case, this doesn't occur as those
// ABIs mandate that the callee allocates the reserved argument area. We do // ABIs mandate that the callee allocates the reserved argument area. We do
// still produce nested CALLSEQ_START..CALLSEQ_END with zero space though. // still produce nested CALLSEQ_START..CALLSEQ_END with zero space though.
▲ Show 20 Lines • Show All 310 Lines • ▼ Show 20 LinesSDValue MipsTargetLowering::LowerCallResult(
SelectionDAG &DAG, SmallVectorImpl<SDValue> &InVals, SelectionDAG &DAG, SmallVectorImpl<SDValue> &InVals,
TargetLowering::CallLoweringInfo &CLI) const { TargetLowering::CallLoweringInfo &CLI) const {
// Assign locations to each value returned by this call. // Assign locations to each value returned by this call.
SmallVector<CCValAssign, 16> RVLocs; SmallVector<CCValAssign, 16> RVLocs;
MipsCCState CCInfo(CallConv, IsVarArg, DAG.getMachineFunction(), RVLocs, MipsCCState CCInfo(CallConv, IsVarArg, DAG.getMachineFunction(), RVLocs,
*DAG.getContext()); *DAG.getContext());
const ExternalSymbolSDNode *ES = const ExternalSymbolSDNode *ES =
dyn_cast_or_null<const ExternalSymbolSDNode>(CLI.Callee.getNode()); dyn_cast_if_present<const ExternalSymbolSDNode>(CLI.Callee.getNode());
CCInfo.AnalyzeCallResult(Ins, RetCC_Mips, CLI.RetTy, CCInfo.AnalyzeCallResult(Ins, RetCC_Mips, CLI.RetTy,
ES ? ES->getSymbol() : nullptr); ES ? ES->getSymbol() : nullptr);
// Copy all of the result registers out of their specified physreg. // Copy all of the result registers out of their specified physreg.
for (unsigned i = 0; i != RVLocs.size(); ++i) { for (unsigned i = 0; i != RVLocs.size(); ++i) {
CCValAssign &VA = RVLocs[i]; CCValAssign &VA = RVLocs[i];
assert(VA.isRegLoc() && "Can only return in registers!"); assert(VA.isRegLoc() && "Can only return in registers!");
▲ Show 20 Lines • Show All 1,518 Lines • Show Last 20 Lines

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

Show First 20 Lines • Show All 1,413 Lines • ▼ Show 20 Lines#endif
LowerPPCMachineInstrToMCInst(MI, TmpInst, *this); LowerPPCMachineInstrToMCInst(MI, TmpInst, *this);
EmitToStreamer(*OutStreamer, TmpInst); EmitToStreamer(*OutStreamer, TmpInst);
} }
void PPCLinuxAsmPrinter::emitGNUAttributes(Module &M) { void PPCLinuxAsmPrinter::emitGNUAttributes(Module &M) {
// Emit float ABI into GNU attribute // Emit float ABI into GNU attribute
Metadata *MD = M.getModuleFlag("float-abi"); Metadata *MD = M.getModuleFlag("float-abi");
MDString *FloatABI = dyn_cast_or_null<MDString>(MD); MDString *FloatABI = dyn_cast_if_present<MDString>(MD);
if (!FloatABI) if (!FloatABI)
return; return;
StringRef flt = FloatABI->getString(); StringRef flt = FloatABI->getString();
// TODO: Support emitting soft-fp and hard double/single attributes. // TODO: Support emitting soft-fp and hard double/single attributes.
if (flt == "doubledouble") if (flt == "doubledouble")
OutStreamer->emitGNUAttribute(Tag_GNU_Power_ABI_FP, OutStreamer->emitGNUAttribute(Tag_GNU_Power_ABI_FP,
Val_GNU_Power_ABI_HardFloat_DP | Val_GNU_Power_ABI_HardFloat_DP |
Val_GNU_Power_ABI_LDBL_IBM128); Val_GNU_Power_ABI_LDBL_IBM128);
▲ Show 20 Lines • Show All 1,388 Lines • Show Last 20 Lines

llvm/lib/Target/PowerPC/PPCFastISel.cpp

Show First 20 Lines • Show All 2,070 Lines • ▼ Show 20 Linesunsigned PPCFastISel::PPCMaterializeGV(const GlobalValue *GV, MVT VT) {
// what follows assumes everything's a generic (or TLS) global address. // what follows assumes everything's a generic (or TLS) global address.
// FIXME: We don't yet handle the complexity of TLS. // FIXME: We don't yet handle the complexity of TLS.
if (GV->isThreadLocal()) if (GV->isThreadLocal())
return 0; return 0;
// If the global has the toc-data attribute then fallback to DAG-ISEL. // If the global has the toc-data attribute then fallback to DAG-ISEL.
if (TM.getTargetTriple().isOSAIX()) if (TM.getTargetTriple().isOSAIX())
if (const GlobalVariable *Var = dyn_cast_or_null<GlobalVariable>(GV)) if (const GlobalVariable *Var = dyn_cast_if_present<GlobalVariable>(GV))
if (Var->hasAttribute("toc-data")) if (Var->hasAttribute("toc-data"))
return false; return false;
PPCFuncInfo->setUsesTOCBasePtr(); PPCFuncInfo->setUsesTOCBasePtr();
// For small code model, generate a simple TOC load. // For small code model, generate a simple TOC load.
if (CModel == CodeModel::Small) if (CModel == CodeModel::Small)
BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(PPC::LDtoc), BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(PPC::LDtoc),
DestReg) DestReg)
▲ Show 20 Lines • Show All 387 Lines • Show Last 20 Lines

llvm/lib/Target/PowerPC/PPCGenScalarMASSEntries.cpp

Show First 20 Lines • Show All 122 Lines • ▼ Show 20 Lines for (Function &Func : M) {
// The call to createScalarMASSCall() invalidates the iterator over users // The call to createScalarMASSCall() invalidates the iterator over users
// upon replacing the users. Precomputing the current list of users allows // upon replacing the users. Precomputing the current list of users allows
// us to replace all the call sites. // us to replace all the call sites.
SmallVector<User *, 4> TheUsers; SmallVector<User *, 4> TheUsers;
for (auto *User : Func.users()) for (auto *User : Func.users())
TheUsers.push_back(User); TheUsers.push_back(User);
for (auto *User : TheUsers) for (auto *User : TheUsers)
if (auto *CI = dyn_cast_or_null<CallInst>(User)) { if (auto *CI = dyn_cast_if_present<CallInst>(User)) {
if (isCandidateSafeToLower(*CI)) if (isCandidateSafeToLower(*CI))
Changed |= createScalarMASSCall(Iter->second, *CI, Func); Changed |= createScalarMASSCall(Iter->second, *CI, Func);
} }
} }
return Changed; return Changed;
} }
Show All 10 Lines

llvm/lib/Target/PowerPC/PPCISelDAGToDAG.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 498 Lines • ▼ Show 20 Lines
} }
// Check if a SDValue has the toc-data attribute. // Check if a SDValue has the toc-data attribute.
static bool hasTocDataAttr(SDValue Val, unsigned PointerSize) { static bool hasTocDataAttr(SDValue Val, unsigned PointerSize) {
GlobalAddressSDNode *GA = dyn_cast<GlobalAddressSDNode>(Val); GlobalAddressSDNode *GA = dyn_cast<GlobalAddressSDNode>(Val);
if (!GA) if (!GA)
return false; return false;
const GlobalVariable *GV = dyn_cast_or_null<GlobalVariable>(GA->getGlobal()); const GlobalVariable *GV =
dyn_cast_if_present<GlobalVariable>(GA->getGlobal());
if (!GV) if (!GV)
return false; return false;
if (!GV->hasAttribute("toc-data")) if (!GV->hasAttribute("toc-data"))
return false; return false;
// TODO: These asserts should be updated as more support for the toc data // TODO: These asserts should be updated as more support for the toc data
// transformation is added (struct support, etc.). // transformation is added (struct support, etc.).
▲ Show 20 Lines • Show All 7,048 Lines • Show Last 20 Lines

llvm/lib/Target/PowerPC/PPCISelLowering.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 5,326 Lines • ▼ Show 20 Linesstatic SDValue transformCallee(const SDValue &Callee, SelectionDAG &DAG,
if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(Callee)) { if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(Callee)) {
const char *SymName = S->getSymbol(); const char *SymName = S->getSymbol();
if (Subtarget.isAIXABI()) { if (Subtarget.isAIXABI()) {
// If there exists a user-declared function whose name is the same as the // If there exists a user-declared function whose name is the same as the
// ExternalSymbol's, then we pick up the user-declared version. // ExternalSymbol's, then we pick up the user-declared version.
const Module *Mod = DAG.getMachineFunction().getFunction().getParent(); const Module *Mod = DAG.getMachineFunction().getFunction().getParent();
if (const Function *F = if (const Function *F =
dyn_cast_or_null<Function>(Mod->getNamedValue(SymName))) dyn_cast_if_present<Function>(Mod->getNamedValue(SymName)))
return getAIXFuncEntryPointSymbolSDNode(F); return getAIXFuncEntryPointSymbolSDNode(F);
// On AIX, direct function calls reference the symbol for the function's // On AIX, direct function calls reference the symbol for the function's
// entry point, which is named by prepending a "." before the function's // entry point, which is named by prepending a "." before the function's
// C-linkage name. A Qualname is returned here because an external // C-linkage name. A Qualname is returned here because an external
// function entry point is a csect with XTY_ER property. // function entry point is a csect with XTY_ER property.
const auto getExternalFunctionEntryPointSymbol = [&](StringRef SymName) { const auto getExternalFunctionEntryPointSymbol = [&](StringRef SymName) {
auto &Context = DAG.getMachineFunction().getMMI().getContext(); auto &Context = DAG.getMachineFunction().getMMI().getContext();
▲ Show 20 Lines • Show All 12,807 Lines • Show Last 20 Lines

llvm/lib/Target/PowerPC/PPCLowerMASSVEntries.cpp

Show First 20 Lines • Show All 102 Lines • ▼ Show 20 Lines
/// If there are proper fast-math flags, this function creates llvm.pow /// If there are proper fast-math flags, this function creates llvm.pow
/// intrinsics when the exponent is 0.25 or 0.75. /// intrinsics when the exponent is 0.25 or 0.75.
bool PPCLowerMASSVEntries::handlePowSpecialCases(CallInst *CI, Function &Func, bool PPCLowerMASSVEntries::handlePowSpecialCases(CallInst *CI, Function &Func,
Module &M) { Module &M) {
if (Func.getName() != "__powf4" && Func.getName() != "__powd2") if (Func.getName() != "__powf4" && Func.getName() != "__powd2")
return false; return false;
if (Constant *Exp = dyn_cast<Constant>(CI->getArgOperand(1))) if (Constant *Exp = dyn_cast<Constant>(CI->getArgOperand(1)))
if (ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(Exp->getSplatValue())) { if (ConstantFP *CFP =
dyn_cast_if_present<ConstantFP>(Exp->getSplatValue())) {
// If the argument is 0.75 or 0.25 it is cheaper to turn it into pow // If the argument is 0.75 or 0.25 it is cheaper to turn it into pow
// intrinsic so that it could be optimzed as sequence of sqrt's. // intrinsic so that it could be optimzed as sequence of sqrt's.
if (!CI->hasNoInfs() || !CI->hasApproxFunc()) if (!CI->hasNoInfs() || !CI->hasApproxFunc())
return false; return false;
if (!CFP->isExactlyValue(0.75) && !CFP->isExactlyValue(0.25)) if (!CFP->isExactlyValue(0.75) && !CFP->isExactlyValue(0.25))
return false; return false;
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

llvm/lib/Target/RISCV/MCTargetDesc/RISCVMCExpr.cpp

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Linesconst MCFixup *RISCVMCExpr::getPCRelHiFixup(const MCFragment **DFOut) const {
if (!getSubExpr()->evaluateAsRelocatable(AUIPCLoc, nullptr, nullptr)) if (!getSubExpr()->evaluateAsRelocatable(AUIPCLoc, nullptr, nullptr))
return nullptr; return nullptr;
const MCSymbolRefExpr *AUIPCSRE = AUIPCLoc.getSymA(); const MCSymbolRefExpr *AUIPCSRE = AUIPCLoc.getSymA();
if (!AUIPCSRE) if (!AUIPCSRE)
return nullptr; return nullptr;
const MCSymbol *AUIPCSymbol = &AUIPCSRE->getSymbol(); const MCSymbol *AUIPCSymbol = &AUIPCSRE->getSymbol();
const auto *DF = dyn_cast_or_null<MCDataFragment>(AUIPCSymbol->getFragment()); const auto *DF =
dyn_cast_if_present<MCDataFragment>(AUIPCSymbol->getFragment());
if (!DF) if (!DF)
return nullptr; return nullptr;
uint64_t Offset = AUIPCSymbol->getOffset(); uint64_t Offset = AUIPCSymbol->getOffset();
if (DF->getContents().size() == Offset) { if (DF->getContents().size() == Offset) {
DF = dyn_cast_or_null<MCDataFragment>(DF->getNextNode()); DF = dyn_cast_if_present<MCDataFragment>(DF->getNextNode());
if (!DF) if (!DF)
return nullptr; return nullptr;
Offset = 0; Offset = 0;
} }
for (const MCFixup &F : DF->getFixups()) { for (const MCFixup &F : DF->getFixups()) {
if (F.getOffset() != Offset) if (F.getOffset() != Offset)
continue; continue;
▲ Show 20 Lines • Show All 159 Lines • Show Last 20 Lines

llvm/lib/Target/RISCV/RISCVAsmPrinter.cpp

Show First 20 Lines • Show All 198 Lines • ▼ Show 20 Linesbool RISCVAsmPrinter::runOnMachineFunction(MachineFunction &MF) {
emitFunctionBody(); emitFunctionBody();
return false; return false;
} }
void RISCVAsmPrinter::emitStartOfAsmFile(Module &M) { void RISCVAsmPrinter::emitStartOfAsmFile(Module &M) {
RISCVTargetStreamer &RTS = RISCVTargetStreamer &RTS =
static_cast<RISCVTargetStreamer &>(*OutStreamer->getTargetStreamer()); static_cast<RISCVTargetStreamer &>(*OutStreamer->getTargetStreamer());
if (const MDString *ModuleTargetABI = if (const MDString *ModuleTargetABI =
dyn_cast_or_null<MDString>(M.getModuleFlag("target-abi"))) dyn_cast_if_present<MDString>(M.getModuleFlag("target-abi")))
RTS.setTargetABI(RISCVABI::getTargetABI(ModuleTargetABI->getString())); RTS.setTargetABI(RISCVABI::getTargetABI(ModuleTargetABI->getString()));
if (TM.getTargetTriple().isOSBinFormatELF()) if (TM.getTargetTriple().isOSBinFormatELF())
emitAttributes(); emitAttributes();
} }
void RISCVAsmPrinter::emitEndOfAsmFile(Module &M) { void RISCVAsmPrinter::emitEndOfAsmFile(Module &M) {
RISCVTargetStreamer &RTS = RISCVTargetStreamer &RTS =
static_cast<RISCVTargetStreamer &>(*OutStreamer->getTargetStreamer()); static_cast<RISCVTargetStreamer &>(*OutStreamer->getTargetStreamer());
▲ Show 20 Lines • Show All 266 Lines • Show Last 20 Lines

llvm/lib/Target/RISCV/RISCVGatherScatterLowering.cpp

Show First 20 Lines • Show All 101 Lines • ▼ Show 20 Linesbool RISCVGatherScatterLowering::isLegalTypeAndAlignment(Type *DataType,
return true; return true;
} }
// TODO: Should we consider the mask when looking for a stride? // TODO: Should we consider the mask when looking for a stride?
static std::pair<Value *, Value *> matchStridedConstant(Constant *StartC) { static std::pair<Value *, Value *> matchStridedConstant(Constant *StartC) {
unsigned NumElts = cast<FixedVectorType>(StartC->getType())->getNumElements(); unsigned NumElts = cast<FixedVectorType>(StartC->getType())->getNumElements();
// Check that the start value is a strided constant. // Check that the start value is a strided constant.
auto *StartVal = auto *StartVal = dyn_cast_if_present<ConstantInt>(
dyn_cast_or_null<ConstantInt>(StartC->getAggregateElement((unsigned)0)); StartC->getAggregateElement((unsigned)0));
if (!StartVal) if (!StartVal)
return std::make_pair(nullptr, nullptr); return std::make_pair(nullptr, nullptr);
APInt StrideVal(StartVal->getValue().getBitWidth(), 0); APInt StrideVal(StartVal->getValue().getBitWidth(), 0);
ConstantInt *Prev = StartVal; ConstantInt *Prev = StartVal;
for (unsigned i = 1; i != NumElts; ++i) { for (unsigned i = 1; i != NumElts; ++i) {
auto *C = dyn_cast_or_null<ConstantInt>(StartC->getAggregateElement(i)); auto *C = dyn_cast_if_present<ConstantInt>(StartC->getAggregateElement(i));
if (!C) if (!C)
return std::make_pair(nullptr, nullptr); return std::make_pair(nullptr, nullptr);
APInt LocalStride = C->getValue() - Prev->getValue(); APInt LocalStride = C->getValue() - Prev->getValue();
if (i == 1) if (i == 1)
StrideVal = LocalStride; StrideVal = LocalStride;
else if (StrideVal != LocalStride) else if (StrideVal != LocalStride)
return std::make_pair(nullptr, nullptr); return std::make_pair(nullptr, nullptr);
▲ Show 20 Lines • Show All 372 Lines • ▼ Show 20 Lines Changed |= tryCreateStridedLoadStore(
II, II->getType(), II->getArgOperand(0), II->getArgOperand(1)); II, II->getType(), II->getArgOperand(0), II->getArgOperand(1));
for (auto *II : Scatters) for (auto *II : Scatters)
Changed |= Changed |=
tryCreateStridedLoadStore(II, II->getArgOperand(0)->getType(), tryCreateStridedLoadStore(II, II->getArgOperand(0)->getType(),
II->getArgOperand(1), II->getArgOperand(2)); II->getArgOperand(1), II->getArgOperand(2));
// Remove any dead phis. // Remove any dead phis.
while (!MaybeDeadPHIs.empty()) { while (!MaybeDeadPHIs.empty()) {
if (auto *Phi = dyn_cast_or_null<PHINode>(MaybeDeadPHIs.pop_back_val())) if (auto *Phi = dyn_cast_if_present<PHINode>(MaybeDeadPHIs.pop_back_val()))
RecursivelyDeleteDeadPHINode(Phi); RecursivelyDeleteDeadPHINode(Phi);
} }
return Changed; return Changed;
} }

llvm/lib/Target/RISCV/RISCVTargetMachine.cpp

Show First 20 Lines • Show All 100 Lines • ▼ Show 20 LinesRISCVTargetMachine::getSubtargetImpl(const Function &F) const {
std::string Key = CPU + TuneCPU + FS; std::string Key = CPU + TuneCPU + FS;
auto &I = SubtargetMap[Key]; auto &I = SubtargetMap[Key];
if (!I) { if (!I) {
// This needs to be done before we create a new subtarget since any // This needs to be done before we create a new subtarget since any
// creation will depend on the TM and the code generation flags on the // creation will depend on the TM and the code generation flags on the
// function that reside in TargetOptions. // function that reside in TargetOptions.
resetTargetOptions(F); resetTargetOptions(F);
auto ABIName = Options.MCOptions.getABIName(); auto ABIName = Options.MCOptions.getABIName();
if (const MDString *ModuleTargetABI = dyn_cast_or_null<MDString>( if (const MDString *ModuleTargetABI = dyn_cast_if_present<MDString>(
F.getParent()->getModuleFlag("target-abi"))) { F.getParent()->getModuleFlag("target-abi"))) {
auto TargetABI = RISCVABI::getTargetABI(ABIName); auto TargetABI = RISCVABI::getTargetABI(ABIName);
if (TargetABI != RISCVABI::ABI_Unknown && if (TargetABI != RISCVABI::ABI_Unknown &&
ModuleTargetABI->getString() != ABIName) { ModuleTargetABI->getString() != ABIName) {
report_fatal_error("-target-abi option != target-abi module flag"); report_fatal_error("-target-abi option != target-abi module flag");
} }
ABIName = ModuleTargetABI->getString(); ABIName = ModuleTargetABI->getString();
} }
▲ Show 20 Lines • Show All 172 Lines • Show Last 20 Lines

llvm/lib/Target/SPIRV/SPIRVCallLowering.cpp

Show First 20 Lines • Show All 270 Lines • ▼ Show 20 Linesbool SPIRVCallLowering::lowerCall(MachineIRBuilder &MIRBuilder,
GR->setCurrentFunc(MF); GR->setCurrentFunc(MF);
FunctionType *FTy = nullptr; FunctionType *FTy = nullptr;
const Function *CF = nullptr; const Function *CF = nullptr;
// Emit a regular OpFunctionCall. If it's an externally declared function, // Emit a regular OpFunctionCall. If it's an externally declared function,
// be sure to emit its type and function declaration here. It will be hoisted // be sure to emit its type and function declaration here. It will be hoisted
// globally later. // globally later.
if (Info.Callee.isGlobal()) { if (Info.Callee.isGlobal()) {
CF = dyn_cast_or_null<const Function>(Info.Callee.getGlobal()); CF = dyn_cast_if_present<const Function>(Info.Callee.getGlobal());
// TODO: support constexpr casts and indirect calls. // TODO: support constexpr casts and indirect calls.
if (CF == nullptr) if (CF == nullptr)
return false; return false;
FTy = getOriginalFunctionType(*CF); FTy = getOriginalFunctionType(*CF);
} }
Register ResVReg = Register ResVReg =
Info.OrigRet.Regs.empty() ? Register(0) : Info.OrigRet.Regs[0]; Info.OrigRet.Regs.empty() ? Register(0) : Info.OrigRet.Regs[0];
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

llvm/lib/Target/SystemZ/SystemZTargetTransformInfo.cpp

Show First 20 Lines • Show All 450 Lines • ▼ Show 20 LinesInstructionCost SystemZTTIImpl::getArithmeticInstrCost(
// Check for a constant divisor. // Check for a constant divisor.
bool DivRemConst = false; bool DivRemConst = false;
bool DivRemConstPow2 = false; bool DivRemConstPow2 = false;
if ((SignedDivRem || UnsignedDivRem) && Args.size() == 2) { if ((SignedDivRem || UnsignedDivRem) && Args.size() == 2) {
if (const Constant *C = dyn_cast<Constant>(Args[1])) { if (const Constant *C = dyn_cast<Constant>(Args[1])) {
const ConstantInt *CVal = const ConstantInt *CVal =
(C->getType()->isVectorTy() (C->getType()->isVectorTy()
? dyn_cast_or_null<const ConstantInt>(C->getSplatValue()) ? dyn_cast_if_present<const ConstantInt>(C->getSplatValue())
: dyn_cast<const ConstantInt>(C)); : dyn_cast<const ConstantInt>(C));
if (CVal && (CVal->getValue().isPowerOf2() || if (CVal && (CVal->getValue().isPowerOf2() ||
CVal->getValue().isNegatedPowerOf2())) CVal->getValue().isNegatedPowerOf2()))
DivRemConstPow2 = true; DivRemConstPow2 = true;
else else
DivRemConst = true; DivRemConst = true;
} }
} }
▲ Show 20 Lines • Show All 781 Lines • Show Last 20 Lines

llvm/lib/Target/X86/MCTargetDesc/X86AsmBackend.cpp

Show First 20 Lines • Show All 418 Lines • ▼ Show 20 LinesisRightAfterData(MCFragment *CurrentFragment,
// - If the fragment is a DataFragment // - If the fragment is a DataFragment
// - If it's not the fragment where the previous instruction is, // - If it's not the fragment where the previous instruction is,
// returns true. // returns true.
// - If it's the fragment holding the previous instruction but its // - If it's the fragment holding the previous instruction but its
// size changed since the the previous instruction was emitted into // size changed since the the previous instruction was emitted into
// it, returns true. // it, returns true.
// - Otherwise returns false. // - Otherwise returns false.
// - If the fragment is not a DataFragment, returns false. // - If the fragment is not a DataFragment, returns false.
if (auto *DF = dyn_cast_or_null<MCDataFragment>(F)) if (auto *DF = dyn_cast_if_present<MCDataFragment>(F))
return DF != PrevInstPosition.first || return DF != PrevInstPosition.first ||
DF->getContents().size() != PrevInstPosition.second; DF->getContents().size() != PrevInstPosition.second;
return false; return false;
} }
/// \returns the fragment size if it has instructions, otherwise returns 0. /// \returns the fragment size if it has instructions, otherwise returns 0.
static size_t getSizeForInstFragment(const MCFragment *F) { static size_t getSizeForInstFragment(const MCFragment *F) {
▲ Show 20 Lines • Show All 121 Lines • ▼ Show 20 Linesvoid X86AsmBackend::emitInstructionBegin(MCObjectStreamer &OS,
} }
} }
/// Set the last fragment to be aligned for the BoundaryAlignFragment. /// Set the last fragment to be aligned for the BoundaryAlignFragment.
void X86AsmBackend::emitInstructionEnd(MCObjectStreamer &OS, const MCInst &Inst) { void X86AsmBackend::emitInstructionEnd(MCObjectStreamer &OS, const MCInst &Inst) {
PrevInst = Inst; PrevInst = Inst;
MCFragment *CF = OS.getCurrentFragment(); MCFragment *CF = OS.getCurrentFragment();
PrevInstPosition = std::make_pair(CF, getSizeForInstFragment(CF)); PrevInstPosition = std::make_pair(CF, getSizeForInstFragment(CF));
if (auto *F = dyn_cast_or_null<MCRelaxableFragment>(CF)) if (auto *F = dyn_cast_if_present<MCRelaxableFragment>(CF))
F->setAllowAutoPadding(CanPadInst); F->setAllowAutoPadding(CanPadInst);
if (!canPadBranches(OS)) if (!canPadBranches(OS))
return; return;
if (!needAlign(Inst) || !PendingBA) if (!needAlign(Inst) || !PendingBA)
return; return;
▲ Show 20 Lines • Show All 977 Lines • Show Last 20 Lines

llvm/lib/Target/X86/X86FrameLowering.cpp

Show First 20 Lines • Show All 3,142 Lines • ▼ Show 20 Lines
static unsigned getHiPELiteral( static unsigned getHiPELiteral(
NamedMDNode *HiPELiteralsMD, const StringRef LiteralName) { NamedMDNode *HiPELiteralsMD, const StringRef LiteralName) {
for (int i = 0, e = HiPELiteralsMD->getNumOperands(); i != e; ++i) { for (int i = 0, e = HiPELiteralsMD->getNumOperands(); i != e; ++i) {
MDNode *Node = HiPELiteralsMD->getOperand(i); MDNode *Node = HiPELiteralsMD->getOperand(i);
if (Node->getNumOperands() != 2) continue; if (Node->getNumOperands() != 2) continue;
MDString *NodeName = dyn_cast<MDString>(Node->getOperand(0)); MDString *NodeName = dyn_cast<MDString>(Node->getOperand(0));
ValueAsMetadata *NodeVal = dyn_cast<ValueAsMetadata>(Node->getOperand(1)); ValueAsMetadata *NodeVal = dyn_cast<ValueAsMetadata>(Node->getOperand(1));
if (!NodeName || !NodeVal) continue; if (!NodeName || !NodeVal) continue;
ConstantInt *ValConst = dyn_cast_or_null<ConstantInt>(NodeVal->getValue()); ConstantInt *ValConst =
dyn_cast_if_present<ConstantInt>(NodeVal->getValue());
if (ValConst && NodeName->getString() == LiteralName) { if (ValConst && NodeName->getString() == LiteralName) {
return ValConst->getZExtValue(); return ValConst->getZExtValue();
} }
} }
report_fatal_error("HiPE literal " + LiteralName report_fatal_error("HiPE literal " + LiteralName
+ " required but not provided"); + " required but not provided");
} }
▲ Show 20 Lines • Show All 711 Lines • Show Last 20 Lines

llvm/lib/Target/X86/X86ISelDAGToDAG.cpp

Show First 20 Lines • Show All 87 Lines • ▼ Show 20 Lines struct X86ISelAddressMode {
bool hasBaseOrIndexReg() const { bool hasBaseOrIndexReg() const {
return BaseType == FrameIndexBase || return BaseType == FrameIndexBase ||
IndexReg.getNode() != nullptr || Base_Reg.getNode() != nullptr; IndexReg.getNode() != nullptr || Base_Reg.getNode() != nullptr;
} }
/// Return true if this addressing mode is already RIP-relative. /// Return true if this addressing mode is already RIP-relative.
bool isRIPRelative() const { bool isRIPRelative() const {
if (BaseType != RegBase) return false; if (BaseType != RegBase)
return false;
if (RegisterSDNode *RegNode = if (RegisterSDNode *RegNode =
dyn_cast_or_null<RegisterSDNode>(Base_Reg.getNode())) dyn_cast_if_present<RegisterSDNode>(Base_Reg.getNode()))
return RegNode->getReg() == X86::RIP; return RegNode->getReg() == X86::RIP;
return false; return false;
} }
void setBaseReg(SDValue Reg) { void setBaseReg(SDValue Reg) {
BaseType = RegBase; BaseType = RegBase;
Base_Reg = Reg; Base_Reg = Reg;
} }
▲ Show 20 Lines • Show All 273 Lines • ▼ Show 20 Lines bool shouldAvoidImmediateInstFormsForSize(SDNode *N) const {
// Find the other operand of the add/sub. // Find the other operand of the add/sub.
SDValue OtherOp = User->getOperand(0); SDValue OtherOp = User->getOperand(0);
if (OtherOp.getNode() == N) if (OtherOp.getNode() == N)
OtherOp = User->getOperand(1); OtherOp = User->getOperand(1);
// Don't count if the other operand is SP. // Don't count if the other operand is SP.
RegisterSDNode *RegNode; RegisterSDNode *RegNode;
if (OtherOp->getOpcode() == ISD::CopyFromReg && if (OtherOp->getOpcode() == ISD::CopyFromReg &&
(RegNode = dyn_cast_or_null<RegisterSDNode>( (RegNode = dyn_cast_if_present<RegisterSDNode>(
OtherOp->getOperand(1).getNode()))) OtherOp->getOperand(1).getNode())))
if ((RegNode->getReg() == X86::ESP) || if ((RegNode->getReg() == X86::ESP) ||
(RegNode->getReg() == X86::RSP)) (RegNode->getReg() == X86::RSP))
continue; continue;
} }
// ... otherwise, count this and move on. // ... otherwise, count this and move on.
UseCount++; UseCount++;
} }
▲ Show 20 Lines • Show All 5,800 Lines • Show Last 20 Lines

llvm/lib/Target/X86/X86ISelLowering.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 27,386 Lines • ▼ Show 20 Lines case Intrinsic::x86_seh_lsda: {
SDValue Result = DAG.getMCSymbol(LSDASym, VT); SDValue Result = DAG.getMCSymbol(LSDASym, VT);
return DAG.getNode(X86ISD::Wrapper, dl, VT, Result); return DAG.getNode(X86ISD::Wrapper, dl, VT, Result);
} }
case Intrinsic::eh_recoverfp: { case Intrinsic::eh_recoverfp: {
SDValue FnOp = Op.getOperand(1); SDValue FnOp = Op.getOperand(1);
SDValue IncomingFPOp = Op.getOperand(2); SDValue IncomingFPOp = Op.getOperand(2);
GlobalAddressSDNode *GSD = dyn_cast<GlobalAddressSDNode>(FnOp); GlobalAddressSDNode *GSD = dyn_cast<GlobalAddressSDNode>(FnOp);
auto *Fn = dyn_cast_or_null<Function>(GSD ? GSD->getGlobal() : nullptr); auto *Fn = dyn_cast_if_present<Function>(GSD ? GSD->getGlobal() : nullptr);
if (!Fn) if (!Fn)
report_fatal_error( report_fatal_error(
"llvm.eh.recoverfp must take a function as the first argument"); "llvm.eh.recoverfp must take a function as the first argument");
return recoverFramePointer(DAG, Fn, IncomingFPOp); return recoverFramePointer(DAG, Fn, IncomingFPOp);
} }
case Intrinsic::localaddress: { case Intrinsic::localaddress: {
// Returns one of the stack, base, or frame pointer registers, depending on // Returns one of the stack, base, or frame pointer registers, depending on
▲ Show 20 Lines • Show All 29,244 Lines • Show Last 20 Lines

llvm/lib/Target/X86/X86InstCombineIntrinsic.cpp

Show First 20 Lines • Show All 372 Lines • ▼ Show 20 Linesstatic Value *simplifyX86varShift(const IntrinsicInst &II,
SmallVector<int, 8> ShiftAmts; SmallVector<int, 8> ShiftAmts;
for (int I = 0; I < NumElts; ++I) { for (int I = 0; I < NumElts; ++I) {
auto *CElt = CShift->getAggregateElement(I); auto *CElt = CShift->getAggregateElement(I);
if (isa_and_nonnull<UndefValue>(CElt)) { if (isa_and_nonnull<UndefValue>(CElt)) {
ShiftAmts.push_back(-1); ShiftAmts.push_back(-1);
continue; continue;
} }
auto *COp = dyn_cast_or_null<ConstantInt>(CElt); auto *COp = dyn_cast_if_present<ConstantInt>(CElt);
if (!COp) if (!COp)
return nullptr; return nullptr;
// Handle out of range shifts. // Handle out of range shifts.
// If LogicalShift - set to BitWidth (special case). // If LogicalShift - set to BitWidth (special case).
// If ArithmeticShift - set to (BitWidth - 1) (sign splat). // If ArithmeticShift - set to (BitWidth - 1) (sign splat).
APInt ShiftVal = COp->getValue(); APInt ShiftVal = COp->getValue();
if (ShiftVal.uge(BitWidth)) { if (ShiftVal.uge(BitWidth)) {
▲ Show 20 Lines • Show All 232 Lines • ▼ Show 20 Lines auto LowConstantHighUndef = [&](uint64_t Val) {
Type *IntTy64 = Type::getInt64Ty(II.getContext()); Type *IntTy64 = Type::getInt64Ty(II.getContext());
Constant *Args[] = {ConstantInt::get(IntTy64, Val), Constant *Args[] = {ConstantInt::get(IntTy64, Val),
UndefValue::get(IntTy64)}; UndefValue::get(IntTy64)};
return ConstantVector::get(Args); return ConstantVector::get(Args);
}; };
// See if we're dealing with constant values. // See if we're dealing with constant values.
auto *C0 = dyn_cast<Constant>(Op0); auto *C0 = dyn_cast<Constant>(Op0);
auto *CI0 = auto *CI0 = C0 ? dyn_cast_if_present<ConstantInt>(
C0 ? dyn_cast_or_null<ConstantInt>(C0->getAggregateElement((unsigned)0)) C0->getAggregateElement((unsigned)0))
: nullptr; : nullptr;
// Attempt to constant fold. // Attempt to constant fold.
if (CILength && CIIndex) { if (CILength && CIIndex) {
// From AMD documentation: "The bit index and field length are each six // From AMD documentation: "The bit index and field length are each six
// bits in length other bits of the field are ignored." // bits in length other bits of the field are ignored."
APInt APIndex = CIIndex->getValue().zextOrTrunc(6); APInt APIndex = CIIndex->getValue().zextOrTrunc(6);
APInt APLength = CILength->getValue().zextOrTrunc(6); APInt APLength = CILength->getValue().zextOrTrunc(6);
▲ Show 20 Lines • Show All 115 Lines • ▼ Show 20 Lines Value *SV = Builder.CreateShuffleVector(Builder.CreateBitCast(Op0, ShufTy),
Builder.CreateBitCast(Op1, ShufTy), Builder.CreateBitCast(Op1, ShufTy),
ShuffleMask); ShuffleMask);
return Builder.CreateBitCast(SV, II.getType()); return Builder.CreateBitCast(SV, II.getType());
} }
// See if we're dealing with constant values. // See if we're dealing with constant values.
auto *C0 = dyn_cast<Constant>(Op0); auto *C0 = dyn_cast<Constant>(Op0);
auto *C1 = dyn_cast<Constant>(Op1); auto *C1 = dyn_cast<Constant>(Op1);
auto *CI00 = auto *CI00 = C0 ? dyn_cast_if_present<ConstantInt>(
C0 ? dyn_cast_or_null<ConstantInt>(C0->getAggregateElement((unsigned)0)) C0->getAggregateElement((unsigned)0))
: nullptr; : nullptr;
auto *CI10 = auto *CI10 = C1 ? dyn_cast_if_present<ConstantInt>(
C1 ? dyn_cast_or_null<ConstantInt>(C1->getAggregateElement((unsigned)0)) C1->getAggregateElement((unsigned)0))
: nullptr; : nullptr;
// Constant Fold - insert bottom Length bits starting at the Index'th bit. // Constant Fold - insert bottom Length bits starting at the Index'th bit.
if (CI00 && CI10) { if (CI00 && CI10) {
APInt V00 = CI00->getValue(); APInt V00 = CI00->getValue();
APInt V10 = CI10->getValue(); APInt V10 = CI10->getValue();
APInt Mask = APInt::getLowBitsSet(64, Length).shl(Index); APInt Mask = APInt::getLowBitsSet(64, Length).shl(Index);
V00 = V00 & ~Mask; V00 = V00 & ~Mask;
V10 = V10.zextOrTrunc(Length).zextOrTrunc(64).shl(Index); V10 = V10.zextOrTrunc(Length).zextOrTrunc(64).shl(Index);
▲ Show 20 Lines • Show All 686 Lines • ▼ Show 20 Lines case Intrinsic::x86_sse4a_extrq: {
unsigned VWidth0 = cast<FixedVectorType>(Op0->getType())->getNumElements(); unsigned VWidth0 = cast<FixedVectorType>(Op0->getType())->getNumElements();
unsigned VWidth1 = cast<FixedVectorType>(Op1->getType())->getNumElements(); unsigned VWidth1 = cast<FixedVectorType>(Op1->getType())->getNumElements();
assert(Op0->getType()->getPrimitiveSizeInBits() == 128 && assert(Op0->getType()->getPrimitiveSizeInBits() == 128 &&
Op1->getType()->getPrimitiveSizeInBits() == 128 && VWidth0 == 2 && Op1->getType()->getPrimitiveSizeInBits() == 128 && VWidth0 == 2 &&
VWidth1 == 16 && "Unexpected operand sizes"); VWidth1 == 16 && "Unexpected operand sizes");
// See if we're dealing with constant values. // See if we're dealing with constant values.
auto *C1 = dyn_cast<Constant>(Op1); auto *C1 = dyn_cast<Constant>(Op1);
auto *CILength = auto *CILength = C1 ? dyn_cast_if_present<ConstantInt>(
C1 ? dyn_cast_or_null<ConstantInt>(C1->getAggregateElement((unsigned)0)) C1->getAggregateElement((unsigned)0))
: nullptr; : nullptr;
auto *CIIndex = auto *CIIndex = C1 ? dyn_cast_if_present<ConstantInt>(
C1 ? dyn_cast_or_null<ConstantInt>(C1->getAggregateElement((unsigned)1)) C1->getAggregateElement((unsigned)1))
: nullptr; : nullptr;
// Attempt to simplify to a constant, shuffle vector or EXTRQI call. // Attempt to simplify to a constant, shuffle vector or EXTRQI call.
if (Value *V = simplifyX86extrq(II, Op0, CILength, CIIndex, IC.Builder)) { if (Value *V = simplifyX86extrq(II, Op0, CILength, CIIndex, IC.Builder)) {
return IC.replaceInstUsesWith(II, V); return IC.replaceInstUsesWith(II, V);
} }
// EXTRQ only uses the lowest 64-bits of the first 128-bit vector // EXTRQ only uses the lowest 64-bits of the first 128-bit vector
// operands and the lowest 16-bits of the second. // operands and the lowest 16-bits of the second.
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines case Intrinsic::x86_sse4a_insertq: {
unsigned VWidth = cast<FixedVectorType>(Op0->getType())->getNumElements(); unsigned VWidth = cast<FixedVectorType>(Op0->getType())->getNumElements();
assert(Op0->getType()->getPrimitiveSizeInBits() == 128 && assert(Op0->getType()->getPrimitiveSizeInBits() == 128 &&
Op1->getType()->getPrimitiveSizeInBits() == 128 && VWidth == 2 && Op1->getType()->getPrimitiveSizeInBits() == 128 && VWidth == 2 &&
cast<FixedVectorType>(Op1->getType())->getNumElements() == 2 && cast<FixedVectorType>(Op1->getType())->getNumElements() == 2 &&
"Unexpected operand size"); "Unexpected operand size");
// See if we're dealing with constant values. // See if we're dealing with constant values.
auto *C1 = dyn_cast<Constant>(Op1); auto *C1 = dyn_cast<Constant>(Op1);
auto *CI11 = auto *CI11 = C1 ? dyn_cast_if_present<ConstantInt>(
C1 ? dyn_cast_or_null<ConstantInt>(C1->getAggregateElement((unsigned)1)) C1->getAggregateElement((unsigned)1))
: nullptr; : nullptr;
// Attempt to simplify to a constant, shuffle vector or INSERTQI call. // Attempt to simplify to a constant, shuffle vector or INSERTQI call.
if (CI11) { if (CI11) {
const APInt &V11 = CI11->getValue(); const APInt &V11 = CI11->getValue();
APInt Len = V11.zextOrTrunc(6); APInt Len = V11.zextOrTrunc(6);
APInt Idx = V11.lshr(8).zextOrTrunc(6); APInt Idx = V11.lshr(8).zextOrTrunc(6);
if (Value *V = simplifyX86insertq(II, Op0, Op1, Len, Idx, IC.Builder)) { if (Value *V = simplifyX86insertq(II, Op0, Op1, Len, Idx, IC.Builder)) {
return IC.replaceInstUsesWith(II, V); return IC.replaceInstUsesWith(II, V);
▲ Show 20 Lines • Show All 482 Lines • Show Last 20 Lines

llvm/lib/Target/X86/X86Subtarget.cpp

Show First 20 Lines • Show All 207 Lines • ▼ Show 20 LinesX86Subtarget::classifyGlobalFunctionReference(const GlobalValue *GV,
if (isTargetCOFF()) { if (isTargetCOFF()) {
if (!GV) if (!GV)
return X86II::MO_NO_FLAG; return X86II::MO_NO_FLAG;
if (GV->hasDLLImportStorageClass()) if (GV->hasDLLImportStorageClass())
return X86II::MO_DLLIMPORT; return X86II::MO_DLLIMPORT;
return X86II::MO_COFFSTUB; return X86II::MO_COFFSTUB;
} }
const Function *F = dyn_cast_or_null<Function>(GV); const Function *F = dyn_cast_if_present<Function>(GV);
if (isTargetELF()) { if (isTargetELF()) {
if (is64Bit() && F && (CallingConv::X86_RegCall == F->getCallingConv())) if (is64Bit() && F && (CallingConv::X86_RegCall == F->getCallingConv()))
// According to psABI, PLT stub clobbers XMM8-XMM15. // According to psABI, PLT stub clobbers XMM8-XMM15.
// In Regcall calling convention those registers are used for passing // In Regcall calling convention those registers are used for passing
// parameters. Thus we need to prevent lazy binding in Regcall. // parameters. Thus we need to prevent lazy binding in Regcall.
return X86II::MO_GOTPCREL; return X86II::MO_GOTPCREL;
// If PLT must be avoided then the call should be via GOTPCREL. // If PLT must be avoided then the call should be via GOTPCREL.
▲ Show 20 Lines • Show All 148 Lines • Show Last 20 Lines

llvm/lib/Target/X86/X86TargetTransformInfo.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 4,186 Lines • ▼ Show 20 Lines
InstructionCost X86TTIImpl::getMemoryOpCost(unsigned Opcode, Type *Src, InstructionCost X86TTIImpl::getMemoryOpCost(unsigned Opcode, Type *Src,
MaybeAlign Alignment, MaybeAlign Alignment,
unsigned AddressSpace, unsigned AddressSpace,
TTI::TargetCostKind CostKind, TTI::TargetCostKind CostKind,
TTI::OperandValueInfo OpInfo, TTI::OperandValueInfo OpInfo,
const Instruction *I) { const Instruction *I) {
// TODO: Handle other cost kinds. // TODO: Handle other cost kinds.
if (CostKind != TTI::TCK_RecipThroughput) { if (CostKind != TTI::TCK_RecipThroughput) {
if (auto *SI = dyn_cast_or_null<StoreInst>(I)) { if (auto *SI = dyn_cast_if_present<StoreInst>(I)) {
// Store instruction with index and scale costs 2 Uops. // Store instruction with index and scale costs 2 Uops.
// Check the preceding GEP to identify non-const indices. // Check the preceding GEP to identify non-const indices.
if (auto *GEP = dyn_cast<GetElementPtrInst>(SI->getPointerOperand())) { if (auto *GEP = dyn_cast<GetElementPtrInst>(SI->getPointerOperand())) {
if (!all_of(GEP->indices(), [](Value *V) { return isa<Constant>(V); })) if (!all_of(GEP->indices(), [](Value *V) { return isa<Constant>(V); }))
return TTI::TCC_Basic * 2; return TTI::TCC_Basic * 2;
} }
} }
return TTI::TCC_Basic; return TTI::TCC_Basic;
▲ Show 20 Lines • Show All 1,973 Lines • Show Last 20 Lines

llvm/lib/Transforms/Coroutines/CoroFrame.cpp

Show First 20 Lines • Show All 1,950 Lines • ▼ Show 20 Linesstatic void rewritePHIs(BasicBlock &BB) {
// than one incoming edge. // than one incoming edge.
// TODO: Simplify PHINodes in the basic block to remove duplicate // TODO: Simplify PHINodes in the basic block to remove duplicate
// predecessors. // predecessors.
// Special case for CleanupPad: all EH blocks must have the same unwind edge // Special case for CleanupPad: all EH blocks must have the same unwind edge
// so we need to create an additional "dispatcher" block. // so we need to create an additional "dispatcher" block.
if (auto *CleanupPad = if (auto *CleanupPad =
dyn_cast_or_null<CleanupPadInst>(BB.getFirstNonPHI())) { dyn_cast_if_present<CleanupPadInst>(BB.getFirstNonPHI())) {
SmallVector<BasicBlock *, 8> Preds(predecessors(&BB)); SmallVector<BasicBlock *, 8> Preds(predecessors(&BB));
for (BasicBlock *Pred : Preds) { for (BasicBlock *Pred : Preds) {
if (CatchSwitchInst *CS = if (CatchSwitchInst *CS =
dyn_cast<CatchSwitchInst>(Pred->getTerminator())) { dyn_cast<CatchSwitchInst>(Pred->getTerminator())) {
// CleanupPad with a CatchSwitch predecessor: therefore this is an // CleanupPad with a CatchSwitch predecessor: therefore this is an
// unwind destination that needs to be handle specially. // unwind destination that needs to be handle specially.
assert(CS->getUnwindDest() == &BB); assert(CS->getUnwindDest() == &BB);
(void)CS; (void)CS;
rewritePHIsForCleanupPad(&BB, CleanupPad); rewritePHIsForCleanupPad(&BB, CleanupPad);
return; return;
} }
} }
} }
LandingPadInst *LandingPad = nullptr; LandingPadInst *LandingPad = nullptr;
PHINode *ReplPHI = nullptr; PHINode *ReplPHI = nullptr;
if ((LandingPad = dyn_cast_or_null<LandingPadInst>(BB.getFirstNonPHI()))) { if ((LandingPad = dyn_cast_if_present<LandingPadInst>(BB.getFirstNonPHI()))) {
// ehAwareSplitEdge will clone the LandingPad in all the edge blocks. // ehAwareSplitEdge will clone the LandingPad in all the edge blocks.
// We replace the original landing pad with a PHINode that will collect the // We replace the original landing pad with a PHINode that will collect the
// results from all of them. // results from all of them.
ReplPHI = PHINode::Create(LandingPad->getType(), 1, "", LandingPad); ReplPHI = PHINode::Create(LandingPad->getType(), 1, "", LandingPad);
ReplPHI->takeName(LandingPad); ReplPHI->takeName(LandingPad);
LandingPad->replaceAllUsesWith(ReplPHI); LandingPad->replaceAllUsesWith(ReplPHI);
// We will erase the original landing pad at the end of this function after // We will erase the original landing pad at the end of this function after
// ehAwareSplitEdge cloned it in the transition blocks. // ehAwareSplitEdge cloned it in the transition blocks.
▲ Show 20 Lines • Show All 586 Lines • ▼ Show 20 Linesvoid coro::salvageDebugInfo(
Builder.SetInsertPoint(&F->getEntryBlock(), InsertPt); Builder.SetInsertPoint(&F->getEntryBlock(), InsertPt);
DIExpression *Expr = DVI->getExpression(); DIExpression *Expr = DVI->getExpression();
// Follow the pointer arithmetic all the way to the incoming // Follow the pointer arithmetic all the way to the incoming
// function argument and convert into a DIExpression. // function argument and convert into a DIExpression.
bool SkipOutermostLoad = !isa<DbgValueInst>(DVI); bool SkipOutermostLoad = !isa<DbgValueInst>(DVI);
Value *Storage = DVI->getVariableLocationOp(0); Value *Storage = DVI->getVariableLocationOp(0);
Value *OriginalStorage = Storage; Value *OriginalStorage = Storage;
while (auto *Inst = dyn_cast_or_null<Instruction>(Storage)) { while (auto *Inst = dyn_cast_if_present<Instruction>(Storage)) {
if (auto *LdInst = dyn_cast<LoadInst>(Inst)) { if (auto *LdInst = dyn_cast<LoadInst>(Inst)) {
Storage = LdInst->getOperand(0); Storage = LdInst->getOperand(0);
// FIXME: This is a heuristic that works around the fact that // FIXME: This is a heuristic that works around the fact that
// LLVM IR debug intrinsics cannot yet distinguish between // LLVM IR debug intrinsics cannot yet distinguish between
// memory and value locations: Because a dbg.declare(alloca) is // memory and value locations: Because a dbg.declare(alloca) is
// implicitly a memory location no DW_OP_deref operation for the // implicitly a memory location no DW_OP_deref operation for the
// last direct load from an alloca is necessary. This condition // last direct load from an alloca is necessary. This condition
// effectively drops the *last* DW_OP_deref in the expression. // effectively drops the *last* DW_OP_deref in the expression.
▲ Show 20 Lines • Show All 238 Lines • Show Last 20 Lines

llvm/lib/Transforms/Coroutines/CoroSplit.cpp

Show First 20 Lines • Show All 1,307 Lines • ▼ Show 20 Lines if (auto *BR = dyn_cast<BranchInst>(I)) {
ConstantInt *Cond0 = TryResolveConstant(CondCmp->getOperand(0)); ConstantInt *Cond0 = TryResolveConstant(CondCmp->getOperand(0));
auto *Cond1 = dyn_cast<ConstantInt>(CondCmp->getOperand(1)); auto *Cond1 = dyn_cast<ConstantInt>(CondCmp->getOperand(1));
if (!Cond0 || !Cond1) if (!Cond0 || !Cond1)
return false; return false;
// Both operands of the CmpInst are Constant. So that we could evaluate // Both operands of the CmpInst are Constant. So that we could evaluate
// it immediately to get the destination. // it immediately to get the destination.
auto *ConstResult = auto *ConstResult =
dyn_cast_or_null<ConstantInt>(ConstantFoldCompareInstOperands( dyn_cast_if_present<ConstantInt>(ConstantFoldCompareInstOperands(
CondCmp->getPredicate(), Cond0, Cond1, DL)); CondCmp->getPredicate(), Cond0, Cond1, DL));
if (!ConstResult) if (!ConstResult)
return false; return false;
CondCmp->replaceAllUsesWith(ConstResult); CondCmp->replaceAllUsesWith(ConstResult);
CondCmp->eraseFromParent(); CondCmp->eraseFromParent();
// Handle this branch in next iteration. // Handle this branch in next iteration.
▲ Show 20 Lines • Show All 840 Lines • Show Last 20 Lines

llvm/lib/Transforms/IPO/Annotation2Metadata.cpp

Show All 27 Lines
static bool convertAnnotation2Metadata(Module &M) { static bool convertAnnotation2Metadata(Module &M) {
// Only add !annotation metadata if the corresponding remarks pass is also // Only add !annotation metadata if the corresponding remarks pass is also
// enabled. // enabled.
if (!OptimizationRemarkEmitter::allowExtraAnalysis(M.getContext(), if (!OptimizationRemarkEmitter::allowExtraAnalysis(M.getContext(),
"annotation-remarks")) "annotation-remarks"))
return false; return false;
auto *Annotations = M.getGlobalVariable("llvm.global.annotations"); auto *Annotations = M.getGlobalVariable("llvm.global.annotations");
auto *C = dyn_cast_or_null<Constant>(Annotations); auto *C = dyn_cast_if_present<Constant>(Annotations);
if (!C || C->getNumOperands() != 1) if (!C || C->getNumOperands() != 1)
return false; return false;
C = cast<Constant>(C->getOperand(0)); C = cast<Constant>(C->getOperand(0));
// Iterate over all entries in C and attach !annotation metadata to suitable // Iterate over all entries in C and attach !annotation metadata to suitable
// entries. // entries.
for (auto &Op : C->operands()) { for (auto &Op : C->operands()) {
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

llvm/lib/Transforms/IPO/Attributor.cpp

Show First 20 Lines • Show All 225 Lines • ▼ Show 20 Lines if (Constant *Init = getInitialValueOfAllocation(&Obj, TLI, &Ty))
return Init; return Init;
auto *GV = dyn_cast<GlobalVariable>(&Obj); auto *GV = dyn_cast<GlobalVariable>(&Obj);
if (!GV) if (!GV)
return nullptr; return nullptr;
if (!GV->hasLocalLinkage() && !(GV->isConstant() && GV->hasInitializer())) if (!GV->hasLocalLinkage() && !(GV->isConstant() && GV->hasInitializer()))
return nullptr; return nullptr;
if (!GV->hasInitializer()) if (!GV->hasInitializer())
return UndefValue::get(&Ty); return UndefValue::get(&Ty);
return dyn_cast_or_null<Constant>(getWithType(*GV->getInitializer(), Ty)); return dyn_cast_if_present<Constant>(getWithType(*GV->getInitializer(), Ty));
} }
bool AA::isValidInScope(const Value &V, const Function *Scope) { bool AA::isValidInScope(const Value &V, const Function *Scope) {
if (isa<Constant>(V)) if (isa<Constant>(V))
return true; return true;
if (auto *I = dyn_cast<Instruction>(&V)) if (auto *I = dyn_cast<Instruction>(&V))
return I->getFunction() == Scope; return I->getFunction() == Scope;
if (auto *A = dyn_cast<Argument>(&V)) if (auto *A = dyn_cast<Argument>(&V))
▲ Show 20 Lines • Show All 826 Lines • ▼ Show 20 LinesAttributor::getAssumedConstant(const IRPosition &IRP,
if (auto *C = dyn_cast<Constant>(&IRP.getAssociatedValue())) if (auto *C = dyn_cast<Constant>(&IRP.getAssociatedValue()))
return C; return C;
SmallVector<AA::ValueAndContext> Values; SmallVector<AA::ValueAndContext> Values;
if (getAssumedSimplifiedValues(IRP, &AA, Values, if (getAssumedSimplifiedValues(IRP, &AA, Values,
AA::ValueScope::Interprocedural, AA::ValueScope::Interprocedural,
UsedAssumedInformation)) { UsedAssumedInformation)) {
if (Values.empty()) if (Values.empty())
return llvm::None; return llvm::None;
if (auto *C = dyn_cast_or_null<Constant>( if (auto *C = dyn_cast_if_present<Constant>(
AAPotentialValues::getSingleValue(*this, AA, IRP, Values))) AAPotentialValues::getSingleValue(*this, AA, IRP, Values)))
return C; return C;
} }
return nullptr; return nullptr;
} }
Optional<Value *> Attributor::getAssumedSimplified(const IRPosition &IRP, Optional<Value *> Attributor::getAssumedSimplified(const IRPosition &IRP,
const AbstractAttribute *AA, const AbstractAttribute *AA,
▲ Show 20 Lines • Show All 919 Lines • ▼ Show 20 Lines auto ReplaceUse = [&](Use *U, Value *NewV) {
} while (true); } while (true);
Instruction *I = dyn_cast<Instruction>(U->getUser()); Instruction *I = dyn_cast<Instruction>(U->getUser());
assert((!I || isRunOn(*I->getFunction())) && assert((!I || isRunOn(*I->getFunction())) &&
"Cannot replace an instruction outside the current SCC!"); "Cannot replace an instruction outside the current SCC!");
// Do not replace uses in returns if the value is a must-tail call we will // Do not replace uses in returns if the value is a must-tail call we will
// not delete. // not delete.
if (auto *RI = dyn_cast_or_null<ReturnInst>(I)) { if (auto *RI = dyn_cast_if_present<ReturnInst>(I)) {
if (auto *CI = dyn_cast<CallInst>(OldV->stripPointerCasts())) if (auto *CI = dyn_cast<CallInst>(OldV->stripPointerCasts()))
if (CI->isMustTailCall() && !ToBeDeletedInsts.count(CI)) if (CI->isMustTailCall() && !ToBeDeletedInsts.count(CI))
return; return;
// If we rewrite a return and the new value is not an argument, strip the // If we rewrite a return and the new value is not an argument, strip the
// `returned` attribute as it is wrong now. // `returned` attribute as it is wrong now.
if (!isa<Argument>(NewV)) if (!isa<Argument>(NewV))
for (auto &Arg : RI->getFunction()->args()) for (auto &Arg : RI->getFunction()->args())
Arg.removeAttr(Attribute::Returned); Arg.removeAttr(Attribute::Returned);
} }
// Do not perform call graph altering changes outside the SCC. // Do not perform call graph altering changes outside the SCC.
if (auto *CB = dyn_cast_or_null<CallBase>(I)) if (auto *CB = dyn_cast_if_present<CallBase>(I))
if (CB->isCallee(U)) if (CB->isCallee(U))
return; return;
LLVM_DEBUG(dbgs() << "Use " << *NewV << " in " << *U->getUser() LLVM_DEBUG(dbgs() << "Use " << *NewV << " in " << *U->getUser()
<< " instead of " << *OldV << "\n"); << " instead of " << *OldV << "\n");
U->set(NewV); U->set(NewV);
if (Instruction *I = dyn_cast<Instruction>(OldV)) { if (Instruction *I = dyn_cast<Instruction>(OldV)) {
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines for (Use *U : Uses) {
if (auto *I = dyn_cast<Instruction>(U->getUser())) if (auto *I = dyn_cast<Instruction>(U->getUser()))
if (!isRunOn(*I->getFunction())) if (!isRunOn(*I->getFunction()))
continue; continue;
ReplaceUse(U, NewV); ReplaceUse(U, NewV);
} }
} }
for (const auto &V : InvokeWithDeadSuccessor) for (const auto &V : InvokeWithDeadSuccessor)
if (InvokeInst *II = dyn_cast_or_null<InvokeInst>(V)) { if (InvokeInst *II = dyn_cast_if_present<InvokeInst>(V)) {
assert(isRunOn(*II->getFunction()) && assert(isRunOn(*II->getFunction()) &&
"Cannot replace an invoke outside the current SCC!"); "Cannot replace an invoke outside the current SCC!");
bool UnwindBBIsDead = II->hasFnAttr(Attribute::NoUnwind); bool UnwindBBIsDead = II->hasFnAttr(Attribute::NoUnwind);
bool NormalBBIsDead = II->hasFnAttr(Attribute::NoReturn); bool NormalBBIsDead = II->hasFnAttr(Attribute::NoReturn);
bool Invoke2CallAllowed = bool Invoke2CallAllowed =
!AAIsDead::mayCatchAsynchronousExceptions(*II->getFunction()); !AAIsDead::mayCatchAsynchronousExceptions(*II->getFunction());
assert((UnwindBBIsDead || NormalBBIsDead) && assert((UnwindBBIsDead || NormalBBIsDead) &&
"Invoke does not have dead successors!"); "Invoke does not have dead successors!");
Show All 16 Lines for (const auto &V : InvokeWithDeadSuccessor)
} }
for (Instruction *I : TerminatorsToFold) { for (Instruction *I : TerminatorsToFold) {
assert(isRunOn(*I->getFunction()) && assert(isRunOn(*I->getFunction()) &&
"Cannot replace a terminator outside the current SCC!"); "Cannot replace a terminator outside the current SCC!");
CGModifiedFunctions.insert(I->getFunction()); CGModifiedFunctions.insert(I->getFunction());
ConstantFoldTerminator(I->getParent()); ConstantFoldTerminator(I->getParent());
} }
for (const auto &V : ToBeChangedToUnreachableInsts) for (const auto &V : ToBeChangedToUnreachableInsts)
if (Instruction *I = dyn_cast_or_null<Instruction>(V)) { if (Instruction *I = dyn_cast_if_present<Instruction>(V)) {
LLVM_DEBUG(dbgs() << "[Attributor] Change to unreachable: " << *I LLVM_DEBUG(dbgs() << "[Attributor] Change to unreachable: " << *I
<< "\n"); << "\n");
assert(isRunOn(*I->getFunction()) && assert(isRunOn(*I->getFunction()) &&
"Cannot replace an instruction outside the current SCC!"); "Cannot replace an instruction outside the current SCC!");
CGModifiedFunctions.insert(I->getFunction()); CGModifiedFunctions.insert(I->getFunction());
changeToUnreachable(I); changeToUnreachable(I);
} }
for (const auto &V : ToBeDeletedInsts) { for (const auto &V : ToBeDeletedInsts) {
if (Instruction *I = dyn_cast_or_null<Instruction>(V)) { if (Instruction *I = dyn_cast_if_present<Instruction>(V)) {
if (auto *CB = dyn_cast<CallBase>(I)) { if (auto *CB = dyn_cast<CallBase>(I)) {
assert(isRunOn(*I->getFunction()) && assert(isRunOn(*I->getFunction()) &&
"Cannot delete an instruction outside the current SCC!"); "Cannot delete an instruction outside the current SCC!");
if (!isa<IntrinsicInst>(CB)) if (!isa<IntrinsicInst>(CB))
Configuration.CGUpdater.removeCallSite(*CB); Configuration.CGUpdater.removeCallSite(*CB);
} }
I->dropDroppableUses(); I->dropDroppableUses();
CGModifiedFunctions.insert(I->getFunction()); CGModifiedFunctions.insert(I->getFunction());
▲ Show 20 Lines • Show All 1,437 Lines • Show Last 20 Lines

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 1,483 Lines • ▼ Show 20 Lines AAPointerInfoCallSiteArgument(const IRPosition &IRP, Attributor &A)
: AAPointerInfoFloating(IRP, A) {} : AAPointerInfoFloating(IRP, A) {}
/// See AbstractAttribute::updateImpl(...). /// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override { ChangeStatus updateImpl(Attributor &A) override {
using namespace AA::PointerInfo; using namespace AA::PointerInfo;
// We handle memory intrinsics explicitly, at least the first (= // We handle memory intrinsics explicitly, at least the first (=
// destination) and second (=source) arguments as we know how they are // destination) and second (=source) arguments as we know how they are
// accessed. // accessed.
if (auto *MI = dyn_cast_or_null<MemIntrinsic>(getCtxI())) { if (auto *MI = dyn_cast_if_present<MemIntrinsic>(getCtxI())) {
ConstantInt *Length = dyn_cast<ConstantInt>(MI->getLength()); ConstantInt *Length = dyn_cast<ConstantInt>(MI->getLength());
int64_t LengthVal = OffsetAndSize::Unknown; int64_t LengthVal = OffsetAndSize::Unknown;
if (Length) if (Length)
LengthVal = Length->getSExtValue(); LengthVal = Length->getSExtValue();
Value &Ptr = getAssociatedValue(); Value &Ptr = getAssociatedValue();
unsigned ArgNo = getIRPosition().getCallSiteArgNo(); unsigned ArgNo = getIRPosition().getCallSiteArgNo();
ChangeStatus Changed = ChangeStatus::UNCHANGED; ChangeStatus Changed = ChangeStatus::UNCHANGED;
if (ArgNo == 0) { if (ArgNo == 0) {
▲ Show 20 Lines • Show All 2,026 Lines • ▼ Show 20 Lines if (isa_and_nonnull<StoreInst>(I))
if (isValidState()) if (isValidState())
return "assumed-dead-store"; return "assumed-dead-store";
return AAIsDeadValueImpl::getAsStr(); return AAIsDeadValueImpl::getAsStr();
} }
/// See AbstractAttribute::updateImpl(...). /// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override { ChangeStatus updateImpl(Attributor &A) override {
Instruction *I = dyn_cast<Instruction>(&getAssociatedValue()); Instruction *I = dyn_cast<Instruction>(&getAssociatedValue());
if (auto *SI = dyn_cast_or_null<StoreInst>(I)) { if (auto *SI = dyn_cast_if_present<StoreInst>(I)) {
if (!isDeadStore(A, *SI)) if (!isDeadStore(A, *SI))
return indicatePessimisticFixpoint(); return indicatePessimisticFixpoint();
} else { } else {
if (!isAssumedSideEffectFree(A, I)) if (!isAssumedSideEffectFree(A, I))
return indicatePessimisticFixpoint(); return indicatePessimisticFixpoint();
if (!areAllUsesAssumedDead(A, getAssociatedValue())) if (!areAllUsesAssumedDead(A, getAssociatedValue()))
return indicatePessimisticFixpoint(); return indicatePessimisticFixpoint();
} }
▲ Show 20 Lines • Show All 1,946 Lines • ▼ Show 20 Linesstruct AAValueSimplifyImpl : AAValueSimplify {
/// See AbstractAttribute::manifest(...). /// See AbstractAttribute::manifest(...).
ChangeStatus manifest(Attributor &A) override { ChangeStatus manifest(Attributor &A) override {
ChangeStatus Changed = ChangeStatus::UNCHANGED; ChangeStatus Changed = ChangeStatus::UNCHANGED;
for (auto &U : getAssociatedValue().uses()) { for (auto &U : getAssociatedValue().uses()) {
// Check if we need to adjust the insertion point to make sure the IR is // Check if we need to adjust the insertion point to make sure the IR is
// valid. // valid.
Instruction *IP = dyn_cast<Instruction>(U.getUser()); Instruction *IP = dyn_cast<Instruction>(U.getUser());
if (auto *PHI = dyn_cast_or_null<PHINode>(IP)) if (auto *PHI = dyn_cast_if_present<PHINode>(IP))
IP = PHI->getIncomingBlock(U)->getTerminator(); IP = PHI->getIncomingBlock(U)->getTerminator();
if (auto *NewV = manifestReplacementValue(A, IP)) { if (auto *NewV = manifestReplacementValue(A, IP)) {
LLVM_DEBUG(dbgs() << "[ValueSimplify] " << getAssociatedValue() LLVM_DEBUG(dbgs() << "[ValueSimplify] " << getAssociatedValue()
<< " -> " << *NewV << " :: " << *this << "\n"); << " -> " << *NewV << " :: " << *this << "\n");
if (A.changeUseAfterManifest(U, *NewV)) if (A.changeUseAfterManifest(U, *NewV))
Changed = ChangeStatus::CHANGED; Changed = ChangeStatus::CHANGED;
} }
} }
▲ Show 20 Lines • Show All 528 Lines • ▼ Show 20 Linesstruct AAHeapToStackFunction final : public AAHeapToStack {
Optional<APInt> getAPInt(Attributor &A, const AbstractAttribute &AA, Optional<APInt> getAPInt(Attributor &A, const AbstractAttribute &AA,
Value &V) { Value &V) {
bool UsedAssumedInformation = false; bool UsedAssumedInformation = false;
Optional<Constant *> SimpleV = Optional<Constant *> SimpleV =
A.getAssumedConstant(V, AA, UsedAssumedInformation); A.getAssumedConstant(V, AA, UsedAssumedInformation);
if (!SimpleV) if (!SimpleV)
return APInt(64, 0); return APInt(64, 0);
if (auto *CI = dyn_cast_or_null<ConstantInt>(SimpleV.value())) if (auto *CI = dyn_cast_if_present<ConstantInt>(SimpleV.value()))
return CI->getValue(); return CI->getValue();
return llvm::None; return llvm::None;
} }
Optional<APInt> getSize(Attributor &A, const AbstractAttribute &AA, Optional<APInt> getSize(Attributor &A, const AbstractAttribute &AA,
AllocationInfo &AI) { AllocationInfo &AI) {
auto Mapper = [&](const Value *V) -> const Value * { auto Mapper = [&](const Value *V) -> const Value * {
bool UsedAssumedInformation = false; bool UsedAssumedInformation = false;
▲ Show 20 Lines • Show All 3,793 Lines • ▼ Show 20 Lines static Optional<Value *> askOtherAA(Attributor &A,
return nullptr; return nullptr;
} }
void addValue(Attributor &A, StateType &State, Value &V, void addValue(Attributor &A, StateType &State, Value &V,
const Instruction *CtxI, AA::ValueScope S, const Instruction *CtxI, AA::ValueScope S,
Function *AnchorScope) const { Function *AnchorScope) const {
IRPosition ValIRP = IRPosition::value(V); IRPosition ValIRP = IRPosition::value(V);
if (auto *CB = dyn_cast_or_null<CallBase>(CtxI)) { if (auto *CB = dyn_cast_if_present<CallBase>(CtxI)) {
for (const auto &U : CB->args()) { for (const auto &U : CB->args()) {
if (U.get() != &V) if (U.get() != &V)
continue; continue;
ValIRP = IRPosition::callsite_argument(*CB, CB->getArgOperandNo(&U)); ValIRP = IRPosition::callsite_argument(*CB, CB->getArgOperandNo(&U));
break; break;
} }
} }
▲ Show 20 Lines • Show All 225 Lines • ▼ Show 20 Lines bool handleSelectInst(Attributor &A, SelectInst &SI, ItemInfo II,
const Instruction *CtxI = II.I.getCtxI(); const Instruction *CtxI = II.I.getCtxI();
bool UsedAssumedInformation = false; bool UsedAssumedInformation = false;
Optional<Constant *> C = Optional<Constant *> C =
A.getAssumedConstant(*SI.getCondition(), *this, UsedAssumedInformation); A.getAssumedConstant(*SI.getCondition(), *this, UsedAssumedInformation);
bool NoValueYet = !C.has_value(); bool NoValueYet = !C.has_value();
if (NoValueYet || isa_and_nonnull<UndefValue>(*C)) if (NoValueYet || isa_and_nonnull<UndefValue>(*C))
return true; return true;
if (auto *CI = dyn_cast_or_null<ConstantInt>(*C)) { if (auto *CI = dyn_cast_if_present<ConstantInt>(*C)) {
if (CI->isZero()) if (CI->isZero())
Worklist.push_back({{*SI.getFalseValue(), CtxI}, II.S}); Worklist.push_back({{*SI.getFalseValue(), CtxI}, II.S});
else else
Worklist.push_back({{*SI.getTrueValue(), CtxI}, II.S}); Worklist.push_back({{*SI.getTrueValue(), CtxI}, II.S});
} else { } else {
// We could not simplify the condition, assume both values. // We could not simplify the condition, assume both values.
Worklist.push_back({{*SI.getTrueValue(), CtxI}, II.S}); Worklist.push_back({{*SI.getTrueValue(), CtxI}, II.S});
Worklist.push_back({{*SI.getFalseValue(), CtxI}, II.S}); Worklist.push_back({{*SI.getFalseValue(), CtxI}, II.S});
▲ Show 20 Lines • Show All 791 Lines • Show Last 20 Lines

llvm/lib/Transforms/IPO/CrossDSOCFI.cpp

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Lines
ModulePass *llvm::createCrossDSOCFIPass() { return new CrossDSOCFI; } ModulePass *llvm::createCrossDSOCFIPass() { return new CrossDSOCFI; }
/// Extracts a numeric type identifier from an MDNode containing type metadata. /// Extracts a numeric type identifier from an MDNode containing type metadata.
ConstantInt *CrossDSOCFI::extractNumericTypeId(MDNode *MD) { ConstantInt *CrossDSOCFI::extractNumericTypeId(MDNode *MD) {
// This check excludes vtables for classes inside anonymous namespaces. // This check excludes vtables for classes inside anonymous namespaces.
auto TM = dyn_cast<ValueAsMetadata>(MD->getOperand(1)); auto TM = dyn_cast<ValueAsMetadata>(MD->getOperand(1));
if (!TM) if (!TM)
return nullptr; return nullptr;
auto C = dyn_cast_or_null<ConstantInt>(TM->getValue()); auto C = dyn_cast_if_present<ConstantInt>(TM->getValue());
if (!C) return nullptr; if (!C) return nullptr;
// We are looking for i64 constants. // We are looking for i64 constants.
if (C->getBitWidth() != 64) return nullptr; if (C->getBitWidth() != 64) return nullptr;
return C; return C;
} }
/// buildCFICheck - emits __cfi_check for the current module. /// buildCFICheck - emits __cfi_check for the current module.
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

llvm/lib/Transforms/IPO/FunctionImport.cpp

Show First 20 Lines • Show All 628 Lines • ▼ Show 20 Lines for (auto &ExportPerModule : ImportPerModule.second)
FlattenedImports.insert(ExportPerModule.second.begin(), FlattenedImports.insert(ExportPerModule.second.begin(),
ExportPerModule.second.end()); ExportPerModule.second.end());
// Checks that all GUIDs of read/writeonly vars we see in export lists // Checks that all GUIDs of read/writeonly vars we see in export lists
// are also in the import lists. Otherwise we my face linker undefs, // are also in the import lists. Otherwise we my face linker undefs,
// because readonly and writeonly vars are internalized in their // because readonly and writeonly vars are internalized in their
// source modules. // source modules.
auto IsReadOrWriteOnlyVar = [&](StringRef ModulePath, const ValueInfo &VI) { auto IsReadOrWriteOnlyVar = [&](StringRef ModulePath, const ValueInfo &VI) {
auto *GVS = dyn_cast_or_null<GlobalVarSummary>( auto *GVS = dyn_cast_if_present<GlobalVarSummary>(
Index.findSummaryInModule(VI, ModulePath)); Index.findSummaryInModule(VI, ModulePath));
return GVS && (Index.isReadOnly(GVS) || Index.isWriteOnly(GVS)); return GVS && (Index.isReadOnly(GVS) || Index.isWriteOnly(GVS));
}; };
for (auto &ExportPerModule : ExportLists) for (auto &ExportPerModule : ExportLists)
for (auto &VI : ExportPerModule.second) for (auto &VI : ExportPerModule.second)
if (!FlattenedImports.count(VI.getGUID()) && if (!FlattenedImports.count(VI.getGUID()) &&
IsReadOrWriteOnlyVar(ExportPerModule.first(), VI)) IsReadOrWriteOnlyVar(ExportPerModule.first(), VI))
▲ Show 20 Lines • Show All 476 Lines • ▼ Show 20 Lines if (GlobalValue::isAvailableExternallyLinkage(NewLinkage) &&
LLVM_DEBUG(dbgs() << "ODR fixing up linkage for `" << GV.getName() LLVM_DEBUG(dbgs() << "ODR fixing up linkage for `" << GV.getName()
<< "` from " << GV.getLinkage() << " to " << NewLinkage << "` from " << GV.getLinkage() << " to " << NewLinkage
<< "\n"); << "\n");
GV.setLinkage(NewLinkage); GV.setLinkage(NewLinkage);
} }
// Remove declarations from comdats, including available_externally // Remove declarations from comdats, including available_externally
// as this is a declaration for the linker, and will be dropped eventually. // as this is a declaration for the linker, and will be dropped eventually.
// It is illegal for comdats to contain declarations. // It is illegal for comdats to contain declarations.
auto *GO = dyn_cast_or_null<GlobalObject>(&GV); auto *GO = dyn_cast_if_present<GlobalObject>(&GV);
if (GO && GO->isDeclarationForLinker() && GO->hasComdat()) if (GO && GO->isDeclarationForLinker() && GO->hasComdat())
GO->setComdat(nullptr); GO->setComdat(nullptr);
}; };
// Process functions and global now // Process functions and global now
for (auto &GV : TheModule) for (auto &GV : TheModule)
FinalizeInModule(GV, PropagateAttrs); FinalizeInModule(GV, PropagateAttrs);
for (auto &GV : TheModule.globals()) for (auto &GV : TheModule.globals())
▲ Show 20 Lines • Show All 292 Lines • Show Last 20 Lines

llvm/lib/Transforms/IPO/FunctionSpecialization.cpp

Show First 20 Lines • Show All 155 Lines • ▼ Show 20 Lines if (auto *Store = dyn_cast<StoreInst>(User)) {
if (StoreValue || Store->isVolatile()) if (StoreValue || Store->isVolatile())
return nullptr; return nullptr;
StoreValue = Store->getValueOperand(); StoreValue = Store->getValueOperand();
continue; continue;
} }
// Bail if there is any other unknown usage. // Bail if there is any other unknown usage.
return nullptr; return nullptr;
} }
return dyn_cast_or_null<Constant>(StoreValue); return dyn_cast_if_present<Constant>(StoreValue);
} }
// A constant stack value is an AllocaInst that has a single constant // A constant stack value is an AllocaInst that has a single constant
// value stored to it. Return this constant if such an alloca stack value // value stored to it. Return this constant if such an alloca stack value
// is a function argument. // is a function argument.
static Constant *getConstantStackValue(CallInst *Call, Value *Val, static Constant *getConstantStackValue(CallInst *Call, Value *Val,
SCCPSolver &Solver) { SCCPSolver &Solver) {
if (!Val) if (!Val)
▲ Show 20 Lines • Show All 388 Lines • ▼ Show 20 Lines InstructionCost getSpecializationCost(Function *F) {
// Otherwise, set the specialization cost to be the cost of all the // Otherwise, set the specialization cost to be the cost of all the
// instructions in the function and penalty for specializing more functions. // instructions in the function and penalty for specializing more functions.
unsigned Penalty = NbFunctionsSpecialized + 1; unsigned Penalty = NbFunctionsSpecialized + 1;
return Metrics.NumInsts * InlineConstants::getInstrCost() * Penalty; return Metrics.NumInsts * InlineConstants::getInstrCost() * Penalty;
} }
InstructionCost getUserBonus(User *U, llvm::TargetTransformInfo &TTI, InstructionCost getUserBonus(User *U, llvm::TargetTransformInfo &TTI,
LoopInfo &LI) { LoopInfo &LI) {
auto *I = dyn_cast_or_null<Instruction>(U); auto *I = dyn_cast_if_present<Instruction>(U);
// If not an instruction we do not know how to evaluate. // If not an instruction we do not know how to evaluate.
// Keep minimum possible cost for now so that it doesnt affect // Keep minimum possible cost for now so that it doesnt affect
// specialization. // specialization.
if (!I) if (!I)
return std::numeric_limits<unsigned>::min(); return std::numeric_limits<unsigned>::min();
InstructionCost Cost = InstructionCost Cost =
TTI.getInstructionCost(U, TargetTransformInfo::TCK_SizeAndLatency); TTI.getInstructionCost(U, TargetTransformInfo::TCK_SizeAndLatency);
▲ Show 20 Lines • Show All 373 Lines • Show Last 20 Lines

llvm/lib/Transforms/IPO/GlobalSplit.cpp

Show All 39 Lines
static bool splitGlobal(GlobalVariable &GV) { static bool splitGlobal(GlobalVariable &GV) {
// If the address of the global is taken outside of the module, we cannot // If the address of the global is taken outside of the module, we cannot
// apply this transformation. // apply this transformation.
if (!GV.hasLocalLinkage()) if (!GV.hasLocalLinkage())
return false; return false;
// We currently only know how to split ConstantStructs. // We currently only know how to split ConstantStructs.
auto *Init = dyn_cast_or_null<ConstantStruct>(GV.getInitializer()); auto *Init = dyn_cast_if_present<ConstantStruct>(GV.getInitializer());
if (!Init) if (!Init)
return false; return false;
// Verify that each user of the global is an inrange getelementptr constant. // Verify that each user of the global is an inrange getelementptr constant.
// From this it follows that any loads from or stores to that global must use // From this it follows that any loads from or stores to that global must use
// a pointer derived from an inrange getelementptr constant, which is // a pointer derived from an inrange getelementptr constant, which is
// sufficient to allow us to apply the splitting transform. // sufficient to allow us to apply the splitting transform.
for (User *U : GV.users()) { for (User *U : GV.users()) {
▲ Show 20 Lines • Show All 137 Lines • Show Last 20 Lines

llvm/lib/Transforms/IPO/HotColdSplitting.cpp

Show First 20 Lines • Show All 115 Lines • ▼ Show 20 Lines if (auto *CB = dyn_cast<CallBase>(&I))
if (CB->hasFnAttr(Attribute::Cold) && if (CB->hasFnAttr(Attribute::Cold) &&
!CB->getMetadata(LLVMContext::MD_nosanitize)) !CB->getMetadata(LLVMContext::MD_nosanitize))
return true; return true;
// The block is cold if it has an unreachable terminator, unless it's // The block is cold if it has an unreachable terminator, unless it's
// preceded by a call to a (possibly warm) noreturn call (e.g. longjmp). // preceded by a call to a (possibly warm) noreturn call (e.g. longjmp).
if (blockEndsInUnreachable(BB)) { if (blockEndsInUnreachable(BB)) {
if (auto *CI = if (auto *CI =
dyn_cast_or_null<CallInst>(BB.getTerminator()->getPrevNode())) dyn_cast_if_present<CallInst>(BB.getTerminator()->getPrevNode()))
if (CI->hasFnAttr(Attribute::NoReturn)) if (CI->hasFnAttr(Attribute::NoReturn))
return false; return false;
return true; return true;
} }
return false; return false;
} }
▲ Show 20 Lines • Show All 651 Lines • Show Last 20 Lines

llvm/lib/Transforms/IPO/IROutliner.cpp

Show First 20 Lines • Show All 727 Lines • ▼ Show 20 Lines for (Instruction &Val : CurrBB) {
// Remove the debug information for outlined functions. // Remove the debug information for outlined functions.
Val.setDebugLoc(DebugLoc()); Val.setDebugLoc(DebugLoc());
// Loop info metadata may contain line locations. Update them to have no // Loop info metadata may contain line locations. Update them to have no
// value in the new subprogram since the outlined code could be from // value in the new subprogram since the outlined code could be from
// several locations. // several locations.
auto updateLoopInfoLoc = [&New](Metadata *MD) -> Metadata * { auto updateLoopInfoLoc = [&New](Metadata *MD) -> Metadata * {
if (DISubprogram *SP = New.getSubprogram()) if (DISubprogram *SP = New.getSubprogram())
if (auto *Loc = dyn_cast_or_null<DILocation>(MD)) if (auto *Loc = dyn_cast_if_present<DILocation>(MD))
return DILocation::get(New.getContext(), Loc->getLine(), return DILocation::get(New.getContext(), Loc->getLine(),
Loc->getColumn(), SP, nullptr); Loc->getColumn(), SP, nullptr);
return MD; return MD;
}; };
updateLoopMetadataDebugLocations(Val, updateLoopInfoLoc); updateLoopMetadataDebugLocations(Val, updateLoopInfoLoc);
continue; continue;
} }
▲ Show 20 Lines • Show All 2,343 Lines • Show Last 20 Lines

llvm/lib/Transforms/IPO/MergeFunctions.cpp

Show First 20 Lines • Show All 576 Lines • ▼ Show 20 Lines for (BasicBlock::iterator BI = GEntryBlock->begin(), BIE = GEntryBlock->end();
} else if (auto *DDI = dyn_cast<DbgDeclareInst>(&*BI)) { } else if (auto *DDI = dyn_cast<DbgDeclareInst>(&*BI)) {
LLVM_DEBUG(dbgs() << " Deciding: "); LLVM_DEBUG(dbgs() << " Deciding: ");
LLVM_DEBUG(BI->print(dbgs())); LLVM_DEBUG(BI->print(dbgs()));
LLVM_DEBUG(dbgs() << "\n"); LLVM_DEBUG(dbgs() << "\n");
DILocalVariable *DILocVar = DDI->getVariable(); DILocalVariable *DILocVar = DDI->getVariable();
if (DILocVar->isParameter()) { if (DILocVar->isParameter()) {
LLVM_DEBUG(dbgs() << " Parameter: "); LLVM_DEBUG(dbgs() << " Parameter: ");
LLVM_DEBUG(DILocVar->print(dbgs())); LLVM_DEBUG(DILocVar->print(dbgs()));
AllocaInst *AI = dyn_cast_or_null<AllocaInst>(DDI->getAddress()); AllocaInst *AI = dyn_cast_if_present<AllocaInst>(DDI->getAddress());
if (AI) { if (AI) {
LLVM_DEBUG(dbgs() << " Processing alloca users: "); LLVM_DEBUG(dbgs() << " Processing alloca users: ");
LLVM_DEBUG(dbgs() << "\n"); LLVM_DEBUG(dbgs() << "\n");
for (User *U : AI->users()) { for (User *U : AI->users()) {
if (StoreInst *SI = dyn_cast<StoreInst>(U)) { if (StoreInst *SI = dyn_cast<StoreInst>(U)) {
if (Value *Arg = SI->getValueOperand()) { if (Value *Arg = SI->getValueOperand()) {
if (isa<Argument>(Arg)) { if (isa<Argument>(Arg)) {
LLVM_DEBUG(dbgs() << " Include: "); LLVM_DEBUG(dbgs() << " Include: ");
▲ Show 20 Lines • Show All 368 Lines • Show Last 20 Lines

llvm/lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp

Show First 20 Lines • Show All 274 Lines • ▼ Show 20 Linesvoid splitAndWriteThinLTOBitcode(
// Returns whether a global or its associated global has attached type // Returns whether a global or its associated global has attached type
// metadata. The former may participate in CFI or whole-program // metadata. The former may participate in CFI or whole-program
// devirtualization, so they need to appear in the merged module instead of // devirtualization, so they need to appear in the merged module instead of
// the thin LTO module. Similarly, globals that are associated with globals // the thin LTO module. Similarly, globals that are associated with globals
// with type metadata need to appear in the merged module because they will // with type metadata need to appear in the merged module because they will
// reference the global's section directly. // reference the global's section directly.
auto HasTypeMetadata = [](const GlobalObject *GO) { auto HasTypeMetadata = [](const GlobalObject *GO) {
if (MDNode *MD = GO->getMetadata(LLVMContext::MD_associated)) if (MDNode *MD = GO->getMetadata(LLVMContext::MD_associated))
if (auto *AssocVM = dyn_cast_or_null<ValueAsMetadata>(MD->getOperand(0))) if (auto *AssocVM =
dyn_cast_if_present<ValueAsMetadata>(MD->getOperand(0)))
if (auto *AssocGO = dyn_cast<GlobalObject>(AssocVM->getValue())) if (auto *AssocGO = dyn_cast<GlobalObject>(AssocVM->getValue()))
if (AssocGO->hasMetadata(LLVMContext::MD_type)) if (AssocGO->hasMetadata(LLVMContext::MD_type))
return true; return true;
return GO->hasMetadata(LLVMContext::MD_type); return GO->hasMetadata(LLVMContext::MD_type);
}; };
// Collect the set of virtual functions that are eligible for virtual constant // Collect the set of virtual functions that are eligible for virtual constant
// propagation. Each eligible function must not access memory, must return // propagation. Each eligible function must not access memory, must return
Show All 36 Linesvoid splitAndWriteThinLTOBitcode(
std::unique_ptr<Module> MergedM( std::unique_ptr<Module> MergedM(
CloneModule(M, VMap, [&](const GlobalValue *GV) -> bool { CloneModule(M, VMap, [&](const GlobalValue *GV) -> bool {
if (const auto *C = GV->getComdat()) if (const auto *C = GV->getComdat())
if (MergedMComdats.count(C)) if (MergedMComdats.count(C))
return true; return true;
if (auto *F = dyn_cast<Function>(GV)) if (auto *F = dyn_cast<Function>(GV))
return EligibleVirtualFns.count(F); return EligibleVirtualFns.count(F);
if (auto *GVar = if (auto *GVar =
dyn_cast_or_null<GlobalVariable>(GV->getAliaseeObject())) dyn_cast_if_present<GlobalVariable>(GV->getAliaseeObject()))
return HasTypeMetadata(GVar); return HasTypeMetadata(GVar);
return false; return false;
})); }));
StripDebugInfo(*MergedM); StripDebugInfo(*MergedM);
MergedM->setModuleInlineAsm(""); MergedM->setModuleInlineAsm("");
// Clone any llvm.*used globals to ensure the included values are // Clone any llvm.*used globals to ensure the included values are
// not deleted. // not deleted.
Show All 12 Linesvoid splitAndWriteThinLTOBitcode(
SetVector<GlobalValue *> CfiFunctions; SetVector<GlobalValue *> CfiFunctions;
for (auto &F : M) for (auto &F : M)
if ((!F.hasLocalLinkage() || F.hasAddressTaken()) && HasTypeMetadata(&F)) if ((!F.hasLocalLinkage() || F.hasAddressTaken()) && HasTypeMetadata(&F))
CfiFunctions.insert(&F); CfiFunctions.insert(&F);
// Remove all globals with type metadata, globals with comdats that live in // Remove all globals with type metadata, globals with comdats that live in
// MergedM, and aliases pointing to such globals from the thin LTO module. // MergedM, and aliases pointing to such globals from the thin LTO module.
filterModule(&M, [&](const GlobalValue *GV) { filterModule(&M, [&](const GlobalValue *GV) {
if (auto *GVar = dyn_cast_or_null<GlobalVariable>(GV->getAliaseeObject())) if (auto *GVar =
dyn_cast_if_present<GlobalVariable>(GV->getAliaseeObject()))
if (HasTypeMetadata(GVar)) if (HasTypeMetadata(GVar))
return false; return false;
if (const auto *C = GV->getComdat()) if (const auto *C = GV->getComdat())
if (MergedMComdats.count(C)) if (MergedMComdats.count(C))
return false; return false;
return true; return true;
}); });
▲ Show 20 Lines • Show All 188 Lines • Show Last 20 Lines

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

Show First 20 Lines • Show All 2,011 Lines • ▼ Show 20 Lines if (Constant *CV0 = dyn_cast<Constant>(Arg0)) {
// Couldn't simplify - canonicalize constant to the RHS. // Couldn't simplify - canonicalize constant to the RHS.
std::swap(Arg0, Arg1); std::swap(Arg0, Arg1);
} }
// Handle mul by one: // Handle mul by one:
if (Constant *CV1 = dyn_cast<Constant>(Arg1)) if (Constant *CV1 = dyn_cast<Constant>(Arg1))
if (ConstantInt *Splat = if (ConstantInt *Splat =
dyn_cast_or_null<ConstantInt>(CV1->getSplatValue())) dyn_cast_if_present<ConstantInt>(CV1->getSplatValue()))
if (Splat->isOne()) if (Splat->isOne())
return CastInst::CreateIntegerCast(Arg0, II->getType(), return CastInst::CreateIntegerCast(Arg0, II->getType(),
/*isSigned=*/!Zext); /*isSigned=*/!Zext);
break; break;
} }
case Intrinsic::arm_neon_aesd: case Intrinsic::arm_neon_aesd:
case Intrinsic::arm_neon_aese: case Intrinsic::arm_neon_aese:
▲ Show 20 Lines • Show All 706 Lines • ▼ Show 20 Lines if (FI1SyncScope != FI2->getSyncScopeID() ||
FI1SyncScope != SyncScope::SingleThread)) FI1SyncScope != SyncScope::SingleThread))
return false; return false;
return isAtLeastOrStrongerThan(FI1->getOrdering(), FI2->getOrdering()); return isAtLeastOrStrongerThan(FI1->getOrdering(), FI2->getOrdering());
}; };
if (NFI && isIdenticalOrStrongerFence(NFI, &FI)) if (NFI && isIdenticalOrStrongerFence(NFI, &FI))
return eraseInstFromFunction(FI); return eraseInstFromFunction(FI);
if (auto *PFI = dyn_cast_or_null<FenceInst>(FI.getPrevNonDebugInstruction())) if (auto *PFI =
dyn_cast_if_present<FenceInst>(FI.getPrevNonDebugInstruction()))
if (isIdenticalOrStrongerFence(PFI, &FI)) if (isIdenticalOrStrongerFence(PFI, &FI))
return eraseInstFromFunction(FI); return eraseInstFromFunction(FI);
return nullptr; return nullptr;
} }
// InvokeInst simplification // InvokeInst simplification
Instruction *InstCombinerImpl::visitInvokeInst(InvokeInst &II) { Instruction *InstCombinerImpl::visitInvokeInst(InvokeInst &II) {
return visitCallBase(II); return visitCallBase(II);
▲ Show 20 Lines • Show All 929 Lines • Show Last 20 Lines

llvm/lib/Transforms/InstCombine/InstCombineCasts.cpp

Show First 20 Lines • Show All 1,662 Lines • ▼ Show 20 Linesstatic Type *shrinkFPConstantVector(Value *V) {
unsigned NumElts = CVVTy->getNumElements(); unsigned NumElts = CVVTy->getNumElements();
// For fixed-width vectors we find the minimal type by looking // For fixed-width vectors we find the minimal type by looking
// through the constant values of the vector. // through the constant values of the vector.
for (unsigned i = 0; i != NumElts; ++i) { for (unsigned i = 0; i != NumElts; ++i) {
if (isa<UndefValue>(CV->getAggregateElement(i))) if (isa<UndefValue>(CV->getAggregateElement(i)))
continue; continue;
auto *CFP = dyn_cast_or_null<ConstantFP>(CV->getAggregateElement(i)); auto *CFP = dyn_cast_if_present<ConstantFP>(CV->getAggregateElement(i));
if (!CFP) if (!CFP)
return nullptr; return nullptr;
Type *T = shrinkFPConstant(CFP); Type *T = shrinkFPConstant(CFP);
if (!T) if (!T)
return nullptr; return nullptr;
// If we haven't found a type yet or this type has a larger mantissa than // If we haven't found a type yet or this type has a larger mantissa than
▲ Show 20 Lines • Show All 1,244 Lines • Show Last 20 Lines

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 3,947 Lines • ▼ Show 20 Lines unsigned MaximalPossibleTotalShiftAmount =
(WidestTy->getScalarSizeInBits() - 1) + (WidestTy->getScalarSizeInBits() - 1) +
(NarrowestTy->getScalarSizeInBits() - 1); (NarrowestTy->getScalarSizeInBits() - 1);
APInt MaximalRepresentableShiftAmount = APInt MaximalRepresentableShiftAmount =
APInt::getAllOnes(XShAmt->getType()->getScalarSizeInBits()); APInt::getAllOnes(XShAmt->getType()->getScalarSizeInBits());
if (MaximalRepresentableShiftAmount.ult(MaximalPossibleTotalShiftAmount)) if (MaximalRepresentableShiftAmount.ult(MaximalPossibleTotalShiftAmount))
return nullptr; return nullptr;
// Can we fold (XShAmt+YShAmt) ? // Can we fold (XShAmt+YShAmt) ?
auto *NewShAmt = dyn_cast_or_null<Constant>( auto *NewShAmt = dyn_cast_if_present<Constant>(
simplifyAddInst(XShAmt, YShAmt, /*isNSW=*/false, simplifyAddInst(XShAmt, YShAmt, /*isNSW=*/false,
/*isNUW=*/false, SQ.getWithInstruction(&I))); /*isNUW=*/false, SQ.getWithInstruction(&I)));
if (!NewShAmt) if (!NewShAmt)
return nullptr; return nullptr;
NewShAmt = ConstantExpr::getZExtOrBitCast(NewShAmt, WidestTy); NewShAmt = ConstantExpr::getZExtOrBitCast(NewShAmt, WidestTy);
unsigned WidestBitWidth = WidestTy->getScalarSizeInBits(); unsigned WidestBitWidth = WidestTy->getScalarSizeInBits();
// Is the new shift amount smaller than the bit width? // Is the new shift amount smaller than the bit width?
▲ Show 20 Lines • Show All 1,491 Lines • ▼ Show 20 Linesbool InstCombinerImpl::dominatesAllUses(const Instruction *DI,
return true; return true;
} }
/// Return true when the instruction sequence within a block is select-cmp-br. /// Return true when the instruction sequence within a block is select-cmp-br.
static bool isChainSelectCmpBranch(const SelectInst *SI) { static bool isChainSelectCmpBranch(const SelectInst *SI) {
const BasicBlock *BB = SI->getParent(); const BasicBlock *BB = SI->getParent();
if (!BB) if (!BB)
return false; return false;
auto *BI = dyn_cast_or_null<BranchInst>(BB->getTerminator()); auto *BI = dyn_cast_if_present<BranchInst>(BB->getTerminator());
if (!BI || BI->getNumSuccessors() != 2) if (!BI || BI->getNumSuccessors() != 2)
return false; return false;
auto *IC = dyn_cast<ICmpInst>(BI->getCondition()); auto *IC = dyn_cast<ICmpInst>(BI->getCondition());
if (!IC || (IC->getOperand(0) != SI && IC->getOperand(1) != SI)) if (!IC || (IC->getOperand(0) != SI && IC->getOperand(1) != SI))
return false; return false;
return true; return true;
} }
▲ Show 20 Lines • Show All 1,556 Lines • Show Last 20 Lines

llvm/lib/Transforms/InstCombine/InstCombineShifts.cpp

Show First 20 Lines • Show All 100 Lines • ▼ Show 20 LinesValue *InstCombinerImpl::reassociateShiftAmtsOfTwoSameDirectionShifts(
// If we saw truncation, we'll need to produce extra instruction, // If we saw truncation, we'll need to produce extra instruction,
// and for that one of the operands of the shift must be one-use, // and for that one of the operands of the shift must be one-use,
// unless of course we don't actually plan to produce any instructions here. // unless of course we don't actually plan to produce any instructions here.
if (Trunc && !AnalyzeForSignBitExtraction && if (Trunc && !AnalyzeForSignBitExtraction &&
!match(Sh0, m_c_BinOp(m_OneUse(m_Value()), m_Value()))) !match(Sh0, m_c_BinOp(m_OneUse(m_Value()), m_Value())))
return nullptr; return nullptr;
// Can we fold (ShAmt0+ShAmt1) ? // Can we fold (ShAmt0+ShAmt1) ?
auto *NewShAmt = dyn_cast_or_null<Constant>( auto *NewShAmt = dyn_cast_if_present<Constant>(
simplifyAddInst(ShAmt0, ShAmt1, /*isNSW=*/false, /*isNUW=*/false, simplifyAddInst(ShAmt0, ShAmt1, /*isNSW=*/false, /*isNUW=*/false,
SQ.getWithInstruction(Sh0))); SQ.getWithInstruction(Sh0)));
if (!NewShAmt) if (!NewShAmt)
return nullptr; // Did not simplify. return nullptr; // Did not simplify.
unsigned NewShAmtBitWidth = NewShAmt->getType()->getScalarSizeInBits(); unsigned NewShAmtBitWidth = NewShAmt->getType()->getScalarSizeInBits();
unsigned XBitWidth = X->getType()->getScalarSizeInBits(); unsigned XBitWidth = X->getType()->getScalarSizeInBits();
// Is the new shift amount smaller than the bit width of inner/new shift? // Is the new shift amount smaller than the bit width of inner/new shift?
if (!match(NewShAmt, m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT, if (!match(NewShAmt, m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT,
▲ Show 20 Lines • Show All 108 Lines • ▼ Show 20 Lines if (match(Masked, m_c_And(m_CombineOr(MaskA, MaskB), m_Value(X)))) {
match(MaskShAmt, m_ZExtOrSelf(m_Value(MaskShAmt))); match(MaskShAmt, m_ZExtOrSelf(m_Value(MaskShAmt)));
// Verify that it would be safe to try to add those two shift amounts. // Verify that it would be safe to try to add those two shift amounts.
if (!canTryToConstantAddTwoShiftAmounts(OuterShift, ShiftShAmt, Masked, if (!canTryToConstantAddTwoShiftAmounts(OuterShift, ShiftShAmt, Masked,
MaskShAmt)) MaskShAmt))
return nullptr; return nullptr;
// Can we simplify (MaskShAmt+ShiftShAmt) ? // Can we simplify (MaskShAmt+ShiftShAmt) ?
auto *SumOfShAmts = dyn_cast_or_null<Constant>(simplifyAddInst( auto *SumOfShAmts = dyn_cast_if_present<Constant>(simplifyAddInst(
MaskShAmt, ShiftShAmt, /*IsNSW=*/false, /*IsNUW=*/false, Q)); MaskShAmt, ShiftShAmt, /*IsNSW=*/false, /*IsNUW=*/false, Q));
if (!SumOfShAmts) if (!SumOfShAmts)
return nullptr; // Did not simplify. return nullptr; // Did not simplify.
// In this pattern SumOfShAmts correlates with the number of low bits // In this pattern SumOfShAmts correlates with the number of low bits
// that shall remain in the root value (OuterShift). // that shall remain in the root value (OuterShift).
// An extend of an undef value becomes zero because the high bits are never // An extend of an undef value becomes zero because the high bits are never
// completely unknown. Replace the `undef` shift amounts with final // completely unknown. Replace the `undef` shift amounts with final
Show All 15 Lines if (match(Masked, m_c_And(m_CombineOr(MaskA, MaskB), m_Value(X)))) {
match(MaskShAmt, m_ZExtOrSelf(m_Value(MaskShAmt))); match(MaskShAmt, m_ZExtOrSelf(m_Value(MaskShAmt)));
// Verify that it would be safe to try to add those two shift amounts. // Verify that it would be safe to try to add those two shift amounts.
if (!canTryToConstantAddTwoShiftAmounts(OuterShift, ShiftShAmt, Masked, if (!canTryToConstantAddTwoShiftAmounts(OuterShift, ShiftShAmt, Masked,
MaskShAmt)) MaskShAmt))
return nullptr; return nullptr;
// Can we simplify (ShiftShAmt-MaskShAmt) ? // Can we simplify (ShiftShAmt-MaskShAmt) ?
auto *ShAmtsDiff = dyn_cast_or_null<Constant>(simplifySubInst( auto *ShAmtsDiff = dyn_cast_if_present<Constant>(simplifySubInst(
ShiftShAmt, MaskShAmt, /*IsNSW=*/false, /*IsNUW=*/false, Q)); ShiftShAmt, MaskShAmt, /*IsNSW=*/false, /*IsNUW=*/false, Q));
if (!ShAmtsDiff) if (!ShAmtsDiff)
return nullptr; // Did not simplify. return nullptr; // Did not simplify.
// In this pattern ShAmtsDiff correlates with the number of high bits that // In this pattern ShAmtsDiff correlates with the number of high bits that
// shall be unset in the root value (OuterShift). // shall be unset in the root value (OuterShift).
// An extend of an undef value becomes zero because the high bits are never // An extend of an undef value becomes zero because the high bits are never
// completely unknown. Replace the `undef` shift amounts with negated // completely unknown. Replace the `undef` shift amounts with negated
▲ Show 20 Lines • Show All 1,210 Lines • Show Last 20 Lines

llvm/lib/Transforms/InstCombine/InstCombineVectorOps.cpp

Show First 20 Lines • Show All 939 Lines • ▼ Show 20 Lines auto FindSourceAggregate =
[&](Instruction *Elt, unsigned EltIdx, Optional<BasicBlock *> UseBB, [&](Instruction *Elt, unsigned EltIdx, Optional<BasicBlock *> UseBB,
Optional<BasicBlock *> PredBB) -> Optional<Value *> { Optional<BasicBlock *> PredBB) -> Optional<Value *> {
// For now(?), only deal with, at most, a single level of PHI indirection. // For now(?), only deal with, at most, a single level of PHI indirection.
if (UseBB && PredBB) if (UseBB && PredBB)
Elt = dyn_cast<Instruction>(Elt->DoPHITranslation(*UseBB, *PredBB)); Elt = dyn_cast<Instruction>(Elt->DoPHITranslation(*UseBB, *PredBB));
// FIXME: deal with multiple levels of PHI indirection? // FIXME: deal with multiple levels of PHI indirection?
// Did we find an extraction? // Did we find an extraction?
auto *EVI = dyn_cast_or_null<ExtractValueInst>(Elt); auto *EVI = dyn_cast_if_present<ExtractValueInst>(Elt);
if (!EVI) if (!EVI)
return NotFound; return NotFound;
Value *SourceAggregate = EVI->getAggregateOperand(); Value *SourceAggregate = EVI->getAggregateOperand();
// Is the extraction from the same type into which the insertion was? // Is the extraction from the same type into which the insertion was?
if (SourceAggregate->getType() != AggTy) if (SourceAggregate->getType() != AggTy)
return FoundMismatch; return FoundMismatch;
▲ Show 20 Lines • Show All 1,974 Lines • Show Last 20 Lines

llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

Show First 20 Lines • Show All 4,364 Lines • ▼ Show 20 Lines
public: public:
void analyse(Instruction *I) { void analyse(Instruction *I) {
// This seems to be faster than checking 'mayReadOrWriteMemory()'. // This seems to be faster than checking 'mayReadOrWriteMemory()'.
if (!I->hasMetadataOtherThanDebugLoc()) if (!I->hasMetadataOtherThanDebugLoc())
return; return;
auto Track = [](Metadata *ScopeList, auto &Container) { auto Track = [](Metadata *ScopeList, auto &Container) {
const auto *MDScopeList = dyn_cast_or_null<MDNode>(ScopeList); const auto *MDScopeList = dyn_cast_if_present<MDNode>(ScopeList);
if (!MDScopeList || !Container.insert(MDScopeList).second) if (!MDScopeList || !Container.insert(MDScopeList).second)
return; return;
for (const auto &MDOperand : MDScopeList->operands()) for (const auto &MDOperand : MDScopeList->operands())
if (auto *MDScope = dyn_cast<MDNode>(MDOperand)) if (auto *MDScope = dyn_cast<MDNode>(MDOperand))
Container.insert(MDScope); Container.insert(MDScope);
}; };
Track(I->getMetadata(LLVMContext::MD_alias_scope), UsedAliasScopesAndLists); Track(I->getMetadata(LLVMContext::MD_alias_scope), UsedAliasScopesAndLists);
▲ Show 20 Lines • Show All 336 Lines • Show Last 20 Lines

llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp

Show First 20 Lines • Show All 1,251 Lines • ▼ Show 20 Linesbool AddressSanitizer::ignoreAccess(Instruction *Inst, Value *Ptr) {
// selection. As such they cannot have regular uses like an instrumentation // selection. As such they cannot have regular uses like an instrumentation
// function and it makes no sense to track them as memory. // function and it makes no sense to track them as memory.
if (Ptr->isSwiftError()) if (Ptr->isSwiftError())
return true; return true;
// Treat memory accesses to promotable allocas as non-interesting since they // Treat memory accesses to promotable allocas as non-interesting since they
// will not cause memory violations. This greatly speeds up the instrumented // will not cause memory violations. This greatly speeds up the instrumented
// executable at -O0. // executable at -O0.
if (auto AI = dyn_cast_or_null<AllocaInst>(Ptr)) if (auto AI = dyn_cast_if_present<AllocaInst>(Ptr))
if (ClSkipPromotableAllocas && !isInterestingAlloca(*AI)) if (ClSkipPromotableAllocas && !isInterestingAlloca(*AI))
return true; return true;
if (SSGI != nullptr && SSGI->stackAccessIsSafe(*Inst) && if (SSGI != nullptr && SSGI->stackAccessIsSafe(*Inst) &&
findAllocaForValue(Ptr)) findAllocaForValue(Ptr))
return true; return true;
return false; return false;
▲ Show 20 Lines • Show All 2,178 Lines • Show Last 20 Lines

llvm/lib/Transforms/Instrumentation/BoundsChecking.cpp

Show First 20 Lines • Show All 106 Lines • ▼ Show 20 Lines
/// Adds run-time bounds checks to memory accessing instructions. /// Adds run-time bounds checks to memory accessing instructions.
/// ///
/// \p Or is the condition that should guard the trap. /// \p Or is the condition that should guard the trap.
/// ///
/// \p GetTrapBB is a callable that returns the trap BB to use on failure. /// \p GetTrapBB is a callable that returns the trap BB to use on failure.
template <typename GetTrapBBT> template <typename GetTrapBBT>
static void insertBoundsCheck(Value *Or, BuilderTy &IRB, GetTrapBBT GetTrapBB) { static void insertBoundsCheck(Value *Or, BuilderTy &IRB, GetTrapBBT GetTrapBB) {
// check if the comparison is always false // check if the comparison is always false
ConstantInt *C = dyn_cast_or_null<ConstantInt>(Or); ConstantInt *C = dyn_cast_if_present<ConstantInt>(Or);
if (C) { if (C) {
++ChecksSkipped; ++ChecksSkipped;
// If non-zero, nothing to do. // If non-zero, nothing to do.
if (!C->getZExtValue()) if (!C->getZExtValue())
return; return;
} }
++ChecksAdded; ++ChecksAdded;
▲ Show 20 Lines • Show All 133 Lines • Show Last 20 Lines

llvm/lib/Transforms/Instrumentation/InstrProfiling.cpp

Show First 20 Lines • Show All 174 Lines • ▼ Show 20 Lines for (unsigned i = 0, e = ExitBlocks.size(); i != e; ++i) {
Instruction *InsertPos = InsertPts[i]; Instruction *InsertPos = InsertPts[i];
// Get LiveIn value into the ExitBlock. If there are multiple // Get LiveIn value into the ExitBlock. If there are multiple
// predecessors, the value is defined by a PHI node in this // predecessors, the value is defined by a PHI node in this
// block. // block.
Value *LiveInValue = SSA.GetValueInMiddleOfBlock(ExitBlock); Value *LiveInValue = SSA.GetValueInMiddleOfBlock(ExitBlock);
Value *Addr = cast<StoreInst>(Store)->getPointerOperand(); Value *Addr = cast<StoreInst>(Store)->getPointerOperand();
Type *Ty = LiveInValue->getType(); Type *Ty = LiveInValue->getType();
IRBuilder<> Builder(InsertPos); IRBuilder<> Builder(InsertPos);
if (auto *AddrInst = dyn_cast_or_null<IntToPtrInst>(Addr)) { if (auto *AddrInst = dyn_cast_if_present<IntToPtrInst>(Addr)) {
// If isRuntimeCounterRelocationEnabled() is true then the address of // If isRuntimeCounterRelocationEnabled() is true then the address of
// the store instruction is computed with two instructions in // the store instruction is computed with two instructions in
// InstrProfiling::getCounterAddress(). We need to copy those // InstrProfiling::getCounterAddress(). We need to copy those
// instructions to this block to compute Addr correctly. // instructions to this block to compute Addr correctly.
// %BiasAdd = add i64 ptrtoint <__profc_>, <__llvm_profile_counter_bias> // %BiasAdd = add i64 ptrtoint <__profc_>, <__llvm_profile_counter_bias>
// %Addr = inttoptr i64 %BiasAdd to i64* // %Addr = inttoptr i64 %BiasAdd to i64*
auto *OrigBiasInst = dyn_cast<BinaryOperator>(AddrInst->getOperand(0)); auto *OrigBiasInst = dyn_cast<BinaryOperator>(AddrInst->getOperand(0));
assert(OrigBiasInst->getOpcode() == Instruction::BinaryOps::Add); assert(OrigBiasInst->getOpcode() == Instruction::BinaryOps::Add);
▲ Show 20 Lines • Show All 563 Lines • ▼ Show 20 Linesstatic std::string getVarName(InstrProfInstBase *Inc, StringRef Prefix,
uint64_t FuncHash = Inc->getHash()->getZExtValue(); uint64_t FuncHash = Inc->getHash()->getZExtValue();
SmallVector<char, 24> HashPostfix; SmallVector<char, 24> HashPostfix;
if (Name.endswith((Twine(".") + Twine(FuncHash)).toStringRef(HashPostfix))) if (Name.endswith((Twine(".") + Twine(FuncHash)).toStringRef(HashPostfix)))
return (Prefix + Name).str(); return (Prefix + Name).str();
return (Prefix + Name + "." + Twine(FuncHash)).str(); return (Prefix + Name + "." + Twine(FuncHash)).str();
} }
static uint64_t getIntModuleFlagOrZero(const Module &M, StringRef Flag) { static uint64_t getIntModuleFlagOrZero(const Module &M, StringRef Flag) {
auto *MD = dyn_cast_or_null<ConstantAsMetadata>(M.getModuleFlag(Flag)); auto *MD = dyn_cast_if_present<ConstantAsMetadata>(M.getModuleFlag(Flag));
if (!MD) if (!MD)
return 0; return 0;
// If the flag is a ConstantAsMetadata, it should be an integer representable // If the flag is a ConstantAsMetadata, it should be an integer representable
// in 64-bits. // in 64-bits.
return cast<ConstantInt>(MD->getValue())->getZExtValue(); return cast<ConstantInt>(MD->getValue())->getZExtValue();
} }
▲ Show 20 Lines • Show All 512 Lines • Show Last 20 Lines

llvm/lib/Transforms/Instrumentation/MemProfiler.cpp

Show First 20 Lines • Show All 503 Lines • ▼ Show 20 Linesvoid MemProfiler::instrumentAddress(Instruction *OrigIns,
Value *Inc = ConstantInt::get(Type::getInt64Ty(*C), 1); Value *Inc = ConstantInt::get(Type::getInt64Ty(*C), 1);
ShadowValue = IRB.CreateAdd(ShadowValue, Inc); ShadowValue = IRB.CreateAdd(ShadowValue, Inc);
IRB.CreateStore(ShadowValue, ShadowAddr); IRB.CreateStore(ShadowValue, ShadowAddr);
} }
// Create the variable for the profile file name. // Create the variable for the profile file name.
void createProfileFileNameVar(Module &M) { void createProfileFileNameVar(Module &M) {
const MDString *MemProfFilename = const MDString *MemProfFilename =
dyn_cast_or_null<MDString>(M.getModuleFlag("MemProfProfileFilename")); dyn_cast_if_present<MDString>(M.getModuleFlag("MemProfProfileFilename"));
if (!MemProfFilename) if (!MemProfFilename)
return; return;
assert(!MemProfFilename->getString().empty() && assert(!MemProfFilename->getString().empty() &&
"Unexpected MemProfProfileFilename metadata with empty string"); "Unexpected MemProfProfileFilename metadata with empty string");
Constant *ProfileNameConst = ConstantDataArray::getString( Constant *ProfileNameConst = ConstantDataArray::getString(
M.getContext(), MemProfFilename->getString(), true); M.getContext(), MemProfFilename->getString(), true);
GlobalVariable *ProfileNameVar = new GlobalVariable( GlobalVariable *ProfileNameVar = new GlobalVariable(
M, ProfileNameConst->getType(), /*isConstant=*/true, M, ProfileNameConst->getType(), /*isConstant=*/true,
▲ Show 20 Lines • Show All 143 Lines • Show Last 20 Lines

llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp

Show First 20 Lines • Show All 1,820 Lines • ▼ Show 20 Lines void insertShadowCheck(Value *Val, Instruction *OrigIns) {
assert(Val); assert(Val);
Value *Shadow, *Origin; Value *Shadow, *Origin;
if (ClCheckConstantShadow) { if (ClCheckConstantShadow) {
Shadow = getShadow(Val); Shadow = getShadow(Val);
if (!Shadow) if (!Shadow)
return; return;
Origin = getOrigin(Val); Origin = getOrigin(Val);
} else { } else {
Shadow = dyn_cast_or_null<Instruction>(getShadow(Val)); Shadow = dyn_cast_if_present<Instruction>(getShadow(Val));
if (!Shadow) if (!Shadow)
return; return;
Origin = dyn_cast_or_null<Instruction>(getOrigin(Val)); Origin = dyn_cast_if_present<Instruction>(getOrigin(Val));
} }
insertShadowCheck(Shadow, Origin, OrigIns); insertShadowCheck(Shadow, Origin, OrigIns);
} }
AtomicOrdering addReleaseOrdering(AtomicOrdering a) { AtomicOrdering addReleaseOrdering(AtomicOrdering a) {
switch (a) { switch (a) {
case AtomicOrdering::NotAtomic: case AtomicOrdering::NotAtomic:
return AtomicOrdering::NotAtomic; return AtomicOrdering::NotAtomic;
▲ Show 20 Lines • Show All 3,547 Lines • Show Last 20 Lines

llvm/lib/Transforms/ObjCARC/ObjCARC.h

Show First 20 Lines • Show All 85 Lines • ▼ Show 20 Lines for (auto &P : BB->phis()) {
} }
if (I == E) if (I == E)
PHIList.push_back(&P); PHIList.push_back(&P);
} }
} }
static inline MDString *getRVInstMarker(Module &M) { static inline MDString *getRVInstMarker(Module &M) {
const char *MarkerKey = getRVMarkerModuleFlagStr(); const char *MarkerKey = getRVMarkerModuleFlagStr();
return dyn_cast_or_null<MDString>(M.getModuleFlag(MarkerKey)); return dyn_cast_if_present<MDString>(M.getModuleFlag(MarkerKey));
} }
/// Create a call instruction with the correct funclet token. This should be /// Create a call instruction with the correct funclet token. This should be
/// called instead of calling CallInst::Create directly unless the call is /// called instead of calling CallInst::Create directly unless the call is
/// going to be removed from the IR before WinEHPrepare. /// going to be removed from the IR before WinEHPrepare.
CallInst *createCallInstWithColors( CallInst *createCallInstWithColors(
FunctionCallee Func, ArrayRef<Value *> Args, const Twine &NameStr, FunctionCallee Func, ArrayRef<Value *> Args, const Twine &NameStr,
Instruction *InsertBefore, Instruction *InsertBefore,
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

llvm/lib/Transforms/ObjCARC/ObjCARCContract.cpp

Show First 20 Lines • Show All 157 Lines • ▼ Show 20 Linesbool ObjCARCContract::contractAutorelease(Function &F, Instruction *Autorelease,
ARCInstKind Class) { ARCInstKind Class) {
const Value *Arg = GetArgRCIdentityRoot(Autorelease); const Value *Arg = GetArgRCIdentityRoot(Autorelease);
// Check that there are no instructions between the retain and the autorelease // Check that there are no instructions between the retain and the autorelease
// (such as an autorelease_pop) which may change the count. // (such as an autorelease_pop) which may change the count.
DependenceKind DK = Class == ARCInstKind::AutoreleaseRV DependenceKind DK = Class == ARCInstKind::AutoreleaseRV
? RetainAutoreleaseRVDep ? RetainAutoreleaseRVDep
: RetainAutoreleaseDep; : RetainAutoreleaseDep;
auto *Retain = dyn_cast_or_null<CallInst>( auto *Retain = dyn_cast_if_present<CallInst>(
findSingleDependency(DK, Arg, Autorelease->getParent(), Autorelease, PA)); findSingleDependency(DK, Arg, Autorelease->getParent(), Autorelease, PA));
if (!Retain || GetBasicARCInstKind(Retain) != ARCInstKind::Retain || if (!Retain || GetBasicARCInstKind(Retain) != ARCInstKind::Retain ||
GetArgRCIdentityRoot(Retain) != Arg) GetArgRCIdentityRoot(Retain) != Arg)
return false; return false;
Changed = true; Changed = true;
++NumPeeps; ++NumPeeps;
▲ Show 20 Lines • Show All 586 Lines • Show Last 20 Lines

llvm/lib/Transforms/ObjCARC/ObjCARCOpts.cpp

Show First 20 Lines • Show All 2,297 Lines • ▼ Show 20 Lines
} }
/// Check if there is a dependent call earlier that does not have anything in /// Check if there is a dependent call earlier that does not have anything in
/// between the Retain and the call that can affect the reference count of their /// between the Retain and the call that can affect the reference count of their
/// shared pointer argument. Note that Retain need not be in BB. /// shared pointer argument. Note that Retain need not be in BB.
static CallInst *HasSafePathToPredecessorCall(const Value *Arg, static CallInst *HasSafePathToPredecessorCall(const Value *Arg,
Instruction *Retain, Instruction *Retain,
ProvenanceAnalysis &PA) { ProvenanceAnalysis &PA) {
auto *Call = dyn_cast_or_null<CallInst>(findSingleDependency( auto *Call = dyn_cast_if_present<CallInst>(findSingleDependency(
CanChangeRetainCount, Arg, Retain->getParent(), Retain, PA)); CanChangeRetainCount, Arg, Retain->getParent(), Retain, PA));
// Check that the pointer is the return value of the call. // Check that the pointer is the return value of the call.
if (!Call || Arg != Call) if (!Call || Arg != Call)
return nullptr; return nullptr;
// Check that the call is a regular call. // Check that the call is a regular call.
ARCInstKind Class = GetBasicARCInstKind(Call); ARCInstKind Class = GetBasicARCInstKind(Call);
return Class == ARCInstKind::CallOrUser || Class == ARCInstKind::Call return Class == ARCInstKind::CallOrUser || Class == ARCInstKind::Call
? Call ? Call
: nullptr; : nullptr;
} }
/// Find a dependent retain that precedes the given autorelease for which there /// Find a dependent retain that precedes the given autorelease for which there
/// is nothing in between the two instructions that can affect the ref count of /// is nothing in between the two instructions that can affect the ref count of
/// Arg. /// Arg.
static CallInst * static CallInst *
FindPredecessorRetainWithSafePath(const Value *Arg, BasicBlock *BB, FindPredecessorRetainWithSafePath(const Value *Arg, BasicBlock *BB,
Instruction *Autorelease, Instruction *Autorelease,
ProvenanceAnalysis &PA) { ProvenanceAnalysis &PA) {
auto *Retain = dyn_cast_or_null<CallInst>( auto *Retain = dyn_cast_if_present<CallInst>(
findSingleDependency(CanChangeRetainCount, Arg, BB, Autorelease, PA)); findSingleDependency(CanChangeRetainCount, Arg, BB, Autorelease, PA));
// Check that we found a retain with the same argument. // Check that we found a retain with the same argument.
if (!Retain || !IsRetain(GetBasicARCInstKind(Retain)) || if (!Retain || !IsRetain(GetBasicARCInstKind(Retain)) ||
GetArgRCIdentityRoot(Retain) != Arg) { GetArgRCIdentityRoot(Retain) != Arg) {
return nullptr; return nullptr;
} }
return Retain; return Retain;
} }
/// Look for an ``autorelease'' instruction dependent on Arg such that there are /// Look for an ``autorelease'' instruction dependent on Arg such that there are
/// no instructions dependent on Arg that need a positive ref count in between /// no instructions dependent on Arg that need a positive ref count in between
/// the autorelease and the ret. /// the autorelease and the ret.
static CallInst * static CallInst *
FindPredecessorAutoreleaseWithSafePath(const Value *Arg, BasicBlock *BB, FindPredecessorAutoreleaseWithSafePath(const Value *Arg, BasicBlock *BB,
ReturnInst *Ret, ReturnInst *Ret,
ProvenanceAnalysis &PA) { ProvenanceAnalysis &PA) {
SmallPtrSet<Instruction *, 4> DepInsts; SmallPtrSet<Instruction *, 4> DepInsts;
auto *Autorelease = dyn_cast_or_null<CallInst>( auto *Autorelease = dyn_cast_if_present<CallInst>(
findSingleDependency(NeedsPositiveRetainCount, Arg, BB, Ret, PA)); findSingleDependency(NeedsPositiveRetainCount, Arg, BB, Ret, PA));
if (!Autorelease) if (!Autorelease)
return nullptr; return nullptr;
ARCInstKind AutoreleaseClass = GetBasicARCInstKind(Autorelease); ARCInstKind AutoreleaseClass = GetBasicARCInstKind(Autorelease);
if (!IsAutorelease(AutoreleaseClass)) if (!IsAutorelease(AutoreleaseClass))
return nullptr; return nullptr;
if (GetArgRCIdentityRoot(Autorelease) != Arg) if (GetArgRCIdentityRoot(Autorelease) != Arg)
▲ Show 20 Lines • Show All 190 Lines • Show Last 20 Lines

llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp

Show First 20 Lines • Show All 794 Lines • ▼ Show 20 Lines DSEState(Function &F, AliasAnalysis &AA, MemorySSA &MSSA, DominatorTree &DT,
unsigned PO = 0; unsigned PO = 0;
for (BasicBlock *BB : post_order(&F)) { for (BasicBlock *BB : post_order(&F)) {
PostOrderNumbers[BB] = PO++; PostOrderNumbers[BB] = PO++;
for (Instruction &I : *BB) { for (Instruction &I : *BB) {
MemoryAccess *MA = MSSA.getMemoryAccess(&I); MemoryAccess *MA = MSSA.getMemoryAccess(&I);
if (I.mayThrow() && !MA) if (I.mayThrow() && !MA)
ThrowingBlocks.insert(I.getParent()); ThrowingBlocks.insert(I.getParent());
auto *MD = dyn_cast_or_null<MemoryDef>(MA); auto *MD = dyn_cast_if_present<MemoryDef>(MA);
if (MD && MemDefs.size() < MemorySSADefsPerBlockLimit && if (MD && MemDefs.size() < MemorySSADefsPerBlockLimit &&
(getLocForWrite(&I) || isMemTerminatorInst(&I))) (getLocForWrite(&I) || isMemTerminatorInst(&I)))
MemDefs.push_back(MD); MemDefs.push_back(MD);
} }
} }
// Treat byval or inalloca arguments the same as Allocas, stores to them are // Treat byval or inalloca arguments the same as Allocas, stores to them are
// dead at the end of the function. // dead at the end of the function.
▲ Show 20 Lines • Show All 1,427 Lines • Show Last 20 Lines

llvm/lib/Transforms/Scalar/GVN.cpp

Show First 20 Lines • Show All 1,105 Lines • ▼ Show 20 Lines
/// basic block, before the pointer select. /// basic block, before the pointer select.
/// 3. There must be no instructions between the found loads and \p End that may /// 3. There must be no instructions between the found loads and \p End that may
/// clobber the loads. /// clobber the loads.
static Optional<AvailableValue> static Optional<AvailableValue>
tryToConvertLoadOfPtrSelect(BasicBlock *DepBB, BasicBlock::iterator End, tryToConvertLoadOfPtrSelect(BasicBlock *DepBB, BasicBlock::iterator End,
Value *Address, Type *LoadTy, DominatorTree &DT, Value *Address, Type *LoadTy, DominatorTree &DT,
AAResults *AA) { AAResults *AA) {
auto *Sel = dyn_cast_or_null<SelectInst>(Address); auto *Sel = dyn_cast_if_present<SelectInst>(Address);
if (!Sel || DepBB != Sel->getParent()) if (!Sel || DepBB != Sel->getParent())
return None; return None;
LoadInst *L1 = findDominatingLoad(Sel->getOperand(1), LoadTy, Sel, DT); LoadInst *L1 = findDominatingLoad(Sel->getOperand(1), LoadTy, Sel, DT);
LoadInst *L2 = findDominatingLoad(Sel->getOperand(2), LoadTy, Sel, DT); LoadInst *L2 = findDominatingLoad(Sel->getOperand(2), LoadTy, Sel, DT);
if (!L1 || !L2) if (!L1 || !L2)
return None; return None;
▲ Show 20 Lines • Show All 2,114 Lines • Show Last 20 Lines

llvm/lib/Transforms/Scalar/IndVarSimplify.cpp

Show First 20 Lines • Show All 412 Lines • ▼ Show 20 Linesbool IndVarSimplify::rewriteNonIntegerIVs(Loop *L) {
BasicBlock *Header = L->getHeader(); BasicBlock *Header = L->getHeader();
SmallVector<WeakTrackingVH, 8> PHIs; SmallVector<WeakTrackingVH, 8> PHIs;
for (PHINode &PN : Header->phis()) for (PHINode &PN : Header->phis())
PHIs.push_back(&PN); PHIs.push_back(&PN);
bool Changed = false; bool Changed = false;
for (unsigned i = 0, e = PHIs.size(); i != e; ++i) for (unsigned i = 0, e = PHIs.size(); i != e; ++i)
if (PHINode *PN = dyn_cast_or_null<PHINode>(&*PHIs[i])) if (PHINode *PN = dyn_cast_if_present<PHINode>(&*PHIs[i]))
Changed |= handleFloatingPointIV(L, PN); Changed |= handleFloatingPointIV(L, PN);
// If the loop previously had floating-point IV, ScalarEvolution // If the loop previously had floating-point IV, ScalarEvolution
// may not have been able to compute a trip count. Now that we've done some // may not have been able to compute a trip count. Now that we've done some
// re-writing, the trip count may be computable. // re-writing, the trip count may be computable.
if (Changed) if (Changed)
SE->forgetLoop(L); SE->forgetLoop(L);
return Changed; return Changed;
▲ Show 20 Lines • Show All 1,601 Lines • ▼ Show 20 Lines#endif
// trigger. // trigger.
Rewriter.clear(); Rewriter.clear();
// Now that we're done iterating through lists, clean up any instructions // Now that we're done iterating through lists, clean up any instructions
// which are now dead. // which are now dead.
while (!DeadInsts.empty()) { while (!DeadInsts.empty()) {
Value *V = DeadInsts.pop_back_val(); Value *V = DeadInsts.pop_back_val();
if (PHINode *PHI = dyn_cast_or_null<PHINode>(V)) if (PHINode *PHI = dyn_cast_if_present<PHINode>(V))
Changed |= RecursivelyDeleteDeadPHINode(PHI, TLI, MSSAU.get()); Changed |= RecursivelyDeleteDeadPHINode(PHI, TLI, MSSAU.get());
else if (Instruction *Inst = dyn_cast_or_null<Instruction>(V)) else if (Instruction *Inst = dyn_cast_if_present<Instruction>(V))
Changed |= Changed |=
RecursivelyDeleteTriviallyDeadInstructions(Inst, TLI, MSSAU.get()); RecursivelyDeleteTriviallyDeadInstructions(Inst, TLI, MSSAU.get());
} }
// The Rewriter may not be used from this point on. // The Rewriter may not be used from this point on.
// Loop-invariant instructions in the preheader that aren't used in the // Loop-invariant instructions in the preheader that aren't used in the
// loop may be sunk below the loop to reduce register pressure. // loop may be sunk below the loop to reduce register pressure.
▲ Show 20 Lines • Show All 106 Lines • Show Last 20 Lines

llvm/lib/Transforms/Scalar/InferAddressSpaces.cpp

Show First 20 Lines • Show All 764 Lines • ▼ Show 20 LinesValue *InferAddressSpacesImpl::cloneValueWithNewAddressSpace(
SmallVectorImpl<const Use *> *UndefUsesToFix) const { SmallVectorImpl<const Use *> *UndefUsesToFix) const {
// All values in Postorder are flat address expressions. // All values in Postorder are flat address expressions.
assert(V->getType()->getPointerAddressSpace() == FlatAddrSpace && assert(V->getType()->getPointerAddressSpace() == FlatAddrSpace &&
isAddressExpression(*V, *DL, TTI)); isAddressExpression(*V, *DL, TTI));
if (Instruction *I = dyn_cast<Instruction>(V)) { if (Instruction *I = dyn_cast<Instruction>(V)) {
Value *NewV = cloneInstructionWithNewAddressSpace( Value *NewV = cloneInstructionWithNewAddressSpace(
I, NewAddrSpace, ValueWithNewAddrSpace, PredicatedAS, UndefUsesToFix); I, NewAddrSpace, ValueWithNewAddrSpace, PredicatedAS, UndefUsesToFix);
if (Instruction *NewI = dyn_cast_or_null<Instruction>(NewV)) { if (Instruction *NewI = dyn_cast_if_present<Instruction>(NewV)) {
if (NewI->getParent() == nullptr) { if (NewI->getParent() == nullptr) {
NewI->insertBefore(I); NewI->insertBefore(I);
NewI->takeName(I); NewI->takeName(I);
} }
} }
return NewV; return NewV;
} }
▲ Show 20 Lines • Show All 549 Lines • Show Last 20 Lines

llvm/lib/Transforms/Scalar/JumpThreading.cpp

Show First 20 Lines • Show All 2,167 Lines • ▼ Show 20 Linesbool JumpThreadingPass::maybethreadThroughTwoBasicBlocks(BasicBlock *BB,
unsigned ZeroCount = 0; unsigned ZeroCount = 0;
unsigned OneCount = 0; unsigned OneCount = 0;
BasicBlock *ZeroPred = nullptr; BasicBlock *ZeroPred = nullptr;
BasicBlock *OnePred = nullptr; BasicBlock *OnePred = nullptr;
for (BasicBlock *P : predecessors(PredBB)) { for (BasicBlock *P : predecessors(PredBB)) {
// If PredPred ends with IndirectBrInst, we can't handle it. // If PredPred ends with IndirectBrInst, we can't handle it.
if (isa<IndirectBrInst>(P->getTerminator())) if (isa<IndirectBrInst>(P->getTerminator()))
continue; continue;
if (ConstantInt *CI = dyn_cast_or_null<ConstantInt>( if (ConstantInt *CI = dyn_cast_if_present<ConstantInt>(
evaluateOnPredecessorEdge(BB, P, Cond))) { evaluateOnPredecessorEdge(BB, P, Cond))) {
if (CI->isZero()) { if (CI->isZero()) {
ZeroCount++; ZeroCount++;
ZeroPred = P; ZeroPred = P;
} else if (CI->isOne()) { } else if (CI->isOne()) {
OneCount++; OneCount++;
OnePred = P; OnePred = P;
} }
▲ Show 20 Lines • Show All 874 Lines • Show Last 20 Lines

llvm/lib/Transforms/Scalar/LoopInstSimplify.cpp

Show First 20 Lines • Show All 126 Lines • ▼ Show 20 Lines for (BasicBlock *BB : RPOT) {
// try to simplify those away. // try to simplify those away.
assert((L.contains(UserI) || isa<PHINode>(UserI)) && assert((L.contains(UserI) || isa<PHINode>(UserI)) &&
"Uses outside the loop should be PHI nodes due to LCSSA!"); "Uses outside the loop should be PHI nodes due to LCSSA!");
if (!IsFirstIteration && L.contains(UserI)) if (!IsFirstIteration && L.contains(UserI))
ToSimplify->insert(UserI); ToSimplify->insert(UserI);
} }
if (MSSAU) if (MSSAU)
if (Instruction *SimpleI = dyn_cast_or_null<Instruction>(V)) if (Instruction *SimpleI = dyn_cast_if_present<Instruction>(V))
if (MemoryAccess *MA = MSSA->getMemoryAccess(&I)) if (MemoryAccess *MA = MSSA->getMemoryAccess(&I))
if (MemoryAccess *ReplacementMA = MSSA->getMemoryAccess(SimpleI)) if (MemoryAccess *ReplacementMA = MSSA->getMemoryAccess(SimpleI))
MA->replaceAllUsesWith(ReplacementMA); MA->replaceAllUsesWith(ReplacementMA);
assert(I.use_empty() && "Should always have replaced all uses!"); assert(I.use_empty() && "Should always have replaced all uses!");
if (isInstructionTriviallyDead(&I, &TLI)) if (isInstructionTriviallyDead(&I, &TLI))
DeadInsts.push_back(&I); DeadInsts.push_back(&I);
++NumSimplified; ++NumSimplified;
▲ Show 20 Lines • Show All 104 Lines • Show Last 20 Lines

llvm/lib/Transforms/Scalar/LoopStrengthReduce.cpp

Show First 20 Lines • Show All 2,469 Lines • ▼ Show 20 Lines if (LatchBlock != ExitingBlock)
SE.getTypeSizeInBits(B->getType())) { SE.getTypeSizeInBits(B->getType())) {
if (SE.getTypeSizeInBits(A->getType()) > if (SE.getTypeSizeInBits(A->getType()) >
SE.getTypeSizeInBits(B->getType())) SE.getTypeSizeInBits(B->getType()))
B = SE.getSignExtendExpr(B, A->getType()); B = SE.getSignExtendExpr(B, A->getType());
else else
A = SE.getSignExtendExpr(A, B->getType()); A = SE.getSignExtendExpr(A, B->getType());
} }
if (const SCEVConstant *D = if (const SCEVConstant *D =
dyn_cast_or_null<SCEVConstant>(getExactSDiv(B, A, SE))) { dyn_cast_if_present<SCEVConstant>(getExactSDiv(B, A, SE))) {
const ConstantInt *C = D->getValue(); const ConstantInt *C = D->getValue();
// Stride of one or negative one can have reuse with non-addresses. // Stride of one or negative one can have reuse with non-addresses.
if (C->isOne() || C->isMinusOne()) if (C->isOne() || C->isMinusOne())
goto decline_post_inc; goto decline_post_inc;
// Avoid weird situations. // Avoid weird situations.
if (C->getValue().getMinSignedBits() >= 64 || if (C->getValue().getMinSignedBits() >= 64 ||
C->getValue().isMinSignedValue()) C->getValue().isMinSignedValue())
goto decline_post_inc; goto decline_post_inc;
// Check for possible scaled-address reuse. // Check for possible scaled-address reuse.
if (isAddressUse(TTI, UI->getUser(), UI->getOperandValToReplace())) { if (isAddressUse(TTI, UI->getUser(),
UI->getOperandValToReplace())) {
MemAccessTy AccessTy = getAccessType( MemAccessTy AccessTy = getAccessType(
TTI, UI->getUser(), UI->getOperandValToReplace()); TTI, UI->getUser(), UI->getOperandValToReplace());
int64_t Scale = C->getSExtValue(); int64_t Scale = C->getSExtValue();
if (TTI.isLegalAddressingMode(AccessTy.MemTy, /*BaseGV=*/nullptr, if (TTI.isLegalAddressingMode(AccessTy.MemTy, /*BaseGV=*/nullptr,
/*BaseOffset=*/0, /*BaseOffset=*/0,
/*HasBaseReg=*/false, Scale, /*HasBaseReg=*/false, Scale,
AccessTy.AddrSpace)) AccessTy.AddrSpace))
goto decline_post_inc; goto decline_post_inc;
▲ Show 20 Lines • Show All 225 Lines • ▼ Show 20 Lines for (SmallSetVector<const SCEV *, 4>::const_iterator NewStrideIter =
if (SE.getTypeSizeInBits(OldStride->getType()) != if (SE.getTypeSizeInBits(OldStride->getType()) !=
SE.getTypeSizeInBits(NewStride->getType())) { SE.getTypeSizeInBits(NewStride->getType())) {
if (SE.getTypeSizeInBits(OldStride->getType()) > if (SE.getTypeSizeInBits(OldStride->getType()) >
SE.getTypeSizeInBits(NewStride->getType())) SE.getTypeSizeInBits(NewStride->getType()))
NewStride = SE.getSignExtendExpr(NewStride, OldStride->getType()); NewStride = SE.getSignExtendExpr(NewStride, OldStride->getType());
else else
OldStride = SE.getSignExtendExpr(OldStride, NewStride->getType()); OldStride = SE.getSignExtendExpr(OldStride, NewStride->getType());
} }
if (const SCEVConstant *Factor = if (const SCEVConstant *Factor = dyn_cast_if_present<SCEVConstant>(
dyn_cast_or_null<SCEVConstant>(getExactSDiv(NewStride, OldStride, getExactSDiv(NewStride, OldStride, SE, true))) {
SE, true))) {
if (Factor->getAPInt().getMinSignedBits() <= 64 && !Factor->isZero()) if (Factor->getAPInt().getMinSignedBits() <= 64 && !Factor->isZero())
Factors.insert(Factor->getAPInt().getSExtValue()); Factors.insert(Factor->getAPInt().getSExtValue());
} else if (const SCEVConstant *Factor = } else if (const SCEVConstant *Factor = dyn_cast_if_present<SCEVConstant>(
dyn_cast_or_null<SCEVConstant>(getExactSDiv(OldStride, getExactSDiv(OldStride, NewStride, SE, true))) {
NewStride,
SE, true))) {
if (Factor->getAPInt().getMinSignedBits() <= 64 && !Factor->isZero()) if (Factor->getAPInt().getMinSignedBits() <= 64 && !Factor->isZero())
Factors.insert(Factor->getAPInt().getSExtValue()); Factors.insert(Factor->getAPInt().getSExtValue());
} }
} }
// If all uses use the same type, don't bother looking for truncation-based // If all uses use the same type, don't bother looking for truncation-based
// reuse. // reuse.
if (Types.size() == 1) if (Types.size() == 1)
▲ Show 20 Lines • Show All 3,954 Lines • Show Last 20 Lines

llvm/lib/Transforms/Scalar/LowerConstantIntrinsics.cpp

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Lines replaceAndRecursivelySimplify(II, NewValue, nullptr, nullptr, nullptr,
&UnsimplifiedUsers); &UnsimplifiedUsers);
// UnsimplifiedUsers can contain PHI nodes that may be removed when // UnsimplifiedUsers can contain PHI nodes that may be removed when
// replacing the branch instructions, so use a value handle worklist // replacing the branch instructions, so use a value handle worklist
// to handle those possibly removed instructions. // to handle those possibly removed instructions.
SmallVector<WeakVH, 8> Worklist(UnsimplifiedUsers.begin(), SmallVector<WeakVH, 8> Worklist(UnsimplifiedUsers.begin(),
UnsimplifiedUsers.end()); UnsimplifiedUsers.end());
for (auto &VH : Worklist) { for (auto &VH : Worklist) {
BranchInst *BI = dyn_cast_or_null<BranchInst>(VH); BranchInst *BI = dyn_cast_if_present<BranchInst>(VH);
if (!BI) if (!BI)
continue; continue;
if (BI->isUnconditional()) if (BI->isUnconditional())
continue; continue;
BasicBlock *Target, *Other; BasicBlock *Target, *Other;
if (match(BI->getOperand(0), m_Zero())) { if (match(BI->getOperand(0), m_Zero())) {
Target = BI->getSuccessor(1); Target = BI->getSuccessor(1);
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines

llvm/lib/Transforms/Scalar/MemCpyOptimizer.cpp

Show First 20 Lines • Show All 759 Lines • ▼ Show 20 Lines if (LI->isSimple() && LI->hasOneUse() &&
// Detect cases where we're performing call slot forwarding, but // Detect cases where we're performing call slot forwarding, but
// happen to be using a load-store pair to implement it, rather than // happen to be using a load-store pair to implement it, rather than
// a memcpy. // a memcpy.
auto GetCall = [&]() -> CallInst * { auto GetCall = [&]() -> CallInst * {
// We defer this expensive clobber walk until the cheap checks // We defer this expensive clobber walk until the cheap checks
// have been done on the source inside performCallSlotOptzn. // have been done on the source inside performCallSlotOptzn.
if (auto *LoadClobber = dyn_cast<MemoryUseOrDef>( if (auto *LoadClobber = dyn_cast<MemoryUseOrDef>(
MSSA->getWalker()->getClobberingMemoryAccess(LI))) MSSA->getWalker()->getClobberingMemoryAccess(LI)))
return dyn_cast_or_null<CallInst>(LoadClobber->getMemoryInst()); return dyn_cast_if_present<CallInst>(LoadClobber->getMemoryInst());
return nullptr; return nullptr;
}; };
bool changed = performCallSlotOptzn( bool changed = performCallSlotOptzn(
LI, SI, SI->getPointerOperand()->stripPointerCasts(), LI, SI, SI->getPointerOperand()->stripPointerCasts(),
LI->getPointerOperand()->stripPointerCasts(), LI->getPointerOperand()->stripPointerCasts(),
DL.getTypeStoreSize(SI->getOperand(0)->getType()), DL.getTypeStoreSize(SI->getOperand(0)->getType()),
std::min(SI->getAlign(), LI->getAlign()), GetCall); std::min(SI->getAlign(), LI->getAlign()), GetCall);
▲ Show 20 Lines • Show All 511 Lines • ▼ Show 20 Lines
/// Determine whether the instruction has undefined content for the given Size, /// Determine whether the instruction has undefined content for the given Size,
/// either because it was freshly alloca'd or started its lifetime. /// either because it was freshly alloca'd or started its lifetime.
static bool hasUndefContents(MemorySSA *MSSA, AliasAnalysis *AA, Value *V, static bool hasUndefContents(MemorySSA *MSSA, AliasAnalysis *AA, Value *V,
MemoryDef *Def, Value *Size) { MemoryDef *Def, Value *Size) {
if (MSSA->isLiveOnEntryDef(Def)) if (MSSA->isLiveOnEntryDef(Def))
return isa<AllocaInst>(getUnderlyingObject(V)); return isa<AllocaInst>(getUnderlyingObject(V));
if (auto *II = dyn_cast_or_null<IntrinsicInst>(Def->getMemoryInst())) { if (auto *II = dyn_cast_if_present<IntrinsicInst>(Def->getMemoryInst())) {
if (II->getIntrinsicID() == Intrinsic::lifetime_start) { if (II->getIntrinsicID() == Intrinsic::lifetime_start) {
auto *LTSize = cast<ConstantInt>(II->getArgOperand(0)); auto *LTSize = cast<ConstantInt>(II->getArgOperand(0));
if (auto *CSize = dyn_cast<ConstantInt>(Size)) { if (auto *CSize = dyn_cast<ConstantInt>(Size)) {
if (AA->isMustAlias(V, II->getArgOperand(1)) && if (AA->isMustAlias(V, II->getArgOperand(1)) &&
LTSize->getZExtValue() >= CSize->getZExtValue()) LTSize->getZExtValue() >= CSize->getZExtValue())
return true; return true;
} }
▲ Show 20 Lines • Show All 127 Lines • ▼ Show 20 Linesbool MemCpyOptPass::processMemCpy(MemCpyInst *M, BasicBlock::iterator &BBI) {
const MemoryAccess *DestClobber = const MemoryAccess *DestClobber =
MSSA->getWalker()->getClobberingMemoryAccess(AnyClobber, DestLoc); MSSA->getWalker()->getClobberingMemoryAccess(AnyClobber, DestLoc);
// Try to turn a partially redundant memset + memcpy into // Try to turn a partially redundant memset + memcpy into
// memcpy + smaller memset. We don't need the memcpy size for this. // memcpy + smaller memset. We don't need the memcpy size for this.
// The memcpy most post-dom the memset, so limit this to the same basic // The memcpy most post-dom the memset, so limit this to the same basic
// block. A non-local generalization is likely not worthwhile. // block. A non-local generalization is likely not worthwhile.
if (auto *MD = dyn_cast<MemoryDef>(DestClobber)) if (auto *MD = dyn_cast<MemoryDef>(DestClobber))
if (auto *MDep = dyn_cast_or_null<MemSetInst>(MD->getMemoryInst())) if (auto *MDep = dyn_cast_if_present<MemSetInst>(MD->getMemoryInst()))
if (DestClobber->getBlock() == M->getParent()) if (DestClobber->getBlock() == M->getParent())
if (processMemSetMemCpyDependence(M, MDep)) if (processMemSetMemCpyDependence(M, MDep))
return true; return true;
MemoryAccess *SrcClobber = MSSA->getWalker()->getClobberingMemoryAccess( MemoryAccess *SrcClobber = MSSA->getWalker()->getClobberingMemoryAccess(
AnyClobber, MemoryLocation::getForSource(M)); AnyClobber, MemoryLocation::getForSource(M));
// There are four possible optimizations we can do for memcpy: // There are four possible optimizations we can do for memcpy:
▲ Show 20 Lines • Show All 81 Lines • ▼ Show 20 Linesbool MemCpyOptPass::processByValArgument(CallBase &CB, unsigned ArgNo) {
MemoryLocation Loc(ByValArg, LocationSize::precise(ByValSize)); MemoryLocation Loc(ByValArg, LocationSize::precise(ByValSize));
MemoryUseOrDef *CallAccess = MSSA->getMemoryAccess(&CB); MemoryUseOrDef *CallAccess = MSSA->getMemoryAccess(&CB);
if (!CallAccess) if (!CallAccess)
return false; return false;
MemCpyInst *MDep = nullptr; MemCpyInst *MDep = nullptr;
MemoryAccess *Clobber = MSSA->getWalker()->getClobberingMemoryAccess( MemoryAccess *Clobber = MSSA->getWalker()->getClobberingMemoryAccess(
CallAccess->getDefiningAccess(), Loc); CallAccess->getDefiningAccess(), Loc);
if (auto *MD = dyn_cast<MemoryDef>(Clobber)) if (auto *MD = dyn_cast<MemoryDef>(Clobber))
MDep = dyn_cast_or_null<MemCpyInst>(MD->getMemoryInst()); MDep = dyn_cast_if_present<MemCpyInst>(MD->getMemoryInst());
// If the byval argument isn't fed by a memcpy, ignore it. If it is fed by // If the byval argument isn't fed by a memcpy, ignore it. If it is fed by
// a memcpy, see if we can byval from the source of the memcpy instead of the // a memcpy, see if we can byval from the source of the memcpy instead of the
// result. // result.
if (!MDep || MDep->isVolatile() || if (!MDep || MDep->isVolatile() ||
ByValArg->stripPointerCasts() != MDep->getDest()) ByValArg->stripPointerCasts() != MDep->getDest())
return false; return false;
▲ Show 20 Lines • Show All 152 Lines • Show Last 20 Lines

llvm/lib/Transforms/Scalar/NaryReassociate.cpp

Show First 20 Lines • Show All 276 Lines • ▼ Show 20 LinesNaryReassociatePass::matchAndReassociateMinOrMax(Instruction *I,
Value *LHS = nullptr; Value *LHS = nullptr;
Value *RHS = nullptr; Value *RHS = nullptr;
auto MinMaxMatcher = auto MinMaxMatcher =
MaxMin_match<ICmpInst, bind_ty<Value>, bind_ty<Value>, PredT>( MaxMin_match<ICmpInst, bind_ty<Value>, bind_ty<Value>, PredT>(
m_Value(LHS), m_Value(RHS)); m_Value(LHS), m_Value(RHS));
if (match(I, MinMaxMatcher)) { if (match(I, MinMaxMatcher)) {
OrigSCEV = SE->getSCEV(I); OrigSCEV = SE->getSCEV(I);
if (auto *NewMinMax = dyn_cast_or_null<Instruction>( if (auto *NewMinMax = dyn_cast_if_present<Instruction>(
tryReassociateMinOrMax(I, MinMaxMatcher, LHS, RHS))) tryReassociateMinOrMax(I, MinMaxMatcher, LHS, RHS)))
return NewMinMax; return NewMinMax;
if (auto *NewMinMax = dyn_cast_or_null<Instruction>( if (auto *NewMinMax = dyn_cast_if_present<Instruction>(
tryReassociateMinOrMax(I, MinMaxMatcher, RHS, LHS))) tryReassociateMinOrMax(I, MinMaxMatcher, RHS, LHS)))
return NewMinMax; return NewMinMax;
} }
return nullptr; return nullptr;
} }
Instruction *NaryReassociatePass::tryReassociate(Instruction * I, Instruction *NaryReassociatePass::tryReassociate(Instruction * I,
const SCEV *&OrigSCEV) { const SCEV *&OrigSCEV) {
▲ Show 20 Lines • Show All 363 Lines • Show Last 20 Lines

llvm/lib/Transforms/Scalar/NewGVN.cpp

Show First 20 Lines • Show All 1,876 Lines • ▼ Show 20 LinesNewGVN::ExprResult NewGVN::performSymbolicCmpEvaluation(Instruction *I) const {
// back farther through comparisons, you *must* mark the appropriate // back farther through comparisons, you *must* mark the appropriate
// comparisons as users in PredicateInfo.cpp, or you will cause bugs. See if // comparisons as users in PredicateInfo.cpp, or you will cause bugs. See if
// we know something just from the operands themselves // we know something just from the operands themselves
// See if our operands have predicate info, so that we may be able to derive // See if our operands have predicate info, so that we may be able to derive
// something from a previous comparison. // something from a previous comparison.
for (const auto &Op : CI->operands()) { for (const auto &Op : CI->operands()) {
auto *PI = PredInfo->getPredicateInfoFor(Op); auto *PI = PredInfo->getPredicateInfoFor(Op);
if (const auto *PBranch = dyn_cast_or_null<PredicateBranch>(PI)) { if (const auto *PBranch = dyn_cast_if_present<PredicateBranch>(PI)) {
if (PI == LastPredInfo) if (PI == LastPredInfo)
continue; continue;
LastPredInfo = PI; LastPredInfo = PI;
// In phi of ops cases, we may have predicate info that we are evaluating // In phi of ops cases, we may have predicate info that we are evaluating
// in a different context. // in a different context.
if (!DT->dominates(PBranch->To, getBlockForValue(I))) if (!DT->dominates(PBranch->To, getBlockForValue(I)))
continue; continue;
// TODO: Along the false edge, we may know more things too, like // TODO: Along the false edge, we may know more things too, like
▲ Show 20 Lines • Show All 239 Lines • ▼ Show 20 Lines
// congruence class CC, under the assumption that the current leader is going to // congruence class CC, under the assumption that the current leader is going to
// disappear. // disappear.
const MemoryAccess *NewGVN::getNextMemoryLeader(CongruenceClass *CC) const { const MemoryAccess *NewGVN::getNextMemoryLeader(CongruenceClass *CC) const {
// TODO: If this ends up to slow, we can maintain a next memory leader like we // TODO: If this ends up to slow, we can maintain a next memory leader like we
// do for regular leaders. // do for regular leaders.
// Make sure there will be a leader to find. // Make sure there will be a leader to find.
assert(!CC->definesNoMemory() && "Can't get next leader if there is none"); assert(!CC->definesNoMemory() && "Can't get next leader if there is none");
if (CC->getStoreCount() > 0) { if (CC->getStoreCount() > 0) {
if (auto *NL = dyn_cast_or_null<StoreInst>(CC->getNextLeader().first)) if (auto *NL = dyn_cast_if_present<StoreInst>(CC->getNextLeader().first))
return getMemoryAccess(NL); return getMemoryAccess(NL);
// Find the store with the minimum DFS number. // Find the store with the minimum DFS number.
auto *V = getMinDFSOfRange<Value>(make_filter_range( auto *V = getMinDFSOfRange<Value>(make_filter_range(
*CC, [&](const Value *V) { return isa<StoreInst>(V); })); *CC, [&](const Value *V) { return isa<StoreInst>(V); }));
return getMemoryAccess(cast<StoreInst>(V)); return getMemoryAccess(cast<StoreInst>(V));
} }
assert(CC->getStoreCount() == 0); assert(CC->getStoreCount() == 0);
▲ Show 20 Lines • Show All 114 Lines • ▼ Show 20 Lines if (NewClass->getStoreCount() == 0 && !NewClass->getStoredValue()) {
// We rely on the code below handling the MemoryAccess change. // We rely on the code below handling the MemoryAccess change.
} }
NewClass->incStoreCount(); NewClass->incStoreCount();
} }
// True if there is no memory instructions left in a class that had memory // True if there is no memory instructions left in a class that had memory
// instructions before. // instructions before.
// If it's not a memory use, set the MemoryAccess equivalence // If it's not a memory use, set the MemoryAccess equivalence
auto *InstMA = dyn_cast_or_null<MemoryDef>(getMemoryAccess(I)); auto *InstMA = dyn_cast_if_present<MemoryDef>(getMemoryAccess(I));
if (InstMA) if (InstMA)
moveMemoryToNewCongruenceClass(I, InstMA, OldClass, NewClass); moveMemoryToNewCongruenceClass(I, InstMA, OldClass, NewClass);
ValueToClass[I] = NewClass; ValueToClass[I] = NewClass;
// See if we destroyed the class or need to swap leaders. // See if we destroyed the class or need to swap leaders.
if (OldClass->empty() && OldClass != TOPClass) { if (OldClass->empty() && OldClass != TOPClass) {
if (OldClass->getDefiningExpr()) { if (OldClass->getDefiningExpr()) {
LLVM_DEBUG(dbgs() << "Erasing expression " << *OldClass->getDefiningExpr() LLVM_DEBUG(dbgs() << "Erasing expression " << *OldClass->getDefiningExpr()
<< " from table\n"); << " from table\n");
▲ Show 20 Lines • Show All 180 Lines • ▼ Show 20 Linesvoid NewGVN::processOutgoingEdges(Instruction *TI, BasicBlock *B) {
Value *Cond; Value *Cond;
BasicBlock *TrueSucc, *FalseSucc; BasicBlock *TrueSucc, *FalseSucc;
if (match(TI, m_Br(m_Value(Cond), TrueSucc, FalseSucc))) { if (match(TI, m_Br(m_Value(Cond), TrueSucc, FalseSucc))) {
Value *CondEvaluated = findConditionEquivalence(Cond); Value *CondEvaluated = findConditionEquivalence(Cond);
if (!CondEvaluated) { if (!CondEvaluated) {
if (auto *I = dyn_cast<Instruction>(Cond)) { if (auto *I = dyn_cast<Instruction>(Cond)) {
SmallPtrSet<Value *, 4> Visited; SmallPtrSet<Value *, 4> Visited;
auto Res = performSymbolicEvaluation(I, Visited); auto Res = performSymbolicEvaluation(I, Visited);
if (const auto *CE = dyn_cast_or_null<ConstantExpression>(Res.Expr)) { if (const auto *CE =
dyn_cast_if_present<ConstantExpression>(Res.Expr)) {
CondEvaluated = CE->getConstantValue(); CondEvaluated = CE->getConstantValue();
addAdditionalUsers(Res, I); addAdditionalUsers(Res, I);
} else { } else {
// Did not use simplification result, no need to add the extra // Did not use simplification result, no need to add the extra
// dependency. // dependency.
Res.ExtraDep = nullptr; Res.ExtraDep = nullptr;
} }
} else if (isa<ConstantInt>(Cond)) { } else if (isa<ConstantInt>(Cond)) {
▲ Show 20 Lines • Show All 1,125 Lines • ▼ Show 20 Lines for (auto *D : Dense) {
assert(isa<Instruction>(D) && assert(isa<Instruction>(D) &&
"The dense set member should always be an instruction"); "The dense set member should always be an instruction");
Instruction *Def = cast<Instruction>(D); Instruction *Def = cast<Instruction>(D);
VDDef.LocalNum = InstrToDFSNum(D); VDDef.LocalNum = InstrToDFSNum(D);
DFSOrderedSet.push_back(VDDef); DFSOrderedSet.push_back(VDDef);
// If there is a phi node equivalent, add it // If there is a phi node equivalent, add it
if (auto *PN = RealToTemp.lookup(Def)) { if (auto *PN = RealToTemp.lookup(Def)) {
auto *PHIE = auto *PHIE =
dyn_cast_or_null<PHIExpression>(ValueToExpression.lookup(Def)); dyn_cast_if_present<PHIExpression>(ValueToExpression.lookup(Def));
if (PHIE) { if (PHIE) {
VDDef.Def.setInt(false); VDDef.Def.setInt(false);
VDDef.Def.setPointer(PN); VDDef.Def.setPointer(PN);
VDDef.LocalNum = 0; VDDef.LocalNum = 0;
DFSOrderedSet.push_back(VDDef); DFSOrderedSet.push_back(VDDef);
} }
} }
▲ Show 20 Lines • Show All 250 Lines • ▼ Show 20 Linesbool NewGVN::eliminateInstructions(Function &F) {
// using two SparseBitVectors per block. // using two SparseBitVectors per block.
DenseMap<const BasicBlock *, unsigned> ReachablePredCount; DenseMap<const BasicBlock *, unsigned> ReachablePredCount;
for (auto &KV : ReachableEdges) for (auto &KV : ReachableEdges)
ReachablePredCount[KV.getEnd()]++; ReachablePredCount[KV.getEnd()]++;
for (auto &BBPair : RevisitOnReachabilityChange) { for (auto &BBPair : RevisitOnReachabilityChange) {
for (auto InstNum : BBPair.second) { for (auto InstNum : BBPair.second) {
auto *Inst = InstrFromDFSNum(InstNum); auto *Inst = InstrFromDFSNum(InstNum);
auto *PHI = dyn_cast<PHINode>(Inst); auto *PHI = dyn_cast<PHINode>(Inst);
PHI = PHI ? PHI : dyn_cast_or_null<PHINode>(RealToTemp.lookup(Inst)); PHI = PHI ? PHI : dyn_cast_if_present<PHINode>(RealToTemp.lookup(Inst));
if (!PHI) if (!PHI)
continue; continue;
auto *BB = BBPair.first; auto *BB = BBPair.first;
if (ReachablePredCount.lookup(BB) != PHI->getNumIncomingValues()) if (ReachablePredCount.lookup(BB) != PHI->getNumIncomingValues())
ReplaceUnreachablePHIArgs(PHI, BB); ReplaceUnreachablePHIArgs(PHI, BB);
} }
} }
▲ Show 20 Lines • Show All 66 Lines • ▼ Show 20 Lines if (alwaysAvailable(Leader)) {
int MemberDFSIn = VD.DFSIn; int MemberDFSIn = VD.DFSIn;
int MemberDFSOut = VD.DFSOut; int MemberDFSOut = VD.DFSOut;
Value *Def = VD.Def.getPointer(); Value *Def = VD.Def.getPointer();
bool FromStore = VD.Def.getInt(); bool FromStore = VD.Def.getInt();
Use *U = VD.U; Use *U = VD.U;
// We ignore void things because we can't get a value from them. // We ignore void things because we can't get a value from them.
if (Def && Def->getType()->isVoidTy()) if (Def && Def->getType()->isVoidTy())
continue; continue;
auto *DefInst = dyn_cast_or_null<Instruction>(Def); auto *DefInst = dyn_cast_if_present<Instruction>(Def);
if (DefInst && AllTempInstructions.count(DefInst)) { if (DefInst && AllTempInstructions.count(DefInst)) {
auto *PN = cast<PHINode>(DefInst); auto *PN = cast<PHINode>(DefInst);
// If this is a value phi and that's the expression we used, insert // If this is a value phi and that's the expression we used, insert
// it into the program // it into the program
// remove from temp instruction list. // remove from temp instruction list.
AllTempInstructions.erase(PN); AllTempInstructions.erase(PN);
auto *DefBlock = getBlockForValue(Def); auto *DefBlock = getBlockForValue(Def);
▲ Show 20 Lines • Show All 317 Lines • Show Last 20 Lines

llvm/lib/Transforms/Scalar/SROA.cpp

Show First 20 Lines • Show All 1,150 Lines • ▼ Show 20 Lines for (AllocaSlices::const_iterator I = B; I != E; ++I) {
Type *UserTy = nullptr; Type *UserTy = nullptr;
if (LoadInst *LI = dyn_cast<LoadInst>(U->getUser())) { if (LoadInst *LI = dyn_cast<LoadInst>(U->getUser())) {
UserTy = LI->getType(); UserTy = LI->getType();
} else if (StoreInst *SI = dyn_cast<StoreInst>(U->getUser())) { } else if (StoreInst *SI = dyn_cast<StoreInst>(U->getUser())) {
UserTy = SI->getValueOperand()->getType(); UserTy = SI->getValueOperand()->getType();
} }
if (IntegerType *UserITy = dyn_cast_or_null<IntegerType>(UserTy)) { if (IntegerType *UserITy = dyn_cast_if_present<IntegerType>(UserTy)) {
// If the type is larger than the partition, skip it. We only encounter // If the type is larger than the partition, skip it. We only encounter
// this for split integer operations where we want to use the type of the // this for split integer operations where we want to use the type of the
// entity causing the split. Also skip if the type is not a byte width // entity causing the split. Also skip if the type is not a byte width
// multiple. // multiple.
if (UserITy->getBitWidth() % 8 != 0 || if (UserITy->getBitWidth() % 8 != 0 ||
UserITy->getBitWidth() / 8 > (EndOffset - B->beginOffset())) UserITy->getBitWidth() / 8 > (EndOffset - B->beginOffset()))
continue; continue;
▲ Show 20 Lines • Show All 3,512 Lines • ▼ Show 20 Lines
/// are used heavily in the intermediate stages of the algorithm. /// are used heavily in the intermediate stages of the algorithm.
/// ///
/// We also record the alloca instructions deleted here so that they aren't /// We also record the alloca instructions deleted here so that they aren't
/// subsequently handed to mem2reg to promote. /// subsequently handed to mem2reg to promote.
bool SROAPass::deleteDeadInstructions( bool SROAPass::deleteDeadInstructions(
SmallPtrSetImpl<AllocaInst *> &DeletedAllocas) { SmallPtrSetImpl<AllocaInst *> &DeletedAllocas) {
bool Changed = false; bool Changed = false;
while (!DeadInsts.empty()) { while (!DeadInsts.empty()) {
Instruction *I = dyn_cast_or_null<Instruction>(DeadInsts.pop_back_val()); Instruction *I = dyn_cast_if_present<Instruction>(DeadInsts.pop_back_val());
if (!I) continue; if (!I) continue;
LLVM_DEBUG(dbgs() << "Deleting dead instruction: " << *I << "\n"); LLVM_DEBUG(dbgs() << "Deleting dead instruction: " << *I << "\n");
// If the instruction is an alloca, find the possible dbg.declare connected // If the instruction is an alloca, find the possible dbg.declare connected
// to it, and remove it too. We must do this before calling RAUW or we will // to it, and remove it too. We must do this before calling RAUW or we will
// not be able to find it. // not be able to find it.
if (AllocaInst *AI = dyn_cast<AllocaInst>(I)) { if (AllocaInst *AI = dyn_cast<AllocaInst>(I)) {
DeletedAllocas.insert(AI); DeletedAllocas.insert(AI);
▲ Show 20 Lines • Show All 143 Lines • Show Last 20 Lines

llvm/lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp

Show First 20 Lines • Show All 895 Lines • ▼ Show 20 Lines if (AccumulativeByteOffset != 0) {
ResultPtr = ResultPtr =
Builder.CreateGEP(Builder.getInt8Ty(), ResultPtr, Offset, "uglygep"); Builder.CreateGEP(Builder.getInt8Ty(), ResultPtr, Offset, "uglygep");
} else } else
isSwapCandidate = false; isSwapCandidate = false;
// If we created a GEP with constant index, and the base is loop invariant, // If we created a GEP with constant index, and the base is loop invariant,
// then we swap the first one with it, so LICM can move constant GEP out // then we swap the first one with it, so LICM can move constant GEP out
// later. // later.
auto *FirstGEP = dyn_cast_or_null<GetElementPtrInst>(FirstResult); auto *FirstGEP = dyn_cast_if_present<GetElementPtrInst>(FirstResult);
auto *SecondGEP = dyn_cast<GetElementPtrInst>(ResultPtr); auto *SecondGEP = dyn_cast<GetElementPtrInst>(ResultPtr);
if (isSwapCandidate && isLegalToSwapOperand(FirstGEP, SecondGEP, L)) if (isSwapCandidate && isLegalToSwapOperand(FirstGEP, SecondGEP, L))
swapGEPOperand(FirstGEP, SecondGEP); swapGEPOperand(FirstGEP, SecondGEP);
if (ResultPtr->getType() != Variadic->getType()) if (ResultPtr->getType() != Variadic->getType())
ResultPtr = Builder.CreateBitCast(ResultPtr, Variadic->getType()); ResultPtr = Builder.CreateBitCast(ResultPtr, Variadic->getType());
Variadic->replaceAllUsesWith(ResultPtr); Variadic->replaceAllUsesWith(ResultPtr);
▲ Show 20 Lines • Show All 475 Lines • Show Last 20 Lines

llvm/lib/Transforms/Scalar/SimpleLoopUnswitch.cpp

Show First 20 Lines • Show All 245 Lines • ▼ Show 20 Lines RemapInstruction(NewInst, VMap,
RF_NoModuleLevelChanges | RF_IgnoreMissingLocals); RF_NoModuleLevelChanges | RF_IgnoreMissingLocals);
VMap[Val] = NewInst; VMap[Val] = NewInst;
if (!MSSAU) if (!MSSAU)
continue; continue;
MemorySSA *MSSA = MSSAU->getMemorySSA(); MemorySSA *MSSA = MSSAU->getMemorySSA();
if (auto *MemUse = if (auto *MemUse =
dyn_cast_or_null<MemoryUse>(MSSA->getMemoryAccess(Inst))) { dyn_cast_if_present<MemoryUse>(MSSA->getMemoryAccess(Inst))) {
auto *DefiningAccess = MemUse->getDefiningAccess(); auto *DefiningAccess = MemUse->getDefiningAccess();
// Get the first defining access before the loop. // Get the first defining access before the loop.
while (L.contains(DefiningAccess->getBlock())) { while (L.contains(DefiningAccess->getBlock())) {
// If the defining access is a MemoryPhi, get the incoming // If the defining access is a MemoryPhi, get the incoming
// value for the pre-header as defining access. // value for the pre-header as defining access.
if (auto *MemPhi = dyn_cast<MemoryPhi>(DefiningAccess)) if (auto *MemPhi = dyn_cast<MemoryPhi>(DefiningAccess))
DefiningAccess = DefiningAccess =
MemPhi->getIncomingValueForBlock(L.getLoopPreheader()); MemPhi->getIncomingValueForBlock(L.getLoopPreheader());
▲ Show 20 Lines • Show All 3,034 Lines • Show Last 20 Lines

llvm/lib/Transforms/Scalar/SimplifyCFGPass.cpp

Show First 20 Lines • Show All 181 Lines • ▼ Show 20 Lines for (BasicBlock &BB : F) {
// We can't tail-merge block that contains a musttail call. // We can't tail-merge block that contains a musttail call.
if (BB.getTerminatingMustTailCall()) if (BB.getTerminatingMustTailCall())
continue; continue;
// Calls to experimental_deoptimize must be followed by a return // Calls to experimental_deoptimize must be followed by a return
// of the value computed by experimental_deoptimize. // of the value computed by experimental_deoptimize.
// I.e., we can not change `ret` to `br` for this block. // I.e., we can not change `ret` to `br` for this block.
if (auto *CI = if (auto *CI =
dyn_cast_or_null<CallInst>(Term->getPrevNonDebugInstruction())) { dyn_cast_if_present<CallInst>(Term->getPrevNonDebugInstruction())) {
if (Function *F = CI->getCalledFunction()) if (Function *F = CI->getCalledFunction())
if (Intrinsic::ID ID = F->getIntrinsicID()) if (Intrinsic::ID ID = F->getIntrinsicID())
if (ID == Intrinsic::experimental_deoptimize) if (ID == Intrinsic::experimental_deoptimize)
continue; continue;
} }
// PHI nodes cannot have token type, so if the terminator has an operand // PHI nodes cannot have token type, so if the terminator has an operand
// with token type, we can not tail-merge this kind of function terminators. // with token type, we can not tail-merge this kind of function terminators.
▲ Show 20 Lines • Show All 237 Lines • Show Last 20 Lines

llvm/lib/Transforms/Scalar/SpeculativeExecution.cpp

Show First 20 Lines • Show All 261 Lines • ▼ Show 20 Lines
bool SpeculativeExecutionPass::considerHoistingFromTo( bool SpeculativeExecutionPass::considerHoistingFromTo(
BasicBlock &FromBlock, BasicBlock &ToBlock) { BasicBlock &FromBlock, BasicBlock &ToBlock) {
SmallPtrSet<const Instruction *, 8> NotHoisted; SmallPtrSet<const Instruction *, 8> NotHoisted;
const auto AllPrecedingUsesFromBlockHoisted = [&NotHoisted](const User *U) { const auto AllPrecedingUsesFromBlockHoisted = [&NotHoisted](const User *U) {
// Debug variable has special operand to check it's not hoisted. // Debug variable has special operand to check it's not hoisted.
if (const auto *DVI = dyn_cast<DbgVariableIntrinsic>(U)) { if (const auto *DVI = dyn_cast<DbgVariableIntrinsic>(U)) {
return all_of(DVI->location_ops(), [&NotHoisted](Value *V) { return all_of(DVI->location_ops(), [&NotHoisted](Value *V) {
if (const auto *I = dyn_cast_or_null<Instruction>(V)) { if (const auto *I = dyn_cast_if_present<Instruction>(V)) {
if (!NotHoisted.contains(I)) if (!NotHoisted.contains(I))
return true; return true;
} }
return false; return false;
}); });
} }
// Usially debug label intrinsic corresponds to label in LLVM IR. In these // Usially debug label intrinsic corresponds to label in LLVM IR. In these
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

llvm/lib/Transforms/Scalar/StructurizeCFG.cpp

Show First 20 Lines • Show All 674 Lines • ▼ Show 20 Lines
void StructurizeCFG::simplifyAffectedPhis() { void StructurizeCFG::simplifyAffectedPhis() {
bool Changed; bool Changed;
do { do {
Changed = false; Changed = false;
SimplifyQuery Q(Func->getParent()->getDataLayout()); SimplifyQuery Q(Func->getParent()->getDataLayout());
Q.DT = DT; Q.DT = DT;
for (WeakVH VH : AffectedPhis) { for (WeakVH VH : AffectedPhis) {
if (auto Phi = dyn_cast_or_null<PHINode>(VH)) { if (auto Phi = dyn_cast_if_present<PHINode>(VH)) {
if (auto NewValue = simplifyInstruction(Phi, Q)) { if (auto NewValue = simplifyInstruction(Phi, Q)) {
Phi->replaceAllUsesWith(NewValue); Phi->replaceAllUsesWith(NewValue);
Phi->eraseFromParent(); Phi->eraseFromParent();
Changed = true; Changed = true;
} }
} }
} }
} while (Changed); } while (Changed);
▲ Show 20 Lines • Show All 446 Lines • Show Last 20 Lines

llvm/lib/Transforms/Utils/AssumeBundleBuilder.cpp

Show First 20 Lines • Show All 413 Lines • ▼ Show 20 Lines for (BasicBlock *BB : depth_first(&F))
BOI.Tag = IgnoreTag; BOI.Tag = IgnoreTag;
}; };
if (BOI.Tag == IgnoreTag) { if (BOI.Tag == IgnoreTag) {
CleanupToDo.insert(Assume); CleanupToDo.insert(Assume);
continue; continue;
} }
RetainedKnowledge RK = RetainedKnowledge RK =
getKnowledgeFromBundle(cast<AssumeInst>(*Assume), BOI); getKnowledgeFromBundle(cast<AssumeInst>(*Assume), BOI);
if (auto *Arg = dyn_cast_or_null<Argument>(RK.WasOn)) { if (auto *Arg = dyn_cast_if_present<Argument>(RK.WasOn)) {
bool HasSameKindAttr = Arg->hasAttribute(RK.AttrKind); bool HasSameKindAttr = Arg->hasAttribute(RK.AttrKind);
if (HasSameKindAttr) if (HasSameKindAttr)
if (!Attribute::isIntAttrKind(RK.AttrKind) || if (!Attribute::isIntAttrKind(RK.AttrKind) ||
Arg->getAttribute(RK.AttrKind).getValueAsInt() >= Arg->getAttribute(RK.AttrKind).getValueAsInt() >=
RK.ArgValue) { RK.ArgValue) {
RemoveFromAssume(); RemoveFromAssume();
continue; continue;
} }
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines void mergeRange(BasicBlock *BB, MergeIterator Begin, MergeIterator End) {
for (IntrinsicInst *I : make_range(Begin, End)) { for (IntrinsicInst *I : make_range(Begin, End)) {
CleanupToDo.insert(I); CleanupToDo.insert(I);
for (CallInst::BundleOpInfo &BOI : I->bundle_op_infos()) { for (CallInst::BundleOpInfo &BOI : I->bundle_op_infos()) {
RetainedKnowledge RK = RetainedKnowledge RK =
getKnowledgeFromBundle(cast<AssumeInst>(*I), BOI); getKnowledgeFromBundle(cast<AssumeInst>(*I), BOI);
if (!RK) if (!RK)
continue; continue;
Builder.addKnowledge(RK); Builder.addKnowledge(RK);
if (auto *I = dyn_cast_or_null<Instruction>(RK.WasOn)) if (auto *I = dyn_cast_if_present<Instruction>(RK.WasOn))
if (I->getParent() == InsertPt->getParent() && if (I->getParent() == InsertPt->getParent() &&
(InsertPt->comesBefore(I) || InsertPt == I)) (InsertPt->comesBefore(I) || InsertPt == I))
InsertPt = I->getNextNode(); InsertPt = I->getNextNode();
} }
} }
/// Adjust InsertPt if it is before Begin, since mergeAssumes only /// Adjust InsertPt if it is before Begin, since mergeAssumes only
/// guarantees we can place the resulting assume between Begin and End. /// guarantees we can place the resulting assume between Begin and End.
▲ Show 20 Lines • Show All 158 Lines • Show Last 20 Lines

llvm/lib/Transforms/Utils/BasicBlockUtils.cpp

Show First 20 Lines • Show All 163 Lines • ▼ Show 20 Linesbool llvm::DeleteDeadPHIs(BasicBlock *BB, const TargetLibraryInfo *TLI,
// Recursively deleting a PHI may cause multiple PHIs to be deleted // Recursively deleting a PHI may cause multiple PHIs to be deleted
// or RAUW'd undef, so use an array of WeakTrackingVH for the PHIs to delete. // or RAUW'd undef, so use an array of WeakTrackingVH for the PHIs to delete.
SmallVector<WeakTrackingVH, 8> PHIs; SmallVector<WeakTrackingVH, 8> PHIs;
for (PHINode &PN : BB->phis()) for (PHINode &PN : BB->phis())
PHIs.push_back(&PN); PHIs.push_back(&PN);
bool Changed = false; bool Changed = false;
for (unsigned i = 0, e = PHIs.size(); i != e; ++i) for (unsigned i = 0, e = PHIs.size(); i != e; ++i)
if (PHINode *PN = dyn_cast_or_null<PHINode>(PHIs[i].operator Value*())) if (PHINode *PN = dyn_cast_if_present<PHINode>(PHIs[i].operator Value *()))
Changed |= RecursivelyDeleteDeadPHINode(PN, TLI, MSSAU); Changed |= RecursivelyDeleteDeadPHINode(PN, TLI, MSSAU);
return Changed; return Changed;
} }
bool llvm::MergeBlockIntoPredecessor(BasicBlock *BB, DomTreeUpdater *DTU, bool llvm::MergeBlockIntoPredecessor(BasicBlock *BB, DomTreeUpdater *DTU,
LoopInfo *LI, MemorySSAUpdater *MSSAU, LoopInfo *LI, MemorySSAUpdater *MSSAU,
MemoryDependenceResults *MemDep, MemoryDependenceResults *MemDep,
▲ Show 20 Lines • Show All 1,625 Lines • ▼ Show 20 Lines Updates.push_back({DominatorTree::Insert, GuardBlocks[NumGuards - 1],
Outgoing[NumGuards - 1]}); Outgoing[NumGuards - 1]});
Updates.push_back({DominatorTree::Insert, GuardBlocks[NumGuards - 1], Updates.push_back({DominatorTree::Insert, GuardBlocks[NumGuards - 1],
Outgoing[NumGuards]}); Outgoing[NumGuards]});
DTU->applyUpdates(Updates); DTU->applyUpdates(Updates);
} }
for (auto I : DeletionCandidates) { for (auto I : DeletionCandidates) {
if (I->use_empty()) if (I->use_empty())
if (auto Inst = dyn_cast_or_null<Instruction>(I)) if (auto Inst = dyn_cast_if_present<Instruction>(I))
Inst->eraseFromParent(); Inst->eraseFromParent();
} }
return FirstGuardBlock; return FirstGuardBlock;
} }

llvm/lib/Transforms/Utils/CallPromotionUtils.cpp

Show First 20 Lines • Show All 299 Lines • ▼ Show 20 Lines if (OrigInst->isMustTailCall()) {
BasicBlock *ThenBlock = ThenTerm->getParent(); BasicBlock *ThenBlock = ThenTerm->getParent();
ThenBlock->setName("if.true.direct_targ"); ThenBlock->setName("if.true.direct_targ");
CallBase *NewInst = cast<CallBase>(OrigInst->clone()); CallBase *NewInst = cast<CallBase>(OrigInst->clone());
NewInst->insertBefore(ThenTerm); NewInst->insertBefore(ThenTerm);
// Place a clone of the optional bitcast after the new call site. // Place a clone of the optional bitcast after the new call site.
Value *NewRetVal = NewInst; Value *NewRetVal = NewInst;
auto Next = OrigInst->getNextNode(); auto Next = OrigInst->getNextNode();
if (auto *BitCast = dyn_cast_or_null<BitCastInst>(Next)) { if (auto *BitCast = dyn_cast_if_present<BitCastInst>(Next)) {
assert(BitCast->getOperand(0) == OrigInst && assert(BitCast->getOperand(0) == OrigInst &&
"bitcast following musttail call must use the call"); "bitcast following musttail call must use the call");
auto NewBitCast = BitCast->clone(); auto NewBitCast = BitCast->clone();
NewBitCast->replaceUsesOfWith(OrigInst, NewInst); NewBitCast->replaceUsesOfWith(OrigInst, NewInst);
NewBitCast->insertBefore(ThenTerm); NewBitCast->insertBefore(ThenTerm);
NewRetVal = NewBitCast; NewRetVal = NewBitCast;
Next = BitCast->getNextNode(); Next = BitCast->getNextNode();
} }
// Place a clone of the return instruction after the new call site. // Place a clone of the return instruction after the new call site.
ReturnInst *Ret = dyn_cast_or_null<ReturnInst>(Next); ReturnInst *Ret = dyn_cast_if_present<ReturnInst>(Next);
assert(Ret && "musttail call must precede a ret with an optional bitcast"); assert(Ret && "musttail call must precede a ret with an optional bitcast");
auto NewRet = Ret->clone(); auto NewRet = Ret->clone();
if (Ret->getReturnValue()) if (Ret->getReturnValue())
NewRet->replaceUsesOfWith(Ret->getReturnValue(), NewRetVal); NewRet->replaceUsesOfWith(Ret->getReturnValue(), NewRetVal);
NewRet->insertBefore(ThenTerm); NewRet->insertBefore(ThenTerm);
// A return instructions is terminating, so we don't need the terminator // A return instructions is terminating, so we don't need the terminator
// instruction just created. // instruction just created.
▲ Show 20 Lines • Show All 281 Lines • Show Last 20 Lines

llvm/lib/Transforms/Utils/CloneFunction.cpp

Show First 20 Lines • Show All 536 Lines • ▼ Show 20 Linesvoid PruningFunctionCloner::CloneBlock(
bool TerminatorDone = false; bool TerminatorDone = false;
if (const BranchInst *BI = dyn_cast<BranchInst>(OldTI)) { if (const BranchInst *BI = dyn_cast<BranchInst>(OldTI)) {
if (BI->isConditional()) { if (BI->isConditional()) {
// If the condition was a known constant in the callee... // If the condition was a known constant in the callee...
ConstantInt *Cond = dyn_cast<ConstantInt>(BI->getCondition()); ConstantInt *Cond = dyn_cast<ConstantInt>(BI->getCondition());
// Or is a known constant in the caller... // Or is a known constant in the caller...
if (!Cond) { if (!Cond) {
Value *V = VMap.lookup(BI->getCondition()); Value *V = VMap.lookup(BI->getCondition());
Cond = dyn_cast_or_null<ConstantInt>(V); Cond = dyn_cast_if_present<ConstantInt>(V);
} }
// Constant fold to uncond branch! // Constant fold to uncond branch!
if (Cond) { if (Cond) {
BasicBlock *Dest = BI->getSuccessor(!Cond->getZExtValue()); BasicBlock *Dest = BI->getSuccessor(!Cond->getZExtValue());
VMap[OldTI] = BranchInst::Create(Dest, NewBB); VMap[OldTI] = BranchInst::Create(Dest, NewBB);
ToClone.push_back(Dest); ToClone.push_back(Dest);
TerminatorDone = true; TerminatorDone = true;
} }
} }
} else if (const SwitchInst *SI = dyn_cast<SwitchInst>(OldTI)) { } else if (const SwitchInst *SI = dyn_cast<SwitchInst>(OldTI)) {
// If switching on a value known constant in the caller. // If switching on a value known constant in the caller.
ConstantInt *Cond = dyn_cast<ConstantInt>(SI->getCondition()); ConstantInt *Cond = dyn_cast<ConstantInt>(SI->getCondition());
if (!Cond) { // Or known constant after constant prop in the callee... if (!Cond) { // Or known constant after constant prop in the callee...
Value *V = VMap.lookup(SI->getCondition()); Value *V = VMap.lookup(SI->getCondition());
Cond = dyn_cast_or_null<ConstantInt>(V); Cond = dyn_cast_if_present<ConstantInt>(V);
} }
if (Cond) { // Constant fold to uncond branch! if (Cond) { // Constant fold to uncond branch!
SwitchInst::ConstCaseHandle Case = *SI->findCaseValue(Cond); SwitchInst::ConstCaseHandle Case = *SI->findCaseValue(Cond);
BasicBlock *Dest = const_cast<BasicBlock *>(Case.getCaseSuccessor()); BasicBlock *Dest = const_cast<BasicBlock *>(Case.getCaseSuccessor());
VMap[OldTI] = BranchInst::Create(Dest, NewBB); VMap[OldTI] = BranchInst::Create(Dest, NewBB);
ToClone.push_back(Dest); ToClone.push_back(Dest);
TerminatorDone = true; TerminatorDone = true;
} }
▲ Show 20 Lines • Show All 192 Lines • ▼ Show 20 Lines#endif
SmallSetVector<const Value *, 8> Worklist; SmallSetVector<const Value *, 8> Worklist;
for (unsigned Idx = 0, Size = PHIToResolve.size(); Idx != Size; ++Idx) for (unsigned Idx = 0, Size = PHIToResolve.size(); Idx != Size; ++Idx)
if (isa<PHINode>(VMap[PHIToResolve[Idx]])) if (isa<PHINode>(VMap[PHIToResolve[Idx]]))
Worklist.insert(PHIToResolve[Idx]); Worklist.insert(PHIToResolve[Idx]);
// Note that we must test the size on each iteration, the worklist can grow. // Note that we must test the size on each iteration, the worklist can grow.
for (unsigned Idx = 0; Idx != Worklist.size(); ++Idx) { for (unsigned Idx = 0; Idx != Worklist.size(); ++Idx) {
const Value *OrigV = Worklist[Idx]; const Value *OrigV = Worklist[Idx];
auto *I = dyn_cast_or_null<Instruction>(VMap.lookup(OrigV)); auto *I = dyn_cast_if_present<Instruction>(VMap.lookup(OrigV));
if (!I) if (!I)
continue; continue;
// Skip over non-intrinsic callsites, we don't want to remove any nodes from // Skip over non-intrinsic callsites, we don't want to remove any nodes from
// the CGSCC. // the CGSCC.
CallBase *CB = dyn_cast<CallBase>(I); CallBase *CB = dyn_cast<CallBase>(I);
if (CB && CB->getCalledFunction() && if (CB && CB->getCalledFunction() &&
!CB->getCalledFunction()->isIntrinsic()) !CB->getCalledFunction()->isIntrinsic())
▲ Show 20 Lines • Show All 370 Lines • Show Last 20 Lines

llvm/lib/Transforms/Utils/CodeExtractor.cpp

Show First 20 Lines • Show All 1,605 Lines • ▼ Show 20 Linesstatic void fixupDebugInfoPostExtraction(Function &OldFunc, Function &NewFunc,
// Fix up the scope information attached to the line locations in the new // Fix up the scope information attached to the line locations in the new
// function. // function.
for (Instruction &I : instructions(NewFunc)) { for (Instruction &I : instructions(NewFunc)) {
if (const DebugLoc &DL = I.getDebugLoc()) if (const DebugLoc &DL = I.getDebugLoc())
I.setDebugLoc(DILocation::get(Ctx, DL.getLine(), DL.getCol(), NewSP)); I.setDebugLoc(DILocation::get(Ctx, DL.getLine(), DL.getCol(), NewSP));
// Loop info metadata may contain line locations. Fix them up. // Loop info metadata may contain line locations. Fix them up.
auto updateLoopInfoLoc = [&Ctx, NewSP](Metadata *MD) -> Metadata * { auto updateLoopInfoLoc = [&Ctx, NewSP](Metadata *MD) -> Metadata * {
if (auto *Loc = dyn_cast_or_null<DILocation>(MD)) if (auto *Loc = dyn_cast_if_present<DILocation>(MD))
return DILocation::get(Ctx, Loc->getLine(), Loc->getColumn(), NewSP, return DILocation::get(Ctx, Loc->getLine(), Loc->getColumn(), NewSP,
nullptr); nullptr);
return MD; return MD;
}; };
updateLoopMetadataDebugLocations(I, updateLoopInfoLoc); updateLoopMetadataDebugLocations(I, updateLoopInfoLoc);
} }
if (!TheCall.getDebugLoc()) if (!TheCall.getDebugLoc())
TheCall.setDebugLoc(DILocation::get(Ctx, 0, 0, OldSP)); TheCall.setDebugLoc(DILocation::get(Ctx, 0, 0, OldSP));
▲ Show 20 Lines • Show All 227 Lines • ▼ Show 20 Lines LLVM_DEBUG(if (AC && verifyAssumptionCache(*oldFunction, *newFunction, AC))
report_fatal_error("Stale Asumption cache for old Function!")); report_fatal_error("Stale Asumption cache for old Function!"));
return newFunction; return newFunction;
} }
bool CodeExtractor::verifyAssumptionCache(const Function &OldFunc, bool CodeExtractor::verifyAssumptionCache(const Function &OldFunc,
const Function &NewFunc, const Function &NewFunc,
AssumptionCache *AC) { AssumptionCache *AC) {
for (auto AssumeVH : AC->assumptions()) { for (auto AssumeVH : AC->assumptions()) {
auto *I = dyn_cast_or_null<CallInst>(AssumeVH); auto *I = dyn_cast_if_present<CallInst>(AssumeVH);
if (!I) if (!I)
continue; continue;
// There shouldn't be any llvm.assume intrinsics in the new function. // There shouldn't be any llvm.assume intrinsics in the new function.
if (I->getFunction() != &OldFunc) if (I->getFunction() != &OldFunc)
return true; return true;
// There shouldn't be any stale affected values in the assumption cache // There shouldn't be any stale affected values in the assumption cache
// that were previously in the old function, but that have now been moved // that were previously in the old function, but that have now been moved
// to the new function. // to the new function.
for (auto AffectedValVH : AC->assumptionsFor(I->getOperand(0))) { for (auto AffectedValVH : AC->assumptionsFor(I->getOperand(0))) {
auto *AffectedCI = dyn_cast_or_null<CallInst>(AffectedValVH); auto *AffectedCI = dyn_cast_if_present<CallInst>(AffectedValVH);
if (!AffectedCI) if (!AffectedCI)
continue; continue;
if (AffectedCI->getFunction() != &OldFunc) if (AffectedCI->getFunction() != &OldFunc)
return true; return true;
auto *AssumedInst = cast<Instruction>(AffectedCI->getOperand(0)); auto *AssumedInst = cast<Instruction>(AffectedCI->getOperand(0));
if (AssumedInst->getFunction() != &OldFunc) if (AssumedInst->getFunction() != &OldFunc)
return true; return true;
} }
} }
return false; return false;
} }
void CodeExtractor::excludeArgFromAggregate(Value *Arg) { void CodeExtractor::excludeArgFromAggregate(Value *Arg) {
ExcludeArgsFromAggregate.insert(Arg); ExcludeArgsFromAggregate.insert(Arg);
} }

llvm/lib/Transforms/Utils/FunctionImportUtils.cpp

Show First 20 Lines • Show All 258 Lines • ▼ Show 20 Lines if (GlobalVariable *V = dyn_cast<GlobalVariable>(&GV)) {
// same-named locals in different but same-named source files that were // same-named locals in different but same-named source files that were
// compiled in their respective directories (so the source file name // compiled in their respective directories (so the source file name
// and resulting GUID is the same). Find the one in this module. // and resulting GUID is the same). Find the one in this module.
// Handle the case where there is no summary found in this module. That // Handle the case where there is no summary found in this module. That
// can happen in the distributed ThinLTO backend, because the index only // can happen in the distributed ThinLTO backend, because the index only
// contains summaries from the source modules if they are being imported. // contains summaries from the source modules if they are being imported.
// We might have a non-null VI and get here even in that case if the name // We might have a non-null VI and get here even in that case if the name
// matches one in this module (e.g. weak or appending linkage). // matches one in this module (e.g. weak or appending linkage).
auto *GVS = dyn_cast_or_null<GlobalVarSummary>( auto *GVS = dyn_cast_if_present<GlobalVarSummary>(
ImportIndex.findSummaryInModule(VI, M.getModuleIdentifier())); ImportIndex.findSummaryInModule(VI, M.getModuleIdentifier()));
if (GVS && if (GVS &&
(ImportIndex.isReadOnly(GVS) || ImportIndex.isWriteOnly(GVS))) { (ImportIndex.isReadOnly(GVS) || ImportIndex.isWriteOnly(GVS))) {
V->addAttribute("thinlto-internalize"); V->addAttribute("thinlto-internalize");
// Objects referenced by writeonly GV initializer should not be // Objects referenced by writeonly GV initializer should not be
// promoted, because there is no any kind of read access to them // promoted, because there is no any kind of read access to them
// on behalf of this writeonly GV. To avoid promotion we convert // on behalf of this writeonly GV. To avoid promotion we convert
// GV initializer to 'zeroinitializer'. This effectively drops // GV initializer to 'zeroinitializer'. This effectively drops
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

llvm/lib/Transforms/Utils/InlineFunction.cpp

Show First 20 Lines • Show All 1,249 Lines • ▼ Show 20 Linesstatic void AddReturnAttributes(CallBase &CB, ValueToValueMapTy &VMap) {
for (auto &BB : *CalledFunction) { for (auto &BB : *CalledFunction) {
auto *RI = dyn_cast<ReturnInst>(BB.getTerminator()); auto *RI = dyn_cast<ReturnInst>(BB.getTerminator());
if (!RI || !isa<CallBase>(RI->getOperand(0))) if (!RI || !isa<CallBase>(RI->getOperand(0)))
continue; continue;
auto *RetVal = cast<CallBase>(RI->getOperand(0)); auto *RetVal = cast<CallBase>(RI->getOperand(0));
// Check that the cloned RetVal exists and is a call, otherwise we cannot // Check that the cloned RetVal exists and is a call, otherwise we cannot
// add the attributes on the cloned RetVal. Simplification during inlining // add the attributes on the cloned RetVal. Simplification during inlining
// could have transformed the cloned instruction. // could have transformed the cloned instruction.
auto *NewRetVal = dyn_cast_or_null<CallBase>(VMap.lookup(RetVal)); auto *NewRetVal = dyn_cast_if_present<CallBase>(VMap.lookup(RetVal));
if (!NewRetVal) if (!NewRetVal)
continue; continue;
// Backward propagation of attributes to the returned value may be incorrect // Backward propagation of attributes to the returned value may be incorrect
// if it is control flow dependent. // if it is control flow dependent.
// Consider: // Consider:
// @callee { // @callee {
// %rv = call @foo() // %rv = call @foo()
// %rv2 = call @bar() // %rv2 = call @bar()
▲ Show 20 Lines • Show All 277 Lines • ▼ Show 20 Linesstatic void fixupLineNumbers(Function *Fn, Function::iterator FI,
for (; FI != Fn->end(); ++FI) { for (; FI != Fn->end(); ++FI) {
for (BasicBlock::iterator BI = FI->begin(), BE = FI->end(); for (BasicBlock::iterator BI = FI->begin(), BE = FI->end();
BI != BE; ++BI) { BI != BE; ++BI) {
// Loop metadata needs to be updated so that the start and end locs // Loop metadata needs to be updated so that the start and end locs
// reference inlined-at locations. // reference inlined-at locations.
auto updateLoopInfoLoc = [&Ctx, &InlinedAtNode, auto updateLoopInfoLoc = [&Ctx, &InlinedAtNode,
&IANodes](Metadata *MD) -> Metadata * { &IANodes](Metadata *MD) -> Metadata * {
if (auto *Loc = dyn_cast_or_null<DILocation>(MD)) if (auto *Loc = dyn_cast_if_present<DILocation>(MD))
return inlineDebugLoc(Loc, InlinedAtNode, Ctx, IANodes).get(); return inlineDebugLoc(Loc, InlinedAtNode, Ctx, IANodes).get();
return MD; return MD;
}; };
updateLoopMetadataDebugLocations(*BI, updateLoopInfoLoc); updateLoopMetadataDebugLocations(*BI, updateLoopInfoLoc);
if (!NoInlineLineTables) if (!NoInlineLineTables)
if (DebugLoc DL = BI->getDebugLoc()) { if (DebugLoc DL = BI->getDebugLoc()) {
DebugLoc IDL = DebugLoc IDL =
▲ Show 20 Lines • Show All 97 Lines • ▼ Show 20 Lines const uint64_t NewEntryCount =
? 0 ? 0
: PriorEntryCount + EntryDelta; : PriorEntryCount + EntryDelta;
// During inlining ? // During inlining ?
if (VMap) { if (VMap) {
uint64_t CloneEntryCount = PriorEntryCount - NewEntryCount; uint64_t CloneEntryCount = PriorEntryCount - NewEntryCount;
for (auto Entry : *VMap) for (auto Entry : *VMap)
if (isa<CallInst>(Entry.first)) if (isa<CallInst>(Entry.first))
if (auto *CI = dyn_cast_or_null<CallInst>(Entry.second)) if (auto *CI = dyn_cast_if_present<CallInst>(Entry.second))
CI->updateProfWeight(CloneEntryCount, PriorEntryCount); CI->updateProfWeight(CloneEntryCount, PriorEntryCount);
} }
if (EntryDelta) { if (EntryDelta) {
Callee->setEntryCount(NewEntryCount); Callee->setEntryCount(NewEntryCount);
for (BasicBlock &BB : *Callee) for (BasicBlock &BB : *Callee)
// No need to update the callsite if it is pruned during inlining. // No need to update the callsite if it is pruned during inlining.
▲ Show 20 Lines • Show All 347 Lines • ▼ Show 20 Lines for (ByValInit &Init : ByValInits)
&*FirstNewBlock, IFI); &*FirstNewBlock, IFI);
Optional<OperandBundleUse> ParentDeopt = Optional<OperandBundleUse> ParentDeopt =
CB.getOperandBundle(LLVMContext::OB_deopt); CB.getOperandBundle(LLVMContext::OB_deopt);
if (ParentDeopt) { if (ParentDeopt) {
SmallVector<OperandBundleDef, 2> OpDefs; SmallVector<OperandBundleDef, 2> OpDefs;
for (auto &VH : InlinedFunctionInfo.OperandBundleCallSites) { for (auto &VH : InlinedFunctionInfo.OperandBundleCallSites) {
CallBase *ICS = dyn_cast_or_null<CallBase>(VH); CallBase *ICS = dyn_cast_if_present<CallBase>(VH);
if (!ICS) if (!ICS)
continue; // instruction was DCE'd or RAUW'ed to undef continue; // instruction was DCE'd or RAUW'ed to undef
OpDefs.clear(); OpDefs.clear();
OpDefs.reserve(ICS->getNumOperandBundles()); OpDefs.reserve(ICS->getNumOperandBundles());
for (unsigned COBi = 0, COBe = ICS->getNumOperandBundles(); COBi < COBe; for (unsigned COBi = 0, COBe = ICS->getNumOperandBundles(); COBi < COBe;
▲ Show 20 Lines • Show All 402 Lines • ▼ Show 20 Lines for (ReturnInst *RI : Returns) {
NormalReturns.push_back(RI); NormalReturns.push_back(RI);
continue; continue;
} }
if (!NeedBitCast) if (!NeedBitCast)
continue; continue;
// Delete the old return and any preceding bitcast. // Delete the old return and any preceding bitcast.
BasicBlock *CurBB = RI->getParent(); BasicBlock *CurBB = RI->getParent();
auto *OldCast = dyn_cast_or_null<BitCastInst>(RI->getReturnValue()); auto *OldCast = dyn_cast_if_present<BitCastInst>(RI->getReturnValue());
RI->eraseFromParent(); RI->eraseFromParent();
if (OldCast) if (OldCast)
OldCast->eraseFromParent(); OldCast->eraseFromParent();
// Insert a new bitcast and return with the right type. // Insert a new bitcast and return with the right type.
IRBuilder<> Builder(CurBB); IRBuilder<> Builder(CurBB);
Builder.CreateRet(Builder.CreateBitCast(ReturnedMustTail, NewRetTy)); Builder.CreateRet(Builder.CreateBitCast(ReturnedMustTail, NewRetTy));
} }
▲ Show 20 Lines • Show All 219 Lines • Show Last 20 Lines

llvm/lib/Transforms/Utils/Local.cpp

Show First 20 Lines • Show All 1,419 Lines • ▼ Show 20 Linesstatic bool valueCoversEntireFragment(Type *ValTy, DbgVariableIntrinsic *DII) {
// We can't always calculate the size of the DI variable (e.g. if it is a // We can't always calculate the size of the DI variable (e.g. if it is a
// VLA). Try to use the size of the alloca that the dbg intrinsic describes // VLA). Try to use the size of the alloca that the dbg intrinsic describes
// intead. // intead.
if (DII->isAddressOfVariable()) { if (DII->isAddressOfVariable()) {
// DII should have exactly 1 location when it is an address. // DII should have exactly 1 location when it is an address.
assert(DII->getNumVariableLocationOps() == 1 && assert(DII->getNumVariableLocationOps() == 1 &&
"address of variable must have exactly 1 location operand."); "address of variable must have exactly 1 location operand.");
if (auto *AI = if (auto *AI =
dyn_cast_or_null<AllocaInst>(DII->getVariableLocationOp(0))) { dyn_cast_if_present<AllocaInst>(DII->getVariableLocationOp(0))) {
if (Optional<TypeSize> FragmentSize = AI->getAllocationSizeInBits(DL)) { if (Optional<TypeSize> FragmentSize = AI->getAllocationSizeInBits(DL)) {
return TypeSize::isKnownGE(ValueSize, *FragmentSize); return TypeSize::isKnownGE(ValueSize, *FragmentSize);
} }
} }
} }
// Could not determine size of variable. Conservatively return false. // Could not determine size of variable. Conservatively return false.
return false; return false;
} }
▲ Show 20 Lines • Show All 121 Lines • ▼ Show 20 Lines for (Instruction &BI : FI)
if (auto DDI = dyn_cast<DbgDeclareInst>(&BI)) if (auto DDI = dyn_cast<DbgDeclareInst>(&BI))
Dbgs.push_back(DDI); Dbgs.push_back(DDI);
if (Dbgs.empty()) if (Dbgs.empty())
return Changed; return Changed;
for (auto &I : Dbgs) { for (auto &I : Dbgs) {
DbgDeclareInst *DDI = I; DbgDeclareInst *DDI = I;
AllocaInst *AI = dyn_cast_or_null<AllocaInst>(DDI->getAddress()); AllocaInst *AI = dyn_cast_if_present<AllocaInst>(DDI->getAddress());
// If this is an alloca for a scalar variable, insert a dbg.value // If this is an alloca for a scalar variable, insert a dbg.value
// at each load and store to the alloca and erase the dbg.declare. // at each load and store to the alloca and erase the dbg.declare.
// The dbg.values allow tracking a variable even if it is not // The dbg.values allow tracking a variable even if it is not
// stored on the stack, while the dbg.declare can only describe // stored on the stack, while the dbg.declare can only describe
// the stack slot (and at a lexical-scope granularity). Later // the stack slot (and at a lexical-scope granularity). Later
// passes will attempt to elide the stack slot. // passes will attempt to elide the stack slot.
if (!AI || isArray(AI) || isStructure(AI)) if (!AI || isArray(AI) || isStructure(AI))
continue; continue;
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Linesvoid llvm::insertDebugValuesForPHIs(BasicBlock *BB,
if (InsertedPHIs.size() == 0) if (InsertedPHIs.size() == 0)
return; return;
// Map existing PHI nodes to their dbg.values. // Map existing PHI nodes to their dbg.values.
ValueToValueMapTy DbgValueMap; ValueToValueMapTy DbgValueMap;
for (auto &I : *BB) { for (auto &I : *BB) {
if (auto DbgII = dyn_cast<DbgVariableIntrinsic>(&I)) { if (auto DbgII = dyn_cast<DbgVariableIntrinsic>(&I)) {
for (Value *V : DbgII->location_ops()) for (Value *V : DbgII->location_ops())
if (auto *Loc = dyn_cast_or_null<PHINode>(V)) if (auto *Loc = dyn_cast_if_present<PHINode>(V))
DbgValueMap.insert({Loc, DbgII}); DbgValueMap.insert({Loc, DbgII});
} }
} }
if (DbgValueMap.size() == 0) if (DbgValueMap.size() == 0)
return; return;
// Map a pair of the destination BB and old dbg.value to the new dbg.value, // Map a pair of the destination BB and old dbg.value to the new dbg.value,
// so that if a dbg.value is being rewritten to use more than one of the // so that if a dbg.value is being rewritten to use more than one of the
▲ Show 20 Lines • Show All 1,758 Lines • Show Last 20 Lines

llvm/lib/Transforms/Utils/LoopUnroll.cpp

Show First 20 Lines • Show All 220 Lines • ▼ Show 20 Linesvoid llvm::simplifyLoopAfterUnroll(Loop *L, bool SimplifyIVs, LoopInfo *LI,
if (SE && SimplifyIVs) { if (SE && SimplifyIVs) {
SmallVector<WeakTrackingVH, 16> DeadInsts; SmallVector<WeakTrackingVH, 16> DeadInsts;
simplifyLoopIVs(L, SE, DT, LI, TTI, DeadInsts); simplifyLoopIVs(L, SE, DT, LI, TTI, DeadInsts);
// Aggressively clean up dead instructions that simplifyLoopIVs already // Aggressively clean up dead instructions that simplifyLoopIVs already
// identified. Any remaining should be cleaned up below. // identified. Any remaining should be cleaned up below.
while (!DeadInsts.empty()) { while (!DeadInsts.empty()) {
Value *V = DeadInsts.pop_back_val(); Value *V = DeadInsts.pop_back_val();
if (Instruction *Inst = dyn_cast_or_null<Instruction>(V)) if (Instruction *Inst = dyn_cast_if_present<Instruction>(V))
RecursivelyDeleteTriviallyDeadInstructions(Inst); RecursivelyDeleteTriviallyDeadInstructions(Inst);
} }
} }
// At this point, the code is well formed. Perform constprop, instsimplify, // At this point, the code is well formed. Perform constprop, instsimplify,
// and dce. // and dce.
const DataLayout &DL = L->getHeader()->getModule()->getDataLayout(); const DataLayout &DL = L->getHeader()->getModule()->getDataLayout();
SmallVector<WeakTrackingVH, 16> DeadInsts; SmallVector<WeakTrackingVH, 16> DeadInsts;
▲ Show 20 Lines • Show All 630 Lines • Show Last 20 Lines

llvm/lib/Transforms/Utils/LoopUtils.cpp

Show First 20 Lines • Show All 1,737 Lines • ▼ Show 20 Lines while (!WorkList.empty()) {
// Do not duplicate volatile and atomic loads. // Do not duplicate volatile and atomic loads.
if (auto *LI = dyn_cast<LoadInst>(I)) if (auto *LI = dyn_cast<LoadInst>(I))
if (LI->isVolatile() || LI->isAtomic()) if (LI->isVolatile() || LI->isAtomic())
return {}; return {};
InstToDuplicate.push_back(I); InstToDuplicate.push_back(I);
if (MemoryAccess *MA = MSSA.getMemoryAccess(I)) { if (MemoryAccess *MA = MSSA.getMemoryAccess(I)) {
if (auto *MemUse = dyn_cast_or_null<MemoryUse>(MA)) { if (auto *MemUse = dyn_cast_if_present<MemoryUse>(MA)) {
// Queue the defining access to check for alias checks. // Queue the defining access to check for alias checks.
AccessesToCheck.push_back(MemUse->getDefiningAccess()); AccessesToCheck.push_back(MemUse->getDefiningAccess());
AccessedLocs.push_back(MemoryLocation::get(I)); AccessedLocs.push_back(MemoryLocation::get(I));
} else { } else {
// MemoryDefs may clobber the location or may be atomic memory // MemoryDefs may clobber the location or may be atomic memory
// operations. Bail out. // operations. Bail out.
return {}; return {};
} }
▲ Show 20 Lines • Show All 126 Lines • Show Last 20 Lines

llvm/lib/Transforms/Utils/MemoryTaggingSupport.cpp

Show First 20 Lines • Show All 131 Lines • ▼ Show 20 Lines if (II && (II->getIntrinsicID() == Intrinsic::lifetime_start ||
if (II->getIntrinsicID() == Intrinsic::lifetime_start) if (II->getIntrinsicID() == Intrinsic::lifetime_start)
Info.AllocasToInstrument[AI].LifetimeStart.push_back(II); Info.AllocasToInstrument[AI].LifetimeStart.push_back(II);
else else
Info.AllocasToInstrument[AI].LifetimeEnd.push_back(II); Info.AllocasToInstrument[AI].LifetimeEnd.push_back(II);
return; return;
} }
if (auto *DVI = dyn_cast<DbgVariableIntrinsic>(&Inst)) { if (auto *DVI = dyn_cast<DbgVariableIntrinsic>(&Inst)) {
for (Value *V : DVI->location_ops()) { for (Value *V : DVI->location_ops()) {
if (auto *AI = dyn_cast_or_null<AllocaInst>(V)) { if (auto *AI = dyn_cast_if_present<AllocaInst>(V)) {
if (!IsInterestingAlloca(*AI)) if (!IsInterestingAlloca(*AI))
continue; continue;
AllocaInfo &AInfo = Info.AllocasToInstrument[AI]; AllocaInfo &AInfo = Info.AllocasToInstrument[AI];
auto &DVIVec = AInfo.DbgVariableIntrinsics; auto &DVIVec = AInfo.DbgVariableIntrinsics;
if (DVIVec.empty() || DVIVec.back() != DVI) if (DVIVec.empty() || DVIVec.back() != DVI)
DVIVec.push_back(DVI); DVIVec.push_back(DVI);
} }
} }
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

llvm/lib/Transforms/Utils/PredicateInfo.cpp

Show First 20 Lines • Show All 98 Lines • ▼ Show 20 Linesstruct ValueDFS {
Use *U = nullptr; Use *U = nullptr;
// Neither PInfo nor EdgeOnly participate in the ordering // Neither PInfo nor EdgeOnly participate in the ordering
PredicateBase *PInfo = nullptr; PredicateBase *PInfo = nullptr;
bool EdgeOnly = false; bool EdgeOnly = false;
}; };
// Perform a strict weak ordering on instructions and arguments. // Perform a strict weak ordering on instructions and arguments.
static bool valueComesBefore(const Value *A, const Value *B) { static bool valueComesBefore(const Value *A, const Value *B) {
auto *ArgA = dyn_cast_or_null<Argument>(A); auto *ArgA = dyn_cast_if_present<Argument>(A);
auto *ArgB = dyn_cast_or_null<Argument>(B); auto *ArgB = dyn_cast_if_present<Argument>(B);
if (ArgA && !ArgB) if (ArgA && !ArgB)
return true; return true;
if (ArgB && !ArgA) if (ArgB && !ArgA)
return false; return false;
if (ArgA && ArgB) if (ArgA && ArgB)
return ArgA->getArgNo() < ArgB->getArgNo(); return ArgA->getArgNo() < ArgB->getArgNo();
return cast<Instruction>(A)->comesBefore(cast<Instruction>(B)); return cast<Instruction>(A)->comesBefore(cast<Instruction>(B));
} }
▲ Show 20 Lines • Show All 106 Lines • ▼ Show 20 Lines#endif
// whether A comes before B, where both are in the same basic block. // whether A comes before B, where both are in the same basic block.
bool localComesBefore(const ValueDFS &A, const ValueDFS &B) const { bool localComesBefore(const ValueDFS &A, const ValueDFS &B) const {
auto *ADef = getMiddleDef(A); auto *ADef = getMiddleDef(A);
auto *BDef = getMiddleDef(B); auto *BDef = getMiddleDef(B);
// See if we have real values or uses. If we have real values, we are // See if we have real values or uses. If we have real values, we are
// guaranteed they are instructions or arguments. No matter what, we are // guaranteed they are instructions or arguments. No matter what, we are
// guaranteed they are in the same block if they are instructions. // guaranteed they are in the same block if they are instructions.
auto *ArgA = dyn_cast_or_null<Argument>(ADef); auto *ArgA = dyn_cast_if_present<Argument>(ADef);
auto *ArgB = dyn_cast_or_null<Argument>(BDef); auto *ArgB = dyn_cast_if_present<Argument>(BDef);
if (ArgA || ArgB) if (ArgA || ArgB)
return valueComesBefore(ArgA, ArgB); return valueComesBefore(ArgA, ArgB);
auto *AInst = getDefOrUser(ADef, A.U); auto *AInst = getDefOrUser(ADef, A.U);
auto *BInst = getDefOrUser(BDef, B.U); auto *BInst = getDefOrUser(BDef, B.U);
return valueComesBefore(AInst, BInst); return valueComesBefore(AInst, BInst);
} }
▲ Show 20 Lines • Show All 277 Lines • ▼ Show 20 Lines if (auto *BI = dyn_cast<BranchInst>(BranchBB->getTerminator())) {
if (BI->getSuccessor(0) == BI->getSuccessor(1)) if (BI->getSuccessor(0) == BI->getSuccessor(1))
continue; continue;
processBranch(BI, BranchBB, OpsToRename); processBranch(BI, BranchBB, OpsToRename);
} else if (auto *SI = dyn_cast<SwitchInst>(BranchBB->getTerminator())) { } else if (auto *SI = dyn_cast<SwitchInst>(BranchBB->getTerminator())) {
processSwitch(SI, BranchBB, OpsToRename); processSwitch(SI, BranchBB, OpsToRename);
} }
} }
for (auto &Assume : AC.assumptions()) { for (auto &Assume : AC.assumptions()) {
if (auto *II = dyn_cast_or_null<IntrinsicInst>(Assume)) if (auto *II = dyn_cast_if_present<IntrinsicInst>(Assume))
if (DT.isReachableFromEntry(II->getParent())) if (DT.isReachableFromEntry(II->getParent()))
processAssume(II, II->getParent(), OpsToRename); processAssume(II, II->getParent(), OpsToRename);
} }
// Now rename all our operations. // Now rename all our operations.
renameUses(OpsToRename); renameUses(OpsToRename);
} }
// Given the renaming stack, make all the operands currently on the stack real // Given the renaming stack, make all the operands currently on the stack real
▲ Show 20 Lines • Show All 414 Lines • Show Last 20 Lines

llvm/lib/Transforms/Utils/SCCPSolver.cpp

Show First 20 Lines • Show All 122 Lines • ▼ Show 20 Linesclass SCCPInstVisitor : public InstVisitor<SCCPInstVisitor> {
DenseMap<Function *, AnalysisResultsForFn> AnalysisResults; DenseMap<Function *, AnalysisResultsForFn> AnalysisResults;
DenseMap<Value *, SmallPtrSet<User *, 2>> AdditionalUsers; DenseMap<Value *, SmallPtrSet<User *, 2>> AdditionalUsers;
LLVMContext &Ctx; LLVMContext &Ctx;
private: private:
ConstantInt *getConstantInt(const ValueLatticeElement &IV) const { ConstantInt *getConstantInt(const ValueLatticeElement &IV) const {
return dyn_cast_or_null<ConstantInt>(getConstant(IV)); return dyn_cast_if_present<ConstantInt>(getConstant(IV));
} }
// pushToWorkList - Helper for markConstant/markOverdefined // pushToWorkList - Helper for markConstant/markOverdefined
void pushToWorkList(ValueLatticeElement &IV, Value *V); void pushToWorkList(ValueLatticeElement &IV, Value *V);
// Helper to push \p V to the worklist, after updating it to \p IV. Also // Helper to push \p V to the worklist, after updating it to \p IV. Also
// prints a debug message with the updated value. // prints a debug message with the updated value.
void pushToWorkListMsg(ValueLatticeElement &IV, Value *V); void pushToWorkListMsg(ValueLatticeElement &IV, Value *V);
▲ Show 20 Lines • Show All 516 Lines • ▼ Show 20 Lines if (auto *SI = dyn_cast<SwitchInst>(&TI)) {
return; return;
} }
// In case of indirect branch and its address is a blockaddress, we mark // In case of indirect branch and its address is a blockaddress, we mark
// the target as executable. // the target as executable.
if (auto *IBR = dyn_cast<IndirectBrInst>(&TI)) { if (auto *IBR = dyn_cast<IndirectBrInst>(&TI)) {
// Casts are folded by visitCastInst. // Casts are folded by visitCastInst.
ValueLatticeElement IBRValue = getValueState(IBR->getAddress()); ValueLatticeElement IBRValue = getValueState(IBR->getAddress());
BlockAddress *Addr = dyn_cast_or_null<BlockAddress>(getConstant(IBRValue)); BlockAddress *Addr =
dyn_cast_if_present<BlockAddress>(getConstant(IBRValue));
if (!Addr) { // Overdefined or unknown condition? if (!Addr) { // Overdefined or unknown condition?
// All destinations are executable! // All destinations are executable!
if (!IBRValue.isUnknownOrUndef()) if (!IBRValue.isUnknownOrUndef())
Succs.assign(TI.getNumSuccessors(), true); Succs.assign(TI.getNumSuccessors(), true);
return; return;
} }
BasicBlock *T = Addr->getBasicBlock(); BasicBlock *T = Addr->getBasicBlock();
▲ Show 20 Lines • Show All 309 Lines • ▼ Show 20 Lines if (V1State.isOverdefined() && V2State.isOverdefined())
return (void)markOverdefined(&I); return (void)markOverdefined(&I);
// If either of the operands is a constant, try to fold it to a constant. // If either of the operands is a constant, try to fold it to a constant.
// TODO: Use information from notconstant better. // TODO: Use information from notconstant better.
if ((V1State.isConstant() || V2State.isConstant())) { if ((V1State.isConstant() || V2State.isConstant())) {
Value *V1 = isConstant(V1State) ? getConstant(V1State) : I.getOperand(0); Value *V1 = isConstant(V1State) ? getConstant(V1State) : I.getOperand(0);
Value *V2 = isConstant(V2State) ? getConstant(V2State) : I.getOperand(1); Value *V2 = isConstant(V2State) ? getConstant(V2State) : I.getOperand(1);
Value *R = simplifyBinOp(I.getOpcode(), V1, V2, SimplifyQuery(DL)); Value *R = simplifyBinOp(I.getOpcode(), V1, V2, SimplifyQuery(DL));
auto *C = dyn_cast_or_null<Constant>(R); auto *C = dyn_cast_if_present<Constant>(R);
if (C) { if (C) {
// Conservatively assume that the result may be based on operands that may // Conservatively assume that the result may be based on operands that may
// be undef. Note that we use mergeInValue to combine the constant with // be undef. Note that we use mergeInValue to combine the constant with
// the existing lattice value for I, as different constants might be found // the existing lattice value for I, as different constants might be found
// after one of the operands go to overdefined, e.g. due to one operand // after one of the operands go to overdefined, e.g. due to one operand
// being a special floating value. // being a special floating value.
ValueLatticeElement NewV; ValueLatticeElement NewV;
NewV.markConstant(C, /*MayIncludeUndef=*/true); NewV.markConstant(C, /*MayIncludeUndef=*/true);
▲ Show 20 Lines • Show All 622 Lines • Show Last 20 Lines

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

Show First 20 Lines • Show All 274 Lines • ▼ Show 20 Lines
// Copy CallInst "flags" like musttail, notail, and tail. Return New param for // Copy CallInst "flags" like musttail, notail, and tail. Return New param for
// easier chaining. Calls to emit* and B.createCall should probably be wrapped // easier chaining. Calls to emit* and B.createCall should probably be wrapped
// in this function when New is created to replace Old. Callers should take // in this function when New is created to replace Old. Callers should take
// care to check Old.isMustTailCall() if they aren't replacing Old directly // care to check Old.isMustTailCall() if they aren't replacing Old directly
// with New. // with New.
static Value *copyFlags(const CallInst &Old, Value *New) { static Value *copyFlags(const CallInst &Old, Value *New) {
assert(!Old.isMustTailCall() && "do not copy musttail call flags"); assert(!Old.isMustTailCall() && "do not copy musttail call flags");
assert(!Old.isNoTailCall() && "do not copy notail call flags"); assert(!Old.isNoTailCall() && "do not copy notail call flags");
if (auto *NewCI = dyn_cast_or_null<CallInst>(New)) if (auto *NewCI = dyn_cast_if_present<CallInst>(New))
NewCI->setTailCallKind(Old.getTailCallKind()); NewCI->setTailCallKind(Old.getTailCallKind());
return New; return New;
} }
// Helper to avoid truncating the length if size_t is 32-bits. // Helper to avoid truncating the length if size_t is 32-bits.
static StringRef substr(StringRef Str, uint64_t Len) { static StringRef substr(StringRef Str, uint64_t Len) {
return Len >= Str.size() ? Str : Str.substr(0, Len); return Len >= Str.size() ? Str : Str.substr(0, Len);
} }
▲ Show 20 Lines • Show All 3,763 Lines • Show Last 20 Lines

llvm/lib/Transforms/Utils/SplitModule.cpp

Show First 20 Lines • Show All 85 Lines • ▼ Show 20 Lines while (!Worklist.empty()) {
} }
addNonConstUser(GVtoClusterMap, GV, UU); addNonConstUser(GVtoClusterMap, GV, UU);
} }
} }
} }
static const GlobalObject *getGVPartitioningRoot(const GlobalValue *GV) { static const GlobalObject *getGVPartitioningRoot(const GlobalValue *GV) {
const GlobalObject *GO = GV->getAliaseeObject(); const GlobalObject *GO = GV->getAliaseeObject();
if (const auto *GI = dyn_cast_or_null<GlobalIFunc>(GO)) if (const auto *GI = dyn_cast_if_present<GlobalIFunc>(GO))
GO = GI->getResolverFunction(); GO = GI->getResolverFunction();
return GO; return GO;
} }
// Find partitions for module in the way that no locals need to be // Find partitions for module in the way that no locals need to be
// globalized. // globalized.
// Try to balance pack those partitions into N files since this roughly equals // Try to balance pack those partitions into N files since this roughly equals
// thread balancing for the backend codegen step. // thread balancing for the backend codegen step.
▲ Show 20 Lines • Show All 185 Lines • Show Last 20 Lines

llvm/lib/Transforms/Vectorize/LoopVectorizationLegality.cpp

Show First 20 Lines • Show All 1,036 Lines • ▼ Show 20 Lines return any_of(getReductionVars(), [&](auto &Reduction) -> bool {
Value *InvariantAddress = RdxDesc.IntermediateStore->getPointerOperand(); Value *InvariantAddress = RdxDesc.IntermediateStore->getPointerOperand();
return V == InvariantAddress || return V == InvariantAddress ||
SE->getSCEV(V) == SE->getSCEV(InvariantAddress); SE->getSCEV(V) == SE->getSCEV(InvariantAddress);
}); });
} }
bool LoopVectorizationLegality::isInductionPhi(const Value *V) const { bool LoopVectorizationLegality::isInductionPhi(const Value *V) const {
Value *In0 = const_cast<Value *>(V); Value *In0 = const_cast<Value *>(V);
PHINode *PN = dyn_cast_or_null<PHINode>(In0); PHINode *PN = dyn_cast_if_present<PHINode>(In0);
if (!PN) if (!PN)
return false; return false;
return Inductions.count(PN); return Inductions.count(PN);
} }
const InductionDescriptor * const InductionDescriptor *
LoopVectorizationLegality::getIntOrFpInductionDescriptor(PHINode *Phi) const { LoopVectorizationLegality::getIntOrFpInductionDescriptor(PHINode *Phi) const {
▲ Show 20 Lines • Show All 365 Lines • Show Last 20 Lines

llvm/lib/Transforms/Vectorize/LoopVectorize.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 6,906 Lines • ▼ Show 20 Linesvoid LoopVectorizationCostModel::setCostBasedWideningDecision(ElementCount VF) {
if (TTI.prefersVectorizedAddressing()) if (TTI.prefersVectorizedAddressing())
return; return;
// Start with all scalar pointer uses. // Start with all scalar pointer uses.
SmallPtrSet<Instruction *, 8> AddrDefs; SmallPtrSet<Instruction *, 8> AddrDefs;
for (BasicBlock *BB : TheLoop->blocks()) for (BasicBlock *BB : TheLoop->blocks())
for (Instruction &I : *BB) { for (Instruction &I : *BB) {
Instruction *PtrDef = Instruction *PtrDef =
dyn_cast_or_null<Instruction>(getLoadStorePointerOperand(&I)); dyn_cast_if_present<Instruction>(getLoadStorePointerOperand(&I));
if (PtrDef && TheLoop->contains(PtrDef) && if (PtrDef && TheLoop->contains(PtrDef) &&
getWideningDecision(&I, VF) != CM_GatherScatter) getWideningDecision(&I, VF) != CM_GatherScatter)
AddrDefs.insert(PtrDef); AddrDefs.insert(PtrDef);
} }
// Add all instructions used to generate the addresses. // Add all instructions used to generate the addresses.
SmallVector<Instruction *, 4> Worklist; SmallVector<Instruction *, 4> Worklist;
append_range(Worklist, AddrDefs); append_range(Worklist, AddrDefs);
▲ Show 20 Lines • Show All 1,339 Lines • ▼ Show 20 LinesVPRecipeOrVPValueTy VPRecipeBuilder::tryToBlend(PHINode *Phi,
if (llvm::all_equal(Operands)) if (llvm::all_equal(Operands))
return Operands[0]; return Operands[0];
unsigned NumIncoming = Phi->getNumIncomingValues(); unsigned NumIncoming = Phi->getNumIncomingValues();
// For in-loop reductions, we do not need to create an additional select. // For in-loop reductions, we do not need to create an additional select.
VPValue *InLoopVal = nullptr; VPValue *InLoopVal = nullptr;
for (unsigned In = 0; In < NumIncoming; In++) { for (unsigned In = 0; In < NumIncoming; In++) {
PHINode *PhiOp = PHINode *PhiOp =
dyn_cast_or_null<PHINode>(Operands[In]->getUnderlyingValue()); dyn_cast_if_present<PHINode>(Operands[In]->getUnderlyingValue());
if (PhiOp && CM.isInLoopReduction(PhiOp)) { if (PhiOp && CM.isInLoopReduction(PhiOp)) {
assert(!InLoopVal && "Found more than one in-loop reduction!"); assert(!InLoopVal && "Found more than one in-loop reduction!");
InLoopVal = Operands[In]; InLoopVal = Operands[In];
} }
} }
assert((!InLoopVal || NumIncoming == 2) && assert((!InLoopVal || NumIncoming == 2) &&
"Found an in-loop reduction for PHI with unexpected number of " "Found an in-loop reduction for PHI with unexpected number of "
▲ Show 20 Lines • Show All 186 Lines • ▼ Show 20 LinesVPBasicBlock *VPRecipeBuilder::handleReplication(
auto *Recipe = new VPReplicateRecipe(I, Plan->mapToVPValues(I->operands()), auto *Recipe = new VPReplicateRecipe(I, Plan->mapToVPValues(I->operands()),
IsUniform, IsPredicated); IsUniform, IsPredicated);
// Find if I uses a predicated instruction. If so, it will use its scalar // Find if I uses a predicated instruction. If so, it will use its scalar
// value. Avoid hoisting the insert-element which packs the scalar value into // value. Avoid hoisting the insert-element which packs the scalar value into
// a vector value, as that happens iff all users use the vector value. // a vector value, as that happens iff all users use the vector value.
for (VPValue *Op : Recipe->operands()) { for (VPValue *Op : Recipe->operands()) {
auto *PredR = dyn_cast_or_null<VPPredInstPHIRecipe>(Op->getDef()); auto *PredR = dyn_cast_if_present<VPPredInstPHIRecipe>(Op->getDef());
if (!PredR) if (!PredR)
continue; continue;
auto *RepR = auto *RepR =
cast_or_null<VPReplicateRecipe>(PredR->getOperand(0)->getDef()); cast_or_null<VPReplicateRecipe>(PredR->getOperand(0)->getDef());
assert(RepR->isPredicated() && assert(RepR->isPredicated() &&
"expected Replicate recipe to be predicated"); "expected Replicate recipe to be predicated");
RepR->setAlsoPack(false); RepR->setAlsoPack(false);
} }
▲ Show 20 Lines • Show All 413 Lines • ▼ Show 20 Lines for (Instruction &I : BB->instructionsWithoutDebug()) {
if (auto RecipeOrValue = RecipeBuilder.tryToCreateWidenRecipe( if (auto RecipeOrValue = RecipeBuilder.tryToCreateWidenRecipe(
Instr, Operands, Range, VPBB, Plan)) { Instr, Operands, Range, VPBB, Plan)) {
// If Instr can be simplified to an existing VPValue, use it. // If Instr can be simplified to an existing VPValue, use it.
if (RecipeOrValue.is<VPValue *>()) { if (RecipeOrValue.is<VPValue *>()) {
auto *VPV = RecipeOrValue.get<VPValue *>(); auto *VPV = RecipeOrValue.get<VPValue *>();
Plan->addVPValue(Instr, VPV); Plan->addVPValue(Instr, VPV);
// If the re-used value is a recipe, register the recipe for the // If the re-used value is a recipe, register the recipe for the
// instruction, in case the recipe for Instr needs to be recorded. // instruction, in case the recipe for Instr needs to be recorded.
if (auto *R = dyn_cast_or_null<VPRecipeBase>(VPV->getDef())) if (auto *R = dyn_cast_if_present<VPRecipeBase>(VPV->getDef()))
RecipeBuilder.setRecipe(Instr, R); RecipeBuilder.setRecipe(Instr, R);
continue; continue;
} }
// Otherwise, add the new recipe. // Otherwise, add the new recipe.
VPRecipeBase *Recipe = RecipeOrValue.get<VPRecipeBase *>(); VPRecipeBase *Recipe = RecipeOrValue.get<VPRecipeBase *>();
for (auto *Def : Recipe->definedValues()) { for (auto *Def : Recipe->definedValues()) {
auto *UV = Def->getUnderlyingValue(); auto *UV = Def->getUnderlyingValue();
Plan->addVPValue(UV, Def); Plan->addVPValue(UV, Def);
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 LinesVPlanPtr LoopVectorizationPlanner::buildVPlanWithVPRecipes(
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
// Transform initial VPlan: Apply previously taken decisions, in order, to // Transform initial VPlan: Apply previously taken decisions, in order, to
// bring the VPlan to its final state. // bring the VPlan to its final state.
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
// Apply Sink-After legal constraints. // Apply Sink-After legal constraints.
auto GetReplicateRegion = [](VPRecipeBase *R) -> VPRegionBlock * { auto GetReplicateRegion = [](VPRecipeBase *R) -> VPRegionBlock * {
auto *Region = dyn_cast_or_null<VPRegionBlock>(R->getParent()->getParent()); auto *Region =
dyn_cast_if_present<VPRegionBlock>(R->getParent()->getParent());
if (Region && Region->isReplicator()) { if (Region && Region->isReplicator()) {
assert(Region->getNumSuccessors() == 1 && assert(Region->getNumSuccessors() == 1 &&
Region->getNumPredecessors() == 1 && "Expected SESE region!"); Region->getNumPredecessors() == 1 && "Expected SESE region!");
assert(R->getParent()->size() == 1 && assert(R->getParent()->size() == 1 &&
"A recipe in an original replicator region must be the only " "A recipe in an original replicator region must be the only "
"recipe in its block"); "recipe in its block");
return Region; return Region;
} }
▲ Show 20 Lines • Show All 99 Lines • ▼ Show 20 LinesVPlanPtr LoopVectorizationPlanner::buildVPlanWithVPRecipes(
// Interleave memory: for each Interleave Group we marked earlier as relevant // Interleave memory: for each Interleave Group we marked earlier as relevant
// for this VPlan, replace the Recipes widening its memory instructions with a // for this VPlan, replace the Recipes widening its memory instructions with a
// single VPInterleaveRecipe at its insertion point. // single VPInterleaveRecipe at its insertion point.
for (const auto *IG : InterleaveGroups) { for (const auto *IG : InterleaveGroups) {
auto *Recipe = cast<VPWidenMemoryInstructionRecipe>( auto *Recipe = cast<VPWidenMemoryInstructionRecipe>(
RecipeBuilder.getRecipe(IG->getInsertPos())); RecipeBuilder.getRecipe(IG->getInsertPos()));
SmallVector<VPValue *, 4> StoredValues; SmallVector<VPValue *, 4> StoredValues;
for (unsigned i = 0; i < IG->getFactor(); ++i) for (unsigned i = 0; i < IG->getFactor(); ++i)
if (auto *SI = dyn_cast_or_null<StoreInst>(IG->getMember(i))) { if (auto *SI = dyn_cast_if_present<StoreInst>(IG->getMember(i))) {
auto *StoreR = auto *StoreR =
cast<VPWidenMemoryInstructionRecipe>(RecipeBuilder.getRecipe(SI)); cast<VPWidenMemoryInstructionRecipe>(RecipeBuilder.getRecipe(SI));
StoredValues.push_back(StoreR->getStoredValue()); StoredValues.push_back(StoreR->getStoredValue());
} }
auto *VPIG = new VPInterleaveRecipe(IG, Recipe->getAddr(), StoredValues, auto *VPIG = new VPInterleaveRecipe(IG, Recipe->getAddr(), StoredValues,
Recipe->getMask()); Recipe->getMask());
VPIG->insertBefore(Recipe); VPIG->insertBefore(Recipe);
▲ Show 20 Lines • Show All 1,567 Lines • Show Last 20 Lines

llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 6,912 Lines • ▼ Show 20 Lines if (IE2 == VU)
return VU->hasOneUse(); return VU->hasOneUse();
if (IE1 == V) if (IE1 == V)
return V->hasOneUse(); return V->hasOneUse();
if (IE1) { if (IE1) {
if ((IE1 != VU && !IE1->hasOneUse()) || if ((IE1 != VU && !IE1->hasOneUse()) ||
getInsertIndex(IE1).value_or(Idx2) == Idx2) getInsertIndex(IE1).value_or(Idx2) == Idx2)
IE1 = nullptr; IE1 = nullptr;
else else
IE1 = dyn_cast_or_null<InsertElementInst>(GetBaseOperand(IE1)); IE1 = dyn_cast_if_present<InsertElementInst>(GetBaseOperand(IE1));
} }
if (IE2) { if (IE2) {
if ((IE2 != V && !IE2->hasOneUse()) || if ((IE2 != V && !IE2->hasOneUse()) ||
getInsertIndex(IE2).value_or(Idx1) == Idx1) getInsertIndex(IE2).value_or(Idx1) == Idx1)
IE2 = nullptr; IE2 = nullptr;
else else
IE2 = dyn_cast_or_null<InsertElementInst>(GetBaseOperand(IE2)); IE2 = dyn_cast_if_present<InsertElementInst>(GetBaseOperand(IE2));
} }
} while (IE1 || IE2); } while (IE1 || IE2);
return false; return false;
} }
/// Checks if the \p IE1 instructions is followed by \p IE2 instruction in the /// Checks if the \p IE1 instructions is followed by \p IE2 instruction in the
/// buildvector sequence. /// buildvector sequence.
static bool isFirstInsertElement(const InsertElementInst *IE1, static bool isFirstInsertElement(const InsertElementInst *IE1,
▲ Show 20 Lines • Show All 182 Lines • ▼ Show 20 Lines for (ExternalUser &EU : ExternalUses) {
// Already counted the cost for external uses when tried to adjust the cost // Already counted the cost for external uses when tried to adjust the cost
// for extractelements, no need to add it again. // for extractelements, no need to add it again.
if (isa<ExtractElementInst>(EU.Scalar)) if (isa<ExtractElementInst>(EU.Scalar))
continue; continue;
// If found user is an insertelement, do not calculate extract cost but try // If found user is an insertelement, do not calculate extract cost but try
// to detect it as a final shuffled/identity match. // to detect it as a final shuffled/identity match.
if (auto *VU = dyn_cast_or_null<InsertElementInst>(EU.User)) { if (auto *VU = dyn_cast_if_present<InsertElementInst>(EU.User)) {
if (auto *FTy = dyn_cast<FixedVectorType>(VU->getType())) { if (auto *FTy = dyn_cast<FixedVectorType>(VU->getType())) {
Optional<unsigned> InsertIdx = getInsertIndex(VU); Optional<unsigned> InsertIdx = getInsertIndex(VU);
if (InsertIdx) { if (InsertIdx) {
const TreeEntry *ScalarTE = getTreeEntry(EU.Scalar); const TreeEntry *ScalarTE = getTreeEntry(EU.Scalar);
auto *It = find_if( auto *It = find_if(
FirstUsers, FirstUsers,
[this, VU](const std::pair<Value *, const TreeEntry *> &Pair) { [this, VU](const std::pair<Value *, const TreeEntry *> &Pair) {
return areTwoInsertFromSameBuildVector( return areTwoInsertFromSameBuildVector(
▲ Show 20 Lines • Show All 4,574 Lines • ▼ Show 20 Lines
} }
bool SLPVectorizerPass::vectorizeHorReduction( bool SLPVectorizerPass::vectorizeHorReduction(
PHINode *P, Value *V, BasicBlock *BB, BoUpSLP &R, TargetTransformInfo *TTI, PHINode *P, Value *V, BasicBlock *BB, BoUpSLP &R, TargetTransformInfo *TTI,
SmallVectorImpl<WeakTrackingVH> &PostponedInsts) { SmallVectorImpl<WeakTrackingVH> &PostponedInsts) {
if (!ShouldVectorizeHor) if (!ShouldVectorizeHor)
return false; return false;
auto *Root = dyn_cast_or_null<Instruction>(V); auto *Root = dyn_cast_if_present<Instruction>(V);
if (!Root) if (!Root)
return false; return false;
if (!isa<BinaryOperator>(Root)) if (!isa<BinaryOperator>(Root))
P = nullptr; P = nullptr;
if (Root->getParent() != BB || isa<PHINode>(Root)) if (Root->getParent() != BB || isa<PHINode>(Root))
return false; return false;
▲ Show 20 Lines • Show All 810 Lines • Show Last 20 Lines

llvm/lib/Transforms/Vectorize/VPlan.h

Show First 20 Lines • Show All 1,085 Lines • ▼ Show 20 Lines#endif
/// Returns the step value of the induction. /// Returns the step value of the induction.
VPValue *getStepValue() { return getOperand(1); } VPValue *getStepValue() { return getOperand(1); }
const VPValue *getStepValue() const { return getOperand(1); } const VPValue *getStepValue() const { return getOperand(1); }
/// Returns the first defined value as TruncInst, if it is one or nullptr /// Returns the first defined value as TruncInst, if it is one or nullptr
/// otherwise. /// otherwise.
TruncInst *getTruncInst() { TruncInst *getTruncInst() {
return dyn_cast_or_null<TruncInst>(getVPValue(0)->getUnderlyingValue()); return dyn_cast_if_present<TruncInst>(getVPValue(0)->getUnderlyingValue());
} }
const TruncInst *getTruncInst() const { const TruncInst *getTruncInst() const {
return dyn_cast_or_null<TruncInst>(getVPValue(0)->getUnderlyingValue()); return dyn_cast_if_present<TruncInst>(getVPValue(0)->getUnderlyingValue());
} }
PHINode *getPHINode() { return IV; } PHINode *getPHINode() { return IV; }
/// Returns the induction descriptor for the recipe. /// Returns the induction descriptor for the recipe.
const InductionDescriptor &getInductionDescriptor() const { return IndDesc; } const InductionDescriptor &getInductionDescriptor() const { return IndDesc; }
/// Returns true if the induction is canonical, i.e. starting at 0 and /// Returns true if the induction is canonical, i.e. starting at 0 and
▲ Show 20 Lines • Show All 1,748 Lines • ▼ Show 20 Linespublic:
} }
/// Try to merge \p Block into its single predecessor, if \p Block is a /// Try to merge \p Block into its single predecessor, if \p Block is a
/// VPBasicBlock and its predecessor has a single successor. Returns a pointer /// VPBasicBlock and its predecessor has a single successor. Returns a pointer
/// to the predecessor \p Block was merged into or nullptr otherwise. /// to the predecessor \p Block was merged into or nullptr otherwise.
static VPBasicBlock *tryToMergeBlockIntoPredecessor(VPBlockBase *Block) { static VPBasicBlock *tryToMergeBlockIntoPredecessor(VPBlockBase *Block) {
auto *VPBB = dyn_cast<VPBasicBlock>(Block); auto *VPBB = dyn_cast<VPBasicBlock>(Block);
auto *PredVPBB = auto *PredVPBB =
dyn_cast_or_null<VPBasicBlock>(Block->getSinglePredecessor()); dyn_cast_if_present<VPBasicBlock>(Block->getSinglePredecessor());
if (!VPBB || !PredVPBB || PredVPBB->getNumSuccessors() != 1) if (!VPBB || !PredVPBB || PredVPBB->getNumSuccessors() != 1)
return nullptr; return nullptr;
for (VPRecipeBase &R : make_early_inc_range(*VPBB)) for (VPRecipeBase &R : make_early_inc_range(*VPBB))
R.moveBefore(*PredVPBB, PredVPBB->end()); R.moveBefore(*PredVPBB, PredVPBB->end());
VPBlockUtils::disconnectBlocks(PredVPBB, VPBB); VPBlockUtils::disconnectBlocks(PredVPBB, VPBB);
auto *ParentRegion = cast<VPRegionBlock>(Block->getParent()); auto *ParentRegion = cast<VPRegionBlock>(Block->getParent());
if (ParentRegion->getExiting() == Block) if (ParentRegion->getExiting() == Block)
▲ Show 20 Lines • Show All 193 Lines • Show Last 20 Lines

llvm/lib/Transforms/Vectorize/VPlan.cpp

Show First 20 Lines • Show All 80 Lines • ▼ Show 20 Lines
VPValue::~VPValue() { VPValue::~VPValue() {
assert(Users.empty() && "trying to delete a VPValue with remaining users"); assert(Users.empty() && "trying to delete a VPValue with remaining users");
if (Def) if (Def)
Def->removeDefinedValue(this); Def->removeDefinedValue(this);
} }
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
void VPValue::print(raw_ostream &OS, VPSlotTracker &SlotTracker) const { void VPValue::print(raw_ostream &OS, VPSlotTracker &SlotTracker) const {
if (const VPRecipeBase *R = dyn_cast_or_null<VPRecipeBase>(Def)) if (const VPRecipeBase *R = dyn_cast_if_present<VPRecipeBase>(Def))
R->print(OS, "", SlotTracker); R->print(OS, "", SlotTracker);
else else
printAsOperand(OS, SlotTracker); printAsOperand(OS, SlotTracker);
} }
void VPValue::dump() const { void VPValue::dump() const {
const VPRecipeBase *Instr = dyn_cast_or_null<VPRecipeBase>(this->Def); const VPRecipeBase *Instr = dyn_cast_if_present<VPRecipeBase>(this->Def);
VPSlotTracker SlotTracker( VPSlotTracker SlotTracker(
(Instr && Instr->getParent()) ? Instr->getParent()->getPlan() : nullptr); (Instr && Instr->getParent()) ? Instr->getParent()->getPlan() : nullptr);
print(dbgs(), SlotTracker); print(dbgs(), SlotTracker);
dbgs() << "\n"; dbgs() << "\n";
} }
void VPDef::dump() const { void VPDef::dump() const {
const VPRecipeBase *Instr = dyn_cast_or_null<VPRecipeBase>(this); const VPRecipeBase *Instr = dyn_cast_if_present<VPRecipeBase>(this);
VPSlotTracker SlotTracker( VPSlotTracker SlotTracker(
(Instr && Instr->getParent()) ? Instr->getParent()->getPlan() : nullptr); (Instr && Instr->getParent()) ? Instr->getParent()->getPlan() : nullptr);
print(dbgs(), "", SlotTracker); print(dbgs(), "", SlotTracker);
dbgs() << "\n"; dbgs() << "\n";
} }
#endif #endif
// Get the top-most entry block of \p Start. This is the entry block of the // Get the top-most entry block of \p Start. This is the entry block of the
▲ Show 20 Lines • Show All 914 Lines • ▼ Show 20 Linesvoid VPInterleavedAccessInfo::visitBlock(VPBlockBase *Block, Old2NewTy &Old2New,
InterleavedAccessInfo &IAI) { InterleavedAccessInfo &IAI) {
if (VPBasicBlock *VPBB = dyn_cast<VPBasicBlock>(Block)) { if (VPBasicBlock *VPBB = dyn_cast<VPBasicBlock>(Block)) {
for (VPRecipeBase &VPI : *VPBB) { for (VPRecipeBase &VPI : *VPBB) {
if (isa<VPHeaderPHIRecipe>(&VPI)) if (isa<VPHeaderPHIRecipe>(&VPI))
continue; continue;
assert(isa<VPInstruction>(&VPI) && "Can only handle VPInstructions"); assert(isa<VPInstruction>(&VPI) && "Can only handle VPInstructions");
auto *VPInst = cast<VPInstruction>(&VPI); auto *VPInst = cast<VPInstruction>(&VPI);
auto *Inst = dyn_cast_or_null<Instruction>(VPInst->getUnderlyingValue()); auto *Inst =
dyn_cast_if_present<Instruction>(VPInst->getUnderlyingValue());
if (!Inst) if (!Inst)
continue; continue;
auto *IG = IAI.getInterleaveGroup(Inst); auto *IG = IAI.getInterleaveGroup(Inst);
if (!IG) if (!IG)
continue; continue;
auto NewIGIter = Old2New.find(IG); auto NewIGIter = Old2New.find(IG);
if (NewIGIter == Old2New.end()) if (NewIGIter == Old2New.end())
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Linesbool VPRecipeBase::mayWriteToMemory() const {
case VPWidenIntOrFpInductionSC: case VPWidenIntOrFpInductionSC:
case VPWidenCanonicalIVSC: case VPWidenCanonicalIVSC:
case VPWidenPHISC: case VPWidenPHISC:
case VPBlendSC: case VPBlendSC:
case VPWidenSC: case VPWidenSC:
case VPWidenGEPSC: case VPWidenGEPSC:
case VPReductionSC: case VPReductionSC:
case VPWidenSelectSC: { case VPWidenSelectSC: {
const Instruction *I = const Instruction *I = dyn_cast_if_present<Instruction>(
dyn_cast_or_null<Instruction>(getVPSingleValue()->getUnderlyingValue()); getVPSingleValue()->getUnderlyingValue());
(void)I; (void)I;
assert((!I || !I->mayWriteToMemory()) && assert((!I || !I->mayWriteToMemory()) &&
"underlying instruction may write to memory"); "underlying instruction may write to memory");
return false; return false;
} }
default: default:
return true; return true;
} }
Show All 13 Linesbool VPRecipeBase::mayReadFromMemory() const {
case VPWidenIntOrFpInductionSC: case VPWidenIntOrFpInductionSC:
case VPWidenCanonicalIVSC: case VPWidenCanonicalIVSC:
case VPWidenPHISC: case VPWidenPHISC:
case VPBlendSC: case VPBlendSC:
case VPWidenSC: case VPWidenSC:
case VPWidenGEPSC: case VPWidenGEPSC:
case VPReductionSC: case VPReductionSC:
case VPWidenSelectSC: { case VPWidenSelectSC: {
const Instruction *I = const Instruction *I = dyn_cast_if_present<Instruction>(
dyn_cast_or_null<Instruction>(getVPSingleValue()->getUnderlyingValue()); getVPSingleValue()->getUnderlyingValue());
(void)I; (void)I;
assert((!I || !I->mayReadFromMemory()) && assert((!I || !I->mayReadFromMemory()) &&
"underlying instruction may read from memory"); "underlying instruction may read from memory");
return false; return false;
} }
default: default:
return true; return true;
} }
} }
bool VPRecipeBase::mayHaveSideEffects() const { bool VPRecipeBase::mayHaveSideEffects() const {
switch (getVPDefID()) { switch (getVPDefID()) {
case VPPredInstPHISC: case VPPredInstPHISC:
return false; return false;
case VPWidenIntOrFpInductionSC: case VPWidenIntOrFpInductionSC:
case VPWidenPointerInductionSC: case VPWidenPointerInductionSC:
case VPWidenCanonicalIVSC: case VPWidenCanonicalIVSC:
case VPWidenPHISC: case VPWidenPHISC:
case VPBlendSC: case VPBlendSC:
case VPWidenSC: case VPWidenSC:
case VPWidenGEPSC: case VPWidenGEPSC:
case VPReductionSC: case VPReductionSC:
case VPWidenSelectSC: case VPWidenSelectSC:
case VPScalarIVStepsSC: { case VPScalarIVStepsSC: {
const Instruction *I = const Instruction *I = dyn_cast_if_present<Instruction>(
dyn_cast_or_null<Instruction>(getVPSingleValue()->getUnderlyingValue()); getVPSingleValue()->getUnderlyingValue());
(void)I; (void)I;
assert((!I || !I->mayHaveSideEffects()) && assert((!I || !I->mayHaveSideEffects()) &&
"underlying instruction has side-effects"); "underlying instruction has side-effects");
return false; return false;
} }
case VPReplicateSC: { case VPReplicateSC: {
auto *R = cast<VPReplicateRecipe>(this); auto *R = cast<VPReplicateRecipe>(this);
return R->getUnderlyingInstr()->mayHaveSideEffects(); return R->getUnderlyingInstr()->mayHaveSideEffects();
▲ Show 20 Lines • Show All 526 Lines • ▼ Show 20 Linesbool VPScalarIVStepsRecipe::isCanonical() const {
auto *CanIV = getCanonicalIV(); auto *CanIV = getCanonicalIV();
// The start value of the steps-recipe must match the start value of the // The start value of the steps-recipe must match the start value of the
// canonical induction and it must step by 1. // canonical induction and it must step by 1.
if (CanIV->getStartValue() != getStartValue()) if (CanIV->getStartValue() != getStartValue())
return false; return false;
auto *StepVPV = getStepValue(); auto *StepVPV = getStepValue();
if (StepVPV->getDef()) if (StepVPV->getDef())
return false; return false;
auto *StepC = dyn_cast_or_null<ConstantInt>(StepVPV->getLiveInIRValue()); auto *StepC = dyn_cast_if_present<ConstantInt>(StepVPV->getLiveInIRValue());
return StepC && StepC->isOne(); return StepC && StepC->isOne();
} }
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
void VPScalarIVStepsRecipe::print(raw_ostream &O, const Twine &Indent, void VPScalarIVStepsRecipe::print(raw_ostream &O, const Twine &Indent,
VPSlotTracker &SlotTracker) const { VPSlotTracker &SlotTracker) const {
O << Indent; O << Indent;
printAsOperand(O, SlotTracker); printAsOperand(O, SlotTracker);
▲ Show 20 Lines • Show All 569 Lines • Show Last 20 Lines

llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp

Show First 20 Lines • Show All 117 Lines • ▼ Show 20 Lines for (VPBasicBlock *VPBB : VPBlockUtils::blocksOnly<VPBasicBlock>(Iter)) {
} }
} }
// Try to sink each replicate recipe in the worklist. // Try to sink each replicate recipe in the worklist.
while (!WorkList.empty()) { while (!WorkList.empty()) {
VPBasicBlock *SinkTo; VPBasicBlock *SinkTo;
VPValue *C; VPValue *C;
std::tie(SinkTo, C) = WorkList.pop_back_val(); std::tie(SinkTo, C) = WorkList.pop_back_val();
auto *SinkCandidate = dyn_cast_or_null<VPReplicateRecipe>(C->Def); auto *SinkCandidate = dyn_cast_if_present<VPReplicateRecipe>(C->Def);
if (!SinkCandidate || SinkCandidate->isUniform() || if (!SinkCandidate || SinkCandidate->isUniform() ||
SinkCandidate->getParent() == SinkTo || SinkCandidate->getParent() == SinkTo ||
SinkCandidate->mayHaveSideEffects() || SinkCandidate->mayHaveSideEffects() ||
SinkCandidate->mayReadOrWriteMemory()) SinkCandidate->mayReadOrWriteMemory())
continue; continue;
bool NeedsDuplicating = false; bool NeedsDuplicating = false;
// All recipe users of the sink candidate must be in the same block SinkTo // All recipe users of the sink candidate must be in the same block SinkTo
▲ Show 20 Lines • Show All 89 Lines • ▼ Show 20 Linesbool VPlanTransforms::mergeReplicateRegions(VPlan &Plan) {
// Check if Base is a predicated triangle, followed by an empty block, // Check if Base is a predicated triangle, followed by an empty block,
// followed by another predicate triangle. If that's the case, move the // followed by another predicate triangle. If that's the case, move the
// recipes from the first to the second triangle. // recipes from the first to the second triangle.
for (VPRegionBlock *Region1 : CandidateRegions) { for (VPRegionBlock *Region1 : CandidateRegions) {
if (DeletedRegions.contains(Region1)) if (DeletedRegions.contains(Region1))
continue; continue;
auto *MiddleBasicBlock = auto *MiddleBasicBlock =
dyn_cast_or_null<VPBasicBlock>(Region1->getSingleSuccessor()); dyn_cast_if_present<VPBasicBlock>(Region1->getSingleSuccessor());
if (!MiddleBasicBlock || !MiddleBasicBlock->empty()) if (!MiddleBasicBlock || !MiddleBasicBlock->empty())
continue; continue;
auto *Region2 = auto *Region2 = dyn_cast_if_present<VPRegionBlock>(
dyn_cast_or_null<VPRegionBlock>(MiddleBasicBlock->getSingleSuccessor()); MiddleBasicBlock->getSingleSuccessor());
if (!Region2) if (!Region2)
continue; continue;
VPValue *Mask1 = getPredicatedMask(Region1); VPValue *Mask1 = getPredicatedMask(Region1);
VPValue *Mask2 = getPredicatedMask(Region2); VPValue *Mask2 = getPredicatedMask(Region2);
if (!Mask1 || Mask1 != Mask2) if (!Mask1 || Mask1 != Mask2)
continue; continue;
VPBasicBlock *Then1 = getPredicatedThenBlock(Region1); VPBasicBlock *Then1 = getPredicatedThenBlock(Region1);
▲ Show 20 Lines • Show All 187 Lines • Show Last 20 Lines

llvm/lib/Transforms/Vectorize/VectorCombine.cpp

Show First 20 Lines • Show All 626 Lines • ▼ Show 20 Linesbool VectorCombine::scalarizeBinopOrCmp(Instruction &I) {
bool IsConst1 = !V1; bool IsConst1 = !V1;
if (IsConst0 && IsConst1) if (IsConst0 && IsConst1)
return false; return false;
if (!IsConst0 && !IsConst1 && Index0 != Index1) if (!IsConst0 && !IsConst1 && Index0 != Index1)
return false; return false;
// Bail for single insertion if it is a load. // Bail for single insertion if it is a load.
// TODO: Handle this once getVectorInstrCost can cost for load/stores. // TODO: Handle this once getVectorInstrCost can cost for load/stores.
auto *I0 = dyn_cast_or_null<Instruction>(V0); auto *I0 = dyn_cast_if_present<Instruction>(V0);
auto *I1 = dyn_cast_or_null<Instruction>(V1); auto *I1 = dyn_cast_if_present<Instruction>(V1);
if ((IsConst0 && I1 && I1->mayReadFromMemory()) || if ((IsConst0 && I1 && I1->mayReadFromMemory()) ||
(IsConst1 && I0 && I0->mayReadFromMemory())) (IsConst1 && I0 && I0->mayReadFromMemory()))
return false; return false;
uint64_t Index = IsConst0 ? Index1 : Index0; uint64_t Index = IsConst0 ? Index1 : Index0;
Type *ScalarTy = IsConst0 ? V1->getType() : V0->getType(); Type *ScalarTy = IsConst0 ? V1->getType() : V0->getType();
Type *VecTy = I.getType(); Type *VecTy = I.getType();
assert(VecTy->isVectorTy() && assert(VecTy->isVectorTy() &&
▲ Show 20 Lines • Show All 1,026 Lines • Show Last 20 Lines

llvm/unittests/Analysis/LoopInfoTest.cpp

Show First 20 Lines • Show All 271 Lines • ▼ Show 20 Lines runWithLoopInfoPlus(
Optional<Loop::LoopBounds> Bounds = L->getBounds(SE); Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
EXPECT_NE(Bounds, None); EXPECT_NE(Bounds, None);
ConstantInt *InitialIVValue = ConstantInt *InitialIVValue =
dyn_cast<ConstantInt>(&Bounds->getInitialIVValue()); dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero()); EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero());
EXPECT_EQ(Bounds->getStepInst().getName(), "inc"); EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
ConstantInt *StepValue = ConstantInt *StepValue =
dyn_cast_or_null<ConstantInt>(Bounds->getStepValue()); dyn_cast_if_present<ConstantInt>(Bounds->getStepValue());
EXPECT_TRUE(StepValue && StepValue->isOne()); EXPECT_TRUE(StepValue && StepValue->isOne());
EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub"); EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT); EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
EXPECT_EQ(Bounds->getDirection(), EXPECT_EQ(Bounds->getDirection(),
Loop::LoopBounds::Direction::Increasing); Loop::LoopBounds::Direction::Increasing);
EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i"); EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i");
EXPECT_EQ(L->getLoopGuardBranch(), Guard); EXPECT_EQ(L->getLoopGuardBranch(), Guard);
EXPECT_TRUE(L->isGuarded()); EXPECT_TRUE(L->isGuarded());
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines runWithLoopInfoPlus(
Optional<Loop::LoopBounds> Bounds = L->getBounds(SE); Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
EXPECT_NE(Bounds, None); EXPECT_NE(Bounds, None);
ConstantInt *InitialIVValue = ConstantInt *InitialIVValue =
dyn_cast<ConstantInt>(&Bounds->getInitialIVValue()); dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero()); EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero());
EXPECT_EQ(Bounds->getStepInst().getName(), "inc"); EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
ConstantInt *StepValue = ConstantInt *StepValue =
dyn_cast_or_null<ConstantInt>(Bounds->getStepValue()); dyn_cast_if_present<ConstantInt>(Bounds->getStepValue());
EXPECT_TRUE(StepValue && StepValue->isOne()); EXPECT_TRUE(StepValue && StepValue->isOne());
EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub"); EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT); EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
EXPECT_EQ(Bounds->getDirection(), EXPECT_EQ(Bounds->getDirection(),
Loop::LoopBounds::Direction::Increasing); Loop::LoopBounds::Direction::Increasing);
EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i"); EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i");
EXPECT_EQ(L->getLoopGuardBranch(), Guard); EXPECT_EQ(L->getLoopGuardBranch(), Guard);
EXPECT_TRUE(L->isGuarded()); EXPECT_TRUE(L->isGuarded());
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines runWithLoopInfoPlus(
Optional<Loop::LoopBounds> Bounds = L->getBounds(SE); Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
EXPECT_NE(Bounds, None); EXPECT_NE(Bounds, None);
ConstantInt *InitialIVValue = ConstantInt *InitialIVValue =
dyn_cast<ConstantInt>(&Bounds->getInitialIVValue()); dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero()); EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero());
EXPECT_EQ(Bounds->getStepInst().getName(), "inc"); EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
ConstantInt *StepValue = ConstantInt *StepValue =
dyn_cast_or_null<ConstantInt>(Bounds->getStepValue()); dyn_cast_if_present<ConstantInt>(Bounds->getStepValue());
EXPECT_TRUE(StepValue && StepValue->isOne()); EXPECT_TRUE(StepValue && StepValue->isOne());
EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub"); EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT); EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
EXPECT_EQ(Bounds->getDirection(), EXPECT_EQ(Bounds->getDirection(),
Loop::LoopBounds::Direction::Increasing); Loop::LoopBounds::Direction::Increasing);
EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i"); EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i");
EXPECT_EQ(L->getLoopGuardBranch(), Guard); EXPECT_EQ(L->getLoopGuardBranch(), Guard);
EXPECT_TRUE(L->isGuarded()); EXPECT_TRUE(L->isGuarded());
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines runWithLoopInfoPlus(
Optional<Loop::LoopBounds> Bounds = L->getBounds(SE); Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
EXPECT_NE(Bounds, None); EXPECT_NE(Bounds, None);
ConstantInt *InitialIVValue = ConstantInt *InitialIVValue =
dyn_cast<ConstantInt>(&Bounds->getInitialIVValue()); dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero()); EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero());
EXPECT_EQ(Bounds->getStepInst().getName(), "inc"); EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
ConstantInt *StepValue = ConstantInt *StepValue =
dyn_cast_or_null<ConstantInt>(Bounds->getStepValue()); dyn_cast_if_present<ConstantInt>(Bounds->getStepValue());
EXPECT_TRUE(StepValue && StepValue->isOne()); EXPECT_TRUE(StepValue && StepValue->isOne());
EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub"); EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT); EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
EXPECT_EQ(Bounds->getDirection(), EXPECT_EQ(Bounds->getDirection(),
Loop::LoopBounds::Direction::Increasing); Loop::LoopBounds::Direction::Increasing);
EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i"); EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i");
EXPECT_EQ(L->getLoopGuardBranch(), Guard); EXPECT_EQ(L->getLoopGuardBranch(), Guard);
EXPECT_TRUE(L->isGuarded()); EXPECT_TRUE(L->isGuarded());
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines runWithLoopInfoPlus(
Optional<Loop::LoopBounds> Bounds = L->getBounds(SE); Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
EXPECT_NE(Bounds, None); EXPECT_NE(Bounds, None);
ConstantInt *InitialIVValue = ConstantInt *InitialIVValue =
dyn_cast<ConstantInt>(&Bounds->getInitialIVValue()); dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero()); EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero());
EXPECT_EQ(Bounds->getStepInst().getName(), "inc"); EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
ConstantInt *StepValue = ConstantInt *StepValue =
dyn_cast_or_null<ConstantInt>(Bounds->getStepValue()); dyn_cast_if_present<ConstantInt>(Bounds->getStepValue());
EXPECT_TRUE(StepValue && StepValue->isOne()); EXPECT_TRUE(StepValue && StepValue->isOne());
EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub"); EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT); EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
EXPECT_EQ(Bounds->getDirection(), EXPECT_EQ(Bounds->getDirection(),
Loop::LoopBounds::Direction::Increasing); Loop::LoopBounds::Direction::Increasing);
EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i"); EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i");
EXPECT_EQ(L->getLoopGuardBranch(), Guard); EXPECT_EQ(L->getLoopGuardBranch(), Guard);
EXPECT_TRUE(L->isGuarded()); EXPECT_TRUE(L->isGuarded());
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines runWithLoopInfoPlus(
Optional<Loop::LoopBounds> Bounds = L->getBounds(SE); Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
EXPECT_NE(Bounds, None); EXPECT_NE(Bounds, None);
ConstantInt *InitialIVValue = ConstantInt *InitialIVValue =
dyn_cast<ConstantInt>(&Bounds->getInitialIVValue()); dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero()); EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero());
EXPECT_EQ(Bounds->getStepInst().getName(), "inc"); EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
ConstantInt *StepValue = ConstantInt *StepValue =
dyn_cast_or_null<ConstantInt>(Bounds->getStepValue()); dyn_cast_if_present<ConstantInt>(Bounds->getStepValue());
EXPECT_TRUE(StepValue && StepValue->isOne()); EXPECT_TRUE(StepValue && StepValue->isOne());
EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ubPlusOne"); EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ubPlusOne");
EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT); EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
EXPECT_EQ(Bounds->getDirection(), EXPECT_EQ(Bounds->getDirection(),
Loop::LoopBounds::Direction::Increasing); Loop::LoopBounds::Direction::Increasing);
EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i"); EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i");
EXPECT_EQ(L->getLoopGuardBranch(), Guard); EXPECT_EQ(L->getLoopGuardBranch(), Guard);
EXPECT_TRUE(L->isGuarded()); EXPECT_TRUE(L->isGuarded());
▲ Show 20 Lines • Show All 98 Lines • ▼ Show 20 Lines runWithLoopInfoPlus(
Optional<Loop::LoopBounds> Bounds = L->getBounds(SE); Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
EXPECT_NE(Bounds, None); EXPECT_NE(Bounds, None);
ConstantInt *InitialIVValue = ConstantInt *InitialIVValue =
dyn_cast<ConstantInt>(&Bounds->getInitialIVValue()); dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero()); EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero());
EXPECT_EQ(Bounds->getStepInst().getName(), "inc"); EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
ConstantInt *StepValue = ConstantInt *StepValue =
dyn_cast_or_null<ConstantInt>(Bounds->getStepValue()); dyn_cast_if_present<ConstantInt>(Bounds->getStepValue());
EXPECT_TRUE(StepValue && StepValue->isOne()); EXPECT_TRUE(StepValue && StepValue->isOne());
EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub"); EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_ULT); EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_ULT);
EXPECT_EQ(Bounds->getDirection(), EXPECT_EQ(Bounds->getDirection(),
Loop::LoopBounds::Direction::Increasing); Loop::LoopBounds::Direction::Increasing);
EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i"); EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i");
EXPECT_EQ(L->getLoopGuardBranch(), Guard); EXPECT_EQ(L->getLoopGuardBranch(), Guard);
EXPECT_TRUE(L->isGuarded()); EXPECT_TRUE(L->isGuarded());
Show All 40 Lines runWithLoopInfoPlus(
Loop *L = LI.getLoopFor(Header); Loop *L = LI.getLoopFor(Header);
EXPECT_NE(L, nullptr); EXPECT_NE(L, nullptr);
Optional<Loop::LoopBounds> Bounds = L->getBounds(SE); Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
EXPECT_NE(Bounds, None); EXPECT_NE(Bounds, None);
EXPECT_EQ(Bounds->getInitialIVValue().getName(), "ub"); EXPECT_EQ(Bounds->getInitialIVValue().getName(), "ub");
EXPECT_EQ(Bounds->getStepInst().getName(), "inc"); EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
ConstantInt *StepValue = ConstantInt *StepValue =
dyn_cast_or_null<ConstantInt>(Bounds->getStepValue()); dyn_cast_if_present<ConstantInt>(Bounds->getStepValue());
EXPECT_EQ(StepValue, nullptr); EXPECT_EQ(StepValue, nullptr);
ConstantInt *FinalIVValue = ConstantInt *FinalIVValue =
dyn_cast<ConstantInt>(&Bounds->getFinalIVValue()); dyn_cast<ConstantInt>(&Bounds->getFinalIVValue());
EXPECT_TRUE(FinalIVValue && FinalIVValue->isZero()); EXPECT_TRUE(FinalIVValue && FinalIVValue->isZero());
EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SGT); EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SGT);
EXPECT_EQ(Bounds->getDirection(), EXPECT_EQ(Bounds->getDirection(),
Loop::LoopBounds::Direction::Decreasing); Loop::LoopBounds::Direction::Decreasing);
EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i"); EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i");
▲ Show 20 Lines • Show All 105 Lines • ▼ Show 20 Lines runWithLoopInfoPlus(
Optional<Loop::LoopBounds> Bounds = L->getBounds(SE); Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
EXPECT_NE(Bounds, None); EXPECT_NE(Bounds, None);
ConstantInt *InitialIVValue = ConstantInt *InitialIVValue =
dyn_cast<ConstantInt>(&Bounds->getInitialIVValue()); dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero()); EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero());
EXPECT_EQ(Bounds->getStepInst().getName(), "indvars.iv.next"); EXPECT_EQ(Bounds->getStepInst().getName(), "indvars.iv.next");
ConstantInt *StepValue = ConstantInt *StepValue =
dyn_cast_or_null<ConstantInt>(Bounds->getStepValue()); dyn_cast_if_present<ConstantInt>(Bounds->getStepValue());
EXPECT_TRUE(StepValue && StepValue->isOne()); EXPECT_TRUE(StepValue && StepValue->isOne());
EXPECT_EQ(Bounds->getFinalIVValue().getName(), "wide.trip.count"); EXPECT_EQ(Bounds->getFinalIVValue().getName(), "wide.trip.count");
EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_NE); EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_NE);
EXPECT_EQ(Bounds->getDirection(), EXPECT_EQ(Bounds->getDirection(),
Loop::LoopBounds::Direction::Increasing); Loop::LoopBounds::Direction::Increasing);
EXPECT_EQ(L->getInductionVariable(SE)->getName(), "indvars.iv"); EXPECT_EQ(L->getInductionVariable(SE)->getName(), "indvars.iv");
EXPECT_EQ(L->getLoopGuardBranch(), Guard); EXPECT_EQ(L->getLoopGuardBranch(), Guard);
EXPECT_TRUE(L->isGuarded()); EXPECT_TRUE(L->isGuarded());
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines runWithLoopInfoPlus(
Optional<Loop::LoopBounds> Bounds = L->getBounds(SE); Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
EXPECT_NE(Bounds, None); EXPECT_NE(Bounds, None);
ConstantInt *InitialIVValue = ConstantInt *InitialIVValue =
dyn_cast<ConstantInt>(&Bounds->getInitialIVValue()); dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero()); EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero());
EXPECT_EQ(Bounds->getStepInst().getName(), "inc"); EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
ConstantInt *StepValue = ConstantInt *StepValue =
dyn_cast_or_null<ConstantInt>(Bounds->getStepValue()); dyn_cast_if_present<ConstantInt>(Bounds->getStepValue());
EXPECT_TRUE(StepValue && StepValue->isOne()); EXPECT_TRUE(StepValue && StepValue->isOne());
EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub"); EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT); EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
EXPECT_EQ(Bounds->getDirection(), EXPECT_EQ(Bounds->getDirection(),
Loop::LoopBounds::Direction::Increasing); Loop::LoopBounds::Direction::Increasing);
EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i"); EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i");
EXPECT_EQ(L->getLoopGuardBranch(), Guard); EXPECT_EQ(L->getLoopGuardBranch(), Guard);
EXPECT_TRUE(L->isGuarded()); EXPECT_TRUE(L->isGuarded());
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines runWithLoopInfoPlus(
Optional<Loop::LoopBounds> Bounds = L->getBounds(SE); Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
EXPECT_NE(Bounds, None); EXPECT_NE(Bounds, None);
ConstantInt *InitialIVValue = ConstantInt *InitialIVValue =
dyn_cast<ConstantInt>(&Bounds->getInitialIVValue()); dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero()); EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero());
EXPECT_EQ(Bounds->getStepInst().getName(), "inc"); EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
ConstantInt *StepValue = ConstantInt *StepValue =
dyn_cast_or_null<ConstantInt>(Bounds->getStepValue()); dyn_cast_if_present<ConstantInt>(Bounds->getStepValue());
EXPECT_TRUE(StepValue && StepValue->isOne()); EXPECT_TRUE(StepValue && StepValue->isOne());
EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub"); EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT); EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
EXPECT_EQ(Bounds->getDirection(), EXPECT_EQ(Bounds->getDirection(),
Loop::LoopBounds::Direction::Increasing); Loop::LoopBounds::Direction::Increasing);
EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i"); EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i");
EXPECT_EQ(L->getLoopGuardBranch(), nullptr); EXPECT_EQ(L->getLoopGuardBranch(), nullptr);
EXPECT_FALSE(L->isGuarded()); EXPECT_FALSE(L->isGuarded());
Show All 35 Lines runWithLoopInfoPlus(
Optional<Loop::LoopBounds> Bounds = L->getBounds(SE); Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
EXPECT_NE(Bounds, None); EXPECT_NE(Bounds, None);
ConstantInt *InitialIVValue = ConstantInt *InitialIVValue =
dyn_cast<ConstantInt>(&Bounds->getInitialIVValue()); dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero()); EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero());
EXPECT_EQ(Bounds->getStepInst().getName(), "inc"); EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
ConstantInt *StepValue = ConstantInt *StepValue =
dyn_cast_or_null<ConstantInt>(Bounds->getStepValue()); dyn_cast_if_present<ConstantInt>(Bounds->getStepValue());
EXPECT_TRUE(StepValue && StepValue->isOne()); EXPECT_TRUE(StepValue && StepValue->isOne());
EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub"); EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT); EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
EXPECT_EQ(Bounds->getDirection(), EXPECT_EQ(Bounds->getDirection(),
Loop::LoopBounds::Direction::Increasing); Loop::LoopBounds::Direction::Increasing);
EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i"); EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i");
EXPECT_EQ(L->getLoopGuardBranch(), nullptr); EXPECT_EQ(L->getLoopGuardBranch(), nullptr);
EXPECT_FALSE(L->isGuarded()); EXPECT_FALSE(L->isGuarded());
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines runWithLoopInfoPlus(
Optional<Loop::LoopBounds> Bounds = L->getBounds(SE); Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
EXPECT_NE(Bounds, None); EXPECT_NE(Bounds, None);
ConstantInt *InitialIVValue = ConstantInt *InitialIVValue =
dyn_cast<ConstantInt>(&Bounds->getInitialIVValue()); dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero()); EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero());
EXPECT_EQ(Bounds->getStepInst().getName(), "inc"); EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
ConstantInt *StepValue = ConstantInt *StepValue =
dyn_cast_or_null<ConstantInt>(Bounds->getStepValue()); dyn_cast_if_present<ConstantInt>(Bounds->getStepValue());
EXPECT_TRUE(StepValue && StepValue->isOne()); EXPECT_TRUE(StepValue && StepValue->isOne());
EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub"); EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT); EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
EXPECT_EQ(Bounds->getDirection(), EXPECT_EQ(Bounds->getDirection(),
Loop::LoopBounds::Direction::Increasing); Loop::LoopBounds::Direction::Increasing);
EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i"); EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i");
EXPECT_EQ(L->getLoopGuardBranch(), Guard); EXPECT_EQ(L->getLoopGuardBranch(), Guard);
EXPECT_TRUE(L->isGuarded()); EXPECT_TRUE(L->isGuarded());
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Lines runWithLoopInfoPlus(
Optional<Loop::LoopBounds> Bounds = L->getBounds(SE); Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
EXPECT_NE(Bounds, None); EXPECT_NE(Bounds, None);
ConstantInt *InitialIVValue = ConstantInt *InitialIVValue =
dyn_cast<ConstantInt>(&Bounds->getInitialIVValue()); dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero()); EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero());
EXPECT_EQ(Bounds->getStepInst().getName(), "inc.outer"); EXPECT_EQ(Bounds->getStepInst().getName(), "inc.outer");
ConstantInt *StepValue = ConstantInt *StepValue =
dyn_cast_or_null<ConstantInt>(Bounds->getStepValue()); dyn_cast_if_present<ConstantInt>(Bounds->getStepValue());
EXPECT_TRUE(StepValue && StepValue->isOne()); EXPECT_TRUE(StepValue && StepValue->isOne());
EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub"); EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT); EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
EXPECT_EQ(Bounds->getDirection(), EXPECT_EQ(Bounds->getDirection(),
Loop::LoopBounds::Direction::Increasing); Loop::LoopBounds::Direction::Increasing);
EXPECT_EQ(L->getInductionVariable(SE)->getName(), "j"); EXPECT_EQ(L->getInductionVariable(SE)->getName(), "j");
EXPECT_EQ(L->getLoopGuardBranch(), OuterGuard); EXPECT_EQ(L->getLoopGuardBranch(), OuterGuard);
EXPECT_TRUE(L->isGuarded()); EXPECT_TRUE(L->isGuarded());
EXPECT_TRUE(L->isRotatedForm()); EXPECT_TRUE(L->isRotatedForm());
// Next two basic blocks are for.outer and for.inner.preheader - skip // Next two basic blocks are for.outer and for.inner.preheader - skip
// them. // them.
++FI; ++FI;
Header = &*(++FI); Header = &*(++FI);
assert(Header->getName() == "for.inner"); assert(Header->getName() == "for.inner");
L = LI.getLoopFor(Header); L = LI.getLoopFor(Header);
EXPECT_NE(L, nullptr); EXPECT_NE(L, nullptr);
Optional<Loop::LoopBounds> InnerBounds = L->getBounds(SE); Optional<Loop::LoopBounds> InnerBounds = L->getBounds(SE);
EXPECT_NE(InnerBounds, None); EXPECT_NE(InnerBounds, None);
InitialIVValue = InitialIVValue =
dyn_cast<ConstantInt>(&InnerBounds->getInitialIVValue()); dyn_cast<ConstantInt>(&InnerBounds->getInitialIVValue());
EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero()); EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero());
EXPECT_EQ(InnerBounds->getStepInst().getName(), "inc"); EXPECT_EQ(InnerBounds->getStepInst().getName(), "inc");
StepValue = dyn_cast_or_null<ConstantInt>(InnerBounds->getStepValue()); StepValue =
dyn_cast_if_present<ConstantInt>(InnerBounds->getStepValue());
EXPECT_TRUE(StepValue && StepValue->isOne()); EXPECT_TRUE(StepValue && StepValue->isOne());
EXPECT_EQ(InnerBounds->getFinalIVValue().getName(), "ub"); EXPECT_EQ(InnerBounds->getFinalIVValue().getName(), "ub");
EXPECT_EQ(InnerBounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT); EXPECT_EQ(InnerBounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
EXPECT_EQ(InnerBounds->getDirection(), EXPECT_EQ(InnerBounds->getDirection(),
Loop::LoopBounds::Direction::Increasing); Loop::LoopBounds::Direction::Increasing);
EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i"); EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i");
EXPECT_EQ(L->getLoopGuardBranch(), InnerGuard); EXPECT_EQ(L->getLoopGuardBranch(), InnerGuard);
EXPECT_TRUE(L->isGuarded()); EXPECT_TRUE(L->isGuarded());
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Lines runWithLoopInfoPlus(
Optional<Loop::LoopBounds> Bounds = L->getBounds(SE); Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
EXPECT_NE(Bounds, None); EXPECT_NE(Bounds, None);
ConstantInt *InitialIVValue = ConstantInt *InitialIVValue =
dyn_cast<ConstantInt>(&Bounds->getInitialIVValue()); dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero()); EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero());
EXPECT_EQ(Bounds->getStepInst().getName(), "inc"); EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
ConstantInt *StepValue = ConstantInt *StepValue =
dyn_cast_or_null<ConstantInt>(Bounds->getStepValue()); dyn_cast_if_present<ConstantInt>(Bounds->getStepValue());
EXPECT_TRUE(StepValue && StepValue->isOne()); EXPECT_TRUE(StepValue && StepValue->isOne());
EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub"); EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT); EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
EXPECT_EQ(Bounds->getDirection(), EXPECT_EQ(Bounds->getDirection(),
Loop::LoopBounds::Direction::Increasing); Loop::LoopBounds::Direction::Increasing);
EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i"); EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i");
BasicBlock::iterator II = Header->begin(); BasicBlock::iterator II = Header->begin();
PHINode &Instruction_i = cast<PHINode>(*(II)); PHINode &Instruction_i = cast<PHINode>(*(II));
▲ Show 20 Lines • Show All 376 Lines • Show Last 20 Lines

llvm/unittests/Analysis/MemorySSATest.cpp

Show First 20 Lines • Show All 1,018 Lines • ▼ Show 20 LinesTEST_F(MemorySSATest, TestStoreMustAlias) {
StoreInst *SB3 = B.CreateStore(ConstantInt::get(Int8, 3), AllocaB); StoreInst *SB3 = B.CreateStore(ConstantInt::get(Int8, 3), AllocaB);
setupAnalyses(); setupAnalyses();
MemorySSA &MSSA = *Analyses->MSSA; MemorySSA &MSSA = *Analyses->MSSA;
MemorySSAWalker *Walker = Analyses->Walker; MemorySSAWalker *Walker = Analyses->Walker;
unsigned I = 0; unsigned I = 0;
for (StoreInst *V : {SA1, SB1, SA2, SB2, SA3, SB3}) { for (StoreInst *V : {SA1, SB1, SA2, SB2, SA3, SB3}) {
MemoryDef *MemDef = dyn_cast_or_null<MemoryDef>(MSSA.getMemoryAccess(V)); MemoryDef *MemDef = dyn_cast_if_present<MemoryDef>(MSSA.getMemoryAccess(V));
EXPECT_EQ(MemDef->isOptimized(), false) EXPECT_EQ(MemDef->isOptimized(), false)
<< "Store " << I << " is optimized from the start?"; << "Store " << I << " is optimized from the start?";
if (V == SA1) if (V == SA1)
Walker->getClobberingMemoryAccess(V); Walker->getClobberingMemoryAccess(V);
else { else {
MemoryAccess *Def = MemDef->getDefiningAccess(); MemoryAccess *Def = MemDef->getDefiningAccess();
MemoryAccess *Clob = Walker->getClobberingMemoryAccess(V); MemoryAccess *Clob = Walker->getClobberingMemoryAccess(V);
EXPECT_NE(Def, Clob) << "Store " << I EXPECT_NE(Def, Clob) << "Store " << I
Show All 36 LinesTEST_F(MemorySSATest, TestStoreMayAlias) {
std::initializer_list<StoreInst *> Sts = {SA1, SB1, SC1, SA2, SB2, SC2, SB3}; std::initializer_list<StoreInst *> Sts = {SA1, SB1, SC1, SA2, SB2, SC2, SB3};
setupAnalyses(); setupAnalyses();
MemorySSA &MSSA = *Analyses->MSSA; MemorySSA &MSSA = *Analyses->MSSA;
MemorySSAWalker *Walker = Analyses->Walker; MemorySSAWalker *Walker = Analyses->Walker;
unsigned I = 0; unsigned I = 0;
for (StoreInst *V : Sts) { for (StoreInst *V : Sts) {
MemoryDef *MemDef = dyn_cast_or_null<MemoryDef>(MSSA.getMemoryAccess(V)); MemoryDef *MemDef = dyn_cast_if_present<MemoryDef>(MSSA.getMemoryAccess(V));
EXPECT_EQ(MemDef->isOptimized(), false) EXPECT_EQ(MemDef->isOptimized(), false)
<< "Store " << I << " is optimized from the start?"; << "Store " << I << " is optimized from the start?";
++I; ++I;
} }
for (StoreInst *V : Sts) for (StoreInst *V : Sts)
Walker->getClobberingMemoryAccess(V); Walker->getClobberingMemoryAccess(V);
I = 0; I = 0;
for (StoreInst *V : Sts) { for (StoreInst *V : Sts) {
MemoryDef *MemDef = dyn_cast_or_null<MemoryDef>(MSSA.getMemoryAccess(V)); MemoryDef *MemDef = dyn_cast_if_present<MemoryDef>(MSSA.getMemoryAccess(V));
EXPECT_EQ(MemDef->isOptimized(), true) EXPECT_EQ(MemDef->isOptimized(), true)
<< "Store " << I << " was not optimized"; << "Store " << I << " was not optimized";
// EXPECT_EQ expands such that if we increment I above, it won't get // EXPECT_EQ expands such that if we increment I above, it won't get
// incremented except when we try to print the error message. // incremented except when we try to print the error message.
++I; ++I;
} }
} }
▲ Show 20 Lines • Show All 699 Lines • Show Last 20 Lines

llvm/unittests/Analysis/VectorFunctionABITest.cpp

Show First 20 Lines • Show All 617 Lines • ▼ Show 20 LinesTEST(VFABIGetMappingsTest, IndirectCallInst) {
LLVMContext C; LLVMContext C;
std::unique_ptr<Module> M = parseIR(C, R"IR( std::unique_ptr<Module> M = parseIR(C, R"IR(
define void @call(void () * %f) { define void @call(void () * %f) {
entry: entry:
call void %f() call void %f()
ret void ret void
} }
)IR"); )IR");
auto F = dyn_cast_or_null<Function>(M->getNamedValue("call")); auto F = dyn_cast_if_present<Function>(M->getNamedValue("call"));
ASSERT_TRUE(F); ASSERT_TRUE(F);
auto CI = dyn_cast<CallInst>(&F->front().front()); auto CI = dyn_cast<CallInst>(&F->front().front());
ASSERT_TRUE(CI); ASSERT_TRUE(CI);
ASSERT_TRUE(CI->isIndirectCall()); ASSERT_TRUE(CI->isIndirectCall());
auto Mappings = VFDatabase::getMappings(*CI); auto Mappings = VFDatabase::getMappings(*CI);
EXPECT_EQ(Mappings.size(), (unsigned)0); EXPECT_EQ(Mappings.size(), (unsigned)0);
} }

llvm/unittests/CodeGen/AsmPrinterDwarfTest.cpp

Show First 20 Lines • Show All 89 Lines • ▼ Show 20 LinesTEST_F(AsmPrinterEmitDwarfSymbolReferenceTest, ELFDWARF32) {
if (!init("x86_64-pc-linux", /*DwarfVersion=*/4, dwarf::DWARF32)) if (!init("x86_64-pc-linux", /*DwarfVersion=*/4, dwarf::DWARF32))
GTEST_SKIP(); GTEST_SKIP();
const MCExpr *Arg0 = nullptr; const MCExpr *Arg0 = nullptr;
EXPECT_CALL(TestPrinter->getMS(), emitValueImpl(_, 4, _)) EXPECT_CALL(TestPrinter->getMS(), emitValueImpl(_, 4, _))
.WillOnce(SaveArg<0>(&Arg0)); .WillOnce(SaveArg<0>(&Arg0));
TestPrinter->getAP()->emitDwarfSymbolReference(Val, false); TestPrinter->getAP()->emitDwarfSymbolReference(Val, false);
const MCSymbolRefExpr *ActualArg0 = dyn_cast_or_null<MCSymbolRefExpr>(Arg0); const MCSymbolRefExpr *ActualArg0 =
dyn_cast_if_present<MCSymbolRefExpr>(Arg0);
ASSERT_NE(ActualArg0, nullptr); ASSERT_NE(ActualArg0, nullptr);
EXPECT_EQ(&(ActualArg0->getSymbol()), Val); EXPECT_EQ(&(ActualArg0->getSymbol()), Val);
} }
TEST_F(AsmPrinterEmitDwarfSymbolReferenceTest, ELFDWARF32ForceOffset) { TEST_F(AsmPrinterEmitDwarfSymbolReferenceTest, ELFDWARF32ForceOffset) {
if (!init("x86_64-pc-linux", /*DwarfVersion=*/4, dwarf::DWARF32)) if (!init("x86_64-pc-linux", /*DwarfVersion=*/4, dwarf::DWARF32))
GTEST_SKIP(); GTEST_SKIP();
EXPECT_CALL(TestPrinter->getMS(), EXPECT_CALL(TestPrinter->getMS(),
emitAbsoluteSymbolDiff(Val, SecBeginSymbol, 4)); emitAbsoluteSymbolDiff(Val, SecBeginSymbol, 4));
TestPrinter->getAP()->emitDwarfSymbolReference(Val, true); TestPrinter->getAP()->emitDwarfSymbolReference(Val, true);
} }
TEST_F(AsmPrinterEmitDwarfSymbolReferenceTest, ELFDWARF64) { TEST_F(AsmPrinterEmitDwarfSymbolReferenceTest, ELFDWARF64) {
if (!init("x86_64-pc-linux", /*DwarfVersion=*/4, dwarf::DWARF64)) if (!init("x86_64-pc-linux", /*DwarfVersion=*/4, dwarf::DWARF64))
GTEST_SKIP(); GTEST_SKIP();
const MCExpr *Arg0 = nullptr; const MCExpr *Arg0 = nullptr;
EXPECT_CALL(TestPrinter->getMS(), emitValueImpl(_, 8, _)) EXPECT_CALL(TestPrinter->getMS(), emitValueImpl(_, 8, _))
.WillOnce(SaveArg<0>(&Arg0)); .WillOnce(SaveArg<0>(&Arg0));
TestPrinter->getAP()->emitDwarfSymbolReference(Val, false); TestPrinter->getAP()->emitDwarfSymbolReference(Val, false);
const MCSymbolRefExpr *ActualArg0 = dyn_cast_or_null<MCSymbolRefExpr>(Arg0); const MCSymbolRefExpr *ActualArg0 =
dyn_cast_if_present<MCSymbolRefExpr>(Arg0);
ASSERT_NE(ActualArg0, nullptr); ASSERT_NE(ActualArg0, nullptr);
EXPECT_EQ(&(ActualArg0->getSymbol()), Val); EXPECT_EQ(&(ActualArg0->getSymbol()), Val);
} }
TEST_F(AsmPrinterEmitDwarfSymbolReferenceTest, ELFDWARF64ForceOffset) { TEST_F(AsmPrinterEmitDwarfSymbolReferenceTest, ELFDWARF64ForceOffset) {
if (!init("x86_64-pc-linux", /*DwarfVersion=*/4, dwarf::DWARF64)) if (!init("x86_64-pc-linux", /*DwarfVersion=*/4, dwarf::DWARF64))
GTEST_SKIP(); GTEST_SKIP();
Show All 22 LinesTEST_F(AsmPrinterEmitDwarfStringOffsetTest, DWARF32) {
if (!init("x86_64-pc-linux", /*DwarfVersion=*/4, dwarf::DWARF32)) if (!init("x86_64-pc-linux", /*DwarfVersion=*/4, dwarf::DWARF32))
GTEST_SKIP(); GTEST_SKIP();
const MCExpr *Arg0 = nullptr; const MCExpr *Arg0 = nullptr;
EXPECT_CALL(TestPrinter->getMS(), emitValueImpl(_, 4, _)) EXPECT_CALL(TestPrinter->getMS(), emitValueImpl(_, 4, _))
.WillOnce(SaveArg<0>(&Arg0)); .WillOnce(SaveArg<0>(&Arg0));
TestPrinter->getAP()->emitDwarfStringOffset(Val); TestPrinter->getAP()->emitDwarfStringOffset(Val);
const MCSymbolRefExpr *ActualArg0 = dyn_cast_or_null<MCSymbolRefExpr>(Arg0); const MCSymbolRefExpr *ActualArg0 =
dyn_cast_if_present<MCSymbolRefExpr>(Arg0);
ASSERT_NE(ActualArg0, nullptr); ASSERT_NE(ActualArg0, nullptr);
EXPECT_EQ(&(ActualArg0->getSymbol()), Val.Symbol); EXPECT_EQ(&(ActualArg0->getSymbol()), Val.Symbol);
} }
TEST_F(AsmPrinterEmitDwarfStringOffsetTest, TEST_F(AsmPrinterEmitDwarfStringOffsetTest,
DWARF32NoRelocationsAcrossSections) { DWARF32NoRelocationsAcrossSections) {
if (!init("x86_64-pc-linux", /*DwarfVersion=*/4, dwarf::DWARF32)) if (!init("x86_64-pc-linux", /*DwarfVersion=*/4, dwarf::DWARF32))
GTEST_SKIP(); GTEST_SKIP();
TestPrinter->setDwarfUsesRelocationsAcrossSections(false); TestPrinter->setDwarfUsesRelocationsAcrossSections(false);
EXPECT_CALL(TestPrinter->getMS(), emitIntValue(Val.Offset, 4)); EXPECT_CALL(TestPrinter->getMS(), emitIntValue(Val.Offset, 4));
TestPrinter->getAP()->emitDwarfStringOffset(Val); TestPrinter->getAP()->emitDwarfStringOffset(Val);
} }
TEST_F(AsmPrinterEmitDwarfStringOffsetTest, DWARF64) { TEST_F(AsmPrinterEmitDwarfStringOffsetTest, DWARF64) {
if (!init("x86_64-pc-linux", /*DwarfVersion=*/4, dwarf::DWARF64)) if (!init("x86_64-pc-linux", /*DwarfVersion=*/4, dwarf::DWARF64))
GTEST_SKIP(); GTEST_SKIP();
const MCExpr *Arg0 = nullptr; const MCExpr *Arg0 = nullptr;
EXPECT_CALL(TestPrinter->getMS(), emitValueImpl(_, 8, _)) EXPECT_CALL(TestPrinter->getMS(), emitValueImpl(_, 8, _))
.WillOnce(SaveArg<0>(&Arg0)); .WillOnce(SaveArg<0>(&Arg0));
TestPrinter->getAP()->emitDwarfStringOffset(Val); TestPrinter->getAP()->emitDwarfStringOffset(Val);
const MCSymbolRefExpr *ActualArg0 = dyn_cast_or_null<MCSymbolRefExpr>(Arg0); const MCSymbolRefExpr *ActualArg0 =
dyn_cast_if_present<MCSymbolRefExpr>(Arg0);
ASSERT_NE(ActualArg0, nullptr); ASSERT_NE(ActualArg0, nullptr);
EXPECT_EQ(&(ActualArg0->getSymbol()), Val.Symbol); EXPECT_EQ(&(ActualArg0->getSymbol()), Val.Symbol);
} }
TEST_F(AsmPrinterEmitDwarfStringOffsetTest, TEST_F(AsmPrinterEmitDwarfStringOffsetTest,
DWARF64NoRelocationsAcrossSections) { DWARF64NoRelocationsAcrossSections) {
if (!init("x86_64-pc-linux", /*DwarfVersion=*/4, dwarf::DWARF64)) if (!init("x86_64-pc-linux", /*DwarfVersion=*/4, dwarf::DWARF64))
GTEST_SKIP(); GTEST_SKIP();
Show All 22 LinesTEST_F(AsmPrinterEmitDwarfOffsetTest, DWARF32) {
if (!init("x86_64-pc-linux", /*DwarfVersion=*/4, dwarf::DWARF32)) if (!init("x86_64-pc-linux", /*DwarfVersion=*/4, dwarf::DWARF32))
GTEST_SKIP(); GTEST_SKIP();
const MCExpr *Arg0 = nullptr; const MCExpr *Arg0 = nullptr;
EXPECT_CALL(TestPrinter->getMS(), emitValueImpl(_, 4, _)) EXPECT_CALL(TestPrinter->getMS(), emitValueImpl(_, 4, _))
.WillOnce(SaveArg<0>(&Arg0)); .WillOnce(SaveArg<0>(&Arg0));
TestPrinter->getAP()->emitDwarfOffset(Label, Offset); TestPrinter->getAP()->emitDwarfOffset(Label, Offset);
const MCBinaryExpr *ActualArg0 = dyn_cast_or_null<MCBinaryExpr>(Arg0); const MCBinaryExpr *ActualArg0 = dyn_cast_if_present<MCBinaryExpr>(Arg0);
ASSERT_NE(ActualArg0, nullptr); ASSERT_NE(ActualArg0, nullptr);
EXPECT_EQ(ActualArg0->getOpcode(), MCBinaryExpr::Add); EXPECT_EQ(ActualArg0->getOpcode(), MCBinaryExpr::Add);
const MCSymbolRefExpr *ActualLHS = const MCSymbolRefExpr *ActualLHS =
dyn_cast_or_null<MCSymbolRefExpr>(ActualArg0->getLHS()); dyn_cast_if_present<MCSymbolRefExpr>(ActualArg0->getLHS());
ASSERT_NE(ActualLHS, nullptr); ASSERT_NE(ActualLHS, nullptr);
EXPECT_EQ(&(ActualLHS->getSymbol()), Label); EXPECT_EQ(&(ActualLHS->getSymbol()), Label);
const MCConstantExpr *ActualRHS = const MCConstantExpr *ActualRHS =
dyn_cast_or_null<MCConstantExpr>(ActualArg0->getRHS()); dyn_cast_if_present<MCConstantExpr>(ActualArg0->getRHS());
ASSERT_NE(ActualRHS, nullptr); ASSERT_NE(ActualRHS, nullptr);
EXPECT_EQ(static_cast<uint64_t>(ActualRHS->getValue()), Offset); EXPECT_EQ(static_cast<uint64_t>(ActualRHS->getValue()), Offset);
} }
TEST_F(AsmPrinterEmitDwarfOffsetTest, DWARF64) { TEST_F(AsmPrinterEmitDwarfOffsetTest, DWARF64) {
if (!init("x86_64-pc-linux", /*DwarfVersion=*/4, dwarf::DWARF64)) if (!init("x86_64-pc-linux", /*DwarfVersion=*/4, dwarf::DWARF64))
GTEST_SKIP(); GTEST_SKIP();
const MCExpr *Arg0 = nullptr; const MCExpr *Arg0 = nullptr;
EXPECT_CALL(TestPrinter->getMS(), emitValueImpl(_, 8, _)) EXPECT_CALL(TestPrinter->getMS(), emitValueImpl(_, 8, _))
.WillOnce(SaveArg<0>(&Arg0)); .WillOnce(SaveArg<0>(&Arg0));
TestPrinter->getAP()->emitDwarfOffset(Label, Offset); TestPrinter->getAP()->emitDwarfOffset(Label, Offset);
const MCBinaryExpr *ActualArg0 = dyn_cast_or_null<MCBinaryExpr>(Arg0); const MCBinaryExpr *ActualArg0 = dyn_cast_if_present<MCBinaryExpr>(Arg0);
ASSERT_NE(ActualArg0, nullptr); ASSERT_NE(ActualArg0, nullptr);
EXPECT_EQ(ActualArg0->getOpcode(), MCBinaryExpr::Add); EXPECT_EQ(ActualArg0->getOpcode(), MCBinaryExpr::Add);
const MCSymbolRefExpr *ActualLHS = const MCSymbolRefExpr *ActualLHS =
dyn_cast_or_null<MCSymbolRefExpr>(ActualArg0->getLHS()); dyn_cast_if_present<MCSymbolRefExpr>(ActualArg0->getLHS());
ASSERT_NE(ActualLHS, nullptr); ASSERT_NE(ActualLHS, nullptr);
EXPECT_EQ(&(ActualLHS->getSymbol()), Label); EXPECT_EQ(&(ActualLHS->getSymbol()), Label);
const MCConstantExpr *ActualRHS = const MCConstantExpr *ActualRHS =
dyn_cast_or_null<MCConstantExpr>(ActualArg0->getRHS()); dyn_cast_if_present<MCConstantExpr>(ActualArg0->getRHS());
ASSERT_NE(ActualRHS, nullptr); ASSERT_NE(ActualRHS, nullptr);
EXPECT_EQ(static_cast<uint64_t>(ActualRHS->getValue()), Offset); EXPECT_EQ(static_cast<uint64_t>(ActualRHS->getValue()), Offset);
} }
class AsmPrinterEmitDwarfLengthOrOffsetTest : public AsmPrinterFixtureBase { class AsmPrinterEmitDwarfLengthOrOffsetTest : public AsmPrinterFixtureBase {
protected: protected:
uint64_t Val = 42; uint64_t Val = 42;
}; };
▲ Show 20 Lines • Show All 166 Lines • Show Last 20 Lines

llvm/unittests/CodeGen/DIETest.cpp

Show First 20 Lines • Show All 93 Lines • ▼ Show 20 Lines
TEST_P(DIELabelFixture, EmitValue) { TEST_P(DIELabelFixture, EmitValue) {
DIELabel Tst(Val); DIELabel Tst(Val);
const MCExpr *Arg0 = nullptr; const MCExpr *Arg0 = nullptr;
EXPECT_CALL(TestPrinter->getMS(), emitValueImpl(_, Size, _)) EXPECT_CALL(TestPrinter->getMS(), emitValueImpl(_, Size, _))
.WillOnce(SaveArg<0>(&Arg0)); .WillOnce(SaveArg<0>(&Arg0));
Tst.emitValue(TestPrinter->getAP(), Form); Tst.emitValue(TestPrinter->getAP(), Form);
const MCSymbolRefExpr *ActualArg0 = dyn_cast_or_null<MCSymbolRefExpr>(Arg0); const MCSymbolRefExpr *ActualArg0 =
dyn_cast_if_present<MCSymbolRefExpr>(Arg0);
ASSERT_NE(ActualArg0, nullptr); ASSERT_NE(ActualArg0, nullptr);
EXPECT_EQ(&(ActualArg0->getSymbol()), Val); EXPECT_EQ(&(ActualArg0->getSymbol()), Val);
} }
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_SUITE_P(
DIETestParams, DIELabelFixture, DIETestParams, DIELabelFixture,
testing::Values( testing::Values(
DIETestParams{4, dwarf::DWARF32, dwarf::DW_FORM_data4, 4u}, DIETestParams{4, dwarf::DWARF32, dwarf::DW_FORM_data4, 4u},
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

llvm/unittests/Frontend/OpenMPIRBuilderTest.cpp

Show First 20 Lines • Show All 2,979 Lines • ▼ Show 20 LinesTEST_F(OpenMPIRBuilderTest, CopyinBlocks) {
AllocaInst *MasterAddress = Builder.CreateAlloca(Int32->getPointerTo()); AllocaInst *MasterAddress = Builder.CreateAlloca(Int32->getPointerTo());
AllocaInst *PrivAddress = Builder.CreateAlloca(Int32->getPointerTo()); AllocaInst *PrivAddress = Builder.CreateAlloca(Int32->getPointerTo());
BasicBlock *EntryBB = BB; BasicBlock *EntryBB = BB;
OMPBuilder.createCopyinClauseBlocks(Builder.saveIP(), MasterAddress, OMPBuilder.createCopyinClauseBlocks(Builder.saveIP(), MasterAddress,
PrivAddress, Int32, /*BranchtoEnd*/ true); PrivAddress, Int32, /*BranchtoEnd*/ true);
BranchInst *EntryBr = dyn_cast_or_null<BranchInst>(EntryBB->getTerminator()); BranchInst *EntryBr =
dyn_cast_if_present<BranchInst>(EntryBB->getTerminator());
EXPECT_NE(EntryBr, nullptr); EXPECT_NE(EntryBr, nullptr);
EXPECT_TRUE(EntryBr->isConditional()); EXPECT_TRUE(EntryBr->isConditional());
BasicBlock *NotMasterBB = EntryBr->getSuccessor(0); BasicBlock *NotMasterBB = EntryBr->getSuccessor(0);
BasicBlock *CopyinEnd = EntryBr->getSuccessor(1); BasicBlock *CopyinEnd = EntryBr->getSuccessor(1);
CmpInst *CMP = dyn_cast_or_null<CmpInst>(EntryBr->getCondition()); CmpInst *CMP = dyn_cast_if_present<CmpInst>(EntryBr->getCondition());
EXPECT_NE(CMP, nullptr); EXPECT_NE(CMP, nullptr);
EXPECT_NE(NotMasterBB, nullptr); EXPECT_NE(NotMasterBB, nullptr);
EXPECT_NE(CopyinEnd, nullptr); EXPECT_NE(CopyinEnd, nullptr);
BranchInst *NotMasterBr = BranchInst *NotMasterBr =
dyn_cast_or_null<BranchInst>(NotMasterBB->getTerminator()); dyn_cast_if_present<BranchInst>(NotMasterBB->getTerminator());
EXPECT_NE(NotMasterBr, nullptr); EXPECT_NE(NotMasterBr, nullptr);
EXPECT_FALSE(NotMasterBr->isConditional()); EXPECT_FALSE(NotMasterBr->isConditional());
EXPECT_EQ(CopyinEnd, NotMasterBr->getSuccessor(0)); EXPECT_EQ(CopyinEnd, NotMasterBr->getSuccessor(0));
} }
TEST_F(OpenMPIRBuilderTest, SingleDirective) { TEST_F(OpenMPIRBuilderTest, SingleDirective) {
using InsertPointTy = OpenMPIRBuilder::InsertPointTy; using InsertPointTy = OpenMPIRBuilder::InsertPointTy;
OpenMPIRBuilder OMPBuilder(*M); OpenMPIRBuilder OMPBuilder(*M);
▲ Show 20 Lines • Show All 1,200 Lines • ▼ Show 20 LinesTEST_F(OpenMPIRBuilderTest, CreateReductions) {
Value *FirstArrayElemPtr = nullptr; Value *FirstArrayElemPtr = nullptr;
Value *SecondArrayElemPtr = nullptr; Value *SecondArrayElemPtr = nullptr;
EXPECT_EQ(LocalArray->getNumUses(), 3u); EXPECT_EQ(LocalArray->getNumUses(), 3u);
ASSERT_TRUE( ASSERT_TRUE(
findGEPZeroOne(LocalArray, FirstArrayElemPtr, SecondArrayElemPtr)); findGEPZeroOne(LocalArray, FirstArrayElemPtr, SecondArrayElemPtr));
// Check that the values stored into the local array are privatized reduction // Check that the values stored into the local array are privatized reduction
// variables. // variables.
auto *FirstStored = dyn_cast_or_null<BitCastInst>( auto *FirstStored = dyn_cast_if_present<BitCastInst>(
findStoredValue<GetElementPtrInst>(FirstArrayElemPtr)); findStoredValue<GetElementPtrInst>(FirstArrayElemPtr));
auto *SecondStored = dyn_cast_or_null<BitCastInst>( auto *SecondStored = dyn_cast_if_present<BitCastInst>(
findStoredValue<GetElementPtrInst>(SecondArrayElemPtr)); findStoredValue<GetElementPtrInst>(SecondArrayElemPtr));
ASSERT_NE(FirstStored, nullptr); ASSERT_NE(FirstStored, nullptr);
ASSERT_NE(SecondStored, nullptr); ASSERT_NE(SecondStored, nullptr);
Value *FirstPrivatized = FirstStored->getOperand(0); Value *FirstPrivatized = FirstStored->getOperand(0);
Value *SecondPrivatized = SecondStored->getOperand(0); Value *SecondPrivatized = SecondStored->getOperand(0);
EXPECT_TRUE( EXPECT_TRUE(
isSimpleBinaryReduction(FirstPrivatized, FirstStored->getParent())); isSimpleBinaryReduction(FirstPrivatized, FirstStored->getParent()));
EXPECT_TRUE( EXPECT_TRUE(
▲ Show 20 Lines • Show All 960 Lines • ▼ Show 20 Lines CallInst *EndTaskgroupCall = dyn_cast<CallInst>(
->user_back()); ->user_back());
ASSERT_NE(EndTaskgroupCall, nullptr); ASSERT_NE(EndTaskgroupCall, nullptr);
Function *TaskAllocFn = Function *TaskAllocFn =
OMPBuilder.getOrCreateRuntimeFunctionPtr(OMPRTL___kmpc_omp_task_alloc); OMPBuilder.getOrCreateRuntimeFunctionPtr(OMPRTL___kmpc_omp_task_alloc);
ASSERT_EQ(TaskAllocFn->getNumUses(), 2u); ASSERT_EQ(TaskAllocFn->getNumUses(), 2u);
CallInst *FirstTaskAllocCall = CallInst *FirstTaskAllocCall =
dyn_cast_or_null<CallInst>(*TaskAllocFn->users().begin()); dyn_cast_if_present<CallInst>(*TaskAllocFn->users().begin());
CallInst *SecondTaskAllocCall = CallInst *SecondTaskAllocCall =
dyn_cast_or_null<CallInst>(*TaskAllocFn->users().begin()++); dyn_cast_if_present<CallInst>(*TaskAllocFn->users().begin()++);
ASSERT_NE(FirstTaskAllocCall, nullptr); ASSERT_NE(FirstTaskAllocCall, nullptr);
ASSERT_NE(SecondTaskAllocCall, nullptr); ASSERT_NE(SecondTaskAllocCall, nullptr);
// Verify that the tasks have been generated in order and inside taskgroup // Verify that the tasks have been generated in order and inside taskgroup
// construct. // construct.
BasicBlock *RefOrder[] = { BasicBlock *RefOrder[] = {
TaskgroupCall->getParent(), FirstTaskAllocCall->getParent(), TaskgroupCall->getParent(), FirstTaskAllocCall->getParent(),
SecondTaskAllocCall->getParent(), EndTaskgroupCall->getParent()}; SecondTaskAllocCall->getParent(), EndTaskgroupCall->getParent()};
verifyDFSOrder(F, RefOrder); verifyDFSOrder(F, RefOrder);
} }
} // namespace } // namespace

llvm/unittests/IR/IRBuilderTest.cpp

Show First 20 Lines • Show All 927 Lines • ▼ Show 20 Lines for (auto *ET : CU->getEnumTypes())
Names.push_back(ET->getName()); Names.push_back(ET->getName());
for (auto *RT : CU->getRetainedTypes()) for (auto *RT : CU->getRetainedTypes())
Names.push_back(RT->getName()); Names.push_back(RT->getName());
for (auto *GV : CU->getGlobalVariables()) for (auto *GV : CU->getGlobalVariables())
Names.push_back(GV->getVariable()->getName()); Names.push_back(GV->getVariable()->getName());
for (auto *IE : CU->getImportedEntities()) for (auto *IE : CU->getImportedEntities())
Names.push_back(IE->getName()); Names.push_back(IE->getName());
for (auto *Node : CU->getMacros()) for (auto *Node : CU->getMacros())
if (auto *MN = dyn_cast_or_null<DIMacro>(Node)) if (auto *MN = dyn_cast_if_present<DIMacro>(Node))
Names.push_back(MN->getName()); Names.push_back(MN->getName());
return Names; return Names;
}; };
DICompileUnit *CU; DICompileUnit *CU;
{ {
DIBuilder DIB(*M); DIBuilder DIB(*M);
auto *File = DIB.createFile("main.c", "/"); auto *File = DIB.createFile("main.c", "/");
▲ Show 20 Lines • Show All 215 Lines • Show Last 20 Lines

llvm/unittests/IR/MetadataTest.cpp

Show First 20 Lines • Show All 1,395 Lines • ▼ Show 20 LinesTEST_F(DIGenericSubrangeTest, fortranAssumedRankInt) {
auto *LIZero = DIExpression::get(Context, {dwarf::DW_OP_consts, 0}); auto *LIZero = DIExpression::get(Context, {dwarf::DW_OP_consts, 0});
auto *UIZero = DIExpression::get(Context, {dwarf::DW_OP_consts, 0}); auto *UIZero = DIExpression::get(Context, {dwarf::DW_OP_consts, 0});
auto *N = DIGenericSubrange::get(Context, nullptr, LI, UI, SI); auto *N = DIGenericSubrange::get(Context, nullptr, LI, UI, SI);
auto Lower = N->getLowerBound(); auto Lower = N->getLowerBound();
ASSERT_TRUE(Lower); ASSERT_TRUE(Lower);
ASSERT_TRUE(Lower.is<DIExpression *>()); ASSERT_TRUE(Lower.is<DIExpression *>());
EXPECT_EQ(dyn_cast_or_null<DIExpression>(LI), Lower.get<DIExpression *>()); EXPECT_EQ(dyn_cast_if_present<DIExpression>(LI), Lower.get<DIExpression *>());
auto Upper = N->getUpperBound(); auto Upper = N->getUpperBound();
ASSERT_TRUE(Upper); ASSERT_TRUE(Upper);
ASSERT_TRUE(Upper.is<DIExpression *>()); ASSERT_TRUE(Upper.is<DIExpression *>());
EXPECT_EQ(dyn_cast_or_null<DIExpression>(UI), Upper.get<DIExpression *>()); EXPECT_EQ(dyn_cast_if_present<DIExpression>(UI), Upper.get<DIExpression *>());
auto Stride = N->getStride(); auto Stride = N->getStride();
ASSERT_TRUE(Stride); ASSERT_TRUE(Stride);
ASSERT_TRUE(Stride.is<DIExpression *>()); ASSERT_TRUE(Stride.is<DIExpression *>());
EXPECT_EQ(dyn_cast_or_null<DIExpression>(SI), Stride.get<DIExpression *>()); EXPECT_EQ(dyn_cast_if_present<DIExpression>(SI),
Stride.get<DIExpression *>());
EXPECT_EQ(N, DIGenericSubrange::get(Context, nullptr, LI, UI, SI)); EXPECT_EQ(N, DIGenericSubrange::get(Context, nullptr, LI, UI, SI));
EXPECT_NE(N, DIGenericSubrange::get(Context, nullptr, LI, UIother, SI)); EXPECT_NE(N, DIGenericSubrange::get(Context, nullptr, LI, UIother, SI));
EXPECT_NE(N, DIGenericSubrange::get(Context, nullptr, LI, UEother, SI)); EXPECT_NE(N, DIGenericSubrange::get(Context, nullptr, LI, UEother, SI));
EXPECT_NE(N, DIGenericSubrange::get(Context, nullptr, LI, UVother, SI)); EXPECT_NE(N, DIGenericSubrange::get(Context, nullptr, LI, UVother, SI));
auto *NZeroLower = DIGenericSubrange::get(Context, nullptr, LIZero, UI, SI); auto *NZeroLower = DIGenericSubrange::get(Context, nullptr, LIZero, UI, SI);
▲ Show 20 Lines • Show All 2,337 Lines • Show Last 20 Lines

llvm/unittests/Transforms/Utils/SSAUpdaterBulkTest.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 LinesTEST(SSAUpdaterBulk, SimpleMerge) {
Updater.AddAvailableValue(VarNum, FalseBB, SubOp2); Updater.AddAvailableValue(VarNum, FalseBB, SubOp2);
Updater.AddUse(VarNum, &I3->getOperandUse(0)); Updater.AddUse(VarNum, &I3->getOperandUse(0));
Updater.AddUse(VarNum, &I3->getOperandUse(1)); Updater.AddUse(VarNum, &I3->getOperandUse(1));
DominatorTree DT(*F); DominatorTree DT(*F);
Updater.RewriteAllUses(&DT); Updater.RewriteAllUses(&DT);
// Check how %5 and %6 were rewritten. // Check how %5 and %6 were rewritten.
PHINode *UpdatePhiA = dyn_cast_or_null<PHINode>(I1->getOperand(0)); PHINode *UpdatePhiA = dyn_cast_if_present<PHINode>(I1->getOperand(0));
EXPECT_NE(UpdatePhiA, nullptr); EXPECT_NE(UpdatePhiA, nullptr);
EXPECT_EQ(UpdatePhiA->getIncomingValueForBlock(TrueBB), AddOp1); EXPECT_EQ(UpdatePhiA->getIncomingValueForBlock(TrueBB), AddOp1);
EXPECT_EQ(UpdatePhiA->getIncomingValueForBlock(FalseBB), AddOp2); EXPECT_EQ(UpdatePhiA->getIncomingValueForBlock(FalseBB), AddOp2);
EXPECT_EQ(UpdatePhiA, dyn_cast_or_null<PHINode>(I1->getOperand(0))); EXPECT_EQ(UpdatePhiA, dyn_cast_if_present<PHINode>(I1->getOperand(0)));
// Check how %7 was rewritten. // Check how %7 was rewritten.
PHINode *UpdatePhiB = dyn_cast_or_null<PHINode>(I3->getOperand(0)); PHINode *UpdatePhiB = dyn_cast_if_present<PHINode>(I3->getOperand(0));
EXPECT_EQ(UpdatePhiB->getIncomingValueForBlock(TrueBB), SubOp1); EXPECT_EQ(UpdatePhiB->getIncomingValueForBlock(TrueBB), SubOp1);
EXPECT_EQ(UpdatePhiB->getIncomingValueForBlock(FalseBB), SubOp2); EXPECT_EQ(UpdatePhiB->getIncomingValueForBlock(FalseBB), SubOp2);
EXPECT_EQ(UpdatePhiB, dyn_cast_or_null<PHINode>(I3->getOperand(1))); EXPECT_EQ(UpdatePhiB, dyn_cast_if_present<PHINode>(I3->getOperand(1)));
// Check that %8 was kept untouched. // Check that %8 was kept untouched.
EXPECT_EQ(I4->getOperand(0), SubOp1); EXPECT_EQ(I4->getOperand(0), SubOp1);
EXPECT_EQ(I4->getOperand(1), SubOp2); EXPECT_EQ(I4->getOperand(1), SubOp2);
} }
TEST(SSAUpdaterBulk, Irreducible) { TEST(SSAUpdaterBulk, Irreducible) {
SSAUpdaterBulk Updater; SSAUpdaterBulk Updater;
▲ Show 20 Lines • Show All 72 Lines • ▼ Show 20 LinesTEST(SSAUpdaterBulk, Irreducible) {
// Only one phi should have been inserted. // Only one phi should have been inserted.
EXPECT_EQ(Inserted.size(), 1u); EXPECT_EQ(Inserted.size(), 1u);
// I1 and Return should use the same values as they used before. // I1 and Return should use the same values as they used before.
EXPECT_EQ(I1->getOperand(0), AddOp1); EXPECT_EQ(I1->getOperand(0), AddOp1);
EXPECT_EQ(Return->getOperand(0), FirstArg); EXPECT_EQ(Return->getOperand(0), FirstArg);
// I2 should use the new phi. // I2 should use the new phi.
PHINode *UpdatePhi = dyn_cast_or_null<PHINode>(I2->getOperand(0)); PHINode *UpdatePhi = dyn_cast_if_present<PHINode>(I2->getOperand(0));
EXPECT_NE(UpdatePhi, nullptr); EXPECT_NE(UpdatePhi, nullptr);
EXPECT_EQ(UpdatePhi->getIncomingValueForBlock(LoopStartBB), AddOp2); EXPECT_EQ(UpdatePhi->getIncomingValueForBlock(LoopStartBB), AddOp2);
EXPECT_EQ(UpdatePhi->getIncomingValueForBlock(IfBB), UndefValue::get(I32Ty)); EXPECT_EQ(UpdatePhi->getIncomingValueForBlock(IfBB), UndefValue::get(I32Ty));
} }

llvm/utils/TableGen/CodeEmitterGen.cpp

Show First 20 Lines • Show All 263 Lines • ▼ Show 20 Lines for (; bit >= 0; ) {
} }
} }
} }
std::string CodeEmitterGen::getInstructionCase(Record *R, std::string CodeEmitterGen::getInstructionCase(Record *R,
CodeGenTarget &Target) { CodeGenTarget &Target) {
std::string Case; std::string Case;
if (const RecordVal *RV = R->getValue("EncodingInfos")) { if (const RecordVal *RV = R->getValue("EncodingInfos")) {
if (auto *DI = dyn_cast_or_null<DefInit>(RV->getValue())) { if (auto *DI = dyn_cast_if_present<DefInit>(RV->getValue())) {
const CodeGenHwModes &HWM = Target.getHwModes(); const CodeGenHwModes &HWM = Target.getHwModes();
EncodingInfoByHwMode EBM(DI->getDef(), HWM); EncodingInfoByHwMode EBM(DI->getDef(), HWM);
Case += " switch (HwMode) {\n"; Case += " switch (HwMode) {\n";
Case += " default: llvm_unreachable(\"Unhandled HwMode\");\n"; Case += " default: llvm_unreachable(\"Unhandled HwMode\");\n";
for (auto &KV : EBM) { for (auto &KV : EBM) {
Case += " case " + itostr(KV.first) + ": {\n"; Case += " case " + itostr(KV.first) + ": {\n";
Case += getInstructionCaseForEncoding(R, KV.second, Target); Case += getInstructionCaseForEncoding(R, KV.second, Target);
Case += " break;\n"; Case += " break;\n";
▲ Show 20 Lines • Show All 73 Lines • ▼ Show 20 Lines for (const CodeGenInstruction *CGI : NumberedInstructions) {
if (R->getValueAsString("Namespace") == "TargetOpcode" || if (R->getValueAsString("Namespace") == "TargetOpcode" ||
R->getValueAsBit("isPseudo")) { R->getValueAsBit("isPseudo")) {
o << " "; emitInstBits(o, APInt(BitWidth, 0)); o << ",\n"; o << " "; emitInstBits(o, APInt(BitWidth, 0)); o << ",\n";
continue; continue;
} }
Record *EncodingDef = R; Record *EncodingDef = R;
if (const RecordVal *RV = R->getValue("EncodingInfos")) { if (const RecordVal *RV = R->getValue("EncodingInfos")) {
if (auto *DI = dyn_cast_or_null<DefInit>(RV->getValue())) { if (auto *DI = dyn_cast_if_present<DefInit>(RV->getValue())) {
EncodingInfoByHwMode EBM(DI->getDef(), HWM); EncodingInfoByHwMode EBM(DI->getDef(), HWM);
if (EBM.hasMode(HwMode)) if (EBM.hasMode(HwMode))
EncodingDef = EBM.get(HwMode); EncodingDef = EBM.get(HwMode);
} }
} }
BitsInit *BI = EncodingDef->getValueAsBitsInit("Inst"); BitsInit *BI = EncodingDef->getValueAsBitsInit("Inst");
// Start by filling in fixed values. // Start by filling in fixed values.
Show All 31 Lines if (any_of(NumberedInstructions, [](const CodeGenInstruction *CGI) {
BitWidth = 0; BitWidth = 0;
for (const CodeGenInstruction *CGI : NumberedInstructions) { for (const CodeGenInstruction *CGI : NumberedInstructions) {
Record *R = CGI->TheDef; Record *R = CGI->TheDef;
if (R->getValueAsString("Namespace") == "TargetOpcode" || if (R->getValueAsString("Namespace") == "TargetOpcode" ||
R->getValueAsBit("isPseudo")) R->getValueAsBit("isPseudo"))
continue; continue;
if (const RecordVal *RV = R->getValue("EncodingInfos")) { if (const RecordVal *RV = R->getValue("EncodingInfos")) {
if (DefInit *DI = dyn_cast_or_null<DefInit>(RV->getValue())) { if (DefInit *DI = dyn_cast_if_present<DefInit>(RV->getValue())) {
EncodingInfoByHwMode EBM(DI->getDef(), HWM); EncodingInfoByHwMode EBM(DI->getDef(), HWM);
for (auto &KV : EBM) { for (auto &KV : EBM) {
BitsInit *BI = KV.second->getValueAsBitsInit("Inst"); BitsInit *BI = KV.second->getValueAsBitsInit("Inst");
BitWidth = std::max(BitWidth, BI->getNumBits()); BitWidth = std::max(BitWidth, BI->getNumBits());
HwModes.insert(KV.first); HwModes.insert(KV.first);
} }
continue; continue;
} }
▲ Show 20 Lines • Show All 118 Lines • Show Last 20 Lines

llvm/utils/TableGen/CodeGenInstruction.cpp

Show First 20 Lines • Show All 626 Lines • ▼ Show 20 Linesbool CodeGenInstAlias::tryAliasOpMatch(DagInit *Result, unsigned AliasOpNo,
// Bits<n> (also used for 0bxx literals) // Bits<n> (also used for 0bxx literals)
if (BitsInit *BI = dyn_cast<BitsInit>(Arg)) { if (BitsInit *BI = dyn_cast<BitsInit>(Arg)) {
if (hasSubOps || !InstOpRec->isSubClassOf("Operand")) if (hasSubOps || !InstOpRec->isSubClassOf("Operand"))
return false; return false;
if (!BI->isComplete()) if (!BI->isComplete())
return false; return false;
// Convert the bits init to an integer and use that for the result. // Convert the bits init to an integer and use that for the result.
IntInit *II = dyn_cast_or_null<IntInit>( IntInit *II = dyn_cast_if_present<IntInit>(
BI->convertInitializerTo(IntRecTy::get(BI->getRecordKeeper()))); BI->convertInitializerTo(IntRecTy::get(BI->getRecordKeeper())));
if (!II) if (!II)
return false; return false;
ResOp = ResultOperand(II->getValue()); ResOp = ResultOperand(II->getValue());
return true; return true;
} }
// If both are Operands with the same MVT, allow the conversion. It's // If both are Operands with the same MVT, allow the conversion. It's
▲ Show 20 Lines • Show All 146 Lines • Show Last 20 Lines

llvm/utils/TableGen/CodeGenRegisters.cpp

Show First 20 Lines • Show All 780 Lines • ▼ Show 20 Lines while (!Order.empty()) {
PrintFatalError(R->getLoc(), " AltOrder register " + Reg->getName() + PrintFatalError(R->getLoc(), " AltOrder register " + Reg->getName() +
" is not a class member"); " is not a class member");
} }
} }
Namespace = R->getValueAsString("Namespace"); Namespace = R->getValueAsString("Namespace");
if (const RecordVal *RV = R->getValue("RegInfos")) if (const RecordVal *RV = R->getValue("RegInfos"))
if (DefInit *DI = dyn_cast_or_null<DefInit>(RV->getValue())) if (DefInit *DI = dyn_cast_if_present<DefInit>(RV->getValue()))
RSI = RegSizeInfoByHwMode(DI->getDef(), RegBank.getHwModes()); RSI = RegSizeInfoByHwMode(DI->getDef(), RegBank.getHwModes());
unsigned Size = R->getValueAsInt("Size"); unsigned Size = R->getValueAsInt("Size");
assert((RSI.hasDefault() || Size != 0 || VTs[0].isSimple()) && assert((RSI.hasDefault() || Size != 0 || VTs[0].isSimple()) &&
"Impossible to determine register size"); "Impossible to determine register size");
if (!RSI.hasDefault()) { if (!RSI.hasDefault()) {
RegSizeInfo RI; RegSizeInfo RI;
RI.RegSize = RI.SpillSize = Size ? Size RI.RegSize = RI.SpillSize = Size ? Size
: VTs[0].getSimple().getSizeInBits(); : VTs[0].getSimple().getSizeInBits();
▲ Show 20 Lines • Show All 1,698 Lines • Show Last 20 Lines

llvm/utils/TableGen/DecoderEmitter.cpp

Show First 20 Lines • Show All 2,544 Lines • ▼ Show 20 Linesvoid DecoderEmitter::run(raw_ostream &o) {
NumberedEncodings.reserve(NumberedInstructions.size()); NumberedEncodings.reserve(NumberedInstructions.size());
DenseMap<Record *, unsigned> IndexOfInstruction; DenseMap<Record *, unsigned> IndexOfInstruction;
// First, collect all HwModes referenced by the target. // First, collect all HwModes referenced by the target.
for (const auto &NumberedInstruction : NumberedInstructions) { for (const auto &NumberedInstruction : NumberedInstructions) {
IndexOfInstruction[NumberedInstruction->TheDef] = NumberedEncodings.size(); IndexOfInstruction[NumberedInstruction->TheDef] = NumberedEncodings.size();
if (const RecordVal *RV = if (const RecordVal *RV =
NumberedInstruction->TheDef->getValue("EncodingInfos")) { NumberedInstruction->TheDef->getValue("EncodingInfos")) {
if (auto *DI = dyn_cast_or_null<DefInit>(RV->getValue())) { if (auto *DI = dyn_cast_if_present<DefInit>(RV->getValue())) {
const CodeGenHwModes &HWM = Target.getHwModes(); const CodeGenHwModes &HWM = Target.getHwModes();
EncodingInfoByHwMode EBM(DI->getDef(), HWM); EncodingInfoByHwMode EBM(DI->getDef(), HWM);
for (auto &KV : EBM) for (auto &KV : EBM)
HwModeNames.insert(HWM.getMode(KV.first).Name); HwModeNames.insert(HWM.getMode(KV.first).Name);
} }
} }
} }
// If HwModeNames is empty, add the empty string so we always have one HwMode. // If HwModeNames is empty, add the empty string so we always have one HwMode.
if (HwModeNames.empty()) if (HwModeNames.empty())
HwModeNames.insert(""); HwModeNames.insert("");
for (const auto &NumberedInstruction : NumberedInstructions) { for (const auto &NumberedInstruction : NumberedInstructions) {
IndexOfInstruction[NumberedInstruction->TheDef] = NumberedEncodings.size(); IndexOfInstruction[NumberedInstruction->TheDef] = NumberedEncodings.size();
if (const RecordVal *RV = if (const RecordVal *RV =
NumberedInstruction->TheDef->getValue("EncodingInfos")) { NumberedInstruction->TheDef->getValue("EncodingInfos")) {
if (DefInit *DI = dyn_cast_or_null<DefInit>(RV->getValue())) { if (DefInit *DI = dyn_cast_if_present<DefInit>(RV->getValue())) {
const CodeGenHwModes &HWM = Target.getHwModes(); const CodeGenHwModes &HWM = Target.getHwModes();
EncodingInfoByHwMode EBM(DI->getDef(), HWM); EncodingInfoByHwMode EBM(DI->getDef(), HWM);
for (auto &KV : EBM) { for (auto &KV : EBM) {
NumberedEncodings.emplace_back(KV.second, NumberedInstruction, NumberedEncodings.emplace_back(KV.second, NumberedInstruction,
HWM.getMode(KV.first).Name); HWM.getMode(KV.first).Name);
HwModeNames.insert(HWM.getMode(KV.first).Name); HwModeNames.insert(HWM.getMode(KV.first).Name);
} }
continue; continue;
▲ Show 20 Lines • Show All 126 Lines • Show Last 20 Lines

llvm/utils/TableGen/VarLenCodeEmitterGen.cpp

Show First 20 Lines • Show All 195 Lines • ▼ Show 20 Lines for (const CodeGenInstruction *CGI : NumberedInstructions) {
Record *R = CGI->TheDef; Record *R = CGI->TheDef;
// Create the corresponding VarLenInst instance. // Create the corresponding VarLenInst instance.
if (R->getValueAsString("Namespace") == "TargetOpcode" || if (R->getValueAsString("Namespace") == "TargetOpcode" ||
R->getValueAsBit("isPseudo")) R->getValueAsBit("isPseudo"))
continue; continue;
if (const RecordVal *RV = R->getValue("EncodingInfos")) { if (const RecordVal *RV = R->getValue("EncodingInfos")) {
if (auto *DI = dyn_cast_or_null<DefInit>(RV->getValue())) { if (auto *DI = dyn_cast_if_present<DefInit>(RV->getValue())) {
EncodingInfoByHwMode EBM(DI->getDef(), HWM); EncodingInfoByHwMode EBM(DI->getDef(), HWM);
for (auto &KV : EBM) { for (auto &KV : EBM) {
HwModes.insert(KV.first); HwModes.insert(KV.first);
Record *EncodingDef = KV.second; Record *EncodingDef = KV.second;
RecordVal *RV = EncodingDef->getValue("Inst"); RecordVal *RV = EncodingDef->getValue("Inst");
DagInit *DI = cast<DagInit>(RV->getValue()); DagInit *DI = cast<DagInit>(RV->getValue());
VarLenInsts.insert({EncodingDef, VarLenInst(DI, RV)}); VarLenInsts.insert({EncodingDef, VarLenInst(DI, RV)});
} }
▲ Show 20 Lines • Show All 126 Lines • ▼ Show 20 Lines for (const CodeGenInstruction *CGI : NumberedInstructions) {
if (R->getValueAsString("Namespace") == "TargetOpcode" || if (R->getValueAsString("Namespace") == "TargetOpcode" ||
R->getValueAsBit("isPseudo")) { R->getValueAsBit("isPseudo")) {
IS.indent(4) << "{/*NumBits*/0, /*Index*/0},\n"; IS.indent(4) << "{/*NumBits*/0, /*Index*/0},\n";
continue; continue;
} }
Record *EncodingDef = R; Record *EncodingDef = R;
if (const RecordVal *RV = R->getValue("EncodingInfos")) { if (const RecordVal *RV = R->getValue("EncodingInfos")) {
if (auto *DI = dyn_cast_or_null<DefInit>(RV->getValue())) { if (auto *DI = dyn_cast_if_present<DefInit>(RV->getValue())) {
EncodingInfoByHwMode EBM(DI->getDef(), HWM); EncodingInfoByHwMode EBM(DI->getDef(), HWM);
if (EBM.hasMode(HwMode)) if (EBM.hasMode(HwMode))
EncodingDef = EBM.get(HwMode); EncodingDef = EBM.get(HwMode);
} }
} }
auto It = VarLenInsts.find(EncodingDef); auto It = VarLenInsts.find(EncodingDef);
if (It == VarLenInsts.end()) if (It == VarLenInsts.end())
Show All 31 Linesvoid VarLenCodeEmitterGen::emitInstructionBaseValues(
OS << IS.str() << SS.str(); OS << IS.str() << SS.str();
} }
std::string VarLenCodeEmitterGen::getInstructionCase(Record *R, std::string VarLenCodeEmitterGen::getInstructionCase(Record *R,
CodeGenTarget &Target) { CodeGenTarget &Target) {
std::string Case; std::string Case;
if (const RecordVal *RV = R->getValue("EncodingInfos")) { if (const RecordVal *RV = R->getValue("EncodingInfos")) {
if (auto *DI = dyn_cast_or_null<DefInit>(RV->getValue())) { if (auto *DI = dyn_cast_if_present<DefInit>(RV->getValue())) {
const CodeGenHwModes &HWM = Target.getHwModes(); const CodeGenHwModes &HWM = Target.getHwModes();
EncodingInfoByHwMode EBM(DI->getDef(), HWM); EncodingInfoByHwMode EBM(DI->getDef(), HWM);
Case += " switch (HwMode) {\n"; Case += " switch (HwMode) {\n";
Case += " default: llvm_unreachable(\"Unhandled HwMode\");\n"; Case += " default: llvm_unreachable(\"Unhandled HwMode\");\n";
for (auto &KV : EBM) { for (auto &KV : EBM) {
Case += " case " + itostr(KV.first) + ": {\n"; Case += " case " + itostr(KV.first) + ": {\n";
Case += getInstructionCaseForEncoding(R, KV.second, Target); Case += getInstructionCaseForEncoding(R, KV.second, Target);
Case += " break;\n"; Case += " break;\n";
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines