This is an archive of the discontinued LLVM Phabricator instance.

Differential D130822

Fixed loads of typos
AbandonedPublic

Authored by GabrielRavier on Jul 30 2022, 7:21 AM.

Details

Reviewers
probinson
Naville
deadalnix
bollu
alexander-shaposhnikov
rupprecht
jhenderson
rriddle
aartbik
MaskRay
ftynse
aaron.ballman
awarzynski
sjarus
clementval
bondhugula
rafauler
Amir
maksfb
dang
ThomasRaoux
NoQ
ributzka
jdoerfert
sstefan1
nicolasvasilache
herhut
Group Reviewers
Restricted Project
Restricted Project
Restricted Project
Summary

I went over the output of the following mess of a command:

(ulimit -m 2000000; ulimit -v 2000000; git ls-files -z | parallel --xargs -0 cat | aspell list --mode=none --ignore-case | grep -E '^[A-Za-z][a-z]*$' | sort | uniq -c | sort -n | grep -vE '.{25}' | aspell pipe -W3 | grep : | cut -d' ' -f2 | less)

and spent a few days looking at it to find probable typos and
fixed a few hundred of them (note, this is not anywhere near all of
them, but it seems like a good start).

Note: A very large majority of these are in comments and other places
that, as far as I can see, should not be capable of breaking anything,
but there are also a few variable name changes and things like that.

Diff Detail

Unit TestsFailed

TimeTest
60 msx64 debian > LLVM.Examples/IRTransforms/SimplifyCFG::tut-simplify-cfg2-dead-block-order.ll

Event Timeline

GabrielRavier created this revision.Jul 30 2022, 7:21 AM
Herald added a reviewer: deadalnix. · View Herald TranscriptJul 30 2022, 7:21 AM
Herald added a reviewer: bollu. · View Herald Transcript
Herald added a reviewer: alexander-shaposhnikov. · View Herald Transcript
Herald added a reviewer: rupprecht. · View Herald Transcript
Herald added a reviewer: jhenderson. · View Herald Transcript
Herald added a reviewer: rriddle. · View Herald Transcript
Herald added a reviewer: aartbik. · View Herald Transcript
Herald added a reviewer: MaskRay. · View Herald Transcript
Herald added a reviewer: ftynse. · View Herald Transcript
Herald added a reviewer: aaron.ballman. · View Herald Transcript
Herald added a reviewer: aartbik. · View Herald Transcript
Herald added a reviewer: awarzynski. · View Herald Transcript
Herald added a reviewer: sjarus. · View Herald Transcript
Herald added a reviewer: clementval. · View Herald Transcript
Herald added a reviewer: bondhugula. · View Herald Transcript
Herald added a reviewer: rafauler. · View Herald Transcript
Herald added a reviewer: Amir. · View Herald Transcript
Herald added a reviewer: maksfb. · View Herald Transcript
Herald added a reviewer: dang. · View Herald Transcript
Herald added a reviewer: ThomasRaoux. · View Herald Transcript
Herald added a reviewer: NoQ. · View Herald Transcript
Herald added a reviewer: ributzka. · View Herald Transcript
Herald added projects: Restricted Project, Restricted Project, Restricted Project, Restricted Project, Restricted Project. · View Herald Transcript
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added subscribers: libc-commits, libcxx-commits, anlunx and 103 others. · View Herald Transcript
GabrielRavier requested review of this revision.Jul 30 2022, 7:21 AM
Herald added a reviewer: jdoerfert. · View Herald TranscriptJul 30 2022, 7:21 AM
Herald added a reviewer: jdoerfert. · View Herald Transcript
Herald added a reviewer: sstefan1. · View Herald Transcript
Herald added a reviewer: nicolasvasilache. · View Herald Transcript
Herald added a reviewer: herhut. · View Herald Transcript
Herald added projects: Restricted Project, Restricted Project, Restricted Project, Restricted Project, Restricted Project, Restricted Project, Restricted Project, Restricted Project. · View Herald Transcript
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added subscribers: cfe-commits, llvm-commits, openmp-commits and 11 others. · View Herald Transcript
Harbormaster completed remote builds in B178406: Diff 448800.Jul 30 2022, 9:09 AM
Herald added subscribers: Michael137, JDevlieghere. · View Herald TranscriptJul 30 2022, 9:09 AM
yota9 removed a subscriber: yota9.Jul 30 2022, 9:10 AM
clementval requested changes to this revision.Jul 30 2022, 10:17 AM
clementval added inline comments.
flang/docs/Extensions.md
157

This is just wrong

This revision now requires changes to proceed.Jul 30 2022, 10:17 AM
philnik added a subscriber: philnik.Jul 30 2022, 10:23 AM

Could you split this up per project? Large patches like this are really hard to review, since there is no single person/small group that can approve everything.

GabrielRavier added a comment.Jul 30 2022, 10:32 AM

Well, I assumed if I split it up per project I would have been told to merge all the patches into a big one to avoid having a bunch of small ones essentially all doing the same thing, but then again this also makes sense, I'll split it up.

flang/docs/Extensions.md
157

I'll correct it in my per-project patch

GabrielRavier abandoned this revision.Jul 30 2022, 10:32 AM

Revision Contents

PathSize
bolt/
lib/
Passes/
12 lines
12 lines
24 lines
RuntimeLibs/
2 lines
clang-tools-extra/
clang-tidy/
modernize/
2 lines
performance/
2 lines
clangd/
4 lines
4 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
benchmarks/
CompletionModel/
4 lines
index/
2 lines
unittests/
2 lines
2 lines
pseudo/
gen/
2 lines
lib/
cxx/
2 lines
test/
clang-tidy/
checkers/
cppcoreguidelines/
2 lines
clang/
bindings/
python/
clang/
2 lines
cmake/
caches/
2 lines
docs/
2 lines
2 lines
2 lines
analyzer/
user-docs/
2 lines
include/
clang/
AST/
6 lines
8 lines
Analysis/
2 lines
FlowSensitive/
2 lines
Basic/
8 lines
2 lines
6 lines
ExtractAPI/
Serialization/
2 lines
Lex/
2 lines
Sema/
2 lines
13 lines
Serialization/
2 lines
2 lines
StaticAnalyzer/
Core/
2 lines
PathSensitive/
4 lines
Tooling/
Core/
2 lines
Syntax/
2 lines
lib/
AST/
2 lines
Analysis/
2 lines
CodeGen/
4 lines
4 lines
9 lines
2 lines
CrossTU/
2 lines
Driver/
ToolChains/
4 lines
ExtractAPI/
Serialization/
14 lines
Format/
2 lines
Frontend/
Rewrite/
2 lines
Headers/
2 lines
10 lines
Lex/
2 lines
Parse/
2 lines
Sema/
2 lines
10 lines
2 lines
13 lines
StaticAnalyzer/
Core/
2 lines
Tooling/
2 lines
Core/
4 lines
Syntax/
2 lines
test/
CodeGen/
2 lines
CodeGenCXX/
2 lines
SemaCXX/
2 lines
SemaOpenCL/
2 lines
tools/
clang-shlib/
2 lines
include-mapping/
2 lines
scan-build-py/
lib/
libear/
4 lines
unittests/
AST/
2 lines
ASTMatchers/
2 lines
Tooling/
4 lines
utils/
TableGen/
2 lines
analyzer/
2 lines
2 lines
www/
analyzer/
2 lines
compiler-rt/
cmake/
Modules/
2 lines
2 lines
lib/
builtins/
arm/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
fuzzer/
2 lines
profile/
5 lines
2 lines
sanitizer_common/
2 lines
test/
asan/
TestCases/
2 lines
hwasan/
TestCases/
2 lines
orc/
TestCases/
Darwin/
arm64/
2 lines
x86-64/
2 lines
cross-project-tests/
debuginfo-tests/
dexter/
dex/
command/
commands/
2 lines
2 lines
flang/
docs/
6 lines
2 lines
examples/
FlangOmpReport/
2 lines
lib/
Optimizer/
CodeGen/
2 lines
Semantics/
2 lines
test/
Driver/
2 lines
Semantics/
2 lines
2 lines
libc/
benchmarks/
automemcpy/
unittests/
2 lines
cmake/
modules/
2 lines
config/
linux/
2 lines
test/
src/
__support/
2 lines
stdio/
2 lines
2 lines
libcxx/
src/
support/
runtime/
2 lines
libunwind/
docs/
2 lines
lld/
ELF/
2 lines
MachO/
2 lines
test/
ELF/
2 lines
2 lines
lto/
2 lines
MachO/
tools/
2 lines
2 lines
wasm/
2 lines
lldb/
bindings/
interface/
2 lines
8 lines
docs/
use/
2 lines
examples/
python/
2 lines
4 lines
include/
lldb/
Core/
4 lines
2 lines
Symbol/
2 lines
packages/
Python/
lldbsuite/
test/
2 lines
source/
Core/
2 lines
10 lines
Expression/
6 lines
Plugins/
DynamicLoader/
POSIX-DYLD/
2 lines
ExpressionParser/
Clang/
2 lines
Platform/
gdb-server/
2 lines
Process/
gdb-remote/
4 lines
minidump/
2 lines
scripted/
2 lines
SymbolFile/
Breakpad/
2 lines
PDB/
2 lines
2 lines
Symbol/
2 lines
test/
API/
commands/
expression/
codegen-crash-import-def-arraytype-element/
2 lines
functionalities/
breakpoint/
debugbreak/
2 lines
load_unload/
2 lines
memory/
tag/
2 lines
module_cache/
bsd/
2 lines
simple_exe/
2 lines
universal/
2 lines
postmortem/
elf-core/
2 lines
minidump-new/
2 lines
tools/
debugserver/
source/
2 lines
2 lines
MacOSX/
2 lines
unittests/
Utility/
2 lines
llvm/
cmake/
4 lines
modules/
4 lines
2 lines
docs/
GlobalISel/
2 lines
2 lines
4 lines
include/
llvm-c/
4 lines
2 lines
llvm/
Analysis/
2 lines
4 lines
4 lines
2 lines
2 lines
2 lines
CodeGen/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
DebugInfo/
DWARF/
4 lines
ExecutionEngine/
Orc/
2 lines
2 lines
2 lines
2 lines
Frontend/
OpenMP/
2 lines
2 lines
IR/
2 lines
2 lines
6 lines
LTO/
legacy/
2 lines
MC/
2 lines
Support/
2 lines
2 lines
2 lines
Transforms/
IPO/
6 lines
2 lines
Scalar/
2 lines
lib/
Analysis/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
CodeGen/
AsmPrinter/
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
GlobalISel/
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
SelectionDAG/
6 lines
2 lines
2 lines
2 lines
DebugInfo/
DWARF/
4 lines
GSYM/
2 lines
ExecutionEngine/
2 lines
JITLink/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
Orc/
4 lines
2 lines
2 lines
IR/
2 lines
2 lines
2 lines
4 lines
MC/
2 lines
MCParser/
2 lines
2 lines
2 lines
2 lines
Option/
2 lines
ProfileData/
2 lines
Support/
2 lines
2 lines
Unix/
2 lines
TableGen/
4 lines
Target/
AArch64/
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
AMDGPU/
2 lines
ARM/
2 lines
2 lines
2 lines
MCTargetDesc/
6 lines
2 lines
2 lines
AVR/
2 lines
BPF/
2 lines
2 lines
2 lines
CSKY/
2 lines
Hexagon/
2 lines
2 lines
2 lines
2 lines
M68k/
2 lines
MCTargetDesc/
2 lines
MSP430/
2 lines
Mips/
AsmParser/
2 lines
2 lines
NVPTX/
2 lines
PowerPC/
MCTargetDesc/
4 lines
2 lines
8 lines
2 lines
6 lines
2 lines
2 lines
2 lines
2 lines
RISCV/
2 lines
Sparc/
2 lines
SystemZ/
2 lines
WebAssembly/
2 lines
4 lines
2 lines
2 lines
2 lines
X86/
MCTargetDesc/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
Transforms/
Coroutines/
4 lines
2 lines
IPO/
4 lines
2 lines
4 lines
2 lines
2 lines
2 lines
InstCombine/
4 lines
Instrumentation/
2 lines
Scalar/
2 lines
4 lines
12 lines
2 lines
2 lines
2 lines
Utils/
2 lines
5 lines
4 lines
2 lines
Vectorize/
2 lines
4 lines
2 lines
2 lines
test/
Analysis/
BasicAA/
2 lines
DependenceAnalysis/
2 lines
LoopAccessAnalysis/
6 lines
2 lines
BugPoint/
2 lines
CodeGen/
AArch64/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
AMDGPU/
GlobalISel/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
AVR/
pseudo/
2 lines
Hexagon/
2 lines
2 lines
2 lines
M68k/
Arith/
2 lines
2 lines
PowerPC/
2 lines
2 lines
4 lines
2 lines
RISCV/
2 lines
SystemZ/
2 lines
Thumb2/
2 lines
2 lines
WebAssembly/
2 lines
X86/
2 lines
2 lines
2 lines
8 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
DebugInfo/
Generic/
2 lines
MIR/
X86/
2 lines
X86/
2 lines
2 lines
2 lines
Instrumentation/
SanitizerCoverage/
2 lines
MC/
AArch64/
2 lines
ARM/
2 lines
AsmParser/
4 lines
ELF/
2 lines
2 lines
Hexagon/
2 lines
Mips/
mt/
2 lines
X86/
2 lines
Object/
2 lines
ThinLTO/
X86/
2 lines
Transforms/
ArgumentPromotion/
2 lines
Attributor/
ArgumentPromotion/
2 lines
2 lines
2 lines
CodeGenPrepare/
AArch64/
2 lines
DeadArgElim/
2 lines
2 lines
EarlyCSE/
2 lines
2 lines
GlobalOpt/
2 lines
GuardWidening/
4 lines
IndVarSimplify/
2 lines
Inline/
2 lines
InstCombine/
2 lines
2 lines
LICM/
2 lines
LoadStoreVectorizer/
AMDGPU/
2 lines
LoopFusion/
2 lines
LoopStrengthReduce/
X86/
2 lines
2 lines
LoopUnroll/
2 lines
2 lines
LoopUnrollAndJam/
2 lines
LoopVectorize/
X86/
2 lines
2 lines
2 lines
4 lines
LowerTypeTests/
2 lines
MergeFunc/
2 lines
Reassociate/
2 lines
SROA/
2 lines
SampleProfile/
2 lines
SimplifyCFG/
X86/
2 lines
2 lines
2 lines
tools/
llvm-objcopy/
COFF/
2 lines
2 lines
llvm-readobj/
ELF/
2 lines
2 lines
2 lines
obj2yaml/
ELF/
2 lines
tools/
llvm-ar/
2 lines
llvm-cov/
2 lines
llvm-dwarfutil/
10 lines
llvm-exegesis/
lib/
2 lines
llvm-objdump/
2 lines
2 lines
llvm-pdbutil/
2 lines
llvm-profgen/
2 lines
2 lines
llvm-symbolizer/
2 lines
llvm-xray/
2 lines
2 lines
unittests/
ADT/
2 lines
2 lines
Analysis/
6 lines
ExecutionEngine/
Orc/
4 lines
Frontend/
2 lines
utils/
TableGen/
2 lines
40 lines
4 lines
UpdateTestChecks/
2 lines
docker/
2 lines
git/
4 lines
gn/
secondary/
lldb/
tools/
lldb-test/
2 lines
lit/
lit/
2 lines
2 lines
2 lines
2 lines
2 lines
mlir/
docs/
Bindings/
2 lines
2 lines
include/
mlir/
Analysis/
2 lines
Presburger/
2 lines
2 lines
Bindings/
Python/
2 lines
Dialect/
AMDGPU/
2 lines
GPU/
IR/
2 lines
LLVMIR/
4 lines
NVGPU/
IR/
2 lines
Vector/
Transforms/
2 lines
IR/
2 lines
Transforms/
2 lines
lib/
Conversion/
GPUCommon/
2 lines
Dialect/
Linalg/
Transforms/
4 lines
Math/
Transforms/
4 lines
Tosa/
Transforms/
2 lines
ExecutionEngine/
2 lines
Target/
Cpp/
2 lines
LLVMIR/
Dialect/
OpenACC/
6 lines
Transforms/
Utils/
2 lines
python/
mlir/
dialects/
linalg/
opdsl/
lang/
4 lines
test/
Conversion/
NVGPUToNVVM/
2 lines
Integration/
Dialect/
SparseTensor/
taco/
tools/
4 lines
tools/
mlir-linalg-ods-gen/
2 lines
mlir-tblgen/
2 lines
2 lines
openmp/
libomptarget/
plugins/
amdgpu/
src/
2 lines
runtime/
src/
i18n/
6 lines
2 lines
2 lines
test/
affinity/
2 lines
tools/
lib/
2 lines
polly/
docs/
2 lines
include/
polly/
Support/
2 lines
lib/
CodeGen/
2 lines
Transform/
2 lines
2 lines
test/
CodeGen/
2 lines
ForwardOpTree/
2 lines
ScopDetect/
2 lines
ScopDetectionDiagnostics/
2 lines
ScopInfo/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
Simplify/
2 lines
tools/
GPURuntime/
2 lines
www/
documentation/
2 lines
8 lines
6 lines
2 lines
4 lines
utils/
arcanist/
2 lines
bazel/
2 lines
deps_impl/
2 lines

Diff 448800

bolt/lib/Passes/IndirectCallPromotion.cpp

Show First 20 Lines • Show All 410 Lines • ▼ Show 20 Lines dbgs() << "Jmp info: Type = " << (unsigned)Type << ", "
<< "DispExpr = " << DispExpr << ", " << "DispExpr = " << DispExpr << ", "
<< "MemLocInstr = "; << "MemLocInstr = ";
BC.printInstruction(dbgs(), *MemLocInstr, 0, &Function); BC.printInstruction(dbgs(), *MemLocInstr, 0, &Function);
dbgs() << "\n"; dbgs() << "\n";
}); });
++TotalIndexBasedCandidates; ++TotalIndexBasedCandidates;
auto ErrorOrMemAccesssProfile = auto ErrorOrMemAccessProfile =
BC.MIB->tryGetAnnotationAs<MemoryAccessProfile>(*MemLocInstr, BC.MIB->tryGetAnnotationAs<MemoryAccessProfile>(*MemLocInstr,
"MemoryAccessProfile"); "MemoryAccessProfile");
if (!ErrorOrMemAccesssProfile) { if (!ErrorOrMemAccessProfile) {
DEBUG_VERBOSE(1, dbgs() DEBUG_VERBOSE(1, dbgs()
<< "BOLT-INFO: ICP no memory profiling data found\n"); << "BOLT-INFO: ICP no memory profiling data found\n");
return JumpTableInfoType(); return JumpTableInfoType();
} }
MemoryAccessProfile &MemAccessProfile = ErrorOrMemAccesssProfile.get(); MemoryAccessProfile &MemAccessProfile = ErrorOrMemAccessProfile.get();
uint64_t ArrayStart; uint64_t ArrayStart;
if (DispExpr) { if (DispExpr) {
ErrorOr<uint64_t> DispValueOrError = ErrorOr<uint64_t> DispValueOrError =
BC.getSymbolValue(*BC.MIB->getTargetSymbol(DispExpr)); BC.getSymbolValue(*BC.MIB->getTargetSymbol(DispExpr));
assert(DispValueOrError && "global symbol needs a value"); assert(DispValueOrError && "global symbol needs a value");
ArrayStart = *DispValueOrError; ArrayStart = *DispValueOrError;
} else { } else {
▲ Show 20 Lines • Show All 229 Lines • ▼ Show 20 Lines DEBUG_VERBOSE(1, {
for (MCInst *Inst : MethodFetchInsns) for (MCInst *Inst : MethodFetchInsns)
BC.printInstruction(dbgs(), *Inst, 0, &Function); BC.printInstruction(dbgs(), *Inst, 0, &Function);
if (MethodFetchInsns.back() != &Inst) if (MethodFetchInsns.back() != &Inst)
BC.printInstruction(dbgs(), Inst, 0, &Function); BC.printInstruction(dbgs(), Inst, 0, &Function);
}); });
// Try to get value profiling data for the method load instruction. // Try to get value profiling data for the method load instruction.
auto ErrorOrMemAccesssProfile = auto ErrorOrMemAccessProfile =
BC.MIB->tryGetAnnotationAs<MemoryAccessProfile>(*MethodFetchInsns.back(), BC.MIB->tryGetAnnotationAs<MemoryAccessProfile>(*MethodFetchInsns.back(),
"MemoryAccessProfile"); "MemoryAccessProfile");
if (!ErrorOrMemAccesssProfile) { if (!ErrorOrMemAccessProfile) {
DEBUG_VERBOSE(1, dbgs() DEBUG_VERBOSE(1, dbgs()
<< "BOLT-INFO: ICP no memory profiling data found\n"); << "BOLT-INFO: ICP no memory profiling data found\n");
return MethodInfoType(); return MethodInfoType();
} }
MemoryAccessProfile &MemAccessProfile = ErrorOrMemAccesssProfile.get(); MemoryAccessProfile &MemAccessProfile = ErrorOrMemAccessProfile.get();
// Find the vtable that each method belongs to. // Find the vtable that each method belongs to.
std::map<const MCSymbol *, uint64_t> MethodToVtable; std::map<const MCSymbol *, uint64_t> MethodToVtable;
for (const AddressAccess &AccessInfo : MemAccessProfile.AddressAccessInfo) { for (const AddressAccess &AccessInfo : MemAccessProfile.AddressAccessInfo) {
uint64_t Address = AccessInfo.Offset; uint64_t Address = AccessInfo.Offset;
if (AccessInfo.MemoryObject) if (AccessInfo.MemoryObject)
Address += AccessInfo.MemoryObject->getAddress(); Address += AccessInfo.MemoryObject->getAddress();
▲ Show 20 Lines • Show All 779 Lines • Show Last 20 Lines

bolt/lib/Passes/ReorderData.cpp

Show First 20 Lines • Show All 180 Lines • ▼ Show 20 Linesvoid ReorderData::assignMemData(BinaryContext &BC) {
uint64_t TotalCount = 0; uint64_t TotalCount = 0;
for (auto &BFI : BC.getBinaryFunctions()) { for (auto &BFI : BC.getBinaryFunctions()) {
const BinaryFunction &BF = BFI.second; const BinaryFunction &BF = BFI.second;
if (!BF.hasMemoryProfile()) if (!BF.hasMemoryProfile())
continue; continue;
for (const BinaryBasicBlock &BB : BF) { for (const BinaryBasicBlock &BB : BF) {
for (const MCInst &Inst : BB) { for (const MCInst &Inst : BB) {
auto ErrorOrMemAccesssProfile = auto ErrorOrMemAccessProfile =
BC.MIB->tryGetAnnotationAs<MemoryAccessProfile>( BC.MIB->tryGetAnnotationAs<MemoryAccessProfile>(
Inst, "MemoryAccessProfile"); Inst, "MemoryAccessProfile");
if (!ErrorOrMemAccesssProfile) if (!ErrorOrMemAccessProfile)
continue; continue;
const MemoryAccessProfile &MemAccessProfile = const MemoryAccessProfile &MemAccessProfile =
ErrorOrMemAccesssProfile.get(); ErrorOrMemAccessProfile.get();
for (const AddressAccess &AccessInfo : for (const AddressAccess &AccessInfo :
MemAccessProfile.AddressAccessInfo) { MemAccessProfile.AddressAccessInfo) {
if (BinaryData *BD = AccessInfo.MemoryObject) { if (BinaryData *BD = AccessInfo.MemoryObject) {
BinaryDataCounts[BD->getAtomicRoot()] += AccessInfo.Count; BinaryDataCounts[BD->getAtomicRoot()] += AccessInfo.Count;
Counts[BD->getSectionName()] += AccessInfo.Count; Counts[BD->getSectionName()] += AccessInfo.Count;
if (BD->getAtomicRoot()->isJumpTable()) if (BD->getAtomicRoot()->isJumpTable())
JumpTableCounts[BD->getSectionName()] += AccessInfo.Count; JumpTableCounts[BD->getSectionName()] += AccessInfo.Count;
} else { } else {
Show All 32 LinesReorderData::sortedByFunc(BinaryContext &BC, const BinarySection &Section,
auto dataUses = [&BC](const BinaryFunction &BF, bool OnlyHot) { auto dataUses = [&BC](const BinaryFunction &BF, bool OnlyHot) {
std::set<BinaryData *> Uses; std::set<BinaryData *> Uses;
for (const BinaryBasicBlock &BB : BF) { for (const BinaryBasicBlock &BB : BF) {
if (OnlyHot && BB.isCold()) if (OnlyHot && BB.isCold())
continue; continue;
for (const MCInst &Inst : BB) { for (const MCInst &Inst : BB) {
auto ErrorOrMemAccesssProfile = auto ErrorOrMemAccessProfile =
BC.MIB->tryGetAnnotationAs<MemoryAccessProfile>( BC.MIB->tryGetAnnotationAs<MemoryAccessProfile>(
Inst, "MemoryAccessProfile"); Inst, "MemoryAccessProfile");
if (!ErrorOrMemAccesssProfile) if (!ErrorOrMemAccessProfile)
continue; continue;
const MemoryAccessProfile &MemAccessProfile = const MemoryAccessProfile &MemAccessProfile =
ErrorOrMemAccesssProfile.get(); ErrorOrMemAccessProfile.get();
for (const AddressAccess &AccessInfo : for (const AddressAccess &AccessInfo :
MemAccessProfile.AddressAccessInfo) { MemAccessProfile.AddressAccessInfo) {
if (AccessInfo.MemoryObject) if (AccessInfo.MemoryObject)
Uses.insert(AccessInfo.MemoryObject); Uses.insert(AccessInfo.MemoryObject);
} }
} }
} }
return Uses; return Uses;
▲ Show 20 Lines • Show All 270 Lines • Show Last 20 Lines

bolt/lib/Passes/RetpolineInsertion.cpp

Show All 38 Lines
llvm::cl::opt<bool> llvm::cl::opt<bool>
RetpolineLfence("retpoline-lfence", RetpolineLfence("retpoline-lfence",
cl::desc("determine if lfence instruction should exist in the retpoline"), cl::desc("determine if lfence instruction should exist in the retpoline"),
cl::init(true), cl::init(true),
cl::ZeroOrMore, cl::ZeroOrMore,
cl::Hidden, cl::Hidden,
cl::cat(BoltCategory)); cl::cat(BoltCategory));
cl::opt<RetpolineInsertion::AvailabilityOptions> cl::opt<RetpolineInsertion::AvailabilityOptions> R11Availability(
R11Availability("r11-availability", "r11-availability",
cl::desc("determine the availablity of r11 before indirect branches"), cl::desc("determine the availability of r11 before indirect branches"),
cl::init(RetpolineInsertion::AvailabilityOptions::NEVER), cl::init(RetpolineInsertion::AvailabilityOptions::NEVER),
cl::values( cl::values(clEnumValN(RetpolineInsertion::AvailabilityOptions::NEVER,
clEnumValN(RetpolineInsertion::AvailabilityOptions::NEVER,
"never", "r11 not available"), "never", "r11 not available"),
clEnumValN(RetpolineInsertion::AvailabilityOptions::ALWAYS, clEnumValN(RetpolineInsertion::AvailabilityOptions::ALWAYS,
"always", "r11 avaialable before calls and jumps"), "always", "r11 avaialable before calls and jumps"),
clEnumValN(RetpolineInsertion::AvailabilityOptions::ABI, clEnumValN(RetpolineInsertion::AvailabilityOptions::ABI, "abi",
"abi", "r11 avaialable before calls but not before jumps")), "r11 avaialable before calls but not before jumps")),
cl::ZeroOrMore, cl::ZeroOrMore, cl::cat(BoltCategory));
cl::cat(BoltCategory));
} // namespace opts } // namespace opts
namespace llvm { namespace llvm {
namespace bolt { namespace bolt {
// Retpoline function structure: // Retpoline function structure:
// BB0: call BB2 // BB0: call BB2
▲ Show 20 Lines • Show All 266 Lines • Show Last 20 Lines

bolt/lib/RuntimeLibs/HugifyRuntimeLibrary.cpp

Show All 40 Lines
} // namespace opts } // namespace opts
void HugifyRuntimeLibrary::adjustCommandLineOptions( void HugifyRuntimeLibrary::adjustCommandLineOptions(
const BinaryContext &BC) const { const BinaryContext &BC) const {
if (opts::HotText) { if (opts::HotText) {
errs() errs()
<< "BOLT-ERROR: -hot-text should be applied to binaries with " << "BOLT-ERROR: -hot-text should be applied to binaries with "
"pre-compiled manual hugify support, while -hugify will add hugify " "pre-compiled manual hugify support, while -hugify will add hugify "
"support automatcally. These two options cannot both be present.\n"; "support automatically. These two options cannot both be present.\n";
exit(1); exit(1);
} }
// After the check, we set HotText to be true because automated hugify support // After the check, we set HotText to be true because automated hugify support
// relies on it. // relies on it.
opts::HotText = true; opts::HotText = true;
if (!BC.StartFunctionAddress) { if (!BC.StartFunctionAddress) {
errs() << "BOLT-ERROR: hugify runtime libraries require a known entry " errs() << "BOLT-ERROR: hugify runtime libraries require a known entry "
"point of " "point of "
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/modernize/PassByValueCheck.cpp

Show First 20 Lines • Show All 132 Lines • ▼ Show 20 Linesstatic bool hasRValueOverload(const CXXConstructorDecl *Ctor,
const ParmVarDecl *Param) { const ParmVarDecl *Param) {
if (!Param->getType().getCanonicalType()->isLValueReferenceType()) { if (!Param->getType().getCanonicalType()->isLValueReferenceType()) {
// The parameter is passed by value. // The parameter is passed by value.
return false; return false;
} }
const int ParamIdx = Param->getFunctionScopeIndex(); const int ParamIdx = Param->getFunctionScopeIndex();
const CXXRecordDecl *Record = Ctor->getParent(); const CXXRecordDecl *Record = Ctor->getParent();
// Check whether a ctor `C` forms a pair with `Ctor` under the aforementionned // Check whether a ctor `C` forms a pair with `Ctor` under the aforementioned
// rules. // rules.
const auto IsRValueOverload = [&Ctor, ParamIdx](const CXXConstructorDecl *C) { const auto IsRValueOverload = [&Ctor, ParamIdx](const CXXConstructorDecl *C) {
if (C == Ctor || C->isDeleted() || if (C == Ctor || C->isDeleted() ||
C->getNumParams() != Ctor->getNumParams()) C->getNumParams() != Ctor->getNumParams())
return false; return false;
for (int I = 0, E = C->getNumParams(); I < E; ++I) { for (int I = 0, E = C->getNumParams(); I < E; ++I) {
const clang::QualType CandidateParamType = const clang::QualType CandidateParamType =
C->parameters()[I]->getType().getCanonicalType(); C->parameters()[I]->getType().getCanonicalType();
▲ Show 20 Lines • Show All 161 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/performance/TypePromotionInMathFnCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace performance { namespace performance {
/// Finds calls to C math library functions with implicit float to double /// Finds calls to C math library functions with implicit float to double
/// promotions. /// promotions.
/// ///
/// For example, warns on ::sin(0.f), because this funciton's parameter is a /// For example, warns on ::sin(0.f), because this function's parameter is a
/// double. You probably meant to call std::sin(0.f) (in C++), or sinf(0.f) (in /// double. You probably meant to call std::sin(0.f) (in C++), or sinf(0.f) (in
/// C). /// C).
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/performance/type-promotion-in-math-fn.html /// http://clang.llvm.org/extra/clang-tidy/checks/performance/type-promotion-in-math-fn.html
class TypePromotionInMathFnCheck : public ClangTidyCheck { class TypePromotionInMathFnCheck : public ClangTidyCheck {
public: public:
TypePromotionInMathFnCheck(StringRef Name, ClangTidyContext *Context); TypePromotionInMathFnCheck(StringRef Name, ClangTidyContext *Context);
Show All 16 Lines

clang-tools-extra/clangd/CodeComplete.h

Show First 20 Lines • Show All 136 Lines • ▼ Show 20 Linesstruct CodeCompleteOptions {
/// baseline model using A/B testing. /// baseline model using A/B testing.
std::function<DecisionForestScores( std::function<DecisionForestScores(
const SymbolQualitySignals &, const SymbolRelevanceSignals &, float Base)> const SymbolQualitySignals &, const SymbolRelevanceSignals &, float Base)>
DecisionForestScorer = &evaluateDecisionForest; DecisionForestScorer = &evaluateDecisionForest;
/// Weight for combining NameMatch and Prediction of DecisionForest. /// Weight for combining NameMatch and Prediction of DecisionForest.
/// CompletionScore is NameMatch * pow(Base, Prediction). /// CompletionScore is NameMatch * pow(Base, Prediction).
/// The optimal value of Base largely depends on the semantics of the model /// The optimal value of Base largely depends on the semantics of the model
/// and prediction score (e.g. algorithm used during training, number of /// and prediction score (e.g. algorithm used during training, number of
/// trees, etc.). Usually if the range of Prediciton is [-20, 20] then a Base /// trees, etc.). Usually if the range of Prediction is [-20, 20] then a Base
/// in [1.2, 1.7] works fine. /// in [1.2, 1.7] works fine.
/// Semantics: E.g. For Base = 1.3, if the Prediciton score reduces by 2.6 /// Semantics: E.g. For Base = 1.3, if the Prediction score reduces by 2.6
/// points then completion score reduces by 50% or 1.3^(-2.6). /// points then completion score reduces by 50% or 1.3^(-2.6).
float DecisionForestBase = 1.3f; float DecisionForestBase = 1.3f;
}; };
// Semi-structured representation of a code-complete suggestion for our C++ API. // Semi-structured representation of a code-complete suggestion for our C++ API.
// We don't use the LSP structures here (unlike most features) as we want // We don't use the LSP structures here (unlike most features) as we want
// to expose more data to allow for more precise testing and evaluation. // to expose more data to allow for more precise testing and evaluation.
struct CodeCompletion { struct CodeCompletion {
▲ Show 20 Lines • Show All 170 Lines • Show Last 20 Lines

clang-tools-extra/clangd/ConfigFragment.h

Show First 20 Lines • Show All 157 Lines • ▼ Show 20 Lines struct CompileFlagsBlock {
/// Example: /// Example:
/// Command: clang++ --include-directory=/usr/include -DFOO=42 foo.cc /// Command: clang++ --include-directory=/usr/include -DFOO=42 foo.cc
/// Remove: [-I, -DFOO=*] /// Remove: [-I, -DFOO=*]
/// Result: clang++ foo.cc /// Result: clang++ foo.cc
/// ///
/// Flags added by the same CompileFlags entry will not be removed. /// Flags added by the same CompileFlags entry will not be removed.
std::vector<Located<std::string>> Remove; std::vector<Located<std::string>> Remove;
/// Directory to search for compilation database (compile_comands.json etc). /// Directory to search for compilation database (compile_commands.json
/// Valid values are: /// etc). Valid values are:
/// - A single path to a directory (absolute, or relative to the fragment) /// - A single path to a directory (absolute, or relative to the fragment)
/// - Ancestors: search all parent directories (the default) /// - Ancestors: search all parent directories (the default)
/// - None: do not use a compilation database, just default flags. /// - None: do not use a compilation database, just default flags.
llvm::Optional<Located<std::string>> CompilationDatabase; llvm::Optional<Located<std::string>> CompilationDatabase;
}; };
CompileFlagsBlock CompileFlags; CompileFlagsBlock CompileFlags;
/// Controls how clangd understands code outside the current file. /// Controls how clangd understands code outside the current file.
▲ Show 20 Lines • Show All 141 Lines • Show Last 20 Lines

clang-tools-extra/clangd/DumpAST.cpp

Show First 20 Lines • Show All 105 Lines • ▼ Show 20 Linesclass DumpVisitor : public RecursiveASTVisitor<DumpVisitor> {
SourceRange getSourceRange(const T *Node) { SourceRange getSourceRange(const T *Node) {
return Node->getSourceRange(); return Node->getSourceRange();
} }
// TemplateName doesn't have a real Loc node type. // TemplateName doesn't have a real Loc node type.
SourceRange getSourceRange(const TemplateName &Node) { return SourceRange(); } SourceRange getSourceRange(const TemplateName &Node) { return SourceRange(); }
// Attr just uses a weird method name. Maybe we should fix it instead? // Attr just uses a weird method name. Maybe we should fix it instead?
SourceRange getSourceRange(const Attr *Node) { return Node->getRange(); } SourceRange getSourceRange(const Attr *Node) { return Node->getRange(); }
// Kind is usualy the class name, without the suffix ("Type" etc). // Kind is usually the class name, without the suffix ("Type" etc).
// Where there's a set of variants instead, we use the 'Kind' enum values. // Where there's a set of variants instead, we use the 'Kind' enum values.
std::string getKind(const Decl *D) { return D->getDeclKindName(); } std::string getKind(const Decl *D) { return D->getDeclKindName(); }
std::string getKind(const Stmt *S) { std::string getKind(const Stmt *S) {
std::string Result = S->getStmtClassName(); std::string Result = S->getStmtClassName();
if (llvm::StringRef(Result).endswith("Stmt") || if (llvm::StringRef(Result).endswith("Stmt") ||
llvm::StringRef(Result).endswith("Expr")) llvm::StringRef(Result).endswith("Expr"))
Result.resize(Result.size() - 4); Result.resize(Result.size() - 4);
▲ Show 20 Lines • Show All 309 Lines • Show Last 20 Lines

clang-tools-extra/clangd/HeuristicResolver.cpp

Show First 20 Lines • Show All 114 Lines • ▼ Show 20 Linesstd::vector<const NamedDecl *> HeuristicResolver::resolveMemberExpr(
const Type *BaseType = ME->getBaseType().getTypePtrOrNull(); const Type *BaseType = ME->getBaseType().getTypePtrOrNull();
if (ME->isArrow()) { if (ME->isArrow()) {
BaseType = getPointeeType(BaseType); BaseType = getPointeeType(BaseType);
} }
if (!BaseType) if (!BaseType)
return {}; return {};
if (const auto *BT = BaseType->getAs<BuiltinType>()) { if (const auto *BT = BaseType->getAs<BuiltinType>()) {
// If BaseType is the type of a dependent expression, it's just // If BaseType is the type of a dependent expression, it's just
// represented as BultinType::Dependent which gives us no information. We // represented as BuiltinType::Dependent which gives us no information. We
// can get further by analyzing the depedent expression. // can get further by analyzing the dependent expression.
Expr *Base = ME->isImplicitAccess() ? nullptr : ME->getBase(); Expr *Base = ME->isImplicitAccess() ? nullptr : ME->getBase();
if (Base && BT->getKind() == BuiltinType::Dependent) { if (Base && BT->getKind() == BuiltinType::Dependent) {
BaseType = resolveExprToType(Base); BaseType = resolveExprToType(Base);
} }
} }
return resolveDependentMember(BaseType, ME->getMember(), NoFilter); return resolveDependentMember(BaseType, ME->getMember(), NoFilter);
} }
▲ Show 20 Lines • Show All 136 Lines • Show Last 20 Lines

clang-tools-extra/clangd/IncludeCleaner.cpp

Show First 20 Lines • Show All 280 Lines • ▼ Show 20 Linesstatic bool mayConsiderUnused(const Inclusion &Inc, ParsedAST &AST,
// self-contained, skip them. // self-contained, skip them.
if (!AST.getPreprocessor().getHeaderSearchInfo().isFileMultipleIncludeGuarded( if (!AST.getPreprocessor().getHeaderSearchInfo().isFileMultipleIncludeGuarded(
&FE->getFileEntry())) { &FE->getFileEntry())) {
dlog("{0} doesn't have header guard and will not be considered unused", dlog("{0} doesn't have header guard and will not be considered unused",
FE->getName()); FE->getName());
return false; return false;
} }
for (auto &Filter : Cfg.Diagnostics.Includes.IgnoreHeader) { for (auto &Filter : Cfg.Diagnostics.Includes.IgnoreHeader) {
// Convert the path to Unix slashes and try to match aginast the fiilter. // Convert the path to Unix slashes and try to match against the filter.
llvm::SmallString<64> Path(Inc.Resolved); llvm::SmallString<64> Path(Inc.Resolved);
llvm::sys::path::native(Path, llvm::sys::path::Style::posix); llvm::sys::path::native(Path, llvm::sys::path::Style::posix);
if (Filter(Inc.Resolved)) { if (Filter(Inc.Resolved)) {
dlog("{0} header is filtered out by the configuration", FE->getName()); dlog("{0} header is filtered out by the configuration", FE->getName());
return false; return false;
} }
} }
return true; return true;
▲ Show 20 Lines • Show All 219 Lines • Show Last 20 Lines

clang-tools-extra/clangd/InlayHints.cpp

Show First 20 Lines • Show All 377 Lines • ▼ Show 20 Linesprivate:
// make more sense but CallExpr only exposes the closing.) We heuristically // make more sense but CallExpr only exposes the closing.) We heuristically
// assume that if this location does not come from a macro definition, then // assume that if this location does not come from a macro definition, then
// the entire argument list likely appears in the main file and can be hinted. // the entire argument list likely appears in the main file and can be hinted.
void processCall(SourceLocation Anchor, const FunctionDecl *Callee, void processCall(SourceLocation Anchor, const FunctionDecl *Callee,
llvm::ArrayRef<const Expr *> Args) { llvm::ArrayRef<const Expr *> Args) {
if (!Cfg.InlayHints.Parameters || Args.size() == 0 || !Callee) if (!Cfg.InlayHints.Parameters || Args.size() == 0 || !Callee)
return; return;
// If the anchor location comes from a macro defintion, there's nowhere to // If the anchor location comes from a macro definition, there's nowhere to
// put hints. // put hints.
if (!AST.getSourceManager().getTopMacroCallerLoc(Anchor).isFileID()) if (!AST.getSourceManager().getTopMacroCallerLoc(Anchor).isFileID())
return; return;
// The parameter name of a move or copy constructor is not very interesting. // The parameter name of a move or copy constructor is not very interesting.
if (auto *Ctor = dyn_cast<CXXConstructorDecl>(Callee)) if (auto *Ctor = dyn_cast<CXXConstructorDecl>(Callee))
if (Ctor->isCopyOrMoveConstructor()) if (Ctor->isCopyOrMoveConstructor())
return; return;
▲ Show 20 Lines • Show All 324 Lines • Show Last 20 Lines

clang-tools-extra/clangd/Quality.cpp

Show First 20 Lines • Show All 564 Lines • ▼ Show 20 LinesevaluateDecisionForest(const SymbolQualitySignals &Quality,
E.setIsInstanceMember(Relevance.IsInstanceMember); E.setIsInstanceMember(Relevance.IsInstanceMember);
E.setHadContextType(Relevance.HadContextType); E.setHadContextType(Relevance.HadContextType);
E.setHadSymbolType(Relevance.HadSymbolType); E.setHadSymbolType(Relevance.HadSymbolType);
E.setTypeMatchesPreferred(Relevance.TypeMatchesPreferred); E.setTypeMatchesPreferred(Relevance.TypeMatchesPreferred);
DecisionForestScores Scores; DecisionForestScores Scores;
// Exponentiating DecisionForest prediction makes the score of each tree a // Exponentiating DecisionForest prediction makes the score of each tree a
// multiplciative boost (like NameMatch). This allows us to weigh the // multiplciative boost (like NameMatch). This allows us to weigh the
// prediciton score and NameMatch appropriately. // prediction score and NameMatch appropriately.
Scores.ExcludingName = pow(Base, Evaluate(E)); Scores.ExcludingName = pow(Base, Evaluate(E));
// Following cases are not part of the generated training dataset: // Following cases are not part of the generated training dataset:
// - Symbols with `NeedsFixIts`. // - Symbols with `NeedsFixIts`.
// - Forbidden symbols. // - Forbidden symbols.
// - Keywords: Dataset contains only macros and decls. // - Keywords: Dataset contains only macros and decls.
if (Relevance.NeedsFixIts) if (Relevance.NeedsFixIts)
Scores.ExcludingName *= 0.5; Scores.ExcludingName *= 0.5;
if (Relevance.Forbidden) if (Relevance.Forbidden)
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

clang-tools-extra/clangd/SemanticHighlighting.cpp

Show First 20 Lines • Show All 919 Lines • ▼ Show 20 Linesllvm::raw_ostream &operator<<(llvm::raw_ostream &OS, HighlightingKind K) {
case HighlightingKind::InactiveCode: case HighlightingKind::InactiveCode:
return OS << "InactiveCode"; return OS << "InactiveCode";
} }
llvm_unreachable("invalid HighlightingKind"); llvm_unreachable("invalid HighlightingKind");
} }
llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, HighlightingModifier K) { llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, HighlightingModifier K) {
switch (K) { switch (K) {
case HighlightingModifier::Declaration: case HighlightingModifier::Declaration:
return OS << "decl"; // abbrevation for common case return OS << "decl"; // abbreviation for common case
default: default:
return OS << toSemanticTokenModifier(K); return OS << toSemanticTokenModifier(K);
} }
} }
bool operator==(const HighlightingToken &L, const HighlightingToken &R) { bool operator==(const HighlightingToken &L, const HighlightingToken &R) {
return std::tie(L.R, L.Kind, L.Modifiers) == return std::tie(L.R, L.Kind, L.Modifiers) ==
std::tie(R.R, R.Kind, R.Modifiers); std::tie(R.R, R.Kind, R.Modifiers);
▲ Show 20 Lines • Show All 181 Lines • Show Last 20 Lines

clang-tools-extra/clangd/benchmarks/CompletionModel/DecisionForestBenchmark.cpp

Show First 20 Lines • Show All 55 Lines • ▼ Show 20 Lines for (int I = 0; I < NumExamples; ++I) {
E.setHadContextType(FlipCoin(0.6)); // Boolean. E.setHadContextType(FlipCoin(0.6)); // Boolean.
E.setHadSymbolType(FlipCoin(0.6)); // Boolean. E.setHadSymbolType(FlipCoin(0.6)); // Boolean.
E.setTypeMatchesPreferred(FlipCoin(0.5)); // Boolean. E.setTypeMatchesPreferred(FlipCoin(0.5)); // Boolean.
Examples.push_back(E); Examples.push_back(E);
} }
return Examples; return Examples;
} }
void runDecisionForestPrediciton(const std::vector<Example> Examples) { void runDecisionForestPrediction(const std::vector<Example> Examples) {
for (const Example &E : Examples) for (const Example &E : Examples)
Evaluate(E); Evaluate(E);
} }
static void decisionForestPredict(benchmark::State &State) { static void decisionForestPredict(benchmark::State &State) {
srand(0); srand(0);
for (auto _ : State) { for (auto _ : State) {
State.PauseTiming(); State.PauseTiming();
const std::vector<Example> Examples = generateRandomDataset(1000000); const std::vector<Example> Examples = generateRandomDataset(1000000);
State.ResumeTiming(); State.ResumeTiming();
runDecisionForestPrediciton(Examples); runDecisionForestPrediction(Examples);
} }
} }
BENCHMARK(decisionForestPredict); BENCHMARK(decisionForestPredict);
} // namespace } // namespace
} // namespace clangd } // namespace clangd
} // namespace clang } // namespace clang
BENCHMARK_MAIN(); BENCHMARK_MAIN();

clang-tools-extra/clangd/index/CanonicalIncludes.h

Show First 20 Lines • Show All 72 Lines • ▼ Show 20 Lines
/// Currently it only supports IWYU private pragma: /// Currently it only supports IWYU private pragma:
/// https://github.com/include-what-you-use/include-what-you-use/blob/master/docs/IWYUPragmas.md#iwyu-pragma-private /// https://github.com/include-what-you-use/include-what-you-use/blob/master/docs/IWYUPragmas.md#iwyu-pragma-private
/// ///
/// We ignore other pragmas: /// We ignore other pragmas:
/// - keep: this is common but irrelevant: we do not currently remove includes /// - keep: this is common but irrelevant: we do not currently remove includes
/// - export: this is common and potentially interesting, there are three cases: /// - export: this is common and potentially interesting, there are three cases:
/// * Points to a public header (common): we can suppress include2 if you /// * Points to a public header (common): we can suppress include2 if you
/// already have include1. Only marginally useful. /// already have include1. Only marginally useful.
/// * Points to a private header annotated with `private` (somewhat commmon): /// * Points to a private header annotated with `private` (somewhat common):
/// Not incrementally useful as we support private. /// Not incrementally useful as we support private.
/// * Points to a private header without pragmas (rare). This is a reversed /// * Points to a private header without pragmas (rare). This is a reversed
/// private pragma, and is valuable but too rare to be worthwhile. /// private pragma, and is valuable but too rare to be worthwhile.
/// - no_include: this is about as common as private, but only affects the /// - no_include: this is about as common as private, but only affects the
/// current file, so the value is smaller. We could add support. /// current file, so the value is smaller. We could add support.
/// - friend: this is less common than private, has implementation difficulties, /// - friend: this is less common than private, has implementation difficulties,
/// and affects behavior in a limited scope. /// and affects behavior in a limited scope.
/// - associated: extremely rare /// - associated: extremely rare
std::unique_ptr<CommentHandler> std::unique_ptr<CommentHandler>
collectIWYUHeaderMaps(CanonicalIncludes *Includes); collectIWYUHeaderMaps(CanonicalIncludes *Includes);
} // namespace clangd } // namespace clangd
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_CANONICALINCLUDES_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_CANONICALINCLUDES_H

clang-tools-extra/clangd/unittests/TUSchedulerTests.cpp

Show First 20 Lines • Show All 1,029 Lines • ▼ Show 20 Lines EXPECT_THAT(CaptureTUStatus.preambleStatuses(),
// Then goes idle and stays that way as we don't receive any // Then goes idle and stays that way as we don't receive any
// more update requests. // more update requests.
PreambleAction::Idle)); PreambleAction::Idle));
EXPECT_THAT(CaptureTUStatus.astStatuses(), EXPECT_THAT(CaptureTUStatus.astStatuses(),
ElementsAre( ElementsAre(
// Starts handling the update action and blocks until the // Starts handling the update action and blocks until the
// first preamble is built. // first preamble is built.
ASTAction::RunningAction, ASTAction::RunningAction,
// Afterwqards it builds an AST for that preamble to publish // Afterwards it builds an AST for that preamble to publish
// diagnostics. // diagnostics.
ASTAction::Building, ASTAction::Building,
// Then goes idle. // Then goes idle.
ASTAction::Idle, ASTAction::Idle,
// Afterwards we start executing go-to-def. // Afterwards we start executing go-to-def.
ASTAction::RunningAction, ASTAction::RunningAction,
// Then go idle. // Then go idle.
ASTAction::Idle)); ASTAction::Idle));
▲ Show 20 Lines • Show All 479 Lines • Show Last 20 Lines

clang-tools-extra/clangd/unittests/XRefsTests.cpp

Show First 20 Lines • Show All 1,795 Lines • ▼ Show 20 Lines for (StringRef Label : {"0", "1", "2", "3", "4", "5", "6", "7"}) {
for (const auto &Point : Code.points(Label)) { for (const auto &Point : Code.points(Label)) {
EXPECT_THAT(findImplementations(AST, Point, Index.get()), EXPECT_THAT(findImplementations(AST, Point, Index.get()),
UnorderedPointwise(declRange(), Code.ranges(Label))) UnorderedPointwise(declRange(), Code.ranges(Label)))
<< Code.code() << " at " << Point << " for Label " << Label; << Code.code() << " at " << Point << " for Label " << Label;
} }
} }
} }
TEST(FindImplementations, CaptureDefintion) { TEST(FindImplementations, CaptureDefinition) {
llvm::StringRef Test = R"cpp( llvm::StringRef Test = R"cpp(
struct Base { struct Base {
virtual void F^oo(); virtual void F^oo();
}; };
struct Child1 : Base { struct Child1 : Base {
void $Decl[[Foo]]() override; void $Decl[[Foo]]() override;
}; };
struct Child2 : Base { struct Child2 : Base {
▲ Show 20 Lines • Show All 677 Lines • Show Last 20 Lines

clang-tools-extra/pseudo/gen/Main.cpp

Show First 20 Lines • Show All 59 Lines • ▼ Show 20 Lines
namespace clang { namespace clang {
namespace pseudo { namespace pseudo {
namespace { namespace {
// Mangles a symbol name into a valid identifier. // Mangles a symbol name into a valid identifier.
// //
// These follow names in the grammar fairly closely: // These follow names in the grammar fairly closely:
// nonterminal: `ptr-declartor` becomes `ptr_declarator`; // nonterminal: `ptr-declarator` becomes `ptr_declarator`;
// punctuator: `,` becomes `COMMA`; // punctuator: `,` becomes `COMMA`;
// keyword: `INT` becomes `INT`; // keyword: `INT` becomes `INT`;
// terminal: `IDENTIFIER` becomes `IDENTIFIER`; // terminal: `IDENTIFIER` becomes `IDENTIFIER`;
std::string mangleSymbol(SymbolID SID, const Grammar &G) { std::string mangleSymbol(SymbolID SID, const Grammar &G) {
static auto &TokNames = *new std::vector<std::string>{ static auto &TokNames = *new std::vector<std::string>{
#define TOK(X) llvm::StringRef(#X).upper(), #define TOK(X) llvm::StringRef(#X).upper(),
#define KEYWORD(Keyword, Condition) llvm::StringRef(#Keyword).upper(), #define KEYWORD(Keyword, Condition) llvm::StringRef(#Keyword).upper(),
#include "clang/Basic/TokenKinds.def" #include "clang/Basic/TokenKinds.def"
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

clang-tools-extra/pseudo/lib/cxx/cxx.bnf

# This is a C++ grammar from the C++ standard [1]. # This is a C++ grammar from the C++ standard [1].
# #
# The grammar is a superset of the true grammar requring semantic constraints to # The grammar is a superset of the true grammar requring semantic constraints to
# resolve ambiguties. The grammar is context-free and ambiguous (beyond the # resolve ambiguities. The grammar is context-free and ambiguous (beyond the
# limit of LR(k)). We use general parsing algorithm (e.g GLR) to handle the # limit of LR(k)). We use general parsing algorithm (e.g GLR) to handle the
# grammar and generate a transition table which is used to drive the parsing. # grammar and generate a transition table which is used to drive the parsing.
# #
# It aims to align with the ISO C++ grammar as much as possible. We adjust it # It aims to align with the ISO C++ grammar as much as possible. We adjust it
# to fit the need for the grammar-based parser: # to fit the need for the grammar-based parser:
# - attributes are omitted, which will be handled as comments; # - attributes are omitted, which will be handled as comments;
# - we don't allow nullable nonterminal symbols. There are few nullable # - we don't allow nullable nonterminal symbols. There are few nullable
# nonterminals in the spec grammar, they are adjusted to be non-nullable; # nonterminals in the spec grammar, they are adjusted to be non-nullable;
▲ Show 20 Lines • Show All 764 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines/virtual-class-destructor.cpp

Show First 20 Lines • Show All 137 Lines • ▼ Show 20 Lines
class PublicNonVirtualBaseClass { class PublicNonVirtualBaseClass {
virtual void f(); virtual void f();
public: public:
~PublicNonVirtualBaseClass() {} ~PublicNonVirtualBaseClass() {}
// CHECK-FIXES: virtual ~PublicNonVirtualBaseClass() {} // CHECK-FIXES: virtual ~PublicNonVirtualBaseClass() {}
}; };
class PublicNonVirtualNonBaseClass { // OK accoring to C.35, since this class does not have any virtual methods. class PublicNonVirtualNonBaseClass { // OK according to C.35, since this class does not have any virtual methods.
void f(); void f();
public: public:
~PublicNonVirtualNonBaseClass() {} ~PublicNonVirtualNonBaseClass() {}
}; };
class ProtectedNonVirtualClass { // OK class ProtectedNonVirtualClass { // OK
public: public:
▲ Show 20 Lines • Show All 197 Lines • Show Last 20 Lines

clang/bindings/python/clang/cindex.py

Show First 20 Lines • Show All 1,146 Lines • ▼ Show 20 Lines
CursorKind.OBJC_AT_FINALLY_STMT = CursorKind(218) CursorKind.OBJC_AT_FINALLY_STMT = CursorKind(218)
# Objective-C's @throw statement. # Objective-C's @throw statement.
CursorKind.OBJC_AT_THROW_STMT = CursorKind(219) CursorKind.OBJC_AT_THROW_STMT = CursorKind(219)
# Objective-C's @synchronized statement. # Objective-C's @synchronized statement.
CursorKind.OBJC_AT_SYNCHRONIZED_STMT = CursorKind(220) CursorKind.OBJC_AT_SYNCHRONIZED_STMT = CursorKind(220)
# Objective-C's autorealease pool statement. # Objective-C's autorelease pool statement.
CursorKind.OBJC_AUTORELEASE_POOL_STMT = CursorKind(221) CursorKind.OBJC_AUTORELEASE_POOL_STMT = CursorKind(221)
# Objective-C's for collection statement. # Objective-C's for collection statement.
CursorKind.OBJC_FOR_COLLECTION_STMT = CursorKind(222) CursorKind.OBJC_FOR_COLLECTION_STMT = CursorKind(222)
# C++'s catch statement. # C++'s catch statement.
CursorKind.CXX_CATCH_STMT = CursorKind(223) CursorKind.CXX_CATCH_STMT = CursorKind(223)
▲ Show 20 Lines • Show All 3,058 Lines • Show Last 20 Lines

clang/cmake/caches/MultiDistributionExample.cmake

# This file sets up a CMakeCache for a simple build with multiple distributions. # This file sets up a CMakeCache for a simple build with multiple distributions.
# Note that for a real distribution, you likely want to perform a boostrap # Note that for a real distribution, you likely want to perform a bootstrap
# build; see clang/cmake/caches/DistributionExample.cmake and the # build; see clang/cmake/caches/DistributionExample.cmake and the
# BuildingADistribution documentation for details. This cache file doesn't # BuildingADistribution documentation for details. This cache file doesn't
# demonstrate bootstrapping so it can focus on the configuration details # demonstrate bootstrapping so it can focus on the configuration details
# specific to multiple distributions instead. # specific to multiple distributions instead.
# Build an optimized toolchain for an example set of targets. # Build an optimized toolchain for an example set of targets.
set(CMAKE_BUILD_TYPE Release CACHE STRING "") set(CMAKE_BUILD_TYPE Release CACHE STRING "")
set(LLVM_TARGETS_TO_BUILD set(LLVM_TARGETS_TO_BUILD
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

clang/docs/ClangFormat.rst

Show First 20 Lines • Show All 311 Lines • ▼ Show 20 Lines optional arguments:
-i apply edits to files instead of displaying a diff -i apply edits to files instead of displaying a diff
-p NUM strip the smallest prefix containing P slashes -p NUM strip the smallest prefix containing P slashes
-regex PATTERN custom pattern selecting file paths to reformat (case sensitive, overrides -iregex) -regex PATTERN custom pattern selecting file paths to reformat (case sensitive, overrides -iregex)
-iregex PATTERN custom pattern selecting file paths to reformat (case insensitive, overridden by -regex) -iregex PATTERN custom pattern selecting file paths to reformat (case insensitive, overridden by -regex)
-sort-includes let clang-format sort include blocks -sort-includes let clang-format sort include blocks
-v, --verbose be more verbose, ineffective without -i -v, --verbose be more verbose, ineffective without -i
-style STYLE formatting style to apply (LLVM, GNU, Google, Chromium, Microsoft, Mozilla, WebKit) -style STYLE formatting style to apply (LLVM, GNU, Google, Chromium, Microsoft, Mozilla, WebKit)
-fallback-style FALLBACK_STYLE -fallback-style FALLBACK_STYLE
The name of the predefined style used as afallback in case clang-format is invoked with-style=file, but can not The name of the predefined style used as a fallback in case clang-format is invoked with-style=file, but can not
find the .clang-formatfile to use. find the .clang-formatfile to use.
-binary BINARY location of binary to use for clang-format -binary BINARY location of binary to use for clang-format
To reformat all the lines in the latest Mercurial/:program:`hg` commit, do: To reformat all the lines in the latest Mercurial/:program:`hg` commit, do:
.. code-block:: console .. code-block:: console
hg diff -U0 --color=never | clang-format-diff.py -i -p1 hg diff -U0 --color=never | clang-format-diff.py -i -p1
Show All 11 Lines

clang/docs/JSONCompilationDatabase.rst

Show All 23 Lines- Build systems are inherently sequential in the build graph, for
independently of the build still need the generated source code to independently of the build still need the generated source code to
exist, running tools multiple times over unchanging source does not exist, running tools multiple times over unchanging source does not
require serialization of the runs according to the build dependency require serialization of the runs according to the build dependency
graph. graph.
Supported Systems Supported Systems
================= =================
Clang has the ablity to generate compilation database fragments via Clang has the ability to generate compilation database fragments via
the :option:`-MJ argument <clang -MJ\<arg>>`. You can concatenate those the :option:`-MJ argument <clang -MJ\<arg>>`. You can concatenate those
fragments together between ``[`` and ``]`` to create a compilation database. fragments together between ``[`` and ``]`` to create a compilation database.
Currently `CMake <https://cmake.org>`_ (since 2.8.5) supports generation Currently `CMake <https://cmake.org>`_ (since 2.8.5) supports generation
of compilation databases for Unix Makefile builds (Ninja builds in the of compilation databases for Unix Makefile builds (Ninja builds in the
works) with the option ``CMAKE_EXPORT_COMPILE_COMMANDS``. works) with the option ``CMAKE_EXPORT_COMPILE_COMMANDS``.
For projects on Linux, there is an alternative to intercept compiler For projects on Linux, there is an alternative to intercept compiler
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

clang/docs/LanguageExtensions.rst

Show First 20 Lines • Show All 3,000 Lines • ▼ Show 20 Lines
for lookup purposes, such as in the SYCL Integration Header. for lookup purposes, such as in the SYCL Integration Header.
The value of this builtin is computed entirely at compile time, so it can be The value of this builtin is computed entirely at compile time, so it can be
used in constant expressions. This value encodes lambda functions based on a used in constant expressions. This value encodes lambda functions based on a
stable numbering order in which they appear in their local declaration contexts. stable numbering order in which they appear in their local declaration contexts.
Once this builtin is evaluated in a constexpr context, it is erroneous to use Once this builtin is evaluated in a constexpr context, it is erroneous to use
it in an instantiation which changes its value. it in an instantiation which changes its value.
In order to produce the unique name, the current implementation of the bultin In order to produce the unique name, the current implementation of the builtin
uses Itanium mangling even if the host compilation uses a different name uses Itanium mangling even if the host compilation uses a different name
mangling scheme at runtime. The mangler marks all the lambdas required to name mangling scheme at runtime. The mangler marks all the lambdas required to name
the SYCL kernel and emits a stable local ordering of the respective lambdas. the SYCL kernel and emits a stable local ordering of the respective lambdas.
The resulting pattern is demanglable. When non-lambda types are passed to the The resulting pattern is demanglable. When non-lambda types are passed to the
builtin, the mangler emits their usual pattern without any special treatment. builtin, the mangler emits their usual pattern without any special treatment.
**Syntax**: **Syntax**:
▲ Show 20 Lines • Show All 1,696 Lines • Show Last 20 Lines

clang/docs/analyzer/user-docs/CrossTranslationUnit.rst

Show First 20 Lines • Show All 204 Lines • ▼ Show 20 Lines
On-demand analysis On-demand analysis
__________________ __________________
The analysis produces the necessary AST structure of external TUs during analysis. This requires the The analysis produces the necessary AST structure of external TUs during analysis. This requires the
exact compiler invocations for each TU, which can be generated by hand, or by tools driving the analyzer. exact compiler invocations for each TU, which can be generated by hand, or by tools driving the analyzer.
The compiler invocation is a shell command that could be used to compile the TU-s main source file. The compiler invocation is a shell command that could be used to compile the TU-s main source file.
The mapping from absolute source file paths of a TU to lists of compilation command segments used to The mapping from absolute source file paths of a TU to lists of compilation command segments used to
compile said TU are given in YAML format referred to as `invocation list`, and must be passed as an compile said TU are given in YAML format referred to as `invocation list`, and must be passed as an
analyer-config argument. analyzer-config argument.
The index, which maps function USR names to source files containing them must also be generated by the The index, which maps function USR names to source files containing them must also be generated by the
`clang-extdef-mapping`. Entries in the index must *not* have an `.ast` suffix if the goal `clang-extdef-mapping`. Entries in the index must *not* have an `.ast` suffix if the goal
is to use On-demand analysis, as that extension signals that the entry is to be used as an PCH-dump. is to use On-demand analysis, as that extension signals that the entry is to be used as an PCH-dump.
The mapping of external definitions implicitly uses a The mapping of external definitions implicitly uses a
:doc:`compilation database <../../JSONCompilationDatabase>` to determine the compilation flags used. :doc:`compilation database <../../JSONCompilationDatabase>` to determine the compilation flags used.
The analysis invocation must be provided with the directory which contains the mapping The analysis invocation must be provided with the directory which contains the mapping
files, and the `invocation list` which is used to determine compiler flags. files, and the `invocation list` which is used to determine compiler flags.
▲ Show 20 Lines • Show All 155 Lines • Show Last 20 Lines

clang/include/clang/AST/DeclCXX.h

Show First 20 Lines • Show All 1,910 Lines • ▼ Show 20 Lines Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
TypeSourceInfo *TInfo, SourceLocation EndLocation, TypeSourceInfo *TInfo, SourceLocation EndLocation,
CXXConstructorDecl *Ctor = nullptr); CXXConstructorDecl *Ctor = nullptr);
static CXXDeductionGuideDecl *CreateDeserialized(ASTContext &C, unsigned ID); static CXXDeductionGuideDecl *CreateDeserialized(ASTContext &C, unsigned ID);
ExplicitSpecifier getExplicitSpecifier() { return ExplicitSpec; } ExplicitSpecifier getExplicitSpecifier() { return ExplicitSpec; }
const ExplicitSpecifier getExplicitSpecifier() const { return ExplicitSpec; } const ExplicitSpecifier getExplicitSpecifier() const { return ExplicitSpec; }
/// Return true if the declartion is already resolved to be explicit. /// Return true if the declaration is already resolved to be explicit.
bool isExplicit() const { return ExplicitSpec.isExplicit(); } bool isExplicit() const { return ExplicitSpec.isExplicit(); }
/// Get the template for which this guide performs deduction. /// Get the template for which this guide performs deduction.
TemplateDecl *getDeducedTemplate() const { TemplateDecl *getDeducedTemplate() const {
return getDeclName().getCXXDeductionGuideTemplate(); return getDeclName().getCXXDeductionGuideTemplate();
} }
/// Get the constructor from which this deduction guide was generated, if /// Get the constructor from which this deduction guide was generated, if
▲ Show 20 Lines • Show All 579 Lines • ▼ Show 20 Linespublic:
ExplicitSpecifier getExplicitSpecifier() { ExplicitSpecifier getExplicitSpecifier() {
return getCanonicalDecl()->getExplicitSpecifierInternal(); return getCanonicalDecl()->getExplicitSpecifierInternal();
} }
const ExplicitSpecifier getExplicitSpecifier() const { const ExplicitSpecifier getExplicitSpecifier() const {
return getCanonicalDecl()->getExplicitSpecifierInternal(); return getCanonicalDecl()->getExplicitSpecifierInternal();
} }
/// Return true if the declartion is already resolved to be explicit. /// Return true if the declaration is already resolved to be explicit.
bool isExplicit() const { return getExplicitSpecifier().isExplicit(); } bool isExplicit() const { return getExplicitSpecifier().isExplicit(); }
/// Iterates through the member/base initializer list. /// Iterates through the member/base initializer list.
using init_iterator = CXXCtorInitializer **; using init_iterator = CXXCtorInitializer **;
/// Iterates through the member/base initializer list. /// Iterates through the member/base initializer list.
using init_const_iterator = CXXCtorInitializer *const *; using init_const_iterator = CXXCtorInitializer *const *;
▲ Show 20 Lines • Show All 267 Lines • ▼ Show 20 Linespublic:
ExplicitSpecifier getExplicitSpecifier() { ExplicitSpecifier getExplicitSpecifier() {
return getCanonicalDecl()->ExplicitSpec; return getCanonicalDecl()->ExplicitSpec;
} }
const ExplicitSpecifier getExplicitSpecifier() const { const ExplicitSpecifier getExplicitSpecifier() const {
return getCanonicalDecl()->ExplicitSpec; return getCanonicalDecl()->ExplicitSpec;
} }
/// Return true if the declartion is already resolved to be explicit. /// Return true if the declaration is already resolved to be explicit.
bool isExplicit() const { return getExplicitSpecifier().isExplicit(); } bool isExplicit() const { return getExplicitSpecifier().isExplicit(); }
void setExplicitSpecifier(ExplicitSpecifier ES) { ExplicitSpec = ES; } void setExplicitSpecifier(ExplicitSpecifier ES) { ExplicitSpec = ES; }
/// Returns the type that this conversion function is converting to. /// Returns the type that this conversion function is converting to.
QualType getConversionType() const { QualType getConversionType() const {
return getType()->castAs<FunctionType>()->getReturnType(); return getType()->castAs<FunctionType>()->getReturnType();
} }
▲ Show 20 Lines • Show All 1,470 Lines • Show Last 20 Lines

clang/include/clang/AST/OpenMPClause.h

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 8,385 Lines • ▼ Show 20 Linesprivate:
/// Total number of allocators in the clause. /// Total number of allocators in the clause.
unsigned NumOfAllocators = 0; unsigned NumOfAllocators = 0;
/// Build clause. /// Build clause.
/// ///
/// \param StartLoc Starting location of the clause. /// \param StartLoc Starting location of the clause.
/// \param LParenLoc Location of '('. /// \param LParenLoc Location of '('.
/// \param EndLoc Ending location of the clause. /// \param EndLoc Ending location of the clause.
/// \param N Number of allocators asssociated with the clause. /// \param N Number of allocators associated with the clause.
OMPUsesAllocatorsClause(SourceLocation StartLoc, SourceLocation LParenLoc, OMPUsesAllocatorsClause(SourceLocation StartLoc, SourceLocation LParenLoc,
SourceLocation EndLoc, unsigned N) SourceLocation EndLoc, unsigned N)
: OMPClause(llvm::omp::OMPC_uses_allocators, StartLoc, EndLoc), : OMPClause(llvm::omp::OMPC_uses_allocators, StartLoc, EndLoc),
LParenLoc(LParenLoc), NumOfAllocators(N) {} LParenLoc(LParenLoc), NumOfAllocators(N) {}
/// Build an empty clause. /// Build an empty clause.
/// \param N Number of allocators asssociated with the clause. /// \param N Number of allocators associated with the clause.
/// ///
explicit OMPUsesAllocatorsClause(unsigned N) explicit OMPUsesAllocatorsClause(unsigned N)
: OMPClause(llvm::omp::OMPC_uses_allocators, SourceLocation(), : OMPClause(llvm::omp::OMPC_uses_allocators, SourceLocation(),
SourceLocation()), SourceLocation()),
NumOfAllocators(N) {} NumOfAllocators(N) {}
unsigned numTrailingObjects(OverloadToken<Expr *>) const { unsigned numTrailingObjects(OverloadToken<Expr *>) const {
return NumOfAllocators * static_cast<int>(ExprOffsets::Total); return NumOfAllocators * static_cast<int>(ExprOffsets::Total);
▲ Show 20 Lines • Show All 77 Lines • ▼ Show 20 Linesclass OMPAffinityClause final
SourceLocation ColonLoc; SourceLocation ColonLoc;
/// Build clause. /// Build clause.
/// ///
/// \param StartLoc Starting location of the clause. /// \param StartLoc Starting location of the clause.
/// \param LParenLoc Location of '('. /// \param LParenLoc Location of '('.
/// \param ColonLoc Location of ':'. /// \param ColonLoc Location of ':'.
/// \param EndLoc Ending location of the clause. /// \param EndLoc Ending location of the clause.
/// \param N Number of locators asssociated with the clause. /// \param N Number of locators associated with the clause.
OMPAffinityClause(SourceLocation StartLoc, SourceLocation LParenLoc, OMPAffinityClause(SourceLocation StartLoc, SourceLocation LParenLoc,
SourceLocation ColonLoc, SourceLocation EndLoc, unsigned N) SourceLocation ColonLoc, SourceLocation EndLoc, unsigned N)
: OMPVarListClause<OMPAffinityClause>(llvm::omp::OMPC_affinity, StartLoc, : OMPVarListClause<OMPAffinityClause>(llvm::omp::OMPC_affinity, StartLoc,
LParenLoc, EndLoc, N) {} LParenLoc, EndLoc, N) {}
/// Build an empty clause. /// Build an empty clause.
/// \param N Number of locators asssociated with the clause. /// \param N Number of locators associated with the clause.
/// ///
explicit OMPAffinityClause(unsigned N) explicit OMPAffinityClause(unsigned N)
: OMPVarListClause<OMPAffinityClause>(llvm::omp::OMPC_affinity, : OMPVarListClause<OMPAffinityClause>(llvm::omp::OMPC_affinity,
SourceLocation(), SourceLocation(), SourceLocation(), SourceLocation(),
SourceLocation(), N) {} SourceLocation(), N) {}
/// Sets the affinity modifier for the clause, if any. /// Sets the affinity modifier for the clause, if any.
void setModifier(Expr *E) { void setModifier(Expr *E) {
▲ Show 20 Lines • Show All 526 Lines • Show Last 20 Lines

clang/include/clang/Analysis/ConstructionContext.h

Show First 20 Lines • Show All 536 Lines • ▼ Show 20 Lines static bool classof(const ConstructionContext *CC) {
return CC->getKind() == SimpleTemporaryObjectKind; return CC->getKind() == SimpleTemporaryObjectKind;
} }
}; };
/// Represents a temporary object that is constructed for the sole purpose /// Represents a temporary object that is constructed for the sole purpose
/// of being immediately copied by an elidable copy/move constructor. /// of being immediately copied by an elidable copy/move constructor.
/// For example, T t = T(123); includes a temporary T(123) that is immediately /// For example, T t = T(123); includes a temporary T(123) that is immediately
/// copied to variable t. In such cases the elidable copy can (but not /// copied to variable t. In such cases the elidable copy can (but not
/// necessarily should) be omitted ("elided") accodring to the rules of the /// necessarily should) be omitted ("elided") according to the rules of the
/// language; the constructor would then construct variable t directly. /// language; the constructor would then construct variable t directly.
/// This construction context contains information of the elidable constructor /// This construction context contains information of the elidable constructor
/// and its respective construction context. /// and its respective construction context.
class ElidedTemporaryObjectConstructionContext class ElidedTemporaryObjectConstructionContext
: public TemporaryObjectConstructionContext { : public TemporaryObjectConstructionContext {
const CXXConstructExpr *ElidedCE; const CXXConstructExpr *ElidedCE;
const ConstructionContext *ElidedCC; const ConstructionContext *ElidedCC;
▲ Show 20 Lines • Show All 169 Lines • Show Last 20 Lines

clang/include/clang/Analysis/FlowSensitive/DataflowValues.h

Show First 20 Lines • Show All 128 Lines • ▼ Show 20 Linespublic:
/// dataflow values. Usually used by a dataflow solver to compute /// dataflow values. Usually used by a dataflow solver to compute
/// values for blocks. /// values for blocks.
EdgeDataMapTy& getEdgeDataMap() { return EdgeDataMap; } EdgeDataMapTy& getEdgeDataMap() { return EdgeDataMap; }
const EdgeDataMapTy& getEdgeDataMap() const { return EdgeDataMap; } const EdgeDataMapTy& getEdgeDataMap() const { return EdgeDataMap; }
/// getBlockDataMap - Retrieves the internal map between CFGBlocks and /// getBlockDataMap - Retrieves the internal map between CFGBlocks and
/// dataflow values. If the dataflow analysis operates in the forward /// dataflow values. If the dataflow analysis operates in the forward
/// direction, the values correspond to the dataflow values at the start /// direction, the values correspond to the dataflow values at the start
/// of the block. Otherwise, for a backward analysis, the values correpsond /// of the block. Otherwise, for a backward analysis, the values correspond
/// to the dataflow values at the end of the block. /// to the dataflow values at the end of the block.
BlockDataMapTy& getBlockDataMap() { return BlockDataMap; } BlockDataMapTy& getBlockDataMap() { return BlockDataMap; }
const BlockDataMapTy& getBlockDataMap() const { return BlockDataMap; } const BlockDataMapTy& getBlockDataMap() const { return BlockDataMap; }
/// getStmtDataMap - Retrieves the internal map between Stmts and /// getStmtDataMap - Retrieves the internal map between Stmts and
/// dataflow values. /// dataflow values.
StmtDataMapTy& getStmtDataMap() { StmtDataMapTy& getStmtDataMap() {
if (!StmtDataMap) StmtDataMap = new StmtDataMapTy(); if (!StmtDataMap) StmtDataMap = new StmtDataMapTy();
Show All 27 Lines

clang/include/clang/Basic/AttrDocs.td

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 4,383 Lines • ▼ Show 20 Lines
applied to a definition. If ``disable_implicit_base`` is given, we will not applied to a definition. If ``disable_implicit_base`` is given, we will not
introduce an implicit base function for a variant if no base function was introduce an implicit base function for a variant if no base function was
found. The variant is still generated but will never be called, due to the found. The variant is still generated but will never be called, due to the
absence of a base function and consequently calls to a base function. absence of a base function and consequently calls to a base function.
The allow extensions change when the ``begin declare variant`` effect is The allow extensions change when the ``begin declare variant`` effect is
applied to a definition. If ``allow_templates`` is given, template function applied to a definition. If ``allow_templates`` is given, template function
definitions are considered as specializations of existing or assumed template definitions are considered as specializations of existing or assumed template
declarations with the same name. The template parameters for the base functions declarations with the same name. The template parameters for the base functions
are used to instantiate the specialization. If ``bind_to_declartion`` is given, are used to instantiate the specialization. If ``bind_to_declaration`` is given,
apply the same variant rules to function declarations. This allows the user to apply the same variant rules to function declarations. This allows the user to
override declarations with only a function declaration. override declarations with only a function declaration.
}]; }];
} }
def LeafDocs : Documentation { def LeafDocs : Documentation {
let Category = DocCatVariable; let Category = DocCatVariable;
let Content = [{ let Content = [{
▲ Show 20 Lines • Show All 1,700 Lines • ▼ Show 20 Lines
.. code-block:: c++ .. code-block:: c++
namespace empty_namespace {}; namespace empty_namespace {};
__attribute__((using_if_exists)) __attribute__((using_if_exists))
using empty_namespace::does_not_exist; // no error! using empty_namespace::does_not_exist; // no error!
does_not_exist x; // error: use of unresolved 'using_if_exists' does_not_exist x; // error: use of unresolved 'using_if_exists'
The C++ spelling of the attribte (`[[clang::using_if_exists]]`) is also The C++ spelling of the attribute (`[[clang::using_if_exists]]`) is also
supported as a clang extension, since ISO C++ doesn't support attributes in this supported as a clang extension, since ISO C++ doesn't support attributes in this
position. If the entity referred to by the using-declaration is found by name position. If the entity referred to by the using-declaration is found by name
lookup, the attribute has no effect. This attribute is useful for libraries lookup, the attribute has no effect. This attribute is useful for libraries
(primarily, libc++) that wish to redeclare a set of declarations in another (primarily, libc++) that wish to redeclare a set of declarations in another
namespace, when the availability of those declarations is difficult or namespace, when the availability of those declarations is difficult or
impossible to detect at compile time with the preprocessor. impossible to detect at compile time with the preprocessor.
}]; }];
} }
▲ Show 20 Lines • Show All 321 Lines • ▼ Show 20 Lines
The `choice` parameters gives the programmer flexibility to choose the subset The `choice` parameters gives the programmer flexibility to choose the subset
of the call-used registers to be zeroed: of the call-used registers to be zeroed:
- ``skip`` doesn't zero any call-used registers. This choice overrides any - ``skip`` doesn't zero any call-used registers. This choice overrides any
command-line arguments. command-line arguments.
- ``used`` only zeros call-used registers used in the function. By ``used``, we - ``used`` only zeros call-used registers used in the function. By ``used``, we
mean a register whose contents have been set or referenced in the function. mean a register whose contents have been set or referenced in the function.
- ``used-gpr`` only zeros call-used GPR registers used in the funciton. - ``used-gpr`` only zeros call-used GPR registers used in the function.
- ``used-arg`` only zeros call-used registers used to pass arguments to the - ``used-arg`` only zeros call-used registers used to pass arguments to the
function. function.
- ``used-gpr-arg`` only zeros call-used GPR registers used to pass arguments to - ``used-gpr-arg`` only zeros call-used GPR registers used to pass arguments to
the function. the function.
- ``all`` zeros all call-used registers. - ``all`` zeros all call-used registers.
- ``all-gpr`` zeros all call-used GPR registers. - ``all-gpr`` zeros all call-used GPR registers.
- ``all-arg`` zeros all call-used registers used to pass arguments to the - ``all-arg`` zeros all call-used registers used to pass arguments to the
function. function.
- ``all-gpr-arg`` zeros all call-used GPR registers used to pass arguments to - ``all-gpr-arg`` zeros all call-used GPR registers used to pass arguments to
the function. the function.
The default for the attribute is contolled by the ``-fzero-call-used-regs`` The default for the attribute is controlled by the ``-fzero-call-used-regs``
flag. flag.
.. _Return-Oriented Programming: https://en.wikipedia.org/wiki/Return-oriented_programming .. _Return-Oriented Programming: https://en.wikipedia.org/wiki/Return-oriented_programming
}]; }];
} }
def NumThreadsDocs : Documentation { def NumThreadsDocs : Documentation {
let Category = DocCatFunction; let Category = DocCatFunction;
▲ Show 20 Lines • Show All 194 Lines • Show Last 20 Lines

clang/include/clang/Basic/BuiltinsVE.def

Show All 9 Lines
// this file must define the BUILTIN macro to make use of this information. // this file must define the BUILTIN macro to make use of this information.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#if defined(BUILTIN) && !defined(TARGET_BUILTIN) #if defined(BUILTIN) && !defined(TARGET_BUILTIN)
# define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) BUILTIN(ID, TYPE, ATTRS) # define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) BUILTIN(ID, TYPE, ATTRS)
#endif #endif
// The format of this database is decribed in clang/Basic/Builtins.def. // The format of this database is described in clang/Basic/Builtins.def.
BUILTIN(__builtin_ve_vl_pack_f32p, "ULifC*fC*", "n") BUILTIN(__builtin_ve_vl_pack_f32p, "ULifC*fC*", "n")
BUILTIN(__builtin_ve_vl_pack_f32a, "ULifC*", "n") BUILTIN(__builtin_ve_vl_pack_f32a, "ULifC*", "n")
BUILTIN(__builtin_ve_vl_extract_vm512u, "V256bV512b", "n") BUILTIN(__builtin_ve_vl_extract_vm512u, "V256bV512b", "n")
BUILTIN(__builtin_ve_vl_extract_vm512l, "V256bV512b", "n") BUILTIN(__builtin_ve_vl_extract_vm512l, "V256bV512b", "n")
BUILTIN(__builtin_ve_vl_insert_vm512u, "V512bV512bV256b", "n") BUILTIN(__builtin_ve_vl_insert_vm512u, "V512bV512bV256b", "n")
BUILTIN(__builtin_ve_vl_insert_vm512l, "V512bV512bV256b", "n") BUILTIN(__builtin_ve_vl_insert_vm512l, "V512bV512bV256b", "n")
// Use generated BUILTIN definitions // Use generated BUILTIN definitions
#include "clang/Basic/BuiltinsVEVL.gen.def" #include "clang/Basic/BuiltinsVEVL.gen.def"
#undef BUILTIN #undef BUILTIN
#undef TARGET_BUILTIN #undef TARGET_BUILTIN

clang/include/clang/Basic/SourceManager.h

Show First 20 Lines • Show All 1,912 Lines • ▼ Show 20 Lines
public: public:
explicit BeforeThanCompare(SourceManager &SM) : SM(SM) {} explicit BeforeThanCompare(SourceManager &SM) : SM(SM) {}
bool operator()(SourceRange LHS, SourceRange RHS) const { bool operator()(SourceRange LHS, SourceRange RHS) const {
return SM.isBeforeInTranslationUnit(LHS.getBegin(), RHS.getBegin()); return SM.isBeforeInTranslationUnit(LHS.getBegin(), RHS.getBegin());
} }
}; };
/// SourceManager and necessary depdencies (e.g. VFS, FileManager) for a single /// SourceManager and necessary dependencies (e.g. VFS, FileManager) for a
/// in-memorty file. /// single in-memorty file.
class SourceManagerForFile { class SourceManagerForFile {
public: public:
/// Creates SourceManager and necessary depdencies (e.g. VFS, FileManager). /// Creates SourceManager and necessary dependencies (e.g. VFS, FileManager).
/// The main file in the SourceManager will be \p FileName with \p Content. /// The main file in the SourceManager will be \p FileName with \p Content.
SourceManagerForFile(StringRef FileName, StringRef Content); SourceManagerForFile(StringRef FileName, StringRef Content);
SourceManager &get() { SourceManager &get() {
assert(SourceMgr); assert(SourceMgr);
return *SourceMgr; return *SourceMgr;
} }
Show All 12 Lines

clang/include/clang/ExtractAPI/Serialization/SymbolGraphSerializer.h

Show First 20 Lines • Show All 147 Lines • ▼ Show 20 Linesprivate:
void serializeEnumRecord(const EnumRecord &Record); void serializeEnumRecord(const EnumRecord &Record);
/// Serialize a struct record. /// Serialize a struct record.
void serializeStructRecord(const StructRecord &Record); void serializeStructRecord(const StructRecord &Record);
/// Serialize an Objective-C container record. /// Serialize an Objective-C container record.
void serializeObjCContainerRecord(const ObjCContainerRecord &Record); void serializeObjCContainerRecord(const ObjCContainerRecord &Record);
/// Serialize a macro defintion record. /// Serialize a macro definition record.
void serializeMacroDefinitionRecord(const MacroDefinitionRecord &Record); void serializeMacroDefinitionRecord(const MacroDefinitionRecord &Record);
/// Serialize a typedef record. /// Serialize a typedef record.
void serializeTypedefRecord(const TypedefRecord &Record); void serializeTypedefRecord(const TypedefRecord &Record);
/// Push a component to the current path components stack. /// Push a component to the current path components stack.
/// ///
/// \param Component The component to push onto the path components stack. /// \param Component The component to push onto the path components stack.
Show All 14 Lines

clang/include/clang/Lex/DependencyDirectivesScanner.h

Show First 20 Lines • Show All 81 Lines • ▼ Show 20 Linesenum DirectiveKind : uint8_t {
cxx_import_decl, cxx_import_decl,
cxx_export_module_decl, cxx_export_module_decl,
cxx_export_import_decl, cxx_export_import_decl,
pp_eof, pp_eof,
}; };
/// Represents a directive that's lexed as part of the dependency directives /// Represents a directive that's lexed as part of the dependency directives
/// scanning. It's used to track various preprocessor directives that could /// scanning. It's used to track various preprocessor directives that could
/// potentially have an effect on the depedencies. /// potentially have an effect on the dependencies.
struct Directive { struct Directive {
ArrayRef<Token> Tokens; ArrayRef<Token> Tokens;
/// The kind of token. /// The kind of token.
DirectiveKind Kind = pp_none; DirectiveKind Kind = pp_none;
Directive() = default; Directive() = default;
Directive(DirectiveKind K, ArrayRef<Token> Tokens) Directive(DirectiveKind K, ArrayRef<Token> Tokens)
Show All 38 Lines

clang/include/clang/Sema/DeclSpec.h

Show First 20 Lines • Show All 1,337 Lines • ▼ Show 20 Lines struct FunctionTypeInfo {
/// Params - This is a pointer to a new[]'d array of ParamInfo objects that /// Params - This is a pointer to a new[]'d array of ParamInfo objects that
/// describe the parameters specified by this function declarator. null if /// describe the parameters specified by this function declarator. null if
/// there are no parameters specified. /// there are no parameters specified.
ParamInfo *Params; ParamInfo *Params;
/// DeclSpec for the function with the qualifier related info. /// DeclSpec for the function with the qualifier related info.
DeclSpec *MethodQualifiers; DeclSpec *MethodQualifiers;
/// AtttibuteFactory for the MethodQualifiers. /// AttributeFactory for the MethodQualifiers.
AttributeFactory *QualAttrFactory; AttributeFactory *QualAttrFactory;
union { union {
/// Pointer to a new[]'d array of TypeAndRange objects that /// Pointer to a new[]'d array of TypeAndRange objects that
/// contain the types in the function's dynamic exception specification /// contain the types in the function's dynamic exception specification
/// and their locations, if there is one. /// and their locations, if there is one.
TypeAndRange *Exceptions; TypeAndRange *Exceptions;
▲ Show 20 Lines • Show All 1,422 Lines • Show Last 20 Lines

clang/include/clang/Sema/Sema.h

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 300 Lines • ▼ Show 20 Linespublic:
void enterReturn(Sema &S, SourceLocation Tok); void enterReturn(Sema &S, SourceLocation Tok);
void enterVariableInit(SourceLocation Tok, Decl *D); void enterVariableInit(SourceLocation Tok, Decl *D);
/// Handles e.g. BaseType{ .D = Tok... /// Handles e.g. BaseType{ .D = Tok...
void enterDesignatedInitializer(SourceLocation Tok, QualType BaseType, void enterDesignatedInitializer(SourceLocation Tok, QualType BaseType,
const Designation &D); const Designation &D);
/// Computing a type for the function argument may require running /// Computing a type for the function argument may require running
/// overloading, so we postpone its computation until it is actually needed. /// overloading, so we postpone its computation until it is actually needed.
/// ///
/// Clients should be very careful when using this funciton, as it stores a /// Clients should be very careful when using this function, as it stores a
/// function_ref, clients should make sure all calls to get() with the same /// function_ref, clients should make sure all calls to get() with the same
/// location happen while function_ref is alive. /// location happen while function_ref is alive.
/// ///
/// The callback should also emit signature help as a side-effect, but only /// The callback should also emit signature help as a side-effect, but only
/// if the completion point has been reached. /// if the completion point has been reached.
void enterFunctionArgument(SourceLocation Tok, void enterFunctionArgument(SourceLocation Tok,
llvm::function_ref<QualType()> ComputeType); llvm::function_ref<QualType()> ComputeType);
▲ Show 20 Lines • Show All 3,695 Lines • ▼ Show 20 Lines bool resolveAndFixAddressOfSingleOverloadCandidate(
ExprResult &SrcExpr, bool DoFunctionPointerConversion = false); ExprResult &SrcExpr, bool DoFunctionPointerConversion = false);
FunctionDecl * FunctionDecl *
ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl, ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl,
bool Complain = false, bool Complain = false,
DeclAccessPair *Found = nullptr); DeclAccessPair *Found = nullptr);
bool ResolveAndFixSingleFunctionTemplateSpecialization( bool ResolveAndFixSingleFunctionTemplateSpecialization(
ExprResult &SrcExpr, ExprResult &SrcExpr, bool DoFunctionPointerConversion = false,
bool DoFunctionPointerConverion = false, bool Complain = false, SourceRange OpRangeForComplaining = SourceRange(),
bool Complain = false,
SourceRange OpRangeForComplaining = SourceRange(),
QualType DestTypeForComplaining = QualType(), QualType DestTypeForComplaining = QualType(),
unsigned DiagIDForComplaining = 0); unsigned DiagIDForComplaining = 0);
Expr *FixOverloadedFunctionReference(Expr *E, Expr *FixOverloadedFunctionReference(Expr *E,
DeclAccessPair FoundDecl, DeclAccessPair FoundDecl,
FunctionDecl *Fn); FunctionDecl *Fn);
ExprResult FixOverloadedFunctionReference(ExprResult, ExprResult FixOverloadedFunctionReference(ExprResult,
DeclAccessPair FoundDecl, DeclAccessPair FoundDecl,
FunctionDecl *Fn); FunctionDecl *Fn);
void AddOverloadedCallCandidates(UnresolvedLookupExpr *ULE, void AddOverloadedCallCandidates(UnresolvedLookupExpr *ULE,
▲ Show 20 Lines • Show All 9,594 Lines • Show Last 20 Lines

clang/include/clang/Serialization/ASTReader.h

Show First 20 Lines • Show All 375 Lines • ▼ Show 20 Lines enum ASTReadResult {
/// The AST file is out-of-date relative to its input files, /// The AST file is out-of-date relative to its input files,
/// and needs to be regenerated. /// and needs to be regenerated.
OutOfDate, OutOfDate,
/// The AST file was written by a different version of Clang. /// The AST file was written by a different version of Clang.
VersionMismatch, VersionMismatch,
/// The AST file was writtten with a different language/target /// The AST file was written with a different language/target
/// configuration. /// configuration.
ConfigurationMismatch, ConfigurationMismatch,
/// The AST file has errors. /// The AST file has errors.
HadErrors HadErrors
}; };
using ModuleFile = serialization::ModuleFile; using ModuleFile = serialization::ModuleFile;
▲ Show 20 Lines • Show All 1,941 Lines • Show Last 20 Lines

clang/include/clang/Serialization/SourceLocationEncoding.h

//===--- SourceLocationEncoding.h - Small serialized locations --*- C++ -*-===// //===--- SourceLocationEncoding.h - Small serialized locations --*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Source locations are stored pervasively in the AST, making up a third of // Source locations are stored pervasively in the AST, making up a third of
// the size of typical serialized files. Storing them efficiently is important. // the size of typical serialized files. Storing them efficiently is important.
// //
// We use integers optimized by VBR-encoding, because: // We use integers optimized by VBR-encoding, because:
// - when abbrevations cannot be used, VBR6 encoding is our only choice // - when abbreviations cannot be used, VBR6 encoding is our only choice
// - in the worst case a SourceLocation can be ~any 32-bit number, but in // - in the worst case a SourceLocation can be ~any 32-bit number, but in
// practice they are highly predictable // practice they are highly predictable
// //
// We encode the integer so that likely values encode as small numbers that // We encode the integer so that likely values encode as small numbers that
// turn into few VBR chunks: // turn into few VBR chunks:
// - the invalid sentinel location is a very common value: it encodes as 0 // - the invalid sentinel location is a very common value: it encodes as 0
// - the "macro or not" bit is stored at the bottom of the integer // - the "macro or not" bit is stored at the bottom of the integer
// (rather than at the top, as in memory), so macro locations can have // (rather than at the top, as in memory), so macro locations can have
▲ Show 20 Lines • Show All 142 Lines • Show Last 20 Lines

clang/include/clang/StaticAnalyzer/Core/CheckerManager.h

Show First 20 Lines • Show All 147 Lines • ▼ Show 20 Linespublic:
/// checkers. Useful for unit testing, unless the checker infrastructure /// checkers. Useful for unit testing, unless the checker infrastructure
/// itself is tested. /// itself is tested.
CheckerManager(ASTContext &Context, AnalyzerOptions &AOptions, CheckerManager(ASTContext &Context, AnalyzerOptions &AOptions,
const Preprocessor &PP) const Preprocessor &PP)
: CheckerManager(Context, AOptions, PP, {}, {}) {} : CheckerManager(Context, AOptions, PP, {}, {}) {}
/// Constructs a CheckerManager without requiring an AST. No checker /// Constructs a CheckerManager without requiring an AST. No checker
/// registration will take place. Only useful when one needs to print the /// registration will take place. Only useful when one needs to print the
/// help flags through CheckerRegistryData, and the AST is unavalaible. /// help flags through CheckerRegistryData, and the AST is unavailable.
CheckerManager(AnalyzerOptions &AOptions, const LangOptions &LangOpts, CheckerManager(AnalyzerOptions &AOptions, const LangOptions &LangOpts,
DiagnosticsEngine &Diags, ArrayRef<std::string> plugins); DiagnosticsEngine &Diags, ArrayRef<std::string> plugins);
~CheckerManager(); ~CheckerManager();
void setCurrentCheckerName(CheckerNameRef name) { CurrentCheckerName = name; } void setCurrentCheckerName(CheckerNameRef name) { CurrentCheckerName = name; }
CheckerNameRef getCurrentCheckerName() const { return CurrentCheckerName; } CheckerNameRef getCurrentCheckerName() const { return CurrentCheckerName; }
▲ Show 20 Lines • Show All 546 Lines • Show Last 20 Lines

clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h

Show First 20 Lines • Show All 714 Lines • ▼ Show 20 Linespublic:
/// Find location of the object that is being constructed by a given /// Find location of the object that is being constructed by a given
/// constructor. This should ideally always succeed but due to not being /// constructor. This should ideally always succeed but due to not being
/// fully implemented it sometimes indicates that it failed via its /// fully implemented it sometimes indicates that it failed via its
/// out-parameter CallOpts; in such cases a fake temporary region is /// out-parameter CallOpts; in such cases a fake temporary region is
/// returned, which is better than nothing but does not represent /// returned, which is better than nothing but does not represent
/// the actual behavior of the program. The Idx parameter is used if we /// the actual behavior of the program. The Idx parameter is used if we
/// construct an array of objects. In that case it points to the index /// construct an array of objects. In that case it points to the index
/// of the continous memory region. /// of the continuous memory region.
/// E.g.: /// E.g.:
/// For `int arr[4]` this index can be 0,1,2,3. /// For `int arr[4]` this index can be 0,1,2,3.
/// For `int arr2[3][3]` this index can be 0,1,...,7,8. /// For `int arr2[3][3]` this index can be 0,1,...,7,8.
/// A multi-dimensional array is also a continous memory location in a /// A multi-dimensional array is also a continuous memory location in a
/// row major order, so for arr[0][0] Idx is 0 and for arr[2][2] Idx is 8. /// row major order, so for arr[0][0] Idx is 0 and for arr[2][2] Idx is 8.
SVal computeObjectUnderConstruction(const Expr *E, ProgramStateRef State, SVal computeObjectUnderConstruction(const Expr *E, ProgramStateRef State,
const LocationContext *LCtx, const LocationContext *LCtx,
const ConstructionContext *CC, const ConstructionContext *CC,
EvalCallOptions &CallOpts, EvalCallOptions &CallOpts,
unsigned Idx = 0); unsigned Idx = 0);
/// Update the program state with all the path-sensitive information /// Update the program state with all the path-sensitive information
▲ Show 20 Lines • Show All 264 Lines • Show Last 20 Lines

clang/include/clang/Tooling/Core/Replacement.h

Show First 20 Lines • Show All 295 Lines • ▼ Show 20 Linesprivate:
Replacement getReplacementInChangedCode(const Replacement &R) const; Replacement getReplacementInChangedCode(const Replacement &R) const;
// Returns a set of replacements that is equivalent to the current // Returns a set of replacements that is equivalent to the current
// replacements by merging all adjacent replacements. Two sets of replacements // replacements by merging all adjacent replacements. Two sets of replacements
// are considered equivalent if they have the same effect when they are // are considered equivalent if they have the same effect when they are
// applied. // applied.
Replacements getCanonicalReplacements() const; Replacements getCanonicalReplacements() const;
// If `R` and all existing replacements are order-indepedent, then merge it // If `R` and all existing replacements are order-independent, then merge it
// with `Replaces` and returns the merged replacements; otherwise, returns an // with `Replaces` and returns the merged replacements; otherwise, returns an
// error. // error.
llvm::Expected<Replacements> llvm::Expected<Replacements>
mergeIfOrderIndependent(const Replacement &R) const; mergeIfOrderIndependent(const Replacement &R) const;
ReplacementsImpl Replaces; ReplacementsImpl Replaces;
}; };
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

clang/include/clang/Tooling/Syntax/Tree.h

//===- Tree.h - structure of the syntax tree ------------------*- C++ -*-=====// //===- Tree.h - structure of the syntax tree ------------------*- C++ -*-=====//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Defines the basic structure of the syntax tree. There are two kinds of nodes: // Defines the basic structure of the syntax tree. There are two kinds of nodes:
// - leaf nodes correspond to tokens, // - leaf nodes correspond to tokens,
// - tree nodes correspond to language grammar constructs. // - tree nodes correspond to language grammar constructs.
// //
// The tree is initially built from an AST. Each node of a newly built tree // The tree is initially built from an AST. Each node of a newly built tree
// covers a continous subrange of expanded tokens (i.e. tokens after // covers a continuous subrange of expanded tokens (i.e. tokens after
// preprocessing), the specific tokens coverered are stored in the leaf nodes of // preprocessing), the specific tokens coverered are stored in the leaf nodes of
// a tree. A post-order traversal of a tree will visit leaf nodes in an order // a tree. A post-order traversal of a tree will visit leaf nodes in an order
// corresponding the original order of expanded tokens. // corresponding the original order of expanded tokens.
// //
// This is still work in progress and highly experimental, we leave room for // This is still work in progress and highly experimental, we leave room for
// ourselves to completely change the design and/or implementation. // ourselves to completely change the design and/or implementation.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_TOOLING_SYNTAX_TREE_H #ifndef LLVM_CLANG_TOOLING_SYNTAX_TREE_H
▲ Show 20 Lines • Show All 290 Lines • Show Last 20 Lines

clang/lib/AST/ASTContext.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 2,479 Lines • ▼ Show 20 Lines
CharUnits ASTContext::getTypeAlignInChars(QualType T) const { CharUnits ASTContext::getTypeAlignInChars(QualType T) const {
return toCharUnitsFromBits(getTypeAlign(T)); return toCharUnitsFromBits(getTypeAlign(T));
} }
CharUnits ASTContext::getTypeAlignInChars(const Type *T) const { CharUnits ASTContext::getTypeAlignInChars(const Type *T) const {
return toCharUnitsFromBits(getTypeAlign(T)); return toCharUnitsFromBits(getTypeAlign(T));
} }
/// getTypeUnadjustedAlignInChars - Return the ABI-specified alignment of a /// getTypeUnadjustedAlignInChars - Return the ABI-specified alignment of a
/// type, in characters, before alignment adustments. This method does /// type, in characters, before alignment adjustments. This method does
/// not work on incomplete types. /// not work on incomplete types.
CharUnits ASTContext::getTypeUnadjustedAlignInChars(QualType T) const { CharUnits ASTContext::getTypeUnadjustedAlignInChars(QualType T) const {
return toCharUnitsFromBits(getTypeUnadjustedAlign(T)); return toCharUnitsFromBits(getTypeUnadjustedAlign(T));
} }
CharUnits ASTContext::getTypeUnadjustedAlignInChars(const Type *T) const { CharUnits ASTContext::getTypeUnadjustedAlignInChars(const Type *T) const {
return toCharUnitsFromBits(getTypeUnadjustedAlign(T)); return toCharUnitsFromBits(getTypeUnadjustedAlign(T));
} }
▲ Show 20 Lines • Show All 9,924 Lines • Show Last 20 Lines

clang/lib/Analysis/CFG.cpp

Show First 20 Lines • Show All 1,611 Lines • ▼ Show 20 Linesstd::unique_ptr<CFG> CFGBuilder::buildCFG(const Decl *D, Stmt *Statement) {
if (BuildOpts.AddRichCXXConstructors) if (BuildOpts.AddRichCXXConstructors)
assert(ConstructionContextMap.empty() && assert(ConstructionContextMap.empty() &&
"Not all construction contexts were cleaned up!"); "Not all construction contexts were cleaned up!");
return std::move(cfg); return std::move(cfg);
} }
/// createBlock - Used to lazily create blocks that are connected /// createBlock - Used to lazily create blocks that are connected
/// to the current (global) succcessor. /// to the current (global) successor.
CFGBlock *CFGBuilder::createBlock(bool add_successor) { CFGBlock *CFGBuilder::createBlock(bool add_successor) {
CFGBlock *B = cfg->createBlock(); CFGBlock *B = cfg->createBlock();
if (add_successor && Succ) if (add_successor && Succ)
addSuccessor(B, Succ); addSuccessor(B, Succ);
return B; return B;
} }
/// createNoReturnBlock - Used to create a block is a 'noreturn' point in the /// createNoReturnBlock - Used to create a block is a 'noreturn' point in the
▲ Show 20 Lines • Show All 4,657 Lines • Show Last 20 Lines

clang/lib/CodeGen/CGBuiltin.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 11,928 Lines • ▼ Show 20 LinesValue *CodeGenFunction::EmitBPFBuiltinExpr(unsigned BuiltinID,
const CallExpr *E) { const CallExpr *E) {
assert((BuiltinID == BPF::BI__builtin_preserve_field_info || assert((BuiltinID == BPF::BI__builtin_preserve_field_info ||
BuiltinID == BPF::BI__builtin_btf_type_id || BuiltinID == BPF::BI__builtin_btf_type_id ||
BuiltinID == BPF::BI__builtin_preserve_type_info || BuiltinID == BPF::BI__builtin_preserve_type_info ||
BuiltinID == BPF::BI__builtin_preserve_enum_value) && BuiltinID == BPF::BI__builtin_preserve_enum_value) &&
"unexpected BPF builtin"); "unexpected BPF builtin");
// A sequence number, injected into IR builtin functions, to // A sequence number, injected into IR builtin functions, to
// prevent CSE given the only difference of the funciton // prevent CSE given the only difference of the function
// may just be the debuginfo metadata. // may just be the debuginfo metadata.
static uint32_t BuiltinSeqNum; static uint32_t BuiltinSeqNum;
switch (BuiltinID) { switch (BuiltinID) {
default: default:
llvm_unreachable("Unexpected BPF builtin"); llvm_unreachable("Unexpected BPF builtin");
case BPF::BI__builtin_preserve_field_info: { case BPF::BI__builtin_preserve_field_info: {
const Expr *Arg = E->getArg(0); const Expr *Arg = E->getArg(0);
▲ Show 20 Lines • Show All 4,284 Lines • ▼ Show 20 Lines case PPC::BI__builtin_ppc_compare_and_swaplp: {
Address OldValAddr = EmitPointerWithAlignment(E->getArg(1)); Address OldValAddr = EmitPointerWithAlignment(E->getArg(1));
Value *OldVal = Builder.CreateLoad(OldValAddr); Value *OldVal = Builder.CreateLoad(OldValAddr);
QualType AtomicTy = E->getArg(0)->getType()->getPointeeType(); QualType AtomicTy = E->getArg(0)->getType()->getPointeeType();
LValue LV = MakeAddrLValue(Addr, AtomicTy); LValue LV = MakeAddrLValue(Addr, AtomicTy);
Value *Op2 = EmitScalarExpr(E->getArg(2)); Value *Op2 = EmitScalarExpr(E->getArg(2));
auto Pair = EmitAtomicCompareExchange( auto Pair = EmitAtomicCompareExchange(
LV, RValue::get(OldVal), RValue::get(Op2), E->getExprLoc(), LV, RValue::get(OldVal), RValue::get(Op2), E->getExprLoc(),
llvm::AtomicOrdering::Monotonic, llvm::AtomicOrdering::Monotonic, true); llvm::AtomicOrdering::Monotonic, llvm::AtomicOrdering::Monotonic, true);
// Unlike c11's atomic_compare_exchange, accroding to // Unlike c11's atomic_compare_exchange, according to
// https://www.ibm.com/docs/en/xl-c-and-cpp-aix/16.1?topic=functions-compare-swap-compare-swaplp // https://www.ibm.com/docs/en/xl-c-and-cpp-aix/16.1?topic=functions-compare-swap-compare-swaplp
// > In either case, the contents of the memory location specified by addr // > In either case, the contents of the memory location specified by addr
// > are copied into the memory location specified by old_val_addr. // > are copied into the memory location specified by old_val_addr.
// But it hasn't specified storing to OldValAddr is atomic or not and // But it hasn't specified storing to OldValAddr is atomic or not and
// which order to use. Now following XL's codegen, treat it as a normal // which order to use. Now following XL's codegen, treat it as a normal
// store. // store.
Value *LoadedVal = Pair.first.getScalarVal(); Value *LoadedVal = Pair.first.getScalarVal();
Builder.CreateStore(LoadedVal, OldValAddr); Builder.CreateStore(LoadedVal, OldValAddr);
▲ Show 20 Lines • Show All 3,163 Lines • Show Last 20 Lines

clang/lib/CodeGen/CGCall.cpp

Show First 20 Lines • Show All 3,524 Lines • ▼ Show 20 Linesvoid CodeGenFunction::EmitFunctionEpilog(const CGFunctionInfo &FI,
llvm::DebugLoc RetDbgLoc; llvm::DebugLoc RetDbgLoc;
llvm::Value *RV = nullptr; llvm::Value *RV = nullptr;
QualType RetTy = FI.getReturnType(); QualType RetTy = FI.getReturnType();
const ABIArgInfo &RetAI = FI.getReturnInfo(); const ABIArgInfo &RetAI = FI.getReturnInfo();
switch (RetAI.getKind()) { switch (RetAI.getKind()) {
case ABIArgInfo::InAlloca: case ABIArgInfo::InAlloca:
// Aggregrates get evaluated directly into the destination. Sometimes we // Aggregates get evaluated directly into the destination. Sometimes we
// need to return the sret value in a register, though. // need to return the sret value in a register, though.
assert(hasAggregateEvaluationKind(RetTy)); assert(hasAggregateEvaluationKind(RetTy));
if (RetAI.getInAllocaSRet()) { if (RetAI.getInAllocaSRet()) {
llvm::Function::arg_iterator EI = CurFn->arg_end(); llvm::Function::arg_iterator EI = CurFn->arg_end();
--EI; --EI;
llvm::Value *ArgStruct = &*EI; llvm::Value *ArgStruct = &*EI;
llvm::Value *SRet = Builder.CreateStructGEP( llvm::Value *SRet = Builder.CreateStructGEP(
FI.getArgStruct(), ArgStruct, RetAI.getInAllocaFieldIndex()); FI.getArgStruct(), ArgStruct, RetAI.getInAllocaFieldIndex());
Show All 11 Lines case ABIArgInfo::Indirect: {
case TEK_Complex: { case TEK_Complex: {
ComplexPairTy RT = ComplexPairTy RT =
EmitLoadOfComplex(MakeAddrLValue(ReturnValue, RetTy), EndLoc); EmitLoadOfComplex(MakeAddrLValue(ReturnValue, RetTy), EndLoc);
EmitStoreOfComplex(RT, MakeNaturalAlignAddrLValue(&*AI, RetTy), EmitStoreOfComplex(RT, MakeNaturalAlignAddrLValue(&*AI, RetTy),
/*isInit*/ true); /*isInit*/ true);
break; break;
} }
case TEK_Aggregate: case TEK_Aggregate:
// Do nothing; aggregrates get evaluated directly into the destination. // Do nothing; aggregates get evaluated directly into the destination.
break; break;
case TEK_Scalar: { case TEK_Scalar: {
LValueBaseInfo BaseInfo; LValueBaseInfo BaseInfo;
TBAAAccessInfo TBAAInfo; TBAAAccessInfo TBAAInfo;
CharUnits Alignment = CharUnits Alignment =
CGM.getNaturalTypeAlignment(RetTy, &BaseInfo, &TBAAInfo); CGM.getNaturalTypeAlignment(RetTy, &BaseInfo, &TBAAInfo);
Address ArgAddr(&*AI, ConvertType(RetTy), Alignment); Address ArgAddr(&*AI, ConvertType(RetTy), Alignment);
LValue ArgVal = LValue ArgVal =
▲ Show 20 Lines • Show All 2,096 Lines • Show Last 20 Lines

clang/lib/CodeGen/CGOpenMPRuntime.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 4,649 Lines • ▼ Show 20 Lines for (const Expr *E : Data.DepExprs) {
} }
} }
} }
SmallVector<llvm::Value *, 4> CGOpenMPRuntime::emitDepobjElementsSizes( SmallVector<llvm::Value *, 4> CGOpenMPRuntime::emitDepobjElementsSizes(
CodeGenFunction &CGF, QualType &KmpDependInfoTy, CodeGenFunction &CGF, QualType &KmpDependInfoTy,
const OMPTaskDataTy::DependData &Data) { const OMPTaskDataTy::DependData &Data) {
assert(Data.DepKind == OMPC_DEPEND_depobj && assert(Data.DepKind == OMPC_DEPEND_depobj &&
"Expected depobj dependecy kind."); "Expected depobj dependency kind.");
SmallVector<llvm::Value *, 4> Sizes; SmallVector<llvm::Value *, 4> Sizes;
SmallVector<LValue, 4> SizeLVals; SmallVector<LValue, 4> SizeLVals;
ASTContext &C = CGF.getContext(); ASTContext &C = CGF.getContext();
{ {
OMPIteratorGeneratorScope IteratorScope( OMPIteratorGeneratorScope IteratorScope(
CGF, cast_or_null<OMPIteratorExpr>( CGF, cast_or_null<OMPIteratorExpr>(
Data.IteratorExpr ? Data.IteratorExpr->IgnoreParenImpCasts() Data.IteratorExpr ? Data.IteratorExpr->IgnoreParenImpCasts()
: nullptr)); : nullptr));
Show All 23 Lines
} }
void CGOpenMPRuntime::emitDepobjElements(CodeGenFunction &CGF, void CGOpenMPRuntime::emitDepobjElements(CodeGenFunction &CGF,
QualType &KmpDependInfoTy, QualType &KmpDependInfoTy,
LValue PosLVal, LValue PosLVal,
const OMPTaskDataTy::DependData &Data, const OMPTaskDataTy::DependData &Data,
Address DependenciesArray) { Address DependenciesArray) {
assert(Data.DepKind == OMPC_DEPEND_depobj && assert(Data.DepKind == OMPC_DEPEND_depobj &&
"Expected depobj dependecy kind."); "Expected depobj dependency kind.");
llvm::Value *ElSize = CGF.getTypeSize(KmpDependInfoTy); llvm::Value *ElSize = CGF.getTypeSize(KmpDependInfoTy);
{ {
OMPIteratorGeneratorScope IteratorScope( OMPIteratorGeneratorScope IteratorScope(
CGF, cast_or_null<OMPIteratorExpr>( CGF, cast_or_null<OMPIteratorExpr>(
Data.IteratorExpr ? Data.IteratorExpr->IgnoreParenImpCasts() Data.IteratorExpr ? Data.IteratorExpr->IgnoreParenImpCasts()
: nullptr)); : nullptr));
for (unsigned I = 0, End = Data.DepExprs.size(); I < End; ++I) { for (unsigned I = 0, End = Data.DepExprs.size(); I < End; ++I) {
const Expr *E = Data.DepExprs[I]; const Expr *E = Data.DepExprs[I];
Show All 39 Lines unsigned NumDependencies = std::accumulate(
}); });
QualType FlagsTy; QualType FlagsTy;
getDependTypes(C, KmpDependInfoTy, FlagsTy); getDependTypes(C, KmpDependInfoTy, FlagsTy);
bool HasDepobjDeps = false; bool HasDepobjDeps = false;
bool HasRegularWithIterators = false; bool HasRegularWithIterators = false;
llvm::Value *NumOfDepobjElements = llvm::ConstantInt::get(CGF.IntPtrTy, 0); llvm::Value *NumOfDepobjElements = llvm::ConstantInt::get(CGF.IntPtrTy, 0);
llvm::Value *NumOfRegularWithIterators = llvm::Value *NumOfRegularWithIterators =
llvm::ConstantInt::get(CGF.IntPtrTy, 0); llvm::ConstantInt::get(CGF.IntPtrTy, 0);
// Calculate number of depobj dependecies and regular deps with the iterators. // Calculate number of depobj dependencies and regular deps with the
// iterators.
for (const OMPTaskDataTy::DependData &D : Dependencies) { for (const OMPTaskDataTy::DependData &D : Dependencies) {
if (D.DepKind == OMPC_DEPEND_depobj) { if (D.DepKind == OMPC_DEPEND_depobj) {
SmallVector<llvm::Value *, 4> Sizes = SmallVector<llvm::Value *, 4> Sizes =
emitDepobjElementsSizes(CGF, KmpDependInfoTy, D); emitDepobjElementsSizes(CGF, KmpDependInfoTy, D);
for (llvm::Value *Size : Sizes) { for (llvm::Value *Size : Sizes) {
NumOfDepobjElements = NumOfDepobjElements =
CGF.Builder.CreateNUWAdd(NumOfDepobjElements, Size); CGF.Builder.CreateNUWAdd(NumOfDepobjElements, Size);
} }
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Linesstd::pair<llvm::Value *, Address> CGOpenMPRuntime::emitDependClause(
unsigned Pos = 0; unsigned Pos = 0;
for (unsigned I = 0, End = Dependencies.size(); I < End; ++I) { for (unsigned I = 0, End = Dependencies.size(); I < End; ++I) {
if (Dependencies[I].DepKind == OMPC_DEPEND_depobj || if (Dependencies[I].DepKind == OMPC_DEPEND_depobj ||
Dependencies[I].IteratorExpr) Dependencies[I].IteratorExpr)
continue; continue;
emitDependData(CGF, KmpDependInfoTy, &Pos, Dependencies[I], emitDependData(CGF, KmpDependInfoTy, &Pos, Dependencies[I],
DependenciesArray); DependenciesArray);
} }
// Copy regular dependecies with iterators. // Copy regular dependencies with iterators.
LValue PosLVal = CGF.MakeAddrLValue( LValue PosLVal = CGF.MakeAddrLValue(
CGF.CreateMemTemp(C.getSizeType(), "dep.counter.addr"), C.getSizeType()); CGF.CreateMemTemp(C.getSizeType(), "dep.counter.addr"), C.getSizeType());
CGF.EmitStoreOfScalar(llvm::ConstantInt::get(CGF.SizeTy, Pos), PosLVal); CGF.EmitStoreOfScalar(llvm::ConstantInt::get(CGF.SizeTy, Pos), PosLVal);
for (unsigned I = 0, End = Dependencies.size(); I < End; ++I) { for (unsigned I = 0, End = Dependencies.size(); I < End; ++I) {
if (Dependencies[I].DepKind == OMPC_DEPEND_depobj || if (Dependencies[I].DepKind == OMPC_DEPEND_depobj ||
!Dependencies[I].IteratorExpr) !Dependencies[I].IteratorExpr)
continue; continue;
emitDependData(CGF, KmpDependInfoTy, &PosLVal, Dependencies[I], emitDependData(CGF, KmpDependInfoTy, &PosLVal, Dependencies[I],
▲ Show 20 Lines • Show All 8,236 Lines • Show Last 20 Lines

clang/lib/CodeGen/CGOpenMPRuntimeGPU.cpp

Show First 20 Lines • Show All 1,162 Lines • ▼ Show 20 Lines else
emitNonSPMDKernel(D, ParentName, OutlinedFn, OutlinedFnID, IsOffloadEntry, emitNonSPMDKernel(D, ParentName, OutlinedFn, OutlinedFnID, IsOffloadEntry,
CodeGen); CodeGen);
setPropertyExecutionMode(CGM, OutlinedFn->getName(), Mode); setPropertyExecutionMode(CGM, OutlinedFn->getName(), Mode);
} }
namespace { namespace {
LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE(); LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
/// Enum for accesseing the reserved_2 field of the ident_t struct. /// Enum for accessing the reserved_2 field of the ident_t struct.
enum ModeFlagsTy : unsigned { enum ModeFlagsTy : unsigned {
/// Bit set to 1 when in SPMD mode. /// Bit set to 1 when in SPMD mode.
KMP_IDENT_SPMD_MODE = 0x01, KMP_IDENT_SPMD_MODE = 0x01,
/// Bit set to 1 when a simplified runtime is used. /// Bit set to 1 when a simplified runtime is used.
KMP_IDENT_SIMPLE_RT_MODE = 0x02, KMP_IDENT_SIMPLE_RT_MODE = 0x02,
LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/KMP_IDENT_SIMPLE_RT_MODE) LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/KMP_IDENT_SIMPLE_RT_MODE)
}; };
▲ Show 20 Lines • Show All 2,849 Lines • Show Last 20 Lines

clang/lib/CrossTU/CrossTranslationUnit.cpp

Show First 20 Lines • Show All 452 Lines • ▼ Show 20 Lines if (llvm::Error IndexLoadError =
return std::move(IndexLoadError); return std::move(IndexLoadError);
// Check if there is an entry in the index for the function. // Check if there is an entry in the index for the function.
if (!NameFileMap.count(FunctionName)) { if (!NameFileMap.count(FunctionName)) {
++NumNotInOtherTU; ++NumNotInOtherTU;
return llvm::make_error<IndexError>(index_error_code::missing_definition); return llvm::make_error<IndexError>(index_error_code::missing_definition);
} }
// Search in the index for the filename where the definition of FuncitonName // Search in the index for the filename where the definition of FunctionName
// resides. // resides.
if (llvm::Expected<ASTUnit *> FoundForFile = if (llvm::Expected<ASTUnit *> FoundForFile =
getASTUnitForFile(NameFileMap[FunctionName], DisplayCTUProgress)) { getASTUnitForFile(NameFileMap[FunctionName], DisplayCTUProgress)) {
// Update the cache. // Update the cache.
NameASTUnitMap[FunctionName] = *FoundForFile; NameASTUnitMap[FunctionName] = *FoundForFile;
return *FoundForFile; return *FoundForFile;
▲ Show 20 Lines • Show All 348 Lines • Show Last 20 Lines

clang/lib/Driver/ToolChains/Clang.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 5,980 Lines • ▼ Show 20 Lines if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
assert(A->getOption().matches(options::OPT_fvisibility_ms_compat)); assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
CmdArgs.push_back("-fvisibility"); CmdArgs.push_back("-fvisibility");
CmdArgs.push_back("hidden"); CmdArgs.push_back("hidden");
CmdArgs.push_back("-ftype-visibility"); CmdArgs.push_back("-ftype-visibility");
CmdArgs.push_back("default"); CmdArgs.push_back("default");
} }
} else if (IsOpenMPDevice) { } else if (IsOpenMPDevice) {
// When compiling for the OpenMP device we want protected visibility by // When compiling for the OpenMP device we want protected visibility by
// default. This prevents the device from accidenally preempting code on the // default. This prevents the device from accidentally preempting code on
// host, makes the system more robust, and improves performance. // the host, makes the system more robust, and improves performance.
CmdArgs.push_back("-fvisibility"); CmdArgs.push_back("-fvisibility");
CmdArgs.push_back("protected"); CmdArgs.push_back("protected");
} }
if (!RawTriple.isPS4()) if (!RawTriple.isPS4())
if (const Arg *A = if (const Arg *A =
Args.getLastArg(options::OPT_fvisibility_from_dllstorageclass, Args.getLastArg(options::OPT_fvisibility_from_dllstorageclass,
options::OPT_fno_visibility_from_dllstorageclass)) { options::OPT_fno_visibility_from_dllstorageclass)) {
▲ Show 20 Lines • Show All 2,526 Lines • Show Last 20 Lines

clang/lib/ExtractAPI/Serialization/SymbolGraphSerializer.cpp

Show First 20 Lines • Show All 140 Lines • ▼ Show 20 Lines
/// i.e. \c __attribute__((unavailable)) and \c __attribute__((deprecated)). /// i.e. \c __attribute__((unavailable)) and \c __attribute__((deprecated)).
/// ///
/// \returns \c None if the symbol has default availability attributes, or /// \returns \c None if the symbol has default availability attributes, or
/// an \c Object containing the formatted availability information. /// an \c Object containing the formatted availability information.
Optional<Object> serializeAvailability(const AvailabilityInfo &Avail) { Optional<Object> serializeAvailability(const AvailabilityInfo &Avail) {
if (Avail.isDefault()) if (Avail.isDefault())
return None; return None;
Object Availbility; Object Availability;
serializeObject(Availbility, "introducedVersion", serializeObject(Availability, "introducedVersion",
serializeSemanticVersion(Avail.Introduced)); serializeSemanticVersion(Avail.Introduced));
serializeObject(Availbility, "deprecatedVersion", serializeObject(Availability, "deprecatedVersion",
serializeSemanticVersion(Avail.Deprecated)); serializeSemanticVersion(Avail.Deprecated));
serializeObject(Availbility, "obsoletedVersion", serializeObject(Availability, "obsoletedVersion",
serializeSemanticVersion(Avail.Obsoleted)); serializeSemanticVersion(Avail.Obsoleted));
if (Avail.isUnavailable()) if (Avail.isUnavailable())
Availbility["isUnconditionallyUnavailable"] = true; Availability["isUnconditionallyUnavailable"] = true;
if (Avail.isUnconditionallyDeprecated()) if (Avail.isUnconditionallyDeprecated())
Availbility["isUnconditionallyDeprecated"] = true; Availability["isUnconditionallyDeprecated"] = true;
return Availbility; return Availability;
} }
/// Get the language name string for interface language references. /// Get the language name string for interface language references.
StringRef getLanguageName(Language Lang) { StringRef getLanguageName(Language Lang) {
switch (Lang) { switch (Lang) {
case Language::C: case Language::C:
return "c"; return "c";
case Language::ObjC: case Language::ObjC:
▲ Show 20 Lines • Show All 544 Lines • Show Last 20 Lines

clang/lib/Format/UnwrappedLineParser.h

Show First 20 Lines • Show All 202 Lines • ▼ Show 20 Linesprivate:
// should be added as comments before the next token. // should be added as comments before the next token.
// //
// Comments specifies the sequence of comment tokens to analyze. They get // Comments specifies the sequence of comment tokens to analyze. They get
// either pushed to the current line or added to the comments before the next // either pushed to the current line or added to the comments before the next
// token. // token.
// //
// NextTok specifies the next token. A null pointer NextTok is supported, and // NextTok specifies the next token. A null pointer NextTok is supported, and
// signifies either the absence of a next token, or that the next token // signifies either the absence of a next token, or that the next token
// shouldn't be taken into accunt for the analysis. // shouldn't be taken into account for the analysis.
void distributeComments(const SmallVectorImpl<FormatToken *> &Comments, void distributeComments(const SmallVectorImpl<FormatToken *> &Comments,
const FormatToken *NextTok); const FormatToken *NextTok);
// Adds the comment preceding the next token to unwrapped lines. // Adds the comment preceding the next token to unwrapped lines.
void flushComments(bool NewlineBeforeNext); void flushComments(bool NewlineBeforeNext);
void pushToken(FormatToken *Tok); void pushToken(FormatToken *Tok);
void calculateBraceTypes(bool ExpectClassBody = false); void calculateBraceTypes(bool ExpectClassBody = false);
▲ Show 20 Lines • Show All 143 Lines • Show Last 20 Lines

clang/lib/Frontend/Rewrite/RewriteModernObjC.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 6,717 Lines • ▼ Show 20 Linesstatic void Write__extendedMethodTypes_initializer(RewriteModernObjC &RewriteObj,
} }
} }
static void Write_IvarOffsetVar(RewriteModernObjC &RewriteObj, static void Write_IvarOffsetVar(RewriteModernObjC &RewriteObj,
ASTContext *Context, ASTContext *Context,
std::string &Result, std::string &Result,
ArrayRef<ObjCIvarDecl *> Ivars, ArrayRef<ObjCIvarDecl *> Ivars,
ObjCInterfaceDecl *CDecl) { ObjCInterfaceDecl *CDecl) {
// FIXME. visibilty of offset symbols may have to be set; for Darwin // FIXME. visibility of offset symbols may have to be set; for Darwin
// this is what happens: // this is what happens:
/** /**
if (Ivar->getAccessControl() == ObjCIvarDecl::Private || if (Ivar->getAccessControl() == ObjCIvarDecl::Private ||
Ivar->getAccessControl() == ObjCIvarDecl::Package || Ivar->getAccessControl() == ObjCIvarDecl::Package ||
Class->getVisibility() == HiddenVisibility) Class->getVisibility() == HiddenVisibility)
Visibility should be: HiddenVisibility; Visibility should be: HiddenVisibility;
else else
Visibility should be: DefaultVisibility; Visibility should be: DefaultVisibility;
▲ Show 20 Lines • Show All 835 Lines • Show Last 20 Lines

clang/lib/Headers/arm_acle.h

Show First 20 Lines • Show All 271 Lines • ▼ Show 20 Lines
__smulwt(int32_t __a, int32_t __b) { __smulwt(int32_t __a, int32_t __b) {
return __builtin_arm_smulwt(__a, __b); return __builtin_arm_smulwt(__a, __b);
} }
#endif #endif
/* /*
* 9.4 Saturating intrinsics * 9.4 Saturating intrinsics
* *
* FIXME: Change guard to their corrosponding __ARM_FEATURE flag when Q flag * FIXME: Change guard to their corresponding __ARM_FEATURE flag when Q flag
* intrinsics are implemented and the flag is enabled. * intrinsics are implemented and the flag is enabled.
*/ */
/* 9.4.1 Width-specified saturation intrinsics */ /* 9.4.1 Width-specified saturation intrinsics */
#if __ARM_FEATURE_SAT #if __ARM_FEATURE_SAT
#define __ssat(x, y) __builtin_arm_ssat(x, y) #define __ssat(x, y) __builtin_arm_ssat(x, y)
#define __usat(x, y) __builtin_arm_usat(x, y) #define __usat(x, y) __builtin_arm_usat(x, y)
#endif #endif
▲ Show 20 Lines • Show All 489 Lines • Show Last 20 Lines

clang/lib/Headers/opencl-c.h

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 17,841 Lines • ▼ Show 20 Lines
intel_sub_group_avc_sic_payload_t __ovld intel_sub_group_avc_sic_payload_t __ovld
intel_sub_group_avc_sic_initialize( intel_sub_group_avc_sic_initialize(
ushort2 src_coord); ushort2 src_coord);
intel_sub_group_avc_sic_payload_t __ovld intel_sub_group_avc_sic_payload_t __ovld
intel_sub_group_avc_sic_configure_skc( intel_sub_group_avc_sic_configure_skc(
uint skip_block_partition_type, uint skip_motion_vector_mask, uint skip_block_partition_type, uint skip_motion_vector_mask,
ulong motion_vectors, uchar bidirectional_weight, uchar skip_sad_adjustment, ulong motion_vectors, uchar bidirectional_weight, uchar skip_sad_adjustment,
intel_sub_group_avc_sic_payload_t payload); intel_sub_group_avc_sic_payload_t payload);
intel_sub_group_avc_sic_payload_t __ovld intel_sub_group_avc_sic_payload_t __ovld intel_sub_group_avc_sic_configure_ipe(
intel_sub_group_avc_sic_configure_ipe( uchar luma_intra_partition_mask, uchar intra_neighbour_availability,
uchar luma_intra_partition_mask, uchar intra_neighbour_availabilty,
uchar left_edge_luma_pixels, uchar upper_left_corner_luma_pixel, uchar left_edge_luma_pixels, uchar upper_left_corner_luma_pixel,
uchar upper_edge_luma_pixels, uchar upper_right_edge_luma_pixels, uchar upper_edge_luma_pixels, uchar upper_right_edge_luma_pixels,
uchar intra_sad_adjustment, intel_sub_group_avc_sic_payload_t payload); uchar intra_sad_adjustment, intel_sub_group_avc_sic_payload_t payload);
intel_sub_group_avc_sic_payload_t __ovld intel_sub_group_avc_sic_payload_t __ovld intel_sub_group_avc_sic_configure_ipe(
intel_sub_group_avc_sic_configure_ipe( uchar luma_intra_partition_mask, uchar intra_neighbour_availability,
uchar luma_intra_partition_mask, uchar intra_neighbour_availabilty,
uchar left_edge_luma_pixels, uchar upper_left_corner_luma_pixel, uchar left_edge_luma_pixels, uchar upper_left_corner_luma_pixel,
uchar upper_edge_luma_pixels, uchar upper_right_edge_luma_pixels, uchar upper_edge_luma_pixels, uchar upper_right_edge_luma_pixels,
ushort left_edge_chroma_pixels, ushort upper_left_corner_chroma_pixel, ushort left_edge_chroma_pixels, ushort upper_left_corner_chroma_pixel,
ushort upper_edge_chroma_pixels, uchar intra_sad_adjustment, ushort upper_edge_chroma_pixels, uchar intra_sad_adjustment,
intel_sub_group_avc_sic_payload_t payload); intel_sub_group_avc_sic_payload_t payload);
uint __ovld uint __ovld
intel_sub_group_avc_sic_get_motion_vector_mask( intel_sub_group_avc_sic_get_motion_vector_mask(
uint skip_block_partition_type, uchar direction); uint skip_block_partition_type, uchar direction);
▲ Show 20 Lines • Show All 460 Lines • Show Last 20 Lines

clang/lib/Lex/Lexer.cpp

Show First 20 Lines • Show All 3,362 Lines • ▼ Show 20 Lines if (!isLexingRawMode()) {
makeCharRange(*this, StartName, CurPtr - CharSize), makeCharRange(*this, StartName, CurPtr - CharSize),
LooseMatch->Name); LooseMatch->Name);
} }
} }
// When finding a match using Unicode loose matching rules // When finding a match using Unicode loose matching rules
// recover after having emitted a diagnostic. // recover after having emitted a diagnostic.
if (!LooseMatch) if (!LooseMatch)
return llvm::None; return llvm::None;
// We do not offer missspelled character names suggestions here // We do not offer misspelled character names suggestions here
// as the set of what would be a valid suggestion depends on context, // as the set of what would be a valid suggestion depends on context,
// and we should not make invalid suggestions. // and we should not make invalid suggestions.
} }
if (Diagnose && PP && !LooseMatch) if (Diagnose && PP && !LooseMatch)
Diag(BufferPtr, PP->getLangOpts().CPlusPlus2b Diag(BufferPtr, PP->getLangOpts().CPlusPlus2b
? diag::warn_cxx2b_delimited_escape_sequence ? diag::warn_cxx2b_delimited_escape_sequence
: diag::ext_delimited_escape_sequence) : diag::ext_delimited_escape_sequence)
▲ Show 20 Lines • Show All 1,056 Lines • Show Last 20 Lines

clang/lib/Parse/ParseStmt.cpp

Show First 20 Lines • Show All 950 Lines • ▼ Show 20 Lines
/// [GNU] label-declaration /// [GNU] label-declaration
/// [GNU] label-declarations label-declaration /// [GNU] label-declarations label-declaration
/// ///
/// [GNU] label-declaration: /// [GNU] label-declaration:
/// [GNU] '__label__' identifier-list ';' /// [GNU] '__label__' identifier-list ';'
/// ///
StmtResult Parser::ParseCompoundStatement(bool isStmtExpr, StmtResult Parser::ParseCompoundStatement(bool isStmtExpr,
unsigned ScopeFlags) { unsigned ScopeFlags) {
assert(Tok.is(tok::l_brace) && "Not a compount stmt!"); assert(Tok.is(tok::l_brace) && "Not a compound stmt!");
// Enter a scope to hold everything within the compound stmt. Compound // Enter a scope to hold everything within the compound stmt. Compound
// statements can always hold declarations. // statements can always hold declarations.
ParseScope CompoundScope(this, ScopeFlags); ParseScope CompoundScope(this, ScopeFlags);
// Parse the statements in the body. // Parse the statements in the body.
return ParseCompoundStatementBody(isStmtExpr); return ParseCompoundStatementBody(isStmtExpr);
} }
▲ Show 20 Lines • Show All 1,750 Lines • Show Last 20 Lines

clang/lib/Sema/SemaCodeComplete.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 1,206 Lines • ▼ Show 20 Lines
static void setInBaseClass(ResultBuilder::Result &R) { static void setInBaseClass(ResultBuilder::Result &R) {
R.Priority += CCD_InBaseClass; R.Priority += CCD_InBaseClass;
R.InBaseClass = true; R.InBaseClass = true;
} }
enum class OverloadCompare { BothViable, Dominates, Dominated }; enum class OverloadCompare { BothViable, Dominates, Dominated };
// Will Candidate ever be called on the object, when overloaded with Incumbent? // Will Candidate ever be called on the object, when overloaded with Incumbent?
// Returns Dominates if Candidate is always called, Dominated if Incumbent is // Returns Dominates if Candidate is always called, Dominated if Incumbent is
// always called, BothViable if either may be called dependending on arguments. // always called, BothViable if either may be called depending on arguments.
// Precondition: must actually be overloads! // Precondition: must actually be overloads!
static OverloadCompare compareOverloads(const CXXMethodDecl &Candidate, static OverloadCompare compareOverloads(const CXXMethodDecl &Candidate,
const CXXMethodDecl &Incumbent, const CXXMethodDecl &Incumbent,
const Qualifiers &ObjectQuals, const Qualifiers &ObjectQuals,
ExprValueKind ObjectKind) { ExprValueKind ObjectKind) {
// Base/derived shadowing is handled elsewhere. // Base/derived shadowing is handled elsewhere.
if (Candidate.getDeclContext() != Incumbent.getDeclContext()) if (Candidate.getDeclContext() != Incumbent.getDeclContext())
return OverloadCompare::BothViable; return OverloadCompare::BothViable;
▲ Show 20 Lines • Show All 8,858 Lines • Show Last 20 Lines

clang/lib/Sema/SemaDecl.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 3,025 Lines • ▼ Show 20 Lines if (isa<C11NoReturnAttr>(NewAttribute)) {
// Don't warn about applying selectany to implicitly inline variables. // Don't warn about applying selectany to implicitly inline variables.
// Older compilers and language modes would require the use of selectany // Older compilers and language modes would require the use of selectany
// to make such variables inline, and it would have no effect if we // to make such variables inline, and it would have no effect if we
// honored it. // honored it.
++I; ++I;
continue; continue;
} else if (isa<OMPDeclareVariantAttr>(NewAttribute)) { } else if (isa<OMPDeclareVariantAttr>(NewAttribute)) {
// We allow to add OMP[Begin]DeclareVariantAttr to be added to // We allow to add OMP[Begin]DeclareVariantAttr to be added to
// declarations after defintions. // declarations after definitions.
++I; ++I;
continue; continue;
} }
S.Diag(NewAttribute->getLocation(), S.Diag(NewAttribute->getLocation(),
diag::warn_attribute_precede_definition); diag::warn_attribute_precede_definition);
S.Diag(Def->getLocation(), diag::note_previous_definition); S.Diag(Def->getLocation(), diag::note_previous_definition);
NewAttributes.erase(NewAttributes.begin() + I); NewAttributes.erase(NewAttributes.begin() + I);
▲ Show 20 Lines • Show All 7,516 Lines • ▼ Show 20 Lines
} }
/// Returns an implicit CodeSegAttr if a __declspec(code_seg) is found on a /// Returns an implicit CodeSegAttr if a __declspec(code_seg) is found on a
/// containing class. Otherwise it will return implicit SectionAttr if the /// containing class. Otherwise it will return implicit SectionAttr if the
/// function is a definition and there is an active value on CodeSegStack /// function is a definition and there is an active value on CodeSegStack
/// (from the current #pragma code-seg value). /// (from the current #pragma code-seg value).
/// ///
/// \param FD Function being declared. /// \param FD Function being declared.
/// \param IsDefinition Whether it is a definition or just a declarartion. /// \param IsDefinition Whether it is a definition or just a declaration.
/// \returns A CodeSegAttr or SectionAttr to apply to the function or /// \returns A CodeSegAttr or SectionAttr to apply to the function or
/// nullptr if no attribute should be added. /// nullptr if no attribute should be added.
Attr *Sema::getImplicitCodeSegOrSectionAttrForFunction(const FunctionDecl *FD, Attr *Sema::getImplicitCodeSegOrSectionAttrForFunction(const FunctionDecl *FD,
bool IsDefinition) { bool IsDefinition) {
if (Attr *A = getImplicitCodeSegAttrFromClass(*this, FD)) if (Attr *A = getImplicitCodeSegAttrFromClass(*this, FD))
return A; return A;
if (!FD->hasAttr<SectionAttr>() && IsDefinition && if (!FD->hasAttr<SectionAttr>() && IsDefinition &&
CodeSegStack.CurrentValue) CodeSegStack.CurrentValue)
▲ Show 20 Lines • Show All 4,906 Lines • ▼ Show 20 Lines else if (getLangOpts().C99)
diag_id = diag::ext_implicit_function_decl_c99; diag_id = diag::ext_implicit_function_decl_c99;
else else
diag_id = diag::warn_implicit_function_decl; diag_id = diag::warn_implicit_function_decl;
TypoCorrection Corrected; TypoCorrection Corrected;
// Because typo correction is expensive, only do it if the implicit // Because typo correction is expensive, only do it if the implicit
// function declaration is going to be treated as an error. // function declaration is going to be treated as an error.
// //
// Perform the corection before issuing the main diagnostic, as some consumers // Perform the correction before issuing the main diagnostic, as some
// use typo-correction callbacks to enhance the main diagnostic. // consumers use typo-correction callbacks to enhance the main diagnostic.
if (S && !ExternCPrev && if (S && !ExternCPrev &&
(Diags.getDiagnosticLevel(diag_id, Loc) >= DiagnosticsEngine::Error)) { (Diags.getDiagnosticLevel(diag_id, Loc) >= DiagnosticsEngine::Error)) {
DeclFilterCCC<FunctionDecl> CCC{}; DeclFilterCCC<FunctionDecl> CCC{};
Corrected = CorrectTypo(DeclarationNameInfo(&II, Loc), LookupOrdinaryName, Corrected = CorrectTypo(DeclarationNameInfo(&II, Loc), LookupOrdinaryName,
S, nullptr, CCC, CTK_NonError); S, nullptr, CCC, CTK_NonError);
} }
Diag(Loc, diag_id) << &II; Diag(Loc, diag_id) << &II;
▲ Show 20 Lines • Show All 3,706 Lines • ▼ Show 20 Linesvoid Sema::ActOnPragmaRedefineExtname(IdentifierInfo* Name,
// 2) has external linkage // 2) has external linkage
// already exists, add a label attribute to it. // already exists, add a label attribute to it.
if (PrevDecl && (isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl))) { if (PrevDecl && (isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl))) {
if (isDeclExternC(PrevDecl)) if (isDeclExternC(PrevDecl))
PrevDecl->addAttr(Attr); PrevDecl->addAttr(Attr);
else else
Diag(PrevDecl->getLocation(), diag::warn_redefine_extname_not_applied) Diag(PrevDecl->getLocation(), diag::warn_redefine_extname_not_applied)
<< /*Variable*/(isa<FunctionDecl>(PrevDecl) ? 0 : 1) << PrevDecl; << /*Variable*/(isa<FunctionDecl>(PrevDecl) ? 0 : 1) << PrevDecl;
// Otherwise, add a label atttibute to ExtnameUndeclaredIdentifiers. // Otherwise, add a label attribute to ExtnameUndeclaredIdentifiers.
} else } else
(void)ExtnameUndeclaredIdentifiers.insert(std::make_pair(Name, Attr)); (void)ExtnameUndeclaredIdentifiers.insert(std::make_pair(Name, Attr));
} }
void Sema::ActOnPragmaWeakID(IdentifierInfo* Name, void Sema::ActOnPragmaWeakID(IdentifierInfo* Name,
SourceLocation PragmaLoc, SourceLocation PragmaLoc,
SourceLocation NameLoc) { SourceLocation NameLoc) {
Decl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc, LookupOrdinaryName); Decl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc, LookupOrdinaryName);
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

clang/lib/Sema/SemaDeclObjC.cpp

Show First 20 Lines • Show All 3,748 Lines • ▼ Show 20 Lines for (unsigned i = 0, e = Methods.size(); i < e; i++) {
HelperSelectorsForTypoCorrection(SelectedMethods, HelperSelectorsForTypoCorrection(SelectedMethods,
Sel.getAsString(), Methods[i]); Sel.getAsString(), Methods[i]);
} }
return (SelectedMethods.size() == 1) ? SelectedMethods[0] : nullptr; return (SelectedMethods.size() == 1) ? SelectedMethods[0] : nullptr;
} }
/// DiagnoseDuplicateIvars - /// DiagnoseDuplicateIvars -
/// Check for duplicate ivars in the entire class at the start of /// Check for duplicate ivars in the entire class at the start of
/// \@implementation. This becomes necesssary because class extension can /// \@implementation. This becomes necessary because class extension can
/// add ivars to a class in random order which will not be known until /// add ivars to a class in random order which will not be known until
/// class's \@implementation is seen. /// class's \@implementation is seen.
void Sema::DiagnoseDuplicateIvars(ObjCInterfaceDecl *ID, void Sema::DiagnoseDuplicateIvars(ObjCInterfaceDecl *ID,
ObjCInterfaceDecl *SID) { ObjCInterfaceDecl *SID) {
for (auto *Ivar : ID->ivars()) { for (auto *Ivar : ID->ivars()) {
if (Ivar->isInvalidDecl()) if (Ivar->isInvalidDecl())
continue; continue;
if (IdentifierInfo *II = Ivar->getIdentifier()) { if (IdentifierInfo *II = Ivar->getIdentifier()) {
▲ Show 20 Lines • Show All 1,595 Lines • Show Last 20 Lines

clang/lib/Sema/SemaOverload.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 12,563 Lines • ▼ Show 20 Lines
/// Given an overloaded function, tries to turn it into a non-overloaded /// Given an overloaded function, tries to turn it into a non-overloaded
/// function reference using resolveAddressOfSingleOverloadCandidate. This /// function reference using resolveAddressOfSingleOverloadCandidate. This
/// will perform access checks, diagnose the use of the resultant decl, and, if /// will perform access checks, diagnose the use of the resultant decl, and, if
/// requested, potentially perform a function-to-pointer decay. /// requested, potentially perform a function-to-pointer decay.
/// ///
/// Returns false if resolveAddressOfSingleOverloadCandidate fails. /// Returns false if resolveAddressOfSingleOverloadCandidate fails.
/// Otherwise, returns true. This may emit diagnostics and return true. /// Otherwise, returns true. This may emit diagnostics and return true.
bool Sema::resolveAndFixAddressOfSingleOverloadCandidate( bool Sema::resolveAndFixAddressOfSingleOverloadCandidate(
ExprResult &SrcExpr, bool DoFunctionPointerConverion) { ExprResult &SrcExpr, bool DoFunctionPointerConversion) {
Expr *E = SrcExpr.get(); Expr *E = SrcExpr.get();
assert(E->getType() == Context.OverloadTy && "SrcExpr must be an overload"); assert(E->getType() == Context.OverloadTy && "SrcExpr must be an overload");
DeclAccessPair DAP; DeclAccessPair DAP;
FunctionDecl *Found = resolveAddressOfSingleOverloadCandidate(E, DAP); FunctionDecl *Found = resolveAddressOfSingleOverloadCandidate(E, DAP);
if (!Found || Found->isCPUDispatchMultiVersion() || if (!Found || Found->isCPUDispatchMultiVersion() ||
Found->isCPUSpecificMultiVersion()) Found->isCPUSpecificMultiVersion())
return false; return false;
// Emitting multiple diagnostics for a function that is both inaccessible and // Emitting multiple diagnostics for a function that is both inaccessible and
// unavailable is consistent with our behavior elsewhere. So, always check // unavailable is consistent with our behavior elsewhere. So, always check
// for both. // for both.
DiagnoseUseOfDecl(Found, E->getExprLoc()); DiagnoseUseOfDecl(Found, E->getExprLoc());
CheckAddressOfMemberAccess(E, DAP); CheckAddressOfMemberAccess(E, DAP);
Expr *Fixed = FixOverloadedFunctionReference(E, DAP, Found); Expr *Fixed = FixOverloadedFunctionReference(E, DAP, Found);
if (DoFunctionPointerConverion && Fixed->getType()->isFunctionType()) if (DoFunctionPointerConversion && Fixed->getType()->isFunctionType())
SrcExpr = DefaultFunctionArrayConversion(Fixed, /*Diagnose=*/false); SrcExpr = DefaultFunctionArrayConversion(Fixed, /*Diagnose=*/false);
else else
SrcExpr = Fixed; SrcExpr = Fixed;
return true; return true;
} }
/// Given an expression that refers to an overloaded function, try to /// Given an expression that refers to an overloaded function, try to
/// resolve that overloaded function expression down to a single function. /// resolve that overloaded function expression down to a single function.
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines
// because it identifies a single function template specialization. // because it identifies a single function template specialization.
// //
// Last three arguments should only be supplied if Complain = true // Last three arguments should only be supplied if Complain = true
// //
// Return true if it was logically possible to so resolve the // Return true if it was logically possible to so resolve the
// expression, regardless of whether or not it succeeded. Always // expression, regardless of whether or not it succeeded. Always
// returns true if 'complain' is set. // returns true if 'complain' is set.
bool Sema::ResolveAndFixSingleFunctionTemplateSpecialization( bool Sema::ResolveAndFixSingleFunctionTemplateSpecialization(
ExprResult &SrcExpr, bool doFunctionPointerConverion, ExprResult &SrcExpr, bool doFunctionPointerConversion, bool complain,
bool complain, SourceRange OpRangeForComplaining, SourceRange OpRangeForComplaining, QualType DestTypeForComplaining,
QualType DestTypeForComplaining,
unsigned DiagIDForComplaining) { unsigned DiagIDForComplaining) {
assert(SrcExpr.get()->getType() == Context.OverloadTy); assert(SrcExpr.get()->getType() == Context.OverloadTy);
OverloadExpr::FindResult ovl = OverloadExpr::find(SrcExpr.get()); OverloadExpr::FindResult ovl = OverloadExpr::find(SrcExpr.get());
DeclAccessPair found; DeclAccessPair found;
ExprResult SingleFunctionExpression; ExprResult SingleFunctionExpression;
if (FunctionDecl *fn = ResolveSingleFunctionTemplateSpecialization( if (FunctionDecl *fn = ResolveSingleFunctionTemplateSpecialization(
ovl.Expression, /*complain*/ false, &found)) { ovl.Expression, /*complain*/ false, &found)) {
Show All 24 Lines if (!ovl.HasFormOfMemberPointer &&
return true; return true;
} }
// Fix the expression to refer to 'fn'. // Fix the expression to refer to 'fn'.
SingleFunctionExpression = SingleFunctionExpression =
FixOverloadedFunctionReference(SrcExpr.get(), found, fn); FixOverloadedFunctionReference(SrcExpr.get(), found, fn);
// If desired, do function-to-pointer decay. // If desired, do function-to-pointer decay.
if (doFunctionPointerConverion) { if (doFunctionPointerConversion) {
SingleFunctionExpression = SingleFunctionExpression =
DefaultFunctionArrayLvalueConversion(SingleFunctionExpression.get()); DefaultFunctionArrayLvalueConversion(SingleFunctionExpression.get());
if (SingleFunctionExpression.isInvalid()) { if (SingleFunctionExpression.isInvalid()) {
SrcExpr = ExprError(); SrcExpr = ExprError();
return true; return true;
} }
} }
} }
▲ Show 20 Lines • Show All 2,648 Lines • Show Last 20 Lines

clang/lib/StaticAnalyzer/Core/ExprEngine.cpp

Show First 20 Lines • Show All 181 Lines • ▼ Show 20 Lines
typedef llvm::ImmutableMap<ConstructedObjectKey, SVal> typedef llvm::ImmutableMap<ConstructedObjectKey, SVal>
ObjectsUnderConstructionMap; ObjectsUnderConstructionMap;
REGISTER_TRAIT_WITH_PROGRAMSTATE(ObjectsUnderConstruction, REGISTER_TRAIT_WITH_PROGRAMSTATE(ObjectsUnderConstruction,
ObjectsUnderConstructionMap) ObjectsUnderConstructionMap)
// This trait is responsible for storing the index of the element that is to be // This trait is responsible for storing the index of the element that is to be
// constructed in the next iteration. As a result a CXXConstructExpr is only // constructed in the next iteration. As a result a CXXConstructExpr is only
// stored if it is array type. Also the index is the index of the continous // stored if it is array type. Also the index is the index of the continuous
// memory region, which is important for multi-dimensional arrays. E.g:: int // memory region, which is important for multi-dimensional arrays. E.g:: int
// arr[2][2]; assume arr[1][1] will be the next element under construction, so // arr[2][2]; assume arr[1][1] will be the next element under construction, so
// the index is 3. // the index is 3.
typedef llvm::ImmutableMap< typedef llvm::ImmutableMap<
std::pair<const CXXConstructExpr *, const LocationContext *>, unsigned> std::pair<const CXXConstructExpr *, const LocationContext *>, unsigned>
IndexOfElementToConstructMap; IndexOfElementToConstructMap;
REGISTER_TRAIT_WITH_PROGRAMSTATE(IndexOfElementToConstruct, REGISTER_TRAIT_WITH_PROGRAMSTATE(IndexOfElementToConstruct,
IndexOfElementToConstructMap) IndexOfElementToConstructMap)
▲ Show 20 Lines • Show All 3,402 Lines • Show Last 20 Lines

clang/lib/Tooling/AllTUsExecution.cpp

Show First 20 Lines • Show All 115 Lines • ▼ Show 20 Linesllvm::Error AllTUsToolExecutor::execute(
{ {
llvm::ThreadPool Pool(llvm::hardware_concurrency(ThreadCount)); llvm::ThreadPool Pool(llvm::hardware_concurrency(ThreadCount));
for (std::string File : Files) { for (std::string File : Files) {
Pool.async( Pool.async(
[&](std::string Path) { [&](std::string Path) {
Log("[" + std::to_string(Count()) + "/" + TotalNumStr + Log("[" + std::to_string(Count()) + "/" + TotalNumStr +
"] Processing file " + Path); "] Processing file " + Path);
// Each thread gets an indepent copy of a VFS to allow different // Each thread gets an independent copy of a VFS to allow different
// concurrent working directories. // concurrent working directories.
IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS = IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS =
llvm::vfs::createPhysicalFileSystem(); llvm::vfs::createPhysicalFileSystem();
ClangTool Tool(Compilations, {Path}, ClangTool Tool(Compilations, {Path},
std::make_shared<PCHContainerOperations>(), FS); std::make_shared<PCHContainerOperations>(), FS);
Tool.appendArgumentsAdjuster(Action.second); Tool.appendArgumentsAdjuster(Action.second);
Tool.appendArgumentsAdjuster(getDefaultArgumentsAdjusters()); Tool.appendArgumentsAdjuster(getDefaultArgumentsAdjusters());
for (const auto &FileAndContent : OverlayFiles) for (const auto &FileAndContent : OverlayFiles)
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

clang/lib/Tooling/Core/Replacement.cpp

Show First 20 Lines • Show All 264 Lines • ▼ Show 20 Linesllvm::Error Replacements::add(const Replacement &R) {
// entries that start at the end can still be conflicting if R is an // entries that start at the end can still be conflicting if R is an
// insertion. // insertion.
auto I = Replaces.lower_bound(AtEnd); auto I = Replaces.lower_bound(AtEnd);
// If `I` starts at the same offset as `R`, `R` must be an insertion. // If `I` starts at the same offset as `R`, `R` must be an insertion.
if (I != Replaces.end() && R.getOffset() == I->getOffset()) { if (I != Replaces.end() && R.getOffset() == I->getOffset()) {
assert(R.getLength() == 0); assert(R.getLength() == 0);
// `I` is also an insertion, `R` and `I` conflict. // `I` is also an insertion, `R` and `I` conflict.
if (I->getLength() == 0) { if (I->getLength() == 0) {
// Check if two insertions are order-indepedent: if inserting them in // Check if two insertions are order-independent: if inserting them in
// either order produces the same text, they are order-independent. // either order produces the same text, they are order-independent.
if ((R.getReplacementText() + I->getReplacementText()).str() != if ((R.getReplacementText() + I->getReplacementText()).str() !=
(I->getReplacementText() + R.getReplacementText()).str()) (I->getReplacementText() + R.getReplacementText()).str())
return llvm::make_error<ReplacementError>( return llvm::make_error<ReplacementError>(
replacement_error::insert_conflict, R, *I); replacement_error::insert_conflict, R, *I);
// If insertions are order-independent, we can merge them. // If insertions are order-independent, we can merge them.
Replacement NewR( Replacement NewR(
R.getFilePath(), R.getOffset(), 0, R.getFilePath(), R.getOffset(), 0,
Show All 32 Lines if (!Overlap(R, *I)) {
// - If `R` is an insertion, `I` must not be an insertion since it would // - If `R` is an insertion, `I` must not be an insertion since it would
// have come after `AtEnd`. // have come after `AtEnd`.
// - If `R` is not an insertion, `I` must be an insertion; otherwise, `R` // - If `R` is not an insertion, `I` must be an insertion; otherwise, `R`
// and `I` would have overlapped. // and `I` would have overlapped.
// In either case, we can safely insert `R`. // In either case, we can safely insert `R`.
Replaces.insert(R); Replaces.insert(R);
} else { } else {
// `I` overlaps with `R`. We need to check `R` against all overlapping // `I` overlaps with `R`. We need to check `R` against all overlapping
// replacements to see if they are order-indepedent. If they are, merge `R` // replacements to see if they are order-independent. If they are, merge `R`
// with them and replace them with the merged replacements. // with them and replace them with the merged replacements.
auto MergeBegin = I; auto MergeBegin = I;
auto MergeEnd = std::next(I); auto MergeEnd = std::next(I);
while (I != Replaces.begin()) { while (I != Replaces.begin()) {
--I; --I;
// If `I` doesn't overlap with `R`, don't merge it. // If `I` doesn't overlap with `R`, don't merge it.
if (!Overlap(R, *I)) if (!Overlap(R, *I))
break; break;
▲ Show 20 Lines • Show All 297 Lines • Show Last 20 Lines

clang/lib/Tooling/Syntax/Tokens.cpp

Show First 20 Lines • Show All 745 Lines • ▼ Show 20 Lines while (NextSpelled < SpelledTokens.size() &&
SourceLocation KnownEnd = SourceLocation KnownEnd =
CollectedExpansions.lookup(SpelledTokens[NextSpelled].location()); CollectedExpansions.lookup(SpelledTokens[NextSpelled].location());
if (KnownEnd.isValid()) { if (KnownEnd.isValid()) {
FlushMapping(); // Emits [Start, NextSpelled) FlushMapping(); // Emits [Start, NextSpelled)
while (NextSpelled < SpelledTokens.size() && while (NextSpelled < SpelledTokens.size() &&
SpelledTokens[NextSpelled].location() <= KnownEnd) SpelledTokens[NextSpelled].location() <= KnownEnd)
++NextSpelled; ++NextSpelled;
FlushMapping(); // Emits [NextSpelled, KnownEnd] FlushMapping(); // Emits [NextSpelled, KnownEnd]
// Now the loop contitues and will emit (KnownEnd, Target). // Now the loop continues and will emit (KnownEnd, Target).
} else { } else {
++NextSpelled; ++NextSpelled;
} }
} }
FlushMapping(); FlushMapping();
} }
// Consumes the NextExpanded token and others that are part of the same run. // Consumes the NextExpanded token and others that are part of the same run.
▲ Show 20 Lines • Show All 169 Lines • Show Last 20 Lines

clang/test/CodeGen/vectorcall.c

Show First 20 Lines • Show All 104 Lines • ▼ Show 20 Lines
// x86 should pass p2, p6 and p7 in registers, then p1 in the second pass. // x86 should pass p2, p6 and p7 in registers, then p1 in the second pass.
struct HFA2 __vectorcall AddParticles(struct HFA2 p1, float p2, struct HFA4 p3, int p4, struct HFA2 p5, float p6, float p7, int p8){ return p1;} struct HFA2 __vectorcall AddParticles(struct HFA2 p1, float p2, struct HFA4 p3, int p4, struct HFA2 p5, float p6, float p7, int p8){ return p1;}
// X32: define dso_local x86_vectorcallcc %struct.HFA2 @"\01AddParticles@@84"(%struct.HFA2 inreg %p1.coerce, float inreg noundef %p2, %struct.HFA4* inreg noundef %p3, i32 inreg noundef %p4, %struct.HFA2* noundef %p5, float inreg noundef %p6, float inreg noundef %p7, i32 noundef %p8) // X32: define dso_local x86_vectorcallcc %struct.HFA2 @"\01AddParticles@@84"(%struct.HFA2 inreg %p1.coerce, float inreg noundef %p2, %struct.HFA4* inreg noundef %p3, i32 inreg noundef %p4, %struct.HFA2* noundef %p5, float inreg noundef %p6, float inreg noundef %p7, i32 noundef %p8)
// X64: define dso_local x86_vectorcallcc %struct.HFA2 @"\01AddParticles@@104"(%struct.HFA2 inreg %p1.coerce, float noundef %p2, %struct.HFA4* noundef %p3, i32 noundef %p4, %struct.HFA2 inreg %p5.coerce, float noundef %p6, float noundef %p7, i32 noundef %p8) // X64: define dso_local x86_vectorcallcc %struct.HFA2 @"\01AddParticles@@104"(%struct.HFA2 inreg %p1.coerce, float noundef %p2, %struct.HFA4* noundef %p3, i32 noundef %p4, %struct.HFA2 inreg %p5.coerce, float noundef %p6, float noundef %p7, i32 noundef %p8)
// Vectorcall in both architectures allows passing of an HVA as long as there is room, // Vectorcall in both architectures allows passing of an HVA as long as there is room,
// even if it is not one of the first 6 arguments. First pass puts p4 into a // even if it is not one of the first 6 arguments. First pass puts p4 into a
// register on both. p9 ends up in a register in x86 only. Second pass puts p1 // register on both. p9 ends up in a register in x86 only. Second pass puts p1
// in a register, does NOT put p7 in a register (since theres no room), then puts // in a register, does NOT put p7 in a register (since there's no room), then puts
// p8 in a register. // p8 in a register.
void __vectorcall HVAAnywhere(struct HFA2 p1, int p2, int p3, float p4, int p5, int p6, struct HFA4 p7, struct HFA2 p8, float p9){} void __vectorcall HVAAnywhere(struct HFA2 p1, int p2, int p3, float p4, int p5, int p6, struct HFA4 p7, struct HFA2 p8, float p9){}
// X32: define dso_local x86_vectorcallcc void @"\01HVAAnywhere@@88"(%struct.HFA2 inreg %p1.coerce, i32 inreg noundef %p2, i32 inreg noundef %p3, float inreg noundef %p4, i32 noundef %p5, i32 noundef %p6, %struct.HFA4* noundef %p7, %struct.HFA2 inreg %p8.coerce, float inreg noundef %p9) // X32: define dso_local x86_vectorcallcc void @"\01HVAAnywhere@@88"(%struct.HFA2 inreg %p1.coerce, i32 inreg noundef %p2, i32 inreg noundef %p3, float inreg noundef %p4, i32 noundef %p5, i32 noundef %p6, %struct.HFA4* noundef %p7, %struct.HFA2 inreg %p8.coerce, float inreg noundef %p9)
// X64: define dso_local x86_vectorcallcc void @"\01HVAAnywhere@@112"(%struct.HFA2 inreg %p1.coerce, i32 noundef %p2, i32 noundef %p3, float noundef %p4, i32 noundef %p5, i32 noundef %p6, %struct.HFA4* noundef %p7, %struct.HFA2 inreg %p8.coerce, float noundef %p9) // X64: define dso_local x86_vectorcallcc void @"\01HVAAnywhere@@112"(%struct.HFA2 inreg %p1.coerce, i32 noundef %p2, i32 noundef %p3, float noundef %p4, i32 noundef %p5, i32 noundef %p6, %struct.HFA4* noundef %p7, %struct.HFA2 inreg %p8.coerce, float noundef %p9)
#ifndef __x86_64__ #ifndef __x86_64__
// This covers the three ways XMM values can be passed on 32-bit x86: // This covers the three ways XMM values can be passed on 32-bit x86:
// - directly in XMM register (xmm5) // - directly in XMM register (xmm5)
Show All 18 Lines

clang/test/CodeGenCXX/target-features-error.cpp

Show First 20 Lines • Show All 71 Lines • ▼ Show 20 Lines void usage() {
//expected-error@+1{{'CtorAndDTor' requires target feature 'avx512f'}} //expected-error@+1{{'CtorAndDTor' requires target feature 'avx512f'}}
CtorAndDTor c; CtorAndDTor c;
{ {
//expected-error@+1{{'CtorAndDTor' requires target feature 'avx512f'}} //expected-error@+1{{'CtorAndDTor' requires target feature 'avx512f'}}
CtorAndDTor c2; CtorAndDTor c2;
//expected-error@+1{{'~CtorAndDTor' requires target feature 'avx512f'}} //expected-error@+1{{'~CtorAndDTor' requires target feature 'avx512f'}}
c2.~CtorAndDTor(); c2.~CtorAndDTor();
} }
// FIXME: These need to be given a line number, however theres no good way // FIXME: These need to be given a line number, however there's no good way
// to get to the SourceLocation of anything by the time we're doing CodeGen // to get to the SourceLocation of anything by the time we're doing CodeGen
// cleanups. // cleanups.
//expected-error@*{{'~CtorAndDTor' requires target feature 'avx512f'}} //expected-error@*{{'~CtorAndDTor' requires target feature 'avx512f'}}
//expected-error@*{{'~CtorAndDTor' requires target feature 'avx512f'}} //expected-error@*{{'~CtorAndDTor' requires target feature 'avx512f'}}
} }
} }
#endif #endif

clang/test/SemaCXX/builtin-align-cxx.cpp

Show First 20 Lines • Show All 194 Lines • ▼ Show 20 Lines
static_assert(__builtin_align_down(&align32array[2], 4) == &align32array[0], ""); static_assert(__builtin_align_down(&align32array[2], 4) == &align32array[0], "");
static_assert(__builtin_align_down(&align32array[3], 4) == &align32array[0], ""); static_assert(__builtin_align_down(&align32array[3], 4) == &align32array[0], "");
static_assert(__builtin_align_down(&align32array[4], 4) == &align32array[4], ""); static_assert(__builtin_align_down(&align32array[4], 4) == &align32array[4], "");
static_assert(__builtin_align_down(&align32array[5], 4) == &align32array[4], ""); static_assert(__builtin_align_down(&align32array[5], 4) == &align32array[4], "");
static_assert(__builtin_align_down(&align32array[6], 4) == &align32array[4], ""); static_assert(__builtin_align_down(&align32array[6], 4) == &align32array[4], "");
static_assert(__builtin_align_down(&align32array[7], 4) == &align32array[4], ""); static_assert(__builtin_align_down(&align32array[7], 4) == &align32array[4], "");
static_assert(__builtin_align_down(&align32array[8], 4) == &align32array[8], ""); static_assert(__builtin_align_down(&align32array[8], 4) == &align32array[8], "");
// Achiving the same thing using casts to uintptr_t is not allowed: // Achieving the same thing using casts to uintptr_t is not allowed:
static_assert((char *)((__UINTPTR_TYPE__)&align32array[7] & ~3) == &align32array[4], ""); // expected-error{{not an integral constant expression}} static_assert((char *)((__UINTPTR_TYPE__)&align32array[7] & ~3) == &align32array[4], ""); // expected-error{{not an integral constant expression}}
static_assert(__builtin_align_down(&align32array[1], 4) == &align32array[0], ""); static_assert(__builtin_align_down(&align32array[1], 4) == &align32array[0], "");
static_assert(__builtin_align_down(&align32array[1], 64) == &align32array[0], ""); // expected-error{{not an integral constant expression}} static_assert(__builtin_align_down(&align32array[1], 64) == &align32array[0], ""); // expected-error{{not an integral constant expression}}
// expected-note@-1{{cannot constant evaluate the result of adjusting alignment to 64}} // expected-note@-1{{cannot constant evaluate the result of adjusting alignment to 64}}
// Add some checks for __builtin_is_aligned: // Add some checks for __builtin_is_aligned:
static_assert(__builtin_is_aligned(&align32array[0], 32), ""); static_assert(__builtin_is_aligned(&align32array[0], 32), "");
Show All 29 Lines

clang/test/SemaOpenCL/usm-address-spaces-conversions.cl

// RUN: %clang_cc1 %s -ffake-address-space-map -verify -pedantic -fsyntax-only -cl-std=CL2.0 // RUN: %clang_cc1 %s -ffake-address-space-map -verify -pedantic -fsyntax-only -cl-std=CL2.0
// RUN: %clang_cc1 %s -ffake-address-space-map -verify -pedantic -fsyntax-only -cl-std=CL2.0 -DGENERIC // RUN: %clang_cc1 %s -ffake-address-space-map -verify -pedantic -fsyntax-only -cl-std=CL2.0 -DGENERIC
// RUN: %clang_cc1 %s -ffake-address-space-map -verify -pedantic -fsyntax-only -cl-std=CL2.0 -DCONSTANT // RUN: %clang_cc1 %s -ffake-address-space-map -verify -pedantic -fsyntax-only -cl-std=CL2.0 -DCONSTANT
// RUN: %clang_cc1 %s -ffake-address-space-map -verify -pedantic -fsyntax-only -cl-std=CL2.0 -DLOCAL // RUN: %clang_cc1 %s -ffake-address-space-map -verify -pedantic -fsyntax-only -cl-std=CL2.0 -DLOCAL
/* USM (unified shared memory) extension for OpenCLC 2.0 adds two new address /* USM (unified shared memory) extension for OpenCLC 2.0 adds two new address
* spaces: global_device and global_host that are a subset of __global address * spaces: global_device and global_host that are a subset of __global address
* space. As ISO/IEC TR 18037 5.1.3 declares - it's possible to implicitly * space. As ISO/IEC TR 18037 5.1.3 declares - it's possible to implicitly
* convert a subset address space to a superset address space, while conversion * convert a subset address space to a superset address space, while conversion
* in a reversed direction could be achived only with an explicit cast */ * in a reversed direction could be achieved only with an explicit cast */
#ifdef GENERIC #ifdef GENERIC
#define AS_COMP __generic #define AS_COMP __generic
#else #else
#define AS_COMP __global #define AS_COMP __global
#endif // GENERIC #endif // GENERIC
#ifdef CONSTANT #ifdef CONSTANT
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

clang/tools/clang-shlib/CMakeLists.txt

Show All 9 Lines if(XCODE)
# Xcode doesn't support object libraries, so we have to trick it into # Xcode doesn't support object libraries, so we have to trick it into
# linking the static libraries instead. # linking the static libraries instead.
list(APPEND _DEPS "-force_load" ${lib}) list(APPEND _DEPS "-force_load" ${lib})
else() else()
list(APPEND _OBJECTS $<TARGET_OBJECTS:obj.${lib}>) list(APPEND _OBJECTS $<TARGET_OBJECTS:obj.${lib}>)
endif() endif()
if (BUILD_SHARED_LIBS) if (BUILD_SHARED_LIBS)
# If we are building static libraries, then we don't need to add the static # If we are building static libraries, then we don't need to add the static
# libraries as a depedency, because we are already linking against the # libraries as a dependency, because we are already linking against the
# individual object files. # individual object files.
list(APPEND _DEPS $<TARGET_PROPERTY:${lib},INTERFACE_LINK_LIBRARIES>) list(APPEND _DEPS $<TARGET_PROPERTY:${lib},INTERFACE_LINK_LIBRARIES>)
endif() endif()
# clang libraries are redundant since we are linking all the individual # clang libraries are redundant since we are linking all the individual
# object files into libclang-cpp.so, so filter them out from _DEPS. # object files into libclang-cpp.so, so filter them out from _DEPS.
# This avoids problems with LLVM global data when building with # This avoids problems with LLVM global data when building with
# BUILD_SHARED_LIBS=ON # BUILD_SHARED_LIBS=ON
Show All 29 Lines

clang/tools/include-mapping/gen_std.py

#!/usr/bin/env python #!/usr/bin/env python
#===- gen_std.py - ------------------------------------------*- python -*--===# #===- gen_std.py - ------------------------------------------*- python -*--===#
# #
# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
# See https://llvm.org/LICENSE.txt for license information. # See https://llvm.org/LICENSE.txt for license information.
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
# #
#===------------------------------------------------------------------------===# #===------------------------------------------------------------------------===#
"""gen_std.py is a tool to generate a lookup table (from qualified names to """gen_std.py is a tool to generate a lookup table (from qualified names to
include headers) for C/C++ Standard Library symbols by parsing archieved HTML include headers) for C/C++ Standard Library symbols by parsing archived HTML
files from cppreference. files from cppreference.
The generated files are located in clang/include/Tooling/Inclusions. The generated files are located in clang/include/Tooling/Inclusions.
Caveats and FIXMEs: Caveats and FIXMEs:
- only symbols directly in "std" namespace are added, we should also add std's - only symbols directly in "std" namespace are added, we should also add std's
subnamespace symbols (e.g. chrono). subnamespace symbols (e.g. chrono).
- symbols with multiple variants or defined in multiple headers aren't added, - symbols with multiple variants or defined in multiple headers aren't added,
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

clang/tools/scan-build-py/lib/libear/ear.c

Show First 20 Lines • Show All 441 Lines • ▼ Show 20 Lines if (fclose(fd)) {
perror("bear: fclose"); perror("bear: fclose");
pthread_mutex_unlock(&mutex); pthread_mutex_unlock(&mutex);
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
free((void *)cwd); free((void *)cwd);
pthread_mutex_unlock(&mutex); pthread_mutex_unlock(&mutex);
} }
/* update environment assure that chilren processes will copy the desired /* update environment assure that children processes will copy the desired
* behaviour */ * behaviour */
static int bear_capture_env_t(bear_env_t *env) { static int bear_capture_env_t(bear_env_t *env) {
int status = 1; int status = 1;
for (size_t it = 0; it < ENV_SIZE; ++it) { for (size_t it = 0; it < ENV_SIZE; ++it) {
char const *const env_value = getenv(env_names[it]); char const *const env_value = getenv(env_names[it]);
char const *const env_copy = (env_value) ? strdup(env_value) : env_value; char const *const env_copy = (env_value) ? strdup(env_value) : env_value;
(*env)[it] = env_copy; (*env)[it] = env_copy;
▲ Show 20 Lines • Show All 138 Lines • ▼ Show 20 Linesstatic size_t bear_strings_length(char const *const *const in) {
return result; return result;
} }
static void bear_strings_release(char const **in) { static void bear_strings_release(char const **in) {
for (char const *const *it = in; (it) && (*it); ++it) { for (char const *const *it = in; (it) && (*it); ++it) {
free((void *)*it); free((void *)*it);
} }
free((void *)in); free((void *)in);
} }
No newline at end of file

clang/unittests/AST/StructuralEquivalenceTest.cpp

Show First 20 Lines • Show All 180 Lines • ▼ Show 20 Lines
} }
TEST_F(StructuralEquivalenceTest, Char) { TEST_F(StructuralEquivalenceTest, Char) {
auto Decls = makeNamedDecls("char foo;", "char foo;", Lang_CXX03); auto Decls = makeNamedDecls("char foo;", "char foo;", Lang_CXX03);
EXPECT_TRUE(testStructuralMatch(Decls)); EXPECT_TRUE(testStructuralMatch(Decls));
} }
// This test is disabled for now. // This test is disabled for now.
// FIXME Whether this is equivalent is dependendant on the target. // FIXME Whether this is equivalent is dependent on the target.
TEST_F(StructuralEquivalenceTest, DISABLED_CharVsSignedChar) { TEST_F(StructuralEquivalenceTest, DISABLED_CharVsSignedChar) {
auto Decls = makeNamedDecls("char foo;", "signed char foo;", Lang_CXX03); auto Decls = makeNamedDecls("char foo;", "signed char foo;", Lang_CXX03);
EXPECT_FALSE(testStructuralMatch(Decls)); EXPECT_FALSE(testStructuralMatch(Decls));
} }
TEST_F(StructuralEquivalenceTest, ForwardRecordDecl) { TEST_F(StructuralEquivalenceTest, ForwardRecordDecl) {
auto Decls = makeNamedDecls("struct foo;", "struct foo;", Lang_CXX03); auto Decls = makeNamedDecls("struct foo;", "struct foo;", Lang_CXX03);
EXPECT_TRUE(testStructuralMatch(Decls)); EXPECT_TRUE(testStructuralMatch(Decls));
▲ Show 20 Lines • Show All 1,932 Lines • Show Last 20 Lines

clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp

Show First 20 Lines • Show All 649 Lines • ▼ Show 20 Lines if (!GetParam().hasDelayedTemplateParsing()) {
// Dependent contexts, but a non-dependent call. // Dependent contexts, but a non-dependent call.
EXPECT_TRUE( EXPECT_TRUE(
matches("void f(); template <int N> void g() { f(); }", CallFunctionF)); matches("void f(); template <int N> void g() { f(); }", CallFunctionF));
EXPECT_TRUE( EXPECT_TRUE(
matches("void f(); template <int N> struct S { void g() { f(); } };", matches("void f(); template <int N> struct S { void g() { f(); } };",
CallFunctionF)); CallFunctionF));
} }
// Depedent calls don't match. // Dependent calls don't match.
EXPECT_TRUE( EXPECT_TRUE(
notMatches("void f(int); template <typename T> void g(T t) { f(t); }", notMatches("void f(int); template <typename T> void g(T t) { f(t); }",
CallFunctionF)); CallFunctionF));
EXPECT_TRUE( EXPECT_TRUE(
notMatches("void f(int);" notMatches("void f(int);"
"template <typename T> struct S { void g(T t) { f(t); } };", "template <typename T> struct S { void g(T t) { f(t); } };",
CallFunctionF)); CallFunctionF));
▲ Show 20 Lines • Show All 1,969 Lines • Show Last 20 Lines

clang/unittests/Tooling/SourceCodeTest.cpp

Show First 20 Lines • Show All 249 Lines • ▼ Show 20 Lines Visitor.runOverAnnotated(R"cpp(
#define ATTR __attribute__((deprecated("message"))) #define ATTR __attribute__((deprecated("message")))
$r[[ATTR $r[[ATTR
int x;]])cpp"); int x;]])cpp");
// Includes attributes and comments together. // Includes attributes and comments together.
Visitor.runOverAnnotated(R"cpp( Visitor.runOverAnnotated(R"cpp(
#define ATTR __attribute__((deprecated("message"))) #define ATTR __attribute__((deprecated("message")))
$r[[ATTR $r[[ATTR
// Commment. // Comment.
int x;]])cpp"); int x;]])cpp");
} }
TEST(SourceCodeTest, getAssociatedRangeClasses) { TEST(SourceCodeTest, getAssociatedRangeClasses) {
struct RecordDeclsVisitor : AnnotatedCodeVisitor<RecordDeclsVisitor> { struct RecordDeclsVisitor : AnnotatedCodeVisitor<RecordDeclsVisitor> {
bool VisitRecordDecl(RecordDecl *Decl) { return VisitDeclHelper(Decl); } bool VisitRecordDecl(RecordDecl *Decl) { return VisitDeclHelper(Decl); }
}; };
RecordDeclsVisitor Visitor; RecordDeclsVisitor Visitor;
▲ Show 20 Lines • Show All 138 Lines • ▼ Show 20 Lines Visit(R"cpp(
#define ATTR __attribute__((deprecated("message"))) #define ATTR __attribute__((deprecated("message")))
$r[[ATTR $r[[ATTR
int x;]])cpp"); int x;]])cpp");
// Includes attributes and comments together. // Includes attributes and comments together.
Visit(R"cpp( Visit(R"cpp(
#define ATTR __attribute__((deprecated("message"))) #define ATTR __attribute__((deprecated("message")))
$r[[ATTR $r[[ATTR
// Commment. // Comment.
int x;]])cpp"); int x;]])cpp");
} }
TEST(SourceCodeTest, getAssociatedRangeInvalidForPartialExpansions) { TEST(SourceCodeTest, getAssociatedRangeInvalidForPartialExpansions) {
struct FailingVarDeclsVisitor : TestVisitor<FailingVarDeclsVisitor> { struct FailingVarDeclsVisitor : TestVisitor<FailingVarDeclsVisitor> {
FailingVarDeclsVisitor() {} FailingVarDeclsVisitor() {}
bool VisitVarDecl(VarDecl *Decl) { bool VisitVarDecl(VarDecl *Decl) {
EXPECT_TRUE(getAssociatedRange(*Decl, *Context).isInvalid()); EXPECT_TRUE(getAssociatedRange(*Decl, *Context).isInvalid());
▲ Show 20 Lines • Show All 270 Lines • Show Last 20 Lines

clang/utils/TableGen/NeonEmitter.cpp

Show First 20 Lines • Show All 435 Lines • ▼ Show 20 Linespublic:
Type getPolymorphicKeyType() const { return Types[PolymorphicKeyType]; } Type getPolymorphicKeyType() const { return Types[PolymorphicKeyType]; }
/// Return true if the prototype has a scalar argument. /// Return true if the prototype has a scalar argument.
bool protoHasScalar() const; bool protoHasScalar() const;
/// Return the index that parameter PIndex will sit at /// Return the index that parameter PIndex will sit at
/// in a generated function call. This is often just PIndex, /// in a generated function call. This is often just PIndex,
/// but may not be as things such as multiple-vector operands /// but may not be as things such as multiple-vector operands
/// and sret parameters need to be taken into accont. /// and sret parameters need to be taken into account.
unsigned getGeneratedParamIdx(unsigned PIndex) { unsigned getGeneratedParamIdx(unsigned PIndex) {
unsigned Idx = 0; unsigned Idx = 0;
if (getReturnType().getNumVectors() > 1) if (getReturnType().getNumVectors() > 1)
// Multiple vectors are passed as sret. // Multiple vectors are passed as sret.
++Idx; ++Idx;
for (unsigned I = 0; I < PIndex; ++I) for (unsigned I = 0; I < PIndex; ++I)
Idx += std::max(1U, getParamType(I).getNumVectors()); Idx += std::max(1U, getParamType(I).getNumVectors());
▲ Show 20 Lines • Show All 2,179 Lines • Show Last 20 Lines

clang/utils/analyzer/SATest.py

Show First 20 Lines • Show All 315 Lines • ▼ Show 20 Lines dock_parser.add_argument("--llvm-project-dir", action="store",
help="Path to LLVM source code. Defaults " help="Path to LLVM source code. Defaults "
"to the repo where this script is located. ") "to the repo where this script is located. ")
dock_parser.add_argument("--build-dir", action="store", default="", dock_parser.add_argument("--build-dir", action="store", default="",
help="Path to a directory where docker should " help="Path to a directory where docker should "
"build LLVM code.") "build LLVM code.")
dock_parser.add_argument("--clang-dir", action="store", default="", dock_parser.add_argument("--clang-dir", action="store", default="",
help="Path to find/install LLVM installation.") help="Path to find/install LLVM installation.")
dock_parser.add_argument("rest", nargs=argparse.REMAINDER, default=[], dock_parser.add_argument("rest", nargs=argparse.REMAINDER, default=[],
help="Additionall args that will be forwarded " help="Additional args that will be forwarded "
"to the docker's entrypoint.") "to the docker's entrypoint.")
dock_parser.set_defaults(func=docker) dock_parser.set_defaults(func=docker)
# benchmark subcommand # benchmark subcommand
bench_parser = subparsers.add_parser( bench_parser = subparsers.add_parser(
"benchmark", "benchmark",
help="Run benchmarks by building a set of projects multiple times.") help="Run benchmarks by building a set of projects multiple times.")
Show All 33 Lines

clang/utils/analyzer/exploded-graph-rewriter.py

Show First 20 Lines • Show All 382 Lines • ▼ Show 20 Lines def add_raw_line(self, raw_line):
.replace('\\<', '\\\\<') \ .replace('\\<', '\\\\<') \
.replace('\\>', '\\\\>') \ .replace('\\>', '\\\\>') \
.rstrip(',') .rstrip(',')
# Handle `\l` separately because a string literal can be in code # Handle `\l` separately because a string literal can be in code
# like "string\\literal" with the `\l` inside. # like "string\\literal" with the `\l` inside.
# Also on Windows macros __FILE__ produces specific delimiters `\` # Also on Windows macros __FILE__ produces specific delimiters `\`
# and a directory or file may starts with the letter `l`. # and a directory or file may starts with the letter `l`.
# Find all `\l` (like `,\l`, `}\l`, `[\l`) except `\\l`, # Find all `\l` (like `,\l`, `}\l`, `[\l`) except `\\l`,
# because the literal as a rule containes multiple `\` before `\l`. # because the literal as a rule contains multiple `\` before `\l`.
node_label = re.sub(r'(?<!\\)\\l', '', node_label) node_label = re.sub(r'(?<!\\)\\l', '', node_label)
logging.debug(node_label) logging.debug(node_label)
json_node = json.loads(node_label) json_node = json.loads(node_label)
self.nodes[node_id].construct(node_id, json_node) self.nodes[node_id].construct(node_id, json_node)
return return
logging.debug('Skipping.') logging.debug('Skipping.')
▲ Show 20 Lines • Show All 655 Lines • Show Last 20 Lines

clang/www/analyzer/installation.html

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Lines
<p>Most of the files in the <b><tt>checker-XXX</tt></b> directory will <p>Most of the files in the <b><tt>checker-XXX</tt></b> directory will
be supporting files for the analyzer that you can simply ignore. Most be supporting files for the analyzer that you can simply ignore. Most
users will only care about two files, which are located at the top of users will only care about two files, which are located at the top of
the <b><tt>checker-XXX</tt></b> directory:</p> the <b><tt>checker-XXX</tt></b> directory:</p>
<ul> <ul>
<li><b>scan-build</b>: <tt>scan-build</tt> is the high-level command line utility for running the analyzer</li> <li><b>scan-build</b>: <tt>scan-build</tt> is the high-level command line utility for running the analyzer</li>
<li><b>scan-view</b>: <tt>scan-view</tt> a companion comannd line <li><b>scan-view</b>: <tt>scan-view</tt> a companion command line
utility to <tt>scan-build</tt>, <tt>scan-view</tt> is used to view utility to <tt>scan-build</tt>, <tt>scan-view</tt> is used to view
analysis results generated by <tt>scan-build</tt>. There is an option analysis results generated by <tt>scan-build</tt>. There is an option
that one can pass to <tt>scan-build</tt> to cause <tt>scan-view</tt> to that one can pass to <tt>scan-build</tt> to cause <tt>scan-view</tt> to
run as soon as it the analysis of a build completes</li> run as soon as it the analysis of a build completes</li>
</ul> </ul>
<h4>Running scan-build</h4> <h4>Running scan-build</h4>
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

compiler-rt/cmake/Modules/AddCompilerRT.cmake

Show First 20 Lines • Show All 515 Lines • ▼ Show 20 Linesfunction(add_compiler_rt_test test_suite test_name arch)
# If we're not on MSVC, include the linker flags from CMAKE but override them # If we're not on MSVC, include the linker flags from CMAKE but override them
# with the provided link flags. This ensures that flags which are required to # with the provided link flags. This ensures that flags which are required to
# link programs at all are included, but the changes needed for the test # link programs at all are included, but the changes needed for the test
# trump. With MSVC we can't do that because CMake is set up to run link.exe # trump. With MSVC we can't do that because CMake is set up to run link.exe
# when linking, not the compiler. Here, we hack it to use the compiler # when linking, not the compiler. Here, we hack it to use the compiler
# because we want to use -fsanitize flags. # because we want to use -fsanitize flags.
# Only add CMAKE_EXE_LINKER_FLAGS when in a standalone bulid. # Only add CMAKE_EXE_LINKER_FLAGS when in a standalone build.
# Or else CMAKE_EXE_LINKER_FLAGS contains flags for build compiler of Clang/llvm. # Or else CMAKE_EXE_LINKER_FLAGS contains flags for build compiler of Clang/llvm.
# This might not be the same as what the COMPILER_RT_TEST_COMPILER supports. # This might not be the same as what the COMPILER_RT_TEST_COMPILER supports.
# eg: the build compiler use lld linker and we build clang with default ld linker # eg: the build compiler use lld linker and we build clang with default ld linker
# then to be tested clang will complain about lld options like --color-diagnostics. # then to be tested clang will complain about lld options like --color-diagnostics.
if(NOT MSVC AND COMPILER_RT_STANDALONE_BUILD) if(NOT MSVC AND COMPILER_RT_STANDALONE_BUILD)
set(TEST_LINK_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${TEST_LINK_FLAGS}") set(TEST_LINK_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${TEST_LINK_FLAGS}")
separate_arguments(TEST_LINK_FLAGS) separate_arguments(TEST_LINK_FLAGS)
endif() endif()
▲ Show 20 Lines • Show All 234 Lines • Show Last 20 Lines

compiler-rt/cmake/Modules/CompilerRTCompile.cmake

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Linesfunction(sanitizer_test_compile obj_list source arch)
clang_compile(${output_obj} ${source} clang_compile(${output_obj} ${source}
CFLAGS ${TEST_CFLAGS} ${TARGET_CFLAGS} CFLAGS ${TEST_CFLAGS} ${TARGET_CFLAGS}
DEPS ${COMPILE_DEPS}) DEPS ${COMPILE_DEPS})
list(APPEND ${obj_list} ${output_obj}) list(APPEND ${obj_list} ${output_obj})
set("${obj_list}" "${${obj_list}}" PARENT_SCOPE) set("${obj_list}" "${${obj_list}}" PARENT_SCOPE)
endfunction() endfunction()
# Compile a source into an object file with COMPILER_RT_TEST_COMPILER using # Compile a source into an object file with COMPILER_RT_TEST_COMPILER using
# a provided compile flags and dependenices. # a provided compile flags and dependencies.
# clang_compile(<object> <source> # clang_compile(<object> <source>
# CFLAGS <list of compile flags> # CFLAGS <list of compile flags>
# DEPS <list of dependencies>) # DEPS <list of dependencies>)
function(clang_compile object_file source) function(clang_compile object_file source)
cmake_parse_arguments(SOURCE "" "" "CFLAGS;DEPS" ${ARGN}) cmake_parse_arguments(SOURCE "" "" "CFLAGS;DEPS" ${ARGN})
get_filename_component(source_rpath ${source} REALPATH) get_filename_component(source_rpath ${source} REALPATH)
if(NOT COMPILER_RT_STANDALONE_BUILD) if(NOT COMPILER_RT_STANDALONE_BUILD)
list(APPEND SOURCE_DEPS clang compiler-rt-headers) list(APPEND SOURCE_DEPS clang compiler-rt-headers)
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

compiler-rt/lib/builtins/arm/adddf3vfp.S

//===-- adddf3vfp.S - Implement adddf3vfp ---------------------------------===// //===-- adddf3vfp.S - Implement adddf3vfp ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../assembly.h"
// double __adddf3vfp(double a, double b) { return a + b; } // double __adddf3vfp(double a, double b) { return a + b; }
// //
// Adds two double precision floating point numbers using the Darwin // Adds two double precision floating point numbers using the Darwin
// calling convention where double arguments are passsed in GPR pairs // calling convention where double arguments are passed in GPR pairs
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__adddf3vfp) DEFINE_COMPILERRT_FUNCTION(__adddf3vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vadd.f64 d0, d0, d1 vadd.f64 d0, d0, d1
#else #else
vmov d6, r0, r1 // move first param from r0/r1 pair into d6 vmov d6, r0, r1 // move first param from r0/r1 pair into d6
Show All 9 Lines

compiler-rt/lib/builtins/arm/addsf3vfp.S

//===-- addsf3vfp.S - Implement addsf3vfp ---------------------------------===// //===-- addsf3vfp.S - Implement addsf3vfp ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../assembly.h"
// //
// extern float __addsf3vfp(float a, float b); // extern float __addsf3vfp(float a, float b);
// //
// Adds two single precision floating point numbers using the Darwin // Adds two single precision floating point numbers using the Darwin
// calling convention where single arguments are passsed in GPRs // calling convention where single arguments are passed in GPRs
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__addsf3vfp) DEFINE_COMPILERRT_FUNCTION(__addsf3vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vadd.f32 s0, s0, s1 vadd.f32 s0, s0, s1
#else #else
vmov s14, r0 // move first param from r0 into float register vmov s14, r0 // move first param from r0 into float register
Show All 9 Lines

compiler-rt/lib/builtins/arm/divdf3vfp.S

//===-- divdf3vfp.S - Implement divdf3vfp ---------------------------------===// //===-- divdf3vfp.S - Implement divdf3vfp ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../assembly.h"
// //
// extern double __divdf3vfp(double a, double b); // extern double __divdf3vfp(double a, double b);
// //
// Divides two double precision floating point numbers using the Darwin // Divides two double precision floating point numbers using the Darwin
// calling convention where double arguments are passsed in GPR pairs // calling convention where double arguments are passed in GPR pairs
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__divdf3vfp) DEFINE_COMPILERRT_FUNCTION(__divdf3vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vdiv.f64 d0, d0, d1 vdiv.f64 d0, d0, d1
#else #else
vmov d6, r0, r1 // move first param from r0/r1 pair into d6 vmov d6, r0, r1 // move first param from r0/r1 pair into d6
Show All 9 Lines

compiler-rt/lib/builtins/arm/divsf3vfp.S

//===-- divsf3vfp.S - Implement divsf3vfp ---------------------------------===// //===-- divsf3vfp.S - Implement divsf3vfp ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../assembly.h"
// //
// extern float __divsf3vfp(float a, float b); // extern float __divsf3vfp(float a, float b);
// //
// Divides two single precision floating point numbers using the Darwin // Divides two single precision floating point numbers using the Darwin
// calling convention where single arguments are passsed like 32-bit ints. // calling convention where single arguments are passed like 32-bit ints.
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__divsf3vfp) DEFINE_COMPILERRT_FUNCTION(__divsf3vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vdiv.f32 s0, s0, s1 vdiv.f32 s0, s0, s1
#else #else
vmov s14, r0 // move first param from r0 into float register vmov s14, r0 // move first param from r0 into float register
Show All 9 Lines

compiler-rt/lib/builtins/arm/eqdf2vfp.S

//===-- eqdf2vfp.S - Implement eqdf2vfp -----------------------------------===// //===-- eqdf2vfp.S - Implement eqdf2vfp -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../assembly.h"
// extern int __eqdf2vfp(double a, double b); // extern int __eqdf2vfp(double a, double b);
// //
// Returns one iff a == b and neither is NaN. // Returns one iff a == b and neither is NaN.
// Uses Darwin calling convention where double precision arguments are passsed // Uses Darwin calling convention where double precision arguments are passed
// like in GPR pairs. // like in GPR pairs.
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__eqdf2vfp) DEFINE_COMPILERRT_FUNCTION(__eqdf2vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vcmp.f64 d0, d1 vcmp.f64 d0, d1
#else #else
Show All 13 Lines

compiler-rt/lib/builtins/arm/eqsf2vfp.S

//===-- eqsf2vfp.S - Implement eqsf2vfp -----------------------------------===// //===-- eqsf2vfp.S - Implement eqsf2vfp -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../assembly.h"
// //
// extern int __eqsf2vfp(float a, float b); // extern int __eqsf2vfp(float a, float b);
// //
// Returns one iff a == b and neither is NaN. // Returns one iff a == b and neither is NaN.
// Uses Darwin calling convention where single precision arguments are passsed // Uses Darwin calling convention where single precision arguments are passed
// like 32-bit ints // like 32-bit ints
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__eqsf2vfp) DEFINE_COMPILERRT_FUNCTION(__eqsf2vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vcmp.f32 s0, s1 vcmp.f32 s0, s1
#else #else
Show All 13 Lines

compiler-rt/lib/builtins/arm/gedf2vfp.S

//===-- gedf2vfp.S - Implement gedf2vfp -----------------------------------===// //===-- gedf2vfp.S - Implement gedf2vfp -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../assembly.h"
// //
// extern int __gedf2vfp(double a, double b); // extern int __gedf2vfp(double a, double b);
// //
// Returns one iff a >= b and neither is NaN. // Returns one iff a >= b and neither is NaN.
// Uses Darwin calling convention where double precision arguments are passsed // Uses Darwin calling convention where double precision arguments are passed
// like in GPR pairs. // like in GPR pairs.
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__gedf2vfp) DEFINE_COMPILERRT_FUNCTION(__gedf2vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vcmp.f64 d0, d1 vcmp.f64 d0, d1
#else #else
Show All 13 Lines

compiler-rt/lib/builtins/arm/gesf2vfp.S

//===-- gesf2vfp.S - Implement gesf2vfp -----------------------------------===// //===-- gesf2vfp.S - Implement gesf2vfp -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../assembly.h"
// //
// extern int __gesf2vfp(float a, float b); // extern int __gesf2vfp(float a, float b);
// //
// Returns one iff a >= b and neither is NaN. // Returns one iff a >= b and neither is NaN.
// Uses Darwin calling convention where single precision arguments are passsed // Uses Darwin calling convention where single precision arguments are passed
// like 32-bit ints // like 32-bit ints
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__gesf2vfp) DEFINE_COMPILERRT_FUNCTION(__gesf2vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vcmp.f32 s0, s1 vcmp.f32 s0, s1
#else #else
Show All 13 Lines

compiler-rt/lib/builtins/arm/gtdf2vfp.S

//===-- gtdf2vfp.S - Implement gtdf2vfp -----------------------------------===// //===-- gtdf2vfp.S - Implement gtdf2vfp -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../assembly.h"
// //
// extern double __gtdf2vfp(double a, double b); // extern double __gtdf2vfp(double a, double b);
// //
// Returns one iff a > b and neither is NaN. // Returns one iff a > b and neither is NaN.
// Uses Darwin calling convention where double precision arguments are passsed // Uses Darwin calling convention where double precision arguments are passed
// like in GPR pairs. // like in GPR pairs.
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__gtdf2vfp) DEFINE_COMPILERRT_FUNCTION(__gtdf2vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vcmp.f64 d0, d1 vcmp.f64 d0, d1
#else #else
Show All 13 Lines

compiler-rt/lib/builtins/arm/gtsf2vfp.S

//===-- gtsf2vfp.S - Implement gtsf2vfp -----------------------------------===// //===-- gtsf2vfp.S - Implement gtsf2vfp -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../assembly.h"
// //
// extern int __gtsf2vfp(float a, float b); // extern int __gtsf2vfp(float a, float b);
// //
// Returns one iff a > b and neither is NaN. // Returns one iff a > b and neither is NaN.
// Uses Darwin calling convention where single precision arguments are passsed // Uses Darwin calling convention where single precision arguments are passed
// like 32-bit ints // like 32-bit ints
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__gtsf2vfp) DEFINE_COMPILERRT_FUNCTION(__gtsf2vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vcmp.f32 s0, s1 vcmp.f32 s0, s1
#else #else
Show All 13 Lines

compiler-rt/lib/builtins/arm/ledf2vfp.S

//===-- ledf2vfp.S - Implement ledf2vfp -----------------------------------===// //===-- ledf2vfp.S - Implement ledf2vfp -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../assembly.h"
// //
// extern double __ledf2vfp(double a, double b); // extern double __ledf2vfp(double a, double b);
// //
// Returns one iff a <= b and neither is NaN. // Returns one iff a <= b and neither is NaN.
// Uses Darwin calling convention where double precision arguments are passsed // Uses Darwin calling convention where double precision arguments are passed
// like in GPR pairs. // like in GPR pairs.
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__ledf2vfp) DEFINE_COMPILERRT_FUNCTION(__ledf2vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vcmp.f64 d0, d1 vcmp.f64 d0, d1
#else #else
Show All 13 Lines

compiler-rt/lib/builtins/arm/lesf2vfp.S

//===-- lesf2vfp.S - Implement lesf2vfp -----------------------------------===// //===-- lesf2vfp.S - Implement lesf2vfp -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../assembly.h"
// //
// extern int __lesf2vfp(float a, float b); // extern int __lesf2vfp(float a, float b);
// //
// Returns one iff a <= b and neither is NaN. // Returns one iff a <= b and neither is NaN.
// Uses Darwin calling convention where single precision arguments are passsed // Uses Darwin calling convention where single precision arguments are passed
// like 32-bit ints // like 32-bit ints
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__lesf2vfp) DEFINE_COMPILERRT_FUNCTION(__lesf2vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vcmp.f32 s0, s1 vcmp.f32 s0, s1
#else #else
Show All 13 Lines

compiler-rt/lib/builtins/arm/ltdf2vfp.S

//===-- ltdf2vfp.S - Implement ltdf2vfp -----------------------------------===// //===-- ltdf2vfp.S - Implement ltdf2vfp -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../assembly.h"
// //
// extern double __ltdf2vfp(double a, double b); // extern double __ltdf2vfp(double a, double b);
// //
// Returns one iff a < b and neither is NaN. // Returns one iff a < b and neither is NaN.
// Uses Darwin calling convention where double precision arguments are passsed // Uses Darwin calling convention where double precision arguments are passed
// like in GPR pairs. // like in GPR pairs.
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__ltdf2vfp) DEFINE_COMPILERRT_FUNCTION(__ltdf2vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vcmp.f64 d0, d1 vcmp.f64 d0, d1
#else #else
Show All 13 Lines

compiler-rt/lib/builtins/arm/ltsf2vfp.S

//===-- ltsf2vfp.S - Implement ltsf2vfp -----------------------------------===// //===-- ltsf2vfp.S - Implement ltsf2vfp -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../assembly.h"
// //
// extern int __ltsf2vfp(float a, float b); // extern int __ltsf2vfp(float a, float b);
// //
// Returns one iff a < b and neither is NaN. // Returns one iff a < b and neither is NaN.
// Uses Darwin calling convention where single precision arguments are passsed // Uses Darwin calling convention where single precision arguments are passed
// like 32-bit ints // like 32-bit ints
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__ltsf2vfp) DEFINE_COMPILERRT_FUNCTION(__ltsf2vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vcmp.f32 s0, s1 vcmp.f32 s0, s1
#else #else
Show All 13 Lines

compiler-rt/lib/builtins/arm/muldf3vfp.S

//===-- muldf3vfp.S - Implement muldf3vfp ---------------------------------===// //===-- muldf3vfp.S - Implement muldf3vfp ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../assembly.h"
// //
// extern double __muldf3vfp(double a, double b); // extern double __muldf3vfp(double a, double b);
// //
// Multiplies two double precision floating point numbers using the Darwin // Multiplies two double precision floating point numbers using the Darwin
// calling convention where double arguments are passsed in GPR pairs // calling convention where double arguments are passed in GPR pairs
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__muldf3vfp) DEFINE_COMPILERRT_FUNCTION(__muldf3vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vmul.f64 d0, d0, d1 vmul.f64 d0, d0, d1
#else #else
vmov d6, r0, r1 // move first param from r0/r1 pair into d6 vmov d6, r0, r1 // move first param from r0/r1 pair into d6
Show All 9 Lines

compiler-rt/lib/builtins/arm/mulsf3vfp.S

//===-- mulsf3vfp.S - Implement mulsf3vfp ---------------------------------===// //===-- mulsf3vfp.S - Implement mulsf3vfp ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../assembly.h"
// //
// extern float __mulsf3vfp(float a, float b); // extern float __mulsf3vfp(float a, float b);
// //
// Multiplies two single precision floating point numbers using the Darwin // Multiplies two single precision floating point numbers using the Darwin
// calling convention where single arguments are passsed like 32-bit ints. // calling convention where single arguments are passed like 32-bit ints.
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__mulsf3vfp) DEFINE_COMPILERRT_FUNCTION(__mulsf3vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vmul.f32 s0, s0, s1 vmul.f32 s0, s0, s1
#else #else
vmov s14, r0 // move first param from r0 into float register vmov s14, r0 // move first param from r0 into float register
Show All 9 Lines

compiler-rt/lib/builtins/arm/nedf2vfp.S

//===-- nedf2vfp.S - Implement nedf2vfp -----------------------------------===// //===-- nedf2vfp.S - Implement nedf2vfp -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../assembly.h"
// extern double __nedf2vfp(double a, double b); // extern double __nedf2vfp(double a, double b);
// //
// Returns zero if a and b are unequal and neither is NaN. // Returns zero if a and b are unequal and neither is NaN.
// Uses Darwin calling convention where double precision arguments are passsed // Uses Darwin calling convention where double precision arguments are passed
// like in GPR pairs. // like in GPR pairs.
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__nedf2vfp) DEFINE_COMPILERRT_FUNCTION(__nedf2vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vcmp.f64 d0, d1 vcmp.f64 d0, d1
#else #else
Show All 13 Lines

compiler-rt/lib/builtins/arm/negdf2vfp.S

//===-- negdf2vfp.S - Implement negdf2vfp ---------------------------------===// //===-- negdf2vfp.S - Implement negdf2vfp ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../assembly.h"
// //
// extern double __negdf2vfp(double a, double b); // extern double __negdf2vfp(double a, double b);
// //
// Returns the negation a double precision floating point numbers using the // Returns the negation a double precision floating point numbers using the
// Darwin calling convention where double arguments are passsed in GPR pairs. // Darwin calling convention where double arguments are passed in GPR pairs.
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__negdf2vfp) DEFINE_COMPILERRT_FUNCTION(__negdf2vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vneg.f64 d0, d0 vneg.f64 d0, d0
#else #else
eor r1, r1, #-2147483648 // flip sign bit on double in r0/r1 pair eor r1, r1, #-2147483648 // flip sign bit on double in r0/r1 pair
#endif #endif
bx lr bx lr
END_COMPILERRT_FUNCTION(__negdf2vfp) END_COMPILERRT_FUNCTION(__negdf2vfp)
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

compiler-rt/lib/builtins/arm/negsf2vfp.S

//===-- negsf2vfp.S - Implement negsf2vfp ---------------------------------===// //===-- negsf2vfp.S - Implement negsf2vfp ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../assembly.h"
// //
// extern float __negsf2vfp(float a); // extern float __negsf2vfp(float a);
// //
// Returns the negation of a single precision floating point numbers using the // Returns the negation of a single precision floating point numbers using the
// Darwin calling convention where single arguments are passsed like 32-bit ints // Darwin calling convention where single arguments are passed like 32-bit ints
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__negsf2vfp) DEFINE_COMPILERRT_FUNCTION(__negsf2vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vneg.f32 s0, s0 vneg.f32 s0, s0
#else #else
eor r0, r0, #-2147483648 // flip sign bit on float in r0 eor r0, r0, #-2147483648 // flip sign bit on float in r0
#endif #endif
bx lr bx lr
END_COMPILERRT_FUNCTION(__negsf2vfp) END_COMPILERRT_FUNCTION(__negsf2vfp)
NO_EXEC_STACK_DIRECTIVE NO_EXEC_STACK_DIRECTIVE

compiler-rt/lib/builtins/arm/nesf2vfp.S

//===-- nesf2vfp.S - Implement nesf2vfp -----------------------------------===// //===-- nesf2vfp.S - Implement nesf2vfp -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../assembly.h"
// //
// extern int __nesf2vfp(float a, float b); // extern int __nesf2vfp(float a, float b);
// //
// Returns one iff a != b and neither is NaN. // Returns one iff a != b and neither is NaN.
// Uses Darwin calling convention where single precision arguments are passsed // Uses Darwin calling convention where single precision arguments are passed
// like 32-bit ints // like 32-bit ints
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__nesf2vfp) DEFINE_COMPILERRT_FUNCTION(__nesf2vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vcmp.f32 s0, s1 vcmp.f32 s0, s1
#else #else
Show All 13 Lines

compiler-rt/lib/builtins/arm/subdf3vfp.S

//===-- subdf3vfp.S - Implement subdf3vfp ---------------------------------===// //===-- subdf3vfp.S - Implement subdf3vfp ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../assembly.h"
// //
// extern double __subdf3vfp(double a, double b); // extern double __subdf3vfp(double a, double b);
// //
// Returns difference between two double precision floating point numbers using // Returns difference between two double precision floating point numbers using
// the Darwin calling convention where double arguments are passsed in GPR pairs // the Darwin calling convention where double arguments are passed in GPR pairs
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__subdf3vfp) DEFINE_COMPILERRT_FUNCTION(__subdf3vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vsub.f64 d0, d0, d1 vsub.f64 d0, d0, d1
#else #else
vmov d6, r0, r1 // move first param from r0/r1 pair into d6 vmov d6, r0, r1 // move first param from r0/r1 pair into d6
Show All 9 Lines

compiler-rt/lib/builtins/arm/subsf3vfp.S

//===-- subsf3vfp.S - Implement subsf3vfp ---------------------------------===// //===-- subsf3vfp.S - Implement subsf3vfp ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../assembly.h"
// //
// extern float __subsf3vfp(float a, float b); // extern float __subsf3vfp(float a, float b);
// //
// Returns the difference between two single precision floating point numbers // Returns the difference between two single precision floating point numbers
// using the Darwin calling convention where single arguments are passsed // using the Darwin calling convention where single arguments are passed
// like 32-bit ints. // like 32-bit ints.
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__subsf3vfp) DEFINE_COMPILERRT_FUNCTION(__subsf3vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vsub.f32 s0, s0, s1 vsub.f32 s0, s0, s1
#else #else
Show All 10 Lines

compiler-rt/lib/builtins/arm/unorddf2vfp.S

//===-- unorddf2vfp.S - Implement unorddf2vfp ------------------------------===// //===-- unorddf2vfp.S - Implement unorddf2vfp ------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../assembly.h"
// //
// extern int __unorddf2vfp(double a, double b); // extern int __unorddf2vfp(double a, double b);
// //
// Returns one iff a or b is NaN // Returns one iff a or b is NaN
// Uses Darwin calling convention where double precision arguments are passsed // Uses Darwin calling convention where double precision arguments are passed
// like in GPR pairs. // like in GPR pairs.
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__unorddf2vfp) DEFINE_COMPILERRT_FUNCTION(__unorddf2vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vcmp.f64 d0, d1 vcmp.f64 d0, d1
#else #else
Show All 13 Lines

compiler-rt/lib/builtins/arm/unordsf2vfp.S

//===-- unordsf2vfp.S - Implement unordsf2vfp -----------------------------===// //===-- unordsf2vfp.S - Implement unordsf2vfp -----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../assembly.h" #include "../assembly.h"
// //
// extern int __unordsf2vfp(float a, float b); // extern int __unordsf2vfp(float a, float b);
// //
// Returns one iff a or b is NaN // Returns one iff a or b is NaN
// Uses Darwin calling convention where single precision arguments are passsed // Uses Darwin calling convention where single precision arguments are passed
// like 32-bit ints // like 32-bit ints
// //
.syntax unified .syntax unified
.p2align 2 .p2align 2
DEFINE_COMPILERRT_FUNCTION(__unordsf2vfp) DEFINE_COMPILERRT_FUNCTION(__unordsf2vfp)
#if defined(COMPILER_RT_ARMHF_TARGET) #if defined(COMPILER_RT_ARMHF_TARGET)
vcmp.f32 s0, s1 vcmp.f32 s0, s1
#else #else
Show All 13 Lines

compiler-rt/lib/fuzzer/FuzzerCorpus.h

Show First 20 Lines • Show All 361 Lines • ▼ Show 20 Linespublic:
void AddRareFeature(uint32_t Idx) { void AddRareFeature(uint32_t Idx) {
// Maintain *at least* TopXRarestFeatures many rare features // Maintain *at least* TopXRarestFeatures many rare features
// and all features with a frequency below ConsideredRare. // and all features with a frequency below ConsideredRare.
// Remove all other features. // Remove all other features.
while (RareFeatures.size() > Entropic.NumberOfRarestFeatures && while (RareFeatures.size() > Entropic.NumberOfRarestFeatures &&
FreqOfMostAbundantRareFeature > Entropic.FeatureFrequencyThreshold) { FreqOfMostAbundantRareFeature > Entropic.FeatureFrequencyThreshold) {
// Find most and second most abbundant feature. // Find most and second most abundant feature.
uint32_t MostAbundantRareFeatureIndices[2] = {RareFeatures[0], uint32_t MostAbundantRareFeatureIndices[2] = {RareFeatures[0],
RareFeatures[0]}; RareFeatures[0]};
size_t Delete = 0; size_t Delete = 0;
for (size_t i = 0; i < RareFeatures.size(); i++) { for (size_t i = 0; i < RareFeatures.size(); i++) {
uint32_t Idx2 = RareFeatures[i]; uint32_t Idx2 = RareFeatures[i];
if (GlobalFeatureFreqs[Idx2] >= if (GlobalFeatureFreqs[Idx2] >=
GlobalFeatureFreqs[MostAbundantRareFeatureIndices[0]]) { GlobalFeatureFreqs[MostAbundantRareFeatureIndices[0]]) {
MostAbundantRareFeatureIndices[1] = MostAbundantRareFeatureIndices[0]; MostAbundantRareFeatureIndices[1] = MostAbundantRareFeatureIndices[0];
▲ Show 20 Lines • Show All 212 Lines • Show Last 20 Lines

compiler-rt/lib/profile/InstrProfilingFile.c

Show First 20 Lines • Show All 748 Lines • ▼ Show 20 Lines if (FilenamePat[I] == '%') {
PROF_WARN("%%c specifier can only be specified once in %s.\n", PROF_WARN("%%c specifier can only be specified once in %s.\n",
FilenamePat); FilenamePat);
return -1; return -1;
} }
#if defined(__APPLE__) || defined(__ELF__) || defined(_WIN32) #if defined(__APPLE__) || defined(__ELF__) || defined(_WIN32)
__llvm_profile_set_page_size(getpagesize()); __llvm_profile_set_page_size(getpagesize());
__llvm_profile_enable_continuous_mode(); __llvm_profile_enable_continuous_mode();
#else #else
PROF_WARN("%s", "Continous mode is currently only supported for Mach-O," PROF_WARN("%s",
"Continuous mode is currently only supported for Mach-O,"
" ELF and COFF formats."); " ELF and COFF formats.");
return -1; return -1;
#endif #endif
} else { } else {
unsigned MergePoolSize = getMergePoolSize(FilenamePat, &I); unsigned MergePoolSize = getMergePoolSize(FilenamePat, &I);
if (!MergePoolSize) if (!MergePoolSize)
continue; continue;
if (MergingEnabled) { if (MergingEnabled) {
PROF_WARN("%%m specifier can only be specified once in %s.\n", PROF_WARN("%%m specifier can only be specified once in %s.\n",
▲ Show 20 Lines • Show All 428 Lines • Show Last 20 Lines

compiler-rt/lib/profile/InstrProfilingInternal.h

Show First 20 Lines • Show All 181 Lines • ▼ Show 20 Lines
*/ */
unsigned lprofProfileDumped(void); unsigned lprofProfileDumped(void);
void lprofSetProfileDumped(unsigned); void lprofSetProfileDumped(unsigned);
COMPILER_RT_VISIBILITY extern void (*FreeHook)(void *); COMPILER_RT_VISIBILITY extern void (*FreeHook)(void *);
COMPILER_RT_VISIBILITY extern uint8_t *DynamicBufferIOBuffer; COMPILER_RT_VISIBILITY extern uint8_t *DynamicBufferIOBuffer;
COMPILER_RT_VISIBILITY extern uint32_t VPBufferSize; COMPILER_RT_VISIBILITY extern uint32_t VPBufferSize;
COMPILER_RT_VISIBILITY extern uint32_t VPMaxNumValsPerSite; COMPILER_RT_VISIBILITY extern uint32_t VPMaxNumValsPerSite;
/* Pointer to the start of static value counters to be allocted. */ /* Pointer to the start of static value counters to be allocated. */
COMPILER_RT_VISIBILITY extern ValueProfNode *CurrentVNode; COMPILER_RT_VISIBILITY extern ValueProfNode *CurrentVNode;
COMPILER_RT_VISIBILITY extern ValueProfNode *EndVNode; COMPILER_RT_VISIBILITY extern ValueProfNode *EndVNode;
extern void (*VPMergeHook)(struct ValueProfData *, __llvm_profile_data *); extern void (*VPMergeHook)(struct ValueProfData *, __llvm_profile_data *);
/* /*
* Write binary ids into profiles if writer is given. * Write binary ids into profiles if writer is given.
* Return -1 if an error occurs, otherwise, return total size of binary ids. * Return -1 if an error occurs, otherwise, return total size of binary ids.
*/ */
int __llvm_write_binary_ids(ProfDataWriter *Writer); int __llvm_write_binary_ids(ProfDataWriter *Writer);
#endif #endif

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace.h

Show First 20 Lines • Show All 85 Lines • ▼ Show 20 Lines
#if defined(__arm__) #if defined(__arm__)
// T32 (Thumb) branch instructions might be 16 or 32 bit long, // T32 (Thumb) branch instructions might be 16 or 32 bit long,
// so we return (pc-2) in that case in order to be safe. // so we return (pc-2) in that case in order to be safe.
// For A32 mode we return (pc-4) because all instructions are 32 bit long. // For A32 mode we return (pc-4) because all instructions are 32 bit long.
return (pc - 3) & (~1); return (pc - 3) & (~1);
#elif defined(__sparc__) || defined(__mips__) #elif defined(__sparc__) || defined(__mips__)
return pc - 8; return pc - 8;
#elif SANITIZER_RISCV64 #elif SANITIZER_RISCV64
// RV-64 has variable instruciton length... // RV-64 has variable instruction length...
// C extentions gives us 2-byte instructoins // C extentions gives us 2-byte instructoins
// RV-64 has 4-byte instructions // RV-64 has 4-byte instructions
// + RISCV architecture allows instructions up to 8 bytes // + RISCV architecture allows instructions up to 8 bytes
// It seems difficult to figure out the exact instruction length - // It seems difficult to figure out the exact instruction length -
// pc - 2 seems like a safe option for the purposes of stack tracing // pc - 2 seems like a safe option for the purposes of stack tracing
return pc - 2; return pc - 2;
#elif SANITIZER_S390 || SANITIZER_I386 || SANITIZER_X32 || SANITIZER_X64 #elif SANITIZER_S390 || SANITIZER_I386 || SANITIZER_X32 || SANITIZER_X64
return pc - 1; return pc - 1;
▲ Show 20 Lines • Show All 118 Lines • Show Last 20 Lines

compiler-rt/test/asan/TestCases/leaks.cpp

Show All 9 Lines
#include <cstdlib> #include <cstdlib>
#include <stdio.h> #include <stdio.h>
#include <thread> #include <thread>
int *t; int *t;
__attribute__((noopt)) void leak(int n) { __attribute__((noopt)) void leak(int n) {
#if defined(__ANDROID__) || defined(__BIONIC__) #if defined(__ANDROID__) || defined(__BIONIC__)
// Bionic does not acutally allocate when n==0, hence // Bionic does not actually allocate when n==0, hence
// there would not be a leak. // there would not be a leak.
// Re-adjust n so the test can pass. // Re-adjust n so the test can pass.
if (n == 0) if (n == 0)
n = 1; n = 1;
#endif #endif
// Repeat few times to make sure that at least one pointer is // Repeat few times to make sure that at least one pointer is
// not somewhere on the stack. // not somewhere on the stack.
Show All 11 Lines

compiler-rt/test/hwasan/TestCases/use-after-free-and-overflow.c

Show All 40 Lines if (other)
break; break;
} }
if (!other) { if (!other) {
fprintf(stderr, "Could not find closeby allocations.\n"); fprintf(stderr, "Could not find closeby allocations.\n");
abort(); abort();
} }
__hwasan_tag_memory(Untag(one), 3, 16); __hwasan_tag_memory(Untag(one), 3, 16);
__hwasan_tag_memory(Untag(other), 3, 16); __hwasan_tag_memory(Untag(other), 3, 16);
// Tag potential adjaceant allocations with a mismatching tag, otherwise this // Tag potential adjacent allocations with a mismatching tag, otherwise this
// test would flake. // test would flake.
__hwasan_tag_memory(Untag(one) + 16, 4, 16); __hwasan_tag_memory(Untag(one) + 16, 4, 16);
__hwasan_tag_memory(Untag(one) - 16, 4, 16); __hwasan_tag_memory(Untag(one) - 16, 4, 16);
void *retagged_one = __hwasan_tag_pointer(one, 3); void *retagged_one = __hwasan_tag_pointer(one, 3);
free(retagged_one); free(retagged_one);
volatile char *ptr = (char *)retagged_one; volatile char *ptr = (char *)retagged_one;
*ptr = 1; *ptr = 1;
} }
// CHECK-NOT: Cause: heap-buffer-overflow // CHECK-NOT: Cause: heap-buffer-overflow
// CHECK: Cause: use-after-free // CHECK: Cause: use-after-free
// CHECK-NOT: Cause: heap-buffer-overflow // CHECK-NOT: Cause: heap-buffer-overflow

compiler-rt/test/orc/TestCases/Darwin/arm64/trivial-tlv.S

// Test that basic MachO TLVs work by adding together TLVs with values // Test that basic MachO TLVs work by adding together TLVs with values
// 0, 1, and -1, and returning the result (0 for success). This setup // 0, 1, and -1, and returning the result (0 for success). This setup
// tests both zero-initialized (__thread_bss) and non-zero-initialized // tests both zero-initialized (__thread_bss) and non-zero-initialized
// (__thread_data) secitons. // (__thread_data) sections.
// //
// RUN: %clang -c -o %t %s // RUN: %clang -c -o %t %s
// RUN: %llvm_jitlink %t // RUN: %llvm_jitlink %t
.section __TEXT,__text,regular,pure_instructions .section __TEXT,__text,regular,pure_instructions
.build_version macos, 12, 0 sdk_version 12, 0 .build_version macos, 12, 0 sdk_version 12, 0
.globl _main ; -- Begin function main .globl _main ; -- Begin function main
.p2align 2 .p2align 2
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

compiler-rt/test/orc/TestCases/Darwin/x86-64/trivial-tlv.S

// RUN: %clang -c -o %t %s // RUN: %clang -c -o %t %s
// RUN: %llvm_jitlink %t // RUN: %llvm_jitlink %t
// //
// Test that basic MachO TLVs work by adding together TLVs with values // Test that basic MachO TLVs work by adding together TLVs with values
// 0, 1, and -1, and returning the result (0 for success). This setup // 0, 1, and -1, and returning the result (0 for success). This setup
// tests both zero-initialized (__thread_bss) and non-zero-initialized // tests both zero-initialized (__thread_bss) and non-zero-initialized
// (__thread_data) secitons. // (__thread_data) sections.
.section __TEXT,__text,regular,pure_instructions .section __TEXT,__text,regular,pure_instructions
.build_version macos, 11, 0 .build_version macos, 11, 0
.globl _main .globl _main
.p2align 4, 0x90 .p2align 4, 0x90
_main: _main:
pushq %rax pushq %rax
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

cross-project-tests/debuginfo-tests/dexter/dex/command/commands/DexDeclareAddress.py

# DExTer : Debugging Experience Tester # DExTer : Debugging Experience Tester
# ~~~~~~ ~ ~~ ~ ~~ # ~~~~~~ ~ ~~ ~ ~~
# #
# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
# See https://llvm.org/LICENSE.txt for license information. # See https://llvm.org/LICENSE.txt for license information.
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
"""Commmand sets the path for all following commands to 'declared_file'. """Command sets the path for all following commands to 'declared_file'.
""" """
import os import os
from pathlib import PurePath from pathlib import PurePath
from dex.command.CommandBase import CommandBase, StepExpectInfo from dex.command.CommandBase import CommandBase, StepExpectInfo
class DexDeclareAddress(CommandBase): class DexDeclareAddress(CommandBase):
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

cross-project-tests/debuginfo-tests/dexter/dex/command/commands/DexDeclareFile.py

# DExTer : Debugging Experience Tester # DExTer : Debugging Experience Tester
# ~~~~~~ ~ ~~ ~ ~~ # ~~~~~~ ~ ~~ ~ ~~
# #
# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
# See https://llvm.org/LICENSE.txt for license information. # See https://llvm.org/LICENSE.txt for license information.
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
"""Commmand sets the path for all following commands to 'declared_file'. """Command sets the path for all following commands to 'declared_file'.
""" """
from pathlib import PurePath from pathlib import PurePath
from dex.command.CommandBase import CommandBase from dex.command.CommandBase import CommandBase
class DexDeclareFile(CommandBase): class DexDeclareFile(CommandBase):
Show All 16 Lines

flang/docs/Extensions.md

Show First 20 Lines • Show All 134 Lines • ▼ Show 20 Lines
* $ and \ edit descriptors are supported in FORMAT to suppress newline * $ and \ edit descriptors are supported in FORMAT to suppress newline
output on user prompts. output on user prompts.
* Tabs in format strings (not `FORMAT` statements) are allowed on output. * Tabs in format strings (not `FORMAT` statements) are allowed on output.
* REAL and DOUBLE PRECISION variable and bounds in DO loops * REAL and DOUBLE PRECISION variable and bounds in DO loops
* Integer literals without explicit kind specifiers that are out of range * Integer literals without explicit kind specifiers that are out of range
for the default kind of INTEGER are assumed to have the least larger kind for the default kind of INTEGER are assumed to have the least larger kind
that can hold them, if one exists. that can hold them, if one exists.
* BOZ literals can be used as INTEGER values in contexts where the type is * BOZ literals can be used as INTEGER values in contexts where the type is
unambiguous: the right hand sides of assigments and initializations unambiguous: the right hand sides of assignments and initializations
of INTEGER entities, as actual arguments to a few intrinsic functions of INTEGER entities, as actual arguments to a few intrinsic functions
(ACHAR, BTEST, CHAR), and as actual arguments of references to (ACHAR, BTEST, CHAR), and as actual arguments of references to
procedures with explicit interfaces whose corresponding dummy procedures with explicit interfaces whose corresponding dummy
argument has a numeric type to which the BOZ literal may be argument has a numeric type to which the BOZ literal may be
converted. BOZ literals are interpreted as default INTEGER only converted. BOZ literals are interpreted as default INTEGER only
when they appear as the first items of array constructors with no when they appear as the first items of array constructors with no
explicit type. Otherwise, they generally cannot be used if the type would explicit type. Otherwise, they generally cannot be used if the type would
not be known (e.g., `IAND(X'1',X'2')`). not be known (e.g., `IAND(X'1',X'2')`).
* BOZ literals can also be used as REAL values in some contexts where the * BOZ literals can also be used as REAL values in some contexts where the
type is unambiguous, such as initializations of REAL parameters. type is unambiguous, such as initializations of REAL parameters.
* EQUIVALENCE of numeric and character sequences (a ubiquitous extension), * EQUIVALENCE of numeric and character sequences (a ubiquitous extension),
as well as of sequences of non-default kinds of numeric types as well as of sequences of non-default kinds of numeric types
with each other. with each other.
* Values for whole anonymous parent components in structure constructors * Vues for whole anonymous parent components in structure constructors
clementvalUnsubmitted
Not Done
ReplyInline Actions

This is just wrong

clementval: This is just wrong
GabrielRavierAuthorUnsubmitted
Done
ReplyInline Actions

I'll correct it in my per-project patch

GabrielRavier: I'll correct it in my per-project patch
(e.g., `EXTENDEDTYPE(PARENTTYPE(1,2,3))` rather than `EXTENDEDTYPE(1,2,3)` (e.g., `EXTENDEDTYPE(PARENTTYPE(1,2,3))` rather than `EXTENDEDTYPE(1,2,3)`
or `EXTENDEDTYPE(PARENTTYPE=PARENTTYPE(1,2,3))`). or `EXTENDEDTYPE(PARENTTYPE=PARENTTYPE(1,2,3))`).
* Some intrinsic functions are specified in the standard as requiring the * Some intrinsic functions are specified in the standard as requiring the
same type and kind for their arguments (viz., ATAN with two arguments, same type and kind for their arguments (viz., ATAN with two arguments,
ATAN2, DIM, HYPOT, MAX, MIN, MOD, and MODULO); ATAN2, DIM, HYPOT, MAX, MIN, MOD, and MODULO);
we allow distinct types to be used, promoting we allow distinct types to be used, promoting
the arguments as if they were operands to an intrinsic `+` operator, the arguments as if they were operands to an intrinsic `+` operator,
and defining the result type accordingly. and defining the result type accordingly.
▲ Show 20 Lines • Show All 116 Lines • ▼ Show 20 Lines
* ALLOCATE(TYPE(derived)::...) as variant of correct ALLOCATE(derived::...) (PGI only) * ALLOCATE(TYPE(derived)::...) as variant of correct ALLOCATE(derived::...) (PGI only)
* Defining an explicit interface for a subprogram within itself (PGI only) * Defining an explicit interface for a subprogram within itself (PGI only)
* USE association of a procedure interface within that same procedure's definition * USE association of a procedure interface within that same procedure's definition
* NULL() as a structure constructor expression for an ALLOCATABLE component (PGI). * NULL() as a structure constructor expression for an ALLOCATABLE component (PGI).
* Conversion of LOGICAL to INTEGER in expressions. * Conversion of LOGICAL to INTEGER in expressions.
* Use of INTEGER data with the intrinsic logical operators `.NOT.`, `.AND.`, `.OR.`, * Use of INTEGER data with the intrinsic logical operators `.NOT.`, `.AND.`, `.OR.`,
and `.XOR.`. and `.XOR.`.
* IF (integer expression) THEN ... END IF (PGI/Intel) * IF (integer expression) THEN ... END IF (PGI/Intel)
* Comparsion of LOGICAL with ==/.EQ. rather than .EQV. (also .NEQV.) (PGI/Intel) * Comparison of LOGICAL with ==/.EQ. rather than .EQV. (also .NEQV.) (PGI/Intel)
* Procedure pointers in COMMON blocks (PGI/Intel) * Procedure pointers in COMMON blocks (PGI/Intel)
* Underindexing multi-dimensional arrays (e.g., A(1) rather than A(1,1)) (PGI only) * Underindexing multi-dimensional arrays (e.g., A(1) rather than A(1,1)) (PGI only)
* Legacy PGI `NCHARACTER` type and `NC` Kanji character literals * Legacy PGI `NCHARACTER` type and `NC` Kanji character literals
* Using non-integer expressions for array bounds (e.g., REAL A(3.14159)) (PGI/Intel) * Using non-integer expressions for array bounds (e.g., REAL A(3.14159)) (PGI/Intel)
* Mixing INTEGER types as operands to bit intrinsics (e.g., IAND); only two * Mixing INTEGER types as operands to bit intrinsics (e.g., IAND); only two
compilers support it, and they disagree on sign extension. compilers support it, and they disagree on sign extension.
* Module & program names that conflict with an object inside the unit (PGI only). * Module & program names that conflict with an object inside the unit (PGI only).
* When the same name is brought into scope via USE association from * When the same name is brought into scope via USE association from
▲ Show 20 Lines • Show All 114 Lines • Show Last 20 Lines

flang/docs/FIRArrayOperations.md

Show First 20 Lines • Show All 109 Lines • ▼ Show 20 Lines
``` ```
This operation merges the original loaded array value, `%v`, with the This operation merges the original loaded array value, `%v`, with the
chained updates, `%r`, and stores the result to the array at address, `%a`. chained updates, `%r`, and stores the result to the array at address, `%a`.
This operation taken with `array_load`'s captures Fortran's This operation taken with `array_load`'s captures Fortran's
copy-in/copy-out semantics. The first operands of `array_merge_store` is the copy-in/copy-out semantics. The first operands of `array_merge_store` is the
result of the initial `array_load` operation. While this value could be result of the initial `array_load` operation. While this value could be
retrieved by reference chasiing through the different array operations it is retrieved by reference chasing through the different array operations it is
useful to have it on hand directly for analysis passes since this directly useful to have it on hand directly for analysis passes since this directly
defines the "bounds" of the Fortran statement represented by these operations. defines the "bounds" of the Fortran statement represented by these operations.
The intention is to allow copy-in/copy-out regions to be easily delineated, The intention is to allow copy-in/copy-out regions to be easily delineated,
analyzed, and optimized. analyzed, and optimized.
## array_fetch ## array_fetch
The `array_fetch` operation fetches the value of an element in an array value. The `array_fetch` operation fetches the value of an element in an array value.
▲ Show 20 Lines • Show All 216 Lines • Show Last 20 Lines

flang/examples/FlangOmpReport/yaml_summarizer.py

Show All 38 Lines
Pseudo-examples: Pseudo-examples:
Summary: Summary:
$ python3 yaml_summarizer.py file_1.yaml file_2.yaml $ python3 yaml_summarizer.py file_1.yaml file_2.yaml
<Unique OMP constructs with there grouped clauses from file_1.yaml and file_2.yaml> <Unique OMP constructs with there grouped clauses from file_1.yaml and file_2.yaml>
Construcsts are in the form: Constructs are in the form:
- construct: someOMPconstruct - construct: someOMPconstruct
count: 8 count: 8
clauses: clauses:
- clause: clauseOne - clause: clauseOne
count: 4 count: 4
- clause: ClauseTwo - clause: ClauseTwo
count: 2 count: 2
▲ Show 20 Lines • Show All 227 Lines • Show Last 20 Lines

flang/lib/Optimizer/CodeGen/TargetRewrite.cpp

Show First 20 Lines • Show All 428 Lines • ▼ Show 20 Linespublic:
/// As the type signature is being changed, this must also update the /// As the type signature is being changed, this must also update the
/// function itself to use any new arguments, etc. /// function itself to use any new arguments, etc.
mlir::LogicalResult convertTypes(mlir::ModuleOp mod) { mlir::LogicalResult convertTypes(mlir::ModuleOp mod) {
for (auto fn : mod.getOps<mlir::func::FuncOp>()) for (auto fn : mod.getOps<mlir::func::FuncOp>())
convertSignature(fn); convertSignature(fn);
return mlir::success(); return mlir::success();
} }
/// If the signature does not need any special target-specific converions, /// If the signature does not need any special target-specific conversions,
/// then it is considered portable for any target, and this function will /// then it is considered portable for any target, and this function will
/// return `true`. Otherwise, the signature is not portable and `false` is /// return `true`. Otherwise, the signature is not portable and `false` is
/// returned. /// returned.
bool hasPortableSignature(mlir::Type signature) { bool hasPortableSignature(mlir::Type signature) {
assert(signature.isa<mlir::FunctionType>()); assert(signature.isa<mlir::FunctionType>());
auto func = signature.dyn_cast<mlir::FunctionType>(); auto func = signature.dyn_cast<mlir::FunctionType>();
for (auto ty : func.getResults()) for (auto ty : func.getResults())
if ((ty.isa<fir::BoxCharType>() && !noCharacterConversion) || if ((ty.isa<fir::BoxCharType>() && !noCharacterConversion) ||
▲ Show 20 Lines • Show All 406 Lines • Show Last 20 Lines

flang/lib/Semantics/check-nullify.cpp

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Lines common::visit(
}, },
}, },
pointerObject.u); pointerObject.u);
} }
// From 9.7.3.1(1) // From 9.7.3.1(1)
// A pointer-object shall not depend on the value, // A pointer-object shall not depend on the value,
// bounds, or association status of another pointer- // bounds, or association status of another pointer-
// object in the same NULLIFY statement. // object in the same NULLIFY statement.
// This restriction is the programmer's responsibilty. // This restriction is the programmer's responsibility.
// Some dependencies can be found compile time or at // Some dependencies can be found compile time or at
// runtime, but for now we choose to skip such checks. // runtime, but for now we choose to skip such checks.
} }
} // namespace Fortran::semantics } // namespace Fortran::semantics

flang/test/Driver/default-backend-pipelines.f90

! Verify that`-O{n}` is indeed taken into account when definining the LLVM backend pass pipeline. ! Verify that`-O{n}` is indeed taken into account when defining the LLVM backend pass pipeline.
! REQUIRES: aarch64-registered-target ! REQUIRES: aarch64-registered-target
! RUN: %flang_fc1 -S -O2 %s -triple aarch64-unknown-linux-gnu -mllvm -debug-pass=Structure -o /dev/null 2>&1 | FileCheck %s --check-prefix=CHECK-O2 ! RUN: %flang_fc1 -S -O2 %s -triple aarch64-unknown-linux-gnu -mllvm -debug-pass=Structure -o /dev/null 2>&1 | FileCheck %s --check-prefix=CHECK-O2
! RUN: %flang_fc1 -S -O3 %s -triple aarch64-unknown-linux-gnu -mllvm -debug-pass=Structure -o /dev/null 2>&1 | FileCheck %s --check-prefix=CHECK-O3 ! RUN: %flang_fc1 -S -O3 %s -triple aarch64-unknown-linux-gnu -mllvm -debug-pass=Structure -o /dev/null 2>&1 | FileCheck %s --check-prefix=CHECK-O3
! CHECK-O2-NOT: SVE intrinsics optimizations ! CHECK-O2-NOT: SVE intrinsics optimizations
! CHECK-O3: SVE intrinsics optimizations ! CHECK-O3: SVE intrinsics optimizations
subroutine simple_loop subroutine simple_loop
integer :: i integer :: i
do i=1,5 do i=1,5
end do end do
end subroutine end subroutine

flang/test/Semantics/altreturn06.f90

! RUN: %python %S/test_errors.py %s %flang_fc1 ! RUN: %python %S/test_errors.py %s %flang_fc1
! Test alternat return argument passing for internal and external subprograms ! Test alternate return argument passing for internal and external subprograms
! Both of the following are OK ! Both of the following are OK
call extSubprogram (*100) call extSubprogram (*100)
call intSubprogram (*100) call intSubprogram (*100)
call extSubprogram (*101) call extSubprogram (*101)
call intSubprogram (*101) call intSubprogram (*101)
100 PRINT *,'First alternate return' 100 PRINT *,'First alternate return'
!ERROR: Label '101' is not a branch target !ERROR: Label '101' is not a branch target
!ERROR: Label '101' is not a branch target !ERROR: Label '101' is not a branch target
101 FORMAT("abc") 101 FORMAT("abc")
contains contains
subroutine intSubprogram(*) subroutine intSubprogram(*)
return(1) return(1)
end subroutine end subroutine
end end

flang/test/Semantics/call27.f90

! RUN: %python %S/test_errors.py %s %flang_fc1 ! RUN: %python %S/test_errors.py %s %flang_fc1
! Catch NULL() actual argement association with allocatable dummy argument ! Catch NULL() actual argument association with allocatable dummy argument
program test program test
!ERROR: Null actual argument 'NULL()' may not be associated with allocatable dummy argument 'a=' !ERROR: Null actual argument 'NULL()' may not be associated with allocatable dummy argument 'a='
call foo1(null()) call foo1(null())
!ERROR: Null actual argument 'NULL()' may not be associated with allocatable dummy argument 'a=' !ERROR: Null actual argument 'NULL()' may not be associated with allocatable dummy argument 'a='
call foo2(null()) ! perhaps permissible later on user request call foo2(null()) ! perhaps permissible later on user request
call foo3(null()) ! ok call foo3(null()) ! ok
contains contains
subroutine foo1(a) subroutine foo1(a)
Show All 9 Lines

libc/benchmarks/automemcpy/unittests/ResultAnalyzerTest.cpp

Show All 19 Lines
namespace { namespace {
TEST(AutomemcpyJsonResultsAnalyzer, getThroughputsOneSample) { TEST(AutomemcpyJsonResultsAnalyzer, getThroughputsOneSample) {
static constexpr FunctionId Foo1 = {"memcpy1", FunctionType::MEMCPY}; static constexpr FunctionId Foo1 = {"memcpy1", FunctionType::MEMCPY};
static constexpr DistributionId DistA = {{"A"}}; static constexpr DistributionId DistA = {{"A"}};
static constexpr SampleId Id = {Foo1, DistA}; static constexpr SampleId Id = {Foo1, DistA};
static constexpr Sample kSamples[] = { static constexpr Sample kSamples[] = {
Sample{Id, SampleType::ITERATION, 4}, Sample{Id, SampleType::ITERATION, 4},
Sample{Id, SampleType::AGGREGATE, -1}, // Aggegates gets discarded Sample{Id, SampleType::AGGREGATE, -1}, // Aggregates gets discarded
}; };
const std::vector<FunctionData> Data = getThroughputs(kSamples); const std::vector<FunctionData> Data = getThroughputs(kSamples);
EXPECT_THAT(Data, SizeIs(1)); EXPECT_THAT(Data, SizeIs(1));
EXPECT_THAT(Data[0].Id, Foo1); EXPECT_THAT(Data[0].Id, Foo1);
EXPECT_THAT(Data[0].PerDistributionData, SizeIs(1)); EXPECT_THAT(Data[0].PerDistributionData, SizeIs(1));
// A single value is provided. // A single value is provided.
const auto &DistributionData = Data[0].PerDistributionData.lookup(DistA.Name); const auto &DistributionData = Data[0].PerDistributionData.lookup(DistA.Name);
▲ Show 20 Lines • Show All 155 Lines • Show Last 20 Lines

libc/cmake/modules/LLVMLibCObjectRules.cmake

Show First 20 Lines • Show All 377 Lines • ▼ Show 20 Lines if(LLVM_LIBC_ENABLE_LINTING)
endif() endif()
# We only want a second invocation of clang-tidy to run # We only want a second invocation of clang-tidy to run
# restrict-system-libc-headers if the compiler-resource-dir was set in # restrict-system-libc-headers if the compiler-resource-dir was set in
# order to prevent false-positives due to a mismatch between the host # order to prevent false-positives due to a mismatch between the host
# compiler and the compiled clang-tidy. # compiler and the compiled clang-tidy.
if(COMPILER_RESOURCE_DIR) if(COMPILER_RESOURCE_DIR)
# We run restrict-system-libc-headers with --system-headers to prevent # We run restrict-system-libc-headers with --system-headers to prevent
# transitive inclusion through compler provided headers. # transitive inclusion through compiler provided headers.
set(restrict_system_headers_check_invocation set(restrict_system_headers_check_invocation
COMMAND ${LLVM_LIBC_CLANG_TIDY} --system-headers COMMAND ${LLVM_LIBC_CLANG_TIDY} --system-headers
--checks="-*,llvmlibc-restrict-system-libc-headers" --checks="-*,llvmlibc-restrict-system-libc-headers"
# We explicitly set the resource dir here to match the # We explicitly set the resource dir here to match the
# resource dir of the host compiler. # resource dir of the host compiler.
"--extra-arg=-resource-dir=${COMPILER_RESOURCE_DIR}" "--extra-arg=-resource-dir=${COMPILER_RESOURCE_DIR}"
--quiet --quiet
-p ${PROJECT_BINARY_DIR} -p ${PROJECT_BINARY_DIR}
▲ Show 20 Lines • Show All 194 Lines • Show Last 20 Lines

libc/config/linux/app.h

Show First 20 Lines • Show All 81 Lines • ▼ Show 20 Linesstruct TLSDescriptor {
// The size of the TLS area. // The size of the TLS area.
uintptr_t size = 0; uintptr_t size = 0;
// The address of the TLS area. This address can be passed to cleanup // The address of the TLS area. This address can be passed to cleanup
// functions like munmap. // functions like munmap.
uintptr_t addr = 0; uintptr_t addr = 0;
// The value the thread pointer register should be initialized to. // The value the thread pointer register should be initialized to.
// Note that, dependending the target architecture ABI, it can be the // Note that, depending on the target architecture ABI, it can be the
// same as |addr| or something else. // same as |addr| or something else.
uintptr_t tp = 0; uintptr_t tp = 0;
constexpr TLSDescriptor() = default; constexpr TLSDescriptor() = default;
}; };
// Create and initialize the TLS area for the current thread. Should not // Create and initialize the TLS area for the current thread. Should not
// be called before app.tls has been initialized. // be called before app.tls has been initialized.
void init_tls(TLSDescriptor &tls); void init_tls(TLSDescriptor &tls);
// Cleanup the TLS area as described in |tls_descriptor|. // Cleanup the TLS area as described in |tls_descriptor|.
void cleanup_tls(uintptr_t tls_addr, uintptr_t tls_size); void cleanup_tls(uintptr_t tls_addr, uintptr_t tls_size);
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_CONFIG_LINUX_APP_H #endif // LLVM_LIBC_CONFIG_LINUX_APP_H

libc/test/src/__support/uint128_test.cpp

Show All 38 Lines
TEST(LlvmLibcUInt128ClassTest, MultiplicationTests) { TEST(LlvmLibcUInt128ClassTest, MultiplicationTests) {
LL_UInt128 val1({5, 0}); LL_UInt128 val1({5, 0});
LL_UInt128 val2({10, 0}); LL_UInt128 val2({10, 0});
LL_UInt128 result1({50, 0}); LL_UInt128 result1({50, 0});
EXPECT_EQ((val1 * val2), result1); EXPECT_EQ((val1 * val2), result1);
EXPECT_EQ((val1 * val2), (val2 * val1)); // multiplication is reciprocal EXPECT_EQ((val1 * val2), (val2 * val1)); // multiplication is reciprocal
// Check that the multiplication works accross the whole number // Check that the multiplication works across the whole number
LL_UInt128 val3({0xf, 0}); LL_UInt128 val3({0xf, 0});
LL_UInt128 val4({0x1111111111111111, 0x1111111111111111}); LL_UInt128 val4({0x1111111111111111, 0x1111111111111111});
LL_UInt128 result2({0xffffffffffffffff, 0xffffffffffffffff}); LL_UInt128 result2({0xffffffffffffffff, 0xffffffffffffffff});
EXPECT_EQ((val3 * val4), result2); EXPECT_EQ((val3 * val4), result2);
EXPECT_EQ((val3 * val4), (val4 * val3)); EXPECT_EQ((val3 * val4), (val4 * val3));
// Check that multiplication doesn't reorder the bits. // Check that multiplication doesn't reorder the bits.
LL_UInt128 val5({2, 0}); LL_UInt128 val5({2, 0});
▲ Show 20 Lines • Show All 192 Lines • Show Last 20 Lines

libc/test/src/stdio/fileop_test.cpp

//===-- Unittests for file operations like fopen, flcose etc --------------===// //===-- Unittests for file operations like fopen, fclose etc --------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/stdio/clearerr.h" #include "src/stdio/clearerr.h"
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

libc/test/src/stdio/unlocked_fileop_test.cpp

//===-- Unittests for f operations like fopen, flcose etc --------------===// //===-- Unittests for f operations like fopen, fclose etc --------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/stdio/clearerr_unlocked.h" #include "src/stdio/clearerr_unlocked.h"
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

libcxx/src/support/runtime/stdexcept_vcruntime.ipp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef _LIBCPP_ABI_VCRUNTIME #ifndef _LIBCPP_ABI_VCRUNTIME
#error This file may only be used when defering to vcruntime #error This file may only be used when deferring to vcruntime
#endif #endif
namespace std { namespace std {
logic_error::logic_error(std::string const& s) : exception(s.c_str()) {} logic_error::logic_error(std::string const& s) : exception(s.c_str()) {}
runtime_error::runtime_error(std::string const& s) : exception(s.c_str()) {} runtime_error::runtime_error(std::string const& s) : exception(s.c_str()) {}
} // namespace std } // namespace std

libunwind/docs/conf.py

Show First 20 Lines • Show All 236 Lines • ▼ Show 20 Lines
# If false, no module index is generated. # If false, no module index is generated.
#texinfo_domain_indices = True #texinfo_domain_indices = True
# How to display URL addresses: 'footnote', 'no', or 'inline'. # How to display URL addresses: 'footnote', 'no', or 'inline'.
#texinfo_show_urls = 'footnote' #texinfo_show_urls = 'footnote'
# FIXME: Define intersphinx configration. # FIXME: Define intersphinx configuration.
intersphinx_mapping = {} intersphinx_mapping = {}
# -- Options for extensions ---------------------------------------------------- # -- Options for extensions ----------------------------------------------------
# Enable this if you want TODOs to show up in the generated documentation. # Enable this if you want TODOs to show up in the generated documentation.
todo_include_todos = True todo_include_todos = True

lld/ELF/InputSection.cpp

Show First 20 Lines • Show All 914 Lines • ▼ Show 20 Lines if (expr != R_PC && expr != R_ARM_PCA) {
return; return;
} }
// If the control reaches here, we found a PC-relative relocation in a // If the control reaches here, we found a PC-relative relocation in a
// non-ALLOC section. Since non-ALLOC section is not loaded into memory // non-ALLOC section. Since non-ALLOC section is not loaded into memory
// at runtime, the notion of PC-relative doesn't make sense here. So, // at runtime, the notion of PC-relative doesn't make sense here. So,
// this is a usage error. However, GNU linkers historically accept such // this is a usage error. However, GNU linkers historically accept such
// relocations without any errors and relocate them as if they were at // relocations without any errors and relocate them as if they were at
// address 0. For bug-compatibilty, we accept them with warnings. We // address 0. For bug-compatibility, we accept them with warnings. We
// know Steel Bank Common Lisp as of 2018 have this bug. // know Steel Bank Common Lisp as of 2018 have this bug.
warn(msg); warn(msg);
target.relocateNoSym( target.relocateNoSym(
bufLoc, type, bufLoc, type,
SignExtend64<bits>(sym.getVA(addend - offset - outSecOff))); SignExtend64<bits>(sym.getVA(addend - offset - outSecOff)));
} }
} }
▲ Show 20 Lines • Show All 535 Lines • Show Last 20 Lines

lld/MachO/Options.td

Show First 20 Lines • Show All 317 Lines • ▼ Show 20 Linesdef merge_zero_fill_sections : Flag<["-"], "merge_zero_fill_sections">,
HelpText<"Merge all zeroed data into the __zerofill section">, HelpText<"Merge all zeroed data into the __zerofill section">,
Flags<[HelpHidden]>, Flags<[HelpHidden]>,
Group<grp_opts>; Group<grp_opts>;
def no_branch_islands : Flag<["-"], "no_branch_islands">, def no_branch_islands : Flag<["-"], "no_branch_islands">,
HelpText<"Disable infra for branches beyond the maximum branch distance.">, HelpText<"Disable infra for branches beyond the maximum branch distance.">,
Flags<[HelpHidden]>, Flags<[HelpHidden]>,
Group<grp_opts>; Group<grp_opts>;
def no_deduplicate : Flag<["-"], "no_deduplicate">, def no_deduplicate : Flag<["-"], "no_deduplicate">,
HelpText<"Disable code deduplicaiton (synonym for `--icf=none')">, HelpText<"Disable code deduplication (synonym for `--icf=none')">,
Alias<icf_eq>, AliasArgs<["none"]>, Alias<icf_eq>, AliasArgs<["none"]>,
Group<grp_opts>; Group<grp_opts>;
def grp_version : OptionGroup<"version">, HelpText<"VERSION TARGETING">; def grp_version : OptionGroup<"version">, HelpText<"VERSION TARGETING">;
def platform_version : MultiArg<["-"], "platform_version", 3>, def platform_version : MultiArg<["-"], "platform_version", 3>,
MetaVarName<"<platform> <min_version> <sdk_version>">, MetaVarName<"<platform> <min_version> <sdk_version>">,
HelpText<"Platform (e.g., macos, ios, tvos, watchos, bridgeos, mac-catalyst, ios-sim, tvos-sim, watchos-sim, driverkit) and version numbers">, HelpText<"Platform (e.g., macos, ios, tvos, watchos, bridgeos, mac-catalyst, ios-sim, tvos-sim, watchos-sim, driverkit) and version numbers">,
▲ Show 20 Lines • Show All 1,020 Lines • Show Last 20 Lines

lld/test/ELF/common-archive-lookup.s

Show First 20 Lines • Show All 85 Lines • ▼ Show 20 Lines
# NFC: Name: block # NFC: Name: block
# NFC-NEXT: Value: # NFC-NEXT: Value:
# NFC-NEXT: Size: 40 # NFC-NEXT: Size: 40
# NFC-NEXT: Binding: Global (0x1) # NFC-NEXT: Binding: Global (0x1)
# NFC-NEXT: Type: Object (0x1) # NFC-NEXT: Type: Object (0x1)
# NFC-NEXT: Other: 0 # NFC-NEXT: Other: 0
# NFC-NEXT: Section: .bss # NFC-NEXT: Section: .bss
## Expecting the strong definition from the object file, and the defintions from ## Expecting the strong definition from the object file, and the definitions from
## the archive do not interfere. ## the archive do not interfere.
# TEST2-LABEL: Disassembly of section .data: # TEST2-LABEL: Disassembly of section .data:
# TEST2: <block>: # TEST2: <block>:
# TEST2-NEXT: 03 57 14 8b # TEST2-NEXT: 03 57 14 8b
# TEST2-NEXT: 0a bf 05 40 # TEST2-NEXT: 0a bf 05 40
# TEST2-NEXT: ... # TEST2-NEXT: ...
# MAP: 28 8 3.a(2.o):(.data) # MAP: 28 8 3.a(2.o):(.data)
▲ Show 20 Lines • Show All 97 Lines • Show Last 20 Lines

lld/test/ELF/init-fini.s

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
// NOENTRY-NOT: INIT // NOENTRY-NOT: INIT
// NOENTRY-NOT: FINI // NOENTRY-NOT: FINI
// NOENTRY: ] // NOENTRY: ]
// NOENTRY: Symbols [ // NOENTRY: Symbols [
// NOENTRY-NOT: Name: _unknown // NOENTRY-NOT: Name: _unknown
// NOENTRY: ] // NOENTRY: ]
// Should not add entries for "_init" and "_fini" to the symbol table // Should not add entries for "_init" and "_fini" to the symbol table
// if the symbols are defined in non-fetched achive members. // if the symbols are defined in non-fetched archive members.
// RUN: rm -f %t.a // RUN: rm -f %t.a
// RUN: llvm-ar rcs %t.a %t // RUN: llvm-ar rcs %t.a %t
// RUN: ld.lld -shared -m elf_x86_64 -e _unknown %t.a -o %t.so // RUN: ld.lld -shared -m elf_x86_64 -e _unknown %t.a -o %t.so
// RUN: llvm-nm %t.so | \ // RUN: llvm-nm %t.so | \
// RUN: FileCheck %s --implicit-check-not=_init --implicit-check-not=_fini // RUN: FileCheck %s --implicit-check-not=_init --implicit-check-not=_fini
.global _start,_init,_fini,_foo,_bar,_undef .global _start,_init,_fini,_foo,_bar,_undef
_start: _start:
_init = 0x11010 _init = 0x11010
_fini = 0x11020 _fini = 0x11020
_foo = 0x11030 _foo = 0x11030
_bar = 0x11040 _bar = 0x11040

lld/test/ELF/lto/duplicated-name.ll

; REQUIRES: x86 ; REQUIRES: x86
; Cretae two archive with the same member name ; Create two archive with the same member name
; RUN: rm -f %t1.a %t2.a ; RUN: rm -f %t1.a %t2.a
; RUN: opt -module-summary %s -o %t.o ; RUN: opt -module-summary %s -o %t.o
; RUN: llvm-ar rcS %t1.a %t.o ; RUN: llvm-ar rcS %t1.a %t.o
; RUN: opt -module-summary %p/Inputs/duplicated-name.ll -o %t.o ; RUN: opt -module-summary %p/Inputs/duplicated-name.ll -o %t.o
; RUN: llvm-ar rcS %t2.a %t.o ; RUN: llvm-ar rcS %t2.a %t.o
; RUN: ld.lld -m elf_x86_64 -shared -o %t.so -uf1 -uf2 %t1.a %t2.a ; RUN: ld.lld -m elf_x86_64 -shared -o %t.so -uf1 -uf2 %t1.a %t2.a
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @f1() { define void @f1() {
ret void ret void
} }

lld/test/MachO/tools/generate-cfi-funcs.py

Show First 20 Lines • Show All 61 Lines • ▼ Show 20 Lines if have_lsda:
.section __TEXT,__gcc_except_tab .section __TEXT,__gcc_except_tab
.p2align 2 .p2align 2
Lexception%d: Lexception%d:
.space 0x10 .space 0x10
""" % lsda_n) """ % lsda_n)
return func_size return func_size
def random_seed(): def random_seed():
"""Generate a seed that can easily be passsed back in via --seed=STRING""" """Generate a seed that can easily be passed back in via --seed=STRING"""
return ''.join(random.choice(string.ascii_lowercase) for i in range(10)) return ''.join(random.choice(string.ascii_lowercase) for i in range(10))
def main(): def main():
parser = argparse.ArgumentParser( parser = argparse.ArgumentParser(
description=__doc__, description=__doc__,
epilog="""\ epilog="""\
Function sizes begin small then monotonically increase. The goal is Function sizes begin small then monotonically increase. The goal is
to produce early pages that are full and later pages that are less to produce early pages that are full and later pages that are less
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

lld/test/MachO/tools/generate-thunkable-program.py

Show First 20 Lines • Show All 356 Lines • ▼ Show 20 Lines### %s size=%x calls=%x""" % (name, size, calls))
fill = size - 4 * (calls + 1) fill = size - 4 * (calls + 1)
assert fill > 0 assert fill > 0
print("""\ print("""\
.fill 0x%x .fill 0x%x
ret""" % (fill)) ret""" % (fill))
print_here_tail() print_here_tail()
def random_seed(): def random_seed():
"""Generate a seed that can easily be passsed back in via --seed=STRING""" """Generate a seed that can easily be passed back in via --seed=STRING"""
return ''.join(random.choice(string.ascii_lowercase) for i in range(10)) return ''.join(random.choice(string.ascii_lowercase) for i in range(10))
def generate_sizes(base, megabytes): def generate_sizes(base, megabytes):
total = 0 total = 0
while total < megabytes: while total < megabytes:
size = random.randint(0x100, 0x10000) * 0x10 size = random.randint(0x100, 0x10000) * 0x10
yield size yield size
total += size total += size
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

lld/test/wasm/debuginfo-undefined-global.s

# RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t.o %s # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t.o %s
# RUN: wasm-ld -o %t.wasm %t.o # RUN: wasm-ld -o %t.wasm %t.o
# RUN: obj2yaml %t.wasm | FileCheck %s # RUN: obj2yaml %t.wasm | FileCheck %s
# Debug sections are allowed to contains references to non-live symbols that # Debug sections are allowed to contains references to non-live symbols that
# then get GC'd. In this test the .debug_info seciton contains a reference to # then get GC'd. In this test the .debug_info section contains a reference to
# foo which is not otherwise used and will not be marked a live in the output. # foo which is not otherwise used and will not be marked a live in the output.
# Verify the tombstone value is written to debug_info section. # Verify the tombstone value is written to debug_info section.
.globaltype foo, i32 .globaltype foo, i32
.globl _start .globl _start
_start: _start:
.functype _start () -> () .functype _start () -> ()
Show All 10 Lines

lldb/bindings/interface/SBProcess.i

Show First 20 Lines • Show All 416 Lines • ▼ Show 20 Lines use IsValid() to check if the info returned is valid. ::
process_info = process.GetProcessInfo() process_info = process.GetProcessInfo()
if process_info.IsValid(): if process_info.IsValid():
process_info.GetProcessID()") GetProcessInfo; process_info.GetProcessID()") GetProcessInfo;
lldb::SBProcessInfo lldb::SBProcessInfo
GetProcessInfo(); GetProcessInfo();
%feature("autodoc", " %feature("autodoc", "
Allocates a block of memory within the process, with size and Allocates a block of memory within the process, with size and
access permissions specified in the arguments. The permisssions access permissions specified in the arguments. The permissions
argument is an or-combination of zero or more of argument is an or-combination of zero or more of
lldb.ePermissionsWritable, lldb.ePermissionsReadable, and lldb.ePermissionsWritable, lldb.ePermissionsReadable, and
lldb.ePermissionsExecutable. Returns the address lldb.ePermissionsExecutable. Returns the address
of the allocated buffer in the process, or of the allocated buffer in the process, or
lldb.LLDB_INVALID_ADDRESS if the allocation failed.") AllocateMemory; lldb.LLDB_INVALID_ADDRESS if the allocation failed.") AllocateMemory;
lldb::addr_t lldb::addr_t
AllocateMemory(size_t size, uint32_t permissions, lldb::SBError &error); AllocateMemory(size_t size, uint32_t permissions, lldb::SBError &error);
▲ Show 20 Lines • Show All 94 Lines • Show Last 20 Lines

lldb/bindings/interface/SBType.i

Show First 20 Lines • Show All 531 Lines • ▼ Show 20 Linespublic:
") GetVectorElementType; ") GetVectorElementType;
lldb::SBType lldb::SBType
GetVectorElementType (); GetVectorElementType ();
%feature("docstring", %feature("docstring",
"Returns the `BasicType` value that is most appropriate to this type. "Returns the `BasicType` value that is most appropriate to this type.
Returns `eBasicTypeInvalid` if no appropriate `BasicType` was found or this Returns `eBasicTypeInvalid` if no appropriate `BasicType` was found or this
type is invalid. See the `BasicType` documentation for the language-specific m type is invalid. See the `BasicType` documentation for the language-specific
aning of each `BasicType` value. meaning of each `BasicType` value.
**Overload behaviour:** When called with a `BasicType` parameter, the **Overload behaviour:** When called with a `BasicType` parameter, the
following behaviour applies: following behaviour applies:
Returns the `SBType` that represents the passed `BasicType` value. Returns Returns the `SBType` that represents the passed `BasicType` value. Returns
an invalid `SBType` if no fitting `SBType` could be created. an invalid `SBType` if no fitting `SBType` could be created.
Language-specific behaviour: Language-specific behaviour:
▲ Show 20 Lines • Show All 176 Lines • ▼ Show 20 Linespublic:
"Returns the number of template arguments of this type. "Returns the number of template arguments of this type.
Returns ``0`` if this type is not a template. Returns ``0`` if this type is not a template.
Language-specific behaviour: Language-specific behaviour:
* C: Always returns ``0``. * C: Always returns ``0``.
* C++: If this type is a class template instantiation then this returns the * C++: If this type is a class template instantiation then this returns the
number of template parameters that were used in this instantiation. This i number of template parameters that were used in this instantiation. This
cludes both explicit and implicit template parameters. includes both explicit and implicit template parameters.
* Objective-C: Always returns ``0``. * Objective-C: Always returns ``0``.
") GetNumberOfTemplateArguments; ") GetNumberOfTemplateArguments;
uint32_t uint32_t
GetNumberOfTemplateArguments (); GetNumberOfTemplateArguments ();
%feature("docstring", %feature("docstring",
"Returns the type of the template argument with the given index. "Returns the type of the template argument with the given index.
▲ Show 20 Lines • Show All 320 Lines • Show Last 20 Lines

lldb/docs/use/python-reference.rst

Show First 20 Lines • Show All 602 Lines • ▼ Show 20 Lines if __name__ == '__main__':
# lldb.debugger, so we can just create it if it will be needed # lldb.debugger, so we can just create it if it will be needed
debugger = lldb.SBDebugger.Create() debugger = lldb.SBDebugger.Create()
# Next, do whatever work this module should do when run as a command. # Next, do whatever work this module should do when run as a command.
# ... # ...
# Finally, dispose of the debugger you just made. # Finally, dispose of the debugger you just made.
lldb.SBDebugger.Destroy(debugger) lldb.SBDebugger.Destroy(debugger)
# Terminate the debug sesssion # Terminate the debug session
lldb.SBDebugger.Terminate() lldb.SBDebugger.Terminate()
Now we can create a module called ls.py in the file ~/ls.py that will implement Now we can create a module called ls.py in the file ~/ls.py that will implement
a function that can be used by LLDB's python command code: a function that can be used by LLDB's python command code:
:: ::
▲ Show 20 Lines • Show All 315 Lines • Show Last 20 Lines

lldb/examples/python/armv7_cortex_m_target_defintion.py

Show All 25 Lines
# to change and add new registers without requiring a new LLDB build # to change and add new registers without requiring a new LLDB build
# just so we can see new registers. # just so we can see new registers.
# #
# This file implements the x86_64 registers for the darwin version of # This file implements the x86_64 registers for the darwin version of
# GDB and allows you to connect to servers that use this register set. # GDB and allows you to connect to servers that use this register set.
# #
# USAGE # USAGE
# #
# (lldb) settings set plugin.process.gdb-remote.target-definition-file /path/to/armv7_cortex_m_target_defintion.py # (lldb) settings set plugin.process.gdb-remote.target-definition-file /path/to/armv7_cortex_m_target_definition.py
# (lldb) gdb-remote other.baz.com:1234 # (lldb) gdb-remote other.baz.com:1234
# #
# The target definition file will get used if and only if the # The target definition file will get used if and only if the
# qRegisterInfo packets are not supported when connecting to a remote # qRegisterInfo packets are not supported when connecting to a remote
# GDB server. # GDB server.
#---------------------------------------------------------------------- #----------------------------------------------------------------------
from lldb import * from lldb import *
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

lldb/examples/python/lldb_module_utils.py

#!/usr/bin/env python #!/usr/bin/env python
from __future__ import print_function from __future__ import print_function
import lldb import lldb
import optparse import optparse
import shlex import shlex
import string import string
import sys import sys
class DumpLineTables: class DumpLineTables:
command_name = "dump-line-tables" command_name = "dump-line-tables"
short_decription = "Dumps full paths to compile unit files and optionally all line table files." short_description = "Dumps full paths to compile unit files and optionally all line table files."
description = 'Dumps all line tables from all compile units for any modules specified as arguments. Specifying the --verbose flag will output address ranges for each line entry.' description = 'Dumps all line tables from all compile units for any modules specified as arguments. Specifying the --verbose flag will output address ranges for each line entry.'
usage = "usage: %prog [options] MODULE1 [MODULE2 ...]" usage = "usage: %prog [options] MODULE1 [MODULE2 ...]"
def create_options(self): def create_options(self):
self.parser = optparse.OptionParser( self.parser = optparse.OptionParser(
description=self.description, description=self.description,
prog=self.command_name, prog=self.command_name,
usage=self.usage) usage=self.usage)
self.parser.add_option( self.parser.add_option(
'-v', '-v',
'--verbose', '--verbose',
action='store_true', action='store_true',
dest='verbose', dest='verbose',
help='Display verbose output.', help='Display verbose output.',
default=False) default=False)
def get_short_help(self): def get_short_help(self):
return self.short_decription return self.short_description
def get_long_help(self): def get_long_help(self):
return self.help_string return self.help_string
def __init__(self, debugger, unused): def __init__(self, debugger, unused):
self.create_options() self.create_options()
self.help_string = self.parser.format_help() self.help_string = self.parser.format_help()
▲ Show 20 Lines • Show All 153 Lines • Show Last 20 Lines

lldb/include/lldb/Core/Debugger.h

Show First 20 Lines • Show All 398 Lines • ▼ Show 20 Linespublic:
/// debugger identifier that this progress should be delivered to. If this /// debugger identifier that this progress should be delivered to. If this
/// optional parameter does not have a value, the progress will be /// optional parameter does not have a value, the progress will be
/// delivered to all debuggers. /// delivered to all debuggers.
/// ///
/// \param [in] once /// \param [in] once
/// If a pointer is passed to a std::once_flag, then it will be used to /// If a pointer is passed to a std::once_flag, then it will be used to
/// ensure the given warning is only broadcast once. /// ensure the given warning is only broadcast once.
static void static void
ReportWarning(std::string messsage, ReportWarning(std::string message,
llvm::Optional<lldb::user_id_t> debugger_id = llvm::None, llvm::Optional<lldb::user_id_t> debugger_id = llvm::None,
std::once_flag *once = nullptr); std::once_flag *once = nullptr);
/// Report error events. /// Report error events.
/// ///
/// Progress events will be delivered to any debuggers that have listeners /// Progress events will be delivered to any debuggers that have listeners
/// for the eBroadcastBitError. /// for the eBroadcastBitError.
/// ///
/// \param[in] message /// \param[in] message
/// The error message to be reported. /// The error message to be reported.
/// ///
/// \param [in] debugger_id /// \param [in] debugger_id
/// If this optional parameter has a value, it indicates the unique /// If this optional parameter has a value, it indicates the unique
/// debugger identifier that this progress should be delivered to. If this /// debugger identifier that this progress should be delivered to. If this
/// optional parameter does not have a value, the progress will be /// optional parameter does not have a value, the progress will be
/// delivered to all debuggers. /// delivered to all debuggers.
/// ///
/// \param [in] once /// \param [in] once
/// If a pointer is passed to a std::once_flag, then it will be used to /// If a pointer is passed to a std::once_flag, then it will be used to
/// ensure the given error is only broadcast once. /// ensure the given error is only broadcast once.
static void static void
ReportError(std::string messsage, ReportError(std::string message,
llvm::Optional<lldb::user_id_t> debugger_id = llvm::None, llvm::Optional<lldb::user_id_t> debugger_id = llvm::None,
std::once_flag *once = nullptr); std::once_flag *once = nullptr);
protected: protected:
friend class CommandInterpreter; friend class CommandInterpreter;
friend class REPL; friend class REPL;
friend class Progress; friend class Progress;
▲ Show 20 Lines • Show All 152 Lines • Show Last 20 Lines

lldb/include/lldb/Core/Mangled.h

Show All 20 Lines
namespace lldb_private { namespace lldb_private {
/// \class Mangled Mangled.h "lldb/Core/Mangled.h" /// \class Mangled Mangled.h "lldb/Core/Mangled.h"
/// A class that handles mangled names. /// A class that handles mangled names.
/// ///
/// Designed to handle mangled names. The demangled version of any names will /// Designed to handle mangled names. The demangled version of any names will
/// be computed when the demangled name is accessed through the Demangled() /// be computed when the demangled name is accessed through the Demangled()
/// acccessor. This class can also tokenize the demangled version of the name /// accessor. This class can also tokenize the demangled version of the name
/// for powerful searches. Functions and symbols could make instances of this /// for powerful searches. Functions and symbols could make instances of this
/// class for their mangled names. Uniqued string pools are used for the /// class for their mangled names. Uniqued string pools are used for the
/// mangled, demangled, and token string values to allow for faster /// mangled, demangled, and token string values to allow for faster
/// comparisons and for efficient memory use. /// comparisons and for efficient memory use.
class Mangled { class Mangled {
public: public:
enum NamePreference { enum NamePreference {
ePreferMangled, ePreferMangled,
▲ Show 20 Lines • Show All 266 Lines • Show Last 20 Lines

lldb/include/lldb/Symbol/Type.h

Show First 20 Lines • Show All 117 Lines • ▼ Show 20 Linespublic:
/// Since Type instances only keep a "SymbolFile *" internally, other classes /// Since Type instances only keep a "SymbolFile *" internally, other classes
/// like TypeImpl need make sure the module is still around before playing /// like TypeImpl need make sure the module is still around before playing
/// with /// with
/// Type instances. They can store a weak pointer to the Module; /// Type instances. They can store a weak pointer to the Module;
lldb::ModuleSP GetModule(); lldb::ModuleSP GetModule();
/// GetModule may return module for compile unit's object file. /// GetModule may return module for compile unit's object file.
/// GetExeModule returns module for executable object file that contains /// GetExeModule returns module for executable object file that contains
/// compile unit where type was actualy defined. /// compile unit where type was actually defined.
/// GetModule and GetExeModule may return the same value. /// GetModule and GetExeModule may return the same value.
lldb::ModuleSP GetExeModule(); lldb::ModuleSP GetExeModule();
void GetDescription(Stream *s, lldb::DescriptionLevel level, bool show_name, void GetDescription(Stream *s, lldb::DescriptionLevel level, bool show_name,
ExecutionContextScope *exe_scope); ExecutionContextScope *exe_scope);
SymbolFile *GetSymbolFile() { return m_symbol_file; } SymbolFile *GetSymbolFile() { return m_symbol_file; }
const SymbolFile *GetSymbolFile() const { return m_symbol_file; } const SymbolFile *GetSymbolFile() const { return m_symbol_file; }
▲ Show 20 Lines • Show All 394 Lines • Show Last 20 Lines

lldb/packages/Python/lldbsuite/test/lldbbench.py

from __future__ import absolute_import from __future__ import absolute_import
# System modules # System modules
import time import time
# Third-party modules # Third-party modules
# LLDB modules # LLDB modules
from .lldbtest import * from .lldbtest import *
class Stopwatch(object): class Stopwatch(object):
"""Stopwatch provides a simple utility to start/stop your stopwatch multiple """Stopwatch provides a simple utility to start/stop your stopwatch multiple
times. Each start/stop is equal to a lap, with its elapsed time accumulated times. Each start/stop is equal to a lap, with its elapsed time accumulated
while measurment is in progress. while measurement is in progress.
When you're ready to start from scratch for another round of measurements, When you're ready to start from scratch for another round of measurements,
be sure to call the reset() method. be sure to call the reset() method.
For example, For example,
sw = Stopwatch() sw = Stopwatch()
for i in range(1000): for i in range(1000):
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

lldb/source/Core/DynamicLoader.cpp

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Lines for (uint32_t idx = 0;
return instance_up.release(); return instance_up.release();
} }
} }
return nullptr; return nullptr;
} }
DynamicLoader::DynamicLoader(Process *process) : m_process(process) {} DynamicLoader::DynamicLoader(Process *process) : m_process(process) {}
// Accessosors to the global setting as to whether to stop at image (shared // Accessors to the global setting as to whether to stop at image (shared
// library) loading/unloading. // library) loading/unloading.
bool DynamicLoader::GetStopWhenImagesChange() const { bool DynamicLoader::GetStopWhenImagesChange() const {
return m_process->GetStopOnSharedLibraryEvents(); return m_process->GetStopOnSharedLibraryEvents();
} }
void DynamicLoader::SetStopWhenImagesChange(bool stop) { void DynamicLoader::SetStopWhenImagesChange(bool stop) {
m_process->SetStopOnSharedLibraryEvents(stop); m_process->SetStopOnSharedLibraryEvents(stop);
▲ Show 20 Lines • Show All 130 Lines • Show Last 20 Lines

lldb/source/Core/IOHandlerCursesGUI.cpp

Show First 20 Lines • Show All 3,106 Lines • ▼ Show 20 Lines void UpdateFieldsVisibility() override {
} }
} }
static constexpr const char *kLoadDependentFilesNo = "No"; static constexpr const char *kLoadDependentFilesNo = "No";
static constexpr const char *kLoadDependentFilesYes = "Yes"; static constexpr const char *kLoadDependentFilesYes = "Yes";
static constexpr const char *kLoadDependentFilesExecOnly = "Executable only"; static constexpr const char *kLoadDependentFilesExecOnly = "Executable only";
std::vector<std::string> GetLoadDependentFilesChoices() { std::vector<std::string> GetLoadDependentFilesChoices() {
std::vector<std::string> load_depentents_options; std::vector<std::string> load_dependents_options;
load_depentents_options.push_back(kLoadDependentFilesExecOnly); load_dependents_options.push_back(kLoadDependentFilesExecOnly);
load_depentents_options.push_back(kLoadDependentFilesYes); load_dependents_options.push_back(kLoadDependentFilesYes);
load_depentents_options.push_back(kLoadDependentFilesNo); load_dependents_options.push_back(kLoadDependentFilesNo);
return load_depentents_options; return load_dependents_options;
} }
LoadDependentFiles GetLoadDependentFiles() { LoadDependentFiles GetLoadDependentFiles() {
std::string choice = m_load_dependent_files_field->GetChoiceContent(); std::string choice = m_load_dependent_files_field->GetChoiceContent();
if (choice == kLoadDependentFilesNo) if (choice == kLoadDependentFilesNo)
return eLoadDependentsNo; return eLoadDependentsNo;
if (choice == kLoadDependentFilesYes) if (choice == kLoadDependentFilesYes)
return eLoadDependentsYes; return eLoadDependentsYes;
▲ Show 20 Lines • Show All 4,602 Lines • Show Last 20 Lines

lldb/source/Expression/DWARFExpression.cpp

Show First 20 Lines • Show All 465 Lines • ▼ Show 20 Lines case DW_OP_const8u:
break; break;
case DW_OP_form_tls_address: case DW_OP_form_tls_address:
case DW_OP_GNU_push_tls_address: case DW_OP_GNU_push_tls_address:
// DW_OP_form_tls_address and DW_OP_GNU_push_tls_address must be preceded // DW_OP_form_tls_address and DW_OP_GNU_push_tls_address must be preceded
// by a file address on the stack. We assume that DW_OP_const4u or // by a file address on the stack. We assume that DW_OP_const4u or
// DW_OP_const8u is used for these values, and we check that the last // DW_OP_const8u is used for these values, and we check that the last
// opcode we got before either of these was DW_OP_const4u or // opcode we got before either of these was DW_OP_const4u or
// DW_OP_const8u. If so, then we can link the value accodingly. For // DW_OP_const8u. If so, then we can link the value accordingly. For
// Darwin, the value in the DW_OP_const4u or DW_OP_const8u is the file // Darwin, the value in the DW_OP_const4u or DW_OP_const8u is the file
// address of a structure that contains a function pointer, the pthread // address of a structure that contains a function pointer, the pthread
// key and the offset into the data pointed to by the pthread key. So we // key and the offset into the data pointed to by the pthread key. So we
// must link this address and also set the module of this expression to // must link this address and also set the module of this expression to
// the new_module_sp so we can resolve the file address correctly // the new_module_sp so we can resolve the file address correctly
if (const_byte_size > 0) { if (const_byte_size > 0) {
lldb::addr_t linked_file_addr = link_address_callback(const_value); lldb::addr_t linked_file_addr = link_address_callback(const_value);
if (linked_file_addr == LLDB_INVALID_ADDRESS) if (linked_file_addr == LLDB_INVALID_ADDRESS)
▲ Show 20 Lines • Show All 247 Lines • ▼ Show 20 Linesenum LocationDescriptionKind {
/* Composite*/ /* Composite*/
}; };
/// Adjust value's ValueType according to the kind of location description. /// Adjust value's ValueType according to the kind of location description.
void UpdateValueTypeFromLocationDescription(Log *log, const DWARFUnit *dwarf_cu, void UpdateValueTypeFromLocationDescription(Log *log, const DWARFUnit *dwarf_cu,
LocationDescriptionKind kind, LocationDescriptionKind kind,
Value *value = nullptr) { Value *value = nullptr) {
// Note that this function is conflating DWARF expressions with // Note that this function is conflating DWARF expressions with
// DWARF location descriptions. Perhaps it would be better to define // DWARF location descriptions. Perhaps it would be better to define
// a wrapper for DWARFExpresssion::Eval() that deals with DWARF // a wrapper for DWARFExpression::Eval() that deals with DWARF
// location descriptions (which consist of one or more DWARF // location descriptions (which consist of one or more DWARF
// expressions). But doing this would mean we'd also need factor the // expressions). But doing this would mean we'd also need factor the
// handling of DW_OP_(bit_)piece out of this function. // handling of DW_OP_(bit_)piece out of this function.
if (dwarf_cu && dwarf_cu->GetVersion() >= 4) { if (dwarf_cu && dwarf_cu->GetVersion() >= 4) {
const char *log_msg = "DWARF location description kind: %s"; const char *log_msg = "DWARF location description kind: %s";
switch (kind) { switch (kind) {
case Empty: case Empty:
LLDB_LOGF(log, log_msg, "Empty"); LLDB_LOGF(log, log_msg, "Empty");
Show All 21 Lines
/// into a load address. /// into a load address.
/// ///
/// \param exe_ctx Pointer to the execution context /// \param exe_ctx Pointer to the execution context
/// \param module_sp shared_ptr contains the module if we have one /// \param module_sp shared_ptr contains the module if we have one
/// \param error_ptr pointer to Status object if we have one /// \param error_ptr pointer to Status object if we have one
/// \param dw_op_type C-style string used to vary the error output /// \param dw_op_type C-style string used to vary the error output
/// \param file_addr the file address we are trying to resolve and turn into a /// \param file_addr the file address we are trying to resolve and turn into a
/// load address /// load address
/// \param so_addr out parameter, will be set to load addresss or section offset /// \param so_addr out parameter, will be set to load address or section offset
/// \param check_sectionoffset bool which determines if having a section offset /// \param check_sectionoffset bool which determines if having a section offset
/// but not a load address is considerd a success /// but not a load address is considerd a success
/// \returns llvm::Optional containing the load address if resolving and getting /// \returns llvm::Optional containing the load address if resolving and getting
/// the load address succeed or an empty Optinal otherwise. If /// the load address succeed or an empty Optinal otherwise. If
/// check_sectionoffset is true we consider LLDB_INVALID_ADDRESS a /// check_sectionoffset is true we consider LLDB_INVALID_ADDRESS a
/// success if so_addr.IsSectionOffset() is true. /// success if so_addr.IsSectionOffset() is true.
static llvm::Optional<lldb::addr_t> static llvm::Optional<lldb::addr_t>
ResolveLoadAddress(ExecutionContext *exe_ctx, lldb::ModuleSP &module_sp, ResolveLoadAddress(ExecutionContext *exe_ctx, lldb::ModuleSP &module_sp,
▲ Show 20 Lines • Show All 1,908 Lines • Show Last 20 Lines

lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp

Show First 20 Lines • Show All 586 Lines • ▼ Show 20 Lines if (ModuleSP module_sp = DynamicLoader::LoadModuleAtAddress(
file, link_map_addr, base_addr, base_addr_is_offset)) file, link_map_addr, base_addr, base_addr_is_offset))
return module_sp; return module_sp;
// This works around an dynamic linker "bug" on android <= 23, where the // This works around an dynamic linker "bug" on android <= 23, where the
// dynamic linker would report the application name // dynamic linker would report the application name
// (e.g. com.example.myapplication) instead of the main process binary // (e.g. com.example.myapplication) instead of the main process binary
// (/system/bin/app_process(32)). The logic is not sound in general (it // (/system/bin/app_process(32)). The logic is not sound in general (it
// assumes base_addr is the real address, even though it actually is a load // assumes base_addr is the real address, even though it actually is a load
// bias), but it happens to work on adroid because app_process has a file // bias), but it happens to work on android because app_process has a file
// address of zero. // address of zero.
// This should be removed after we drop support for android-23. // This should be removed after we drop support for android-23.
if (m_process->GetTarget().GetArchitecture().GetTriple().isAndroid()) { if (m_process->GetTarget().GetArchitecture().GetTriple().isAndroid()) {
MemoryRegionInfo memory_info; MemoryRegionInfo memory_info;
Status error = m_process->GetMemoryRegionInfo(base_addr, memory_info); Status error = m_process->GetMemoryRegionInfo(base_addr, memory_info);
if (error.Success() && memory_info.GetMapped() && if (error.Success() && memory_info.GetMapped() &&
memory_info.GetRange().GetRangeBase() == base_addr && memory_info.GetRange().GetRangeBase() == base_addr &&
!(memory_info.GetName().IsEmpty())) { !(memory_info.GetName().IsEmpty())) {
▲ Show 20 Lines • Show All 228 Lines • Show Last 20 Lines

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

Show First 20 Lines • Show All 1,909 Lines • ▼ Show 20 Lines if (copied_function_type) {
function_type->GetName(), function_type->GetID()); function_type->GetName(), function_type->GetID());
return; return;
} }
} else { } else {
// We failed to copy the type we found // We failed to copy the type we found
LLDB_LOG(log, LLDB_LOG(log,
" Failed to import the function type '{0}' ({1:x})" " Failed to import the function type '{0}' ({1:x})"
" into the expression parser AST contenxt", " into the expression parser AST context",
function_type->GetName(), function_type->GetID()); function_type->GetName(), function_type->GetID());
return; return;
} }
} else if (symbol) { } else if (symbol) {
fun_address = symbol->GetAddress(); fun_address = symbol->GetAddress();
function_decl = context.AddGenericFunDecl(); function_decl = context.AddGenericFunDecl();
is_indirect_function = symbol->IsIndirect(); is_indirect_function = symbol->IsIndirect();
▲ Show 20 Lines • Show All 134 Lines • Show Last 20 Lines

lldb/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp

Show First 20 Lines • Show All 797 Lines • ▼ Show 20 Lines
size_t PlatformRemoteGDBServer::ConnectToWaitingProcesses(Debugger &debugger, size_t PlatformRemoteGDBServer::ConnectToWaitingProcesses(Debugger &debugger,
Status &error) { Status &error) {
std::vector<std::string> connection_urls; std::vector<std::string> connection_urls;
GetPendingGdbServerList(connection_urls); GetPendingGdbServerList(connection_urls);
for (size_t i = 0; i < connection_urls.size(); ++i) { for (size_t i = 0; i < connection_urls.size(); ++i) {
ConnectProcess(connection_urls[i].c_str(), "gdb-remote", debugger, nullptr, error); ConnectProcess(connection_urls[i].c_str(), "gdb-remote", debugger, nullptr, error);
if (error.Fail()) if (error.Fail())
return i; // We already connected to i process succsessfully return i; // We already connected to i process successfully
} }
return connection_urls.size(); return connection_urls.size();
} }
size_t PlatformRemoteGDBServer::GetPendingGdbServerList( size_t PlatformRemoteGDBServer::GetPendingGdbServerList(
std::vector<std::string> &connection_urls) { std::vector<std::string> &connection_urls) {
std::vector<std::pair<uint16_t, std::string>> remote_servers; std::vector<std::pair<uint16_t, std::string>> remote_servers;
if (!IsConnected()) if (!IsConnected())
Show All 11 Lines

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

Show First 20 Lines • Show All 990 Lines • ▼ Show 20 Lines if (remote_process_arch.IsValid()) {
process_arch = m_gdb_comm.GetHostArchitecture(); process_arch = m_gdb_comm.GetHostArchitecture();
LLDB_LOG(log, LLDB_LOG(log,
"gdb-remote did not have process architecture, using gdb-remote " "gdb-remote did not have process architecture, using gdb-remote "
"host architecture {0} {1}", "host architecture {0} {1}",
process_arch.GetArchitectureName(), process_arch.GetArchitectureName(),
process_arch.GetTriple().getTriple()); process_arch.GetTriple().getTriple());
} }
if (int addresssable_bits = m_gdb_comm.GetAddressingBits()) { if (int addressable_bits = m_gdb_comm.GetAddressingBits()) {
lldb::addr_t address_mask = ~((1ULL << addresssable_bits) - 1); lldb::addr_t address_mask = ~((1ULL << addressable_bits) - 1);
SetCodeAddressMask(address_mask); SetCodeAddressMask(address_mask);
SetDataAddressMask(address_mask); SetDataAddressMask(address_mask);
} }
if (process_arch.IsValid()) { if (process_arch.IsValid()) {
const ArchSpec &target_arch = GetTarget().GetArchitecture(); const ArchSpec &target_arch = GetTarget().GetArchitecture();
if (target_arch.IsValid()) { if (target_arch.IsValid()) {
LLDB_LOG(log, "analyzing target arch, currently {0} {1}", LLDB_LOG(log, "analyzing target arch, currently {0} {1}",
▲ Show 20 Lines • Show All 4,361 Lines • Show Last 20 Lines

lldb/source/Plugins/Process/minidump/MinidumpParser.cpp

Show First 20 Lines • Show All 345 Lines • ▼ Show 20 Linesstd::vector<const minidump::Module *> MinidumpParser::GetFilteredModuleList() {
if (!ExpectedModules) { if (!ExpectedModules) {
LLDB_LOG_ERROR(log, ExpectedModules.takeError(), LLDB_LOG_ERROR(log, ExpectedModules.takeError(),
"Failed to read module list: {0}"); "Failed to read module list: {0}");
return {}; return {};
} }
// Create memory regions from the linux maps only. We do this to avoid issues // Create memory regions from the linux maps only. We do this to avoid issues
// with breakpad generated minidumps where if someone has mmap'ed a shared // with breakpad generated minidumps where if someone has mmap'ed a shared
// library into memory to accesss its data in the object file, we can get a // library into memory to access its data in the object file, we can get a
// minidump with two mappings for a binary: one whose base image points to a // minidump with two mappings for a binary: one whose base image points to a
// memory region that is read + execute and one that is read only. // memory region that is read + execute and one that is read only.
MemoryRegionInfos linux_regions; MemoryRegionInfos linux_regions;
if (CreateRegionsCacheFromLinuxMaps(*this, linux_regions)) if (CreateRegionsCacheFromLinuxMaps(*this, linux_regions))
llvm::sort(linux_regions); llvm::sort(linux_regions);
// map module_name -> filtered_modules index // map module_name -> filtered_modules index
typedef llvm::StringMap<size_t> MapType; typedef llvm::StringMap<size_t> MapType;
▲ Show 20 Lines • Show All 348 Lines • Show Last 20 Lines

lldb/source/Plugins/Process/scripted/ScriptedThread.cpp

Show First 20 Lines • Show All 157 Lines • ▼ Show 20 Linesbool ScriptedThread::LoadArtificialStackFrames() {
size_t arr_size = arr_sp->GetSize(); size_t arr_size = arr_sp->GetSize();
if (arr_size > std::numeric_limits<uint32_t>::max()) if (arr_size > std::numeric_limits<uint32_t>::max())
return ScriptedInterface::ErrorWithMessage<bool>( return ScriptedInterface::ErrorWithMessage<bool>(
LLVM_PRETTY_FUNCTION, LLVM_PRETTY_FUNCTION,
llvm::Twine( llvm::Twine(
"StackFrame array size (" + llvm::Twine(arr_size) + "StackFrame array size (" + llvm::Twine(arr_size) +
llvm::Twine( llvm::Twine(
") is greater than maximum autorized for a StackFrameList.")) ") is greater than maximum authorized for a StackFrameList."))
.str(), .str(),
error, LLDBLog::Thread); error, LLDBLog::Thread);
StackFrameListSP frames = GetStackFrameList(); StackFrameListSP frames = GetStackFrameList();
for (size_t idx = 0; idx < arr_size; idx++) { for (size_t idx = 0; idx < arr_size; idx++) {
StructuredData::Dictionary *dict; StructuredData::Dictionary *dict;
▲ Show 20 Lines • Show All 138 Lines • Show Last 20 Lines

lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp

Show First 20 Lines • Show All 288 Lines • ▼ Show 20 Lines
size_t SymbolFileBreakpad::ParseBlocksRecursive(Function &func) { size_t SymbolFileBreakpad::ParseBlocksRecursive(Function &func) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex()); std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
CompileUnit *comp_unit = func.GetCompileUnit(); CompileUnit *comp_unit = func.GetCompileUnit();
lldbassert(comp_unit); lldbassert(comp_unit);
ParseInlineOriginRecords(); ParseInlineOriginRecords();
// A vector of current each level's parent block. For example, when parsing // A vector of current each level's parent block. For example, when parsing
// "INLINE 0 ...", the current level is 0 and its parent block is the // "INLINE 0 ...", the current level is 0 and its parent block is the
// funciton block at index 0. // function block at index 0.
std::vector<Block *> blocks; std::vector<Block *> blocks;
Block &block = func.GetBlock(false); Block &block = func.GetBlock(false);
block.AddRange(Block::Range(0, func.GetAddressRange().GetByteSize())); block.AddRange(Block::Range(0, func.GetAddressRange().GetByteSize()));
blocks.push_back(&block); blocks.push_back(&block);
size_t blocks_added = 0; size_t blocks_added = 0;
addr_t func_base = func.GetAddressRange().GetBaseAddress().GetOffset(); addr_t func_base = func.GetAddressRange().GetBaseAddress().GetOffset();
CompUnitData &data = m_cu_data->GetEntryRef(comp_unit->GetID()).data; CompUnitData &data = m_cu_data->GetEntryRef(comp_unit->GetID()).data;
▲ Show 20 Lines • Show All 624 Lines • Show Last 20 Lines

lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp

Show First 20 Lines • Show All 680 Lines • ▼ Show 20 Lines case PDB_SymType::ArrayType: {
CompilerType element_ast_type = element_type->GetForwardCompilerType(); CompilerType element_ast_type = element_type->GetForwardCompilerType();
// If element type is UDT, it needs to be complete. // If element type is UDT, it needs to be complete.
if (TypeSystemClang::IsCXXClassType(element_ast_type) && if (TypeSystemClang::IsCXXClassType(element_ast_type) &&
!element_ast_type.GetCompleteType()) { !element_ast_type.GetCompleteType()) {
if (TypeSystemClang::StartTagDeclarationDefinition(element_ast_type)) { if (TypeSystemClang::StartTagDeclarationDefinition(element_ast_type)) {
TypeSystemClang::CompleteTagDeclarationDefinition(element_ast_type); TypeSystemClang::CompleteTagDeclarationDefinition(element_ast_type);
} else { } else {
// We are not able to start defintion. // We are not able to start definition.
return nullptr; return nullptr;
} }
} }
CompilerType array_ast_type = m_ast.CreateArrayType( CompilerType array_ast_type = m_ast.CreateArrayType(
element_ast_type, num_elements, /*is_gnu_vector*/ false); element_ast_type, num_elements, /*is_gnu_vector*/ false);
TypeSP type_sp = std::make_shared<lldb_private::Type>( TypeSP type_sp = std::make_shared<lldb_private::Type>(
array_type->getSymIndexId(), m_ast.GetSymbolFile(), ConstString(), array_type->getSymIndexId(), m_ast.GetSymbolFile(), ConstString(),
bytes, nullptr, LLDB_INVALID_UID, lldb_private::Type::eEncodingIsUID, bytes, nullptr, LLDB_INVALID_UID, lldb_private::Type::eEncodingIsUID,
▲ Show 20 Lines • Show All 747 Lines • Show Last 20 Lines

lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

Show First 20 Lines • Show All 1,934 Lines • ▼ Show 20 Lines if (result_up) {
} }
} }
} }
} }
} }
if (!func_decorated_name.empty()) { if (!func_decorated_name.empty()) {
mangled.SetMangledName(ConstString(func_decorated_name)); mangled.SetMangledName(ConstString(func_decorated_name));
// For MSVC, format of C funciton's decorated name depends on calling // For MSVC, format of C function's decorated name depends on calling
// convention. Unfortunately none of the format is recognized by current // convention. Unfortunately none of the format is recognized by current
// LLDB. For example, `_purecall` is a __cdecl C function. From PDB, // LLDB. For example, `_purecall` is a __cdecl C function. From PDB,
// `__purecall` is retrieved as both its decorated and undecorated name // `__purecall` is retrieved as both its decorated and undecorated name
// (using PDBSymbolFunc::getUndecoratedName method). However `__purecall` // (using PDBSymbolFunc::getUndecoratedName method). However `__purecall`
// string is not treated as mangled in LLDB (neither `?` nor `_Z` prefix). // string is not treated as mangled in LLDB (neither `?` nor `_Z` prefix).
// Mangled::GetDemangledName method will fail internally and caches an // Mangled::GetDemangledName method will fail internally and caches an
// empty string as its undecorated name. So we will face a contradiction // empty string as its undecorated name. So we will face a contradiction
// here for the same symbol: // here for the same symbol:
▲ Show 20 Lines • Show All 108 Lines • Show Last 20 Lines

lldb/source/Symbol/Type.cpp

Show First 20 Lines • Show All 178 Lines • ▼ Show 20 Lines if (type_name) {
*s << ", name = \"" << type_name << '"'; *s << ", name = \"" << type_name << '"';
ConstString qualified_type_name(GetQualifiedName()); ConstString qualified_type_name(GetQualifiedName());
if (qualified_type_name != type_name) { if (qualified_type_name != type_name) {
*s << ", qualified = \"" << qualified_type_name << '"'; *s << ", qualified = \"" << qualified_type_name << '"';
} }
} }
} }
// Call the get byte size accesor so we resolve our byte size // Call the get byte size accessor so we resolve our byte size
if (GetByteSize(exe_scope)) if (GetByteSize(exe_scope))
s->Printf(", byte-size = %" PRIu64, m_byte_size); s->Printf(", byte-size = %" PRIu64, m_byte_size);
bool show_fullpaths = (level == lldb::eDescriptionLevelVerbose); bool show_fullpaths = (level == lldb::eDescriptionLevelVerbose);
m_decl.Dump(s, show_fullpaths); m_decl.Dump(s, show_fullpaths);
if (m_compiler_type.IsValid()) { if (m_compiler_type.IsValid()) {
*s << ", compiler_type = \""; *s << ", compiler_type = \"";
GetForwardCompilerType().DumpTypeDescription(s); GetForwardCompilerType().DumpTypeDescription(s);
▲ Show 20 Lines • Show All 940 Lines • Show Last 20 Lines

lldb/test/API/commands/expression/codegen-crash-import-def-arraytype-element/main.cpp

// This is a reproducer for a crash during codegen. The base issue is when we // This is a reproducer for a crash during codegen. The base issue is when we
// Import the DeclContext we force FieldDecl that are RecordType to be defined // Import the DeclContext we force FieldDecl that are RecordType to be defined
// since we need these to be defined in order to layout the class. // since we need these to be defined in order to layout the class.
// This case involves an array member whose ElementType are records. In this // This case involves an array member whose ElementType are records. In this
// case we need to check the ElementType of an ArrayType and if it is a record // case we need to check the ElementType of an ArrayType and if it is a record
// we need to import the definition. // we need to import the definition.
struct A { struct A {
int x; int x;
}; };
struct B { struct B {
// When we import the all the FieldDecl we need to check if we have an // When we import the all the FieldDecl we need to check if we have an
// ArrayType and then check if the ElementType is a RecordDecl and if so // ArrayType and then check if the ElementType is a RecordDecl and if so
// import the defintion. Otherwise during codegen we will attempt to layout A // import the definition. Otherwise during codegen we will attempt to layout A
// but won't be able to. // but won't be able to.
A s1[2]; A s1[2];
A s2[2][2][3]; A s2[2][2][3];
char o; char o;
}; };
class FB { class FB {
public: public:
Show All 30 Lines

lldb/test/API/functionalities/breakpoint/debugbreak/TestDebugBreak.py

Show All 26 Lines def test_asm_int_3(self):
self.assertState(process.GetState(), lldb.eStateStopped) self.assertState(process.GetState(), lldb.eStateStopped)
stop_reason = lldb.eStopReasonException if (lldbplatformutil.getPlatform( stop_reason = lldb.eStopReasonException if (lldbplatformutil.getPlatform(
) == "windows" or lldbplatformutil.getPlatform() == "macosx") else lldb.eStopReasonSignal ) == "windows" or lldbplatformutil.getPlatform() == "macosx") else lldb.eStopReasonSignal
thread = lldbutil.get_stopped_thread(process, stop_reason) thread = lldbutil.get_stopped_thread(process, stop_reason)
self.assertIsNotNone( self.assertIsNotNone(
thread, "Unable to find thread stopped at the __debugbreak()") thread, "Unable to find thread stopped at the __debugbreak()")
frame = thread.GetFrameAtIndex(0) frame = thread.GetFrameAtIndex(0)
# We should be in funciton 'bar'. # We should be in function 'bar'.
self.assertTrue(frame.IsValid()) self.assertTrue(frame.IsValid())
function_name = frame.GetFunctionName() function_name = frame.GetFunctionName()
self.assertIn('bar', function_name, self.assertIn('bar', function_name,
"Unexpected function name {}".format(function_name)) "Unexpected function name {}".format(function_name))
# We should be able to evaluate the parameter foo. # We should be able to evaluate the parameter foo.
value = frame.EvaluateExpression('*foo') value = frame.EvaluateExpression('*foo')
self.assertEqual(value.GetValueAsSigned(), 42) self.assertEqual(value.GetValueAsSigned(), 42)
Show All 12 Lines

lldb/test/API/functionalities/load_unload/TestLoadUnload.py

Show First 20 Lines • Show All 319 Lines • ▼ Show 20 Lines def run_load_unload(self):
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped', substrs=['stopped',
'a_function', 'a_function',
'stop reason = breakpoint']) 'stop reason = breakpoint'])
# The breakpoint should have a hit count of 1. # The breakpoint should have a hit count of 1.
lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1) lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
# Issue the 'continue' command. We should stop agaian at a_function. # Issue the 'continue' command. We should stop again at a_function.
# The stop reason of the thread should be breakpoint and at a_function. # The stop reason of the thread should be breakpoint and at a_function.
self.runCmd("continue") self.runCmd("continue")
# rdar://problem/8508987 # rdar://problem/8508987
# The a_function breakpoint should be encountered twice. # The a_function breakpoint should be encountered twice.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped', substrs=['stopped',
'a_function', 'a_function',
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

lldb/test/API/functionalities/memory/tag/TestMemoryTag.py

Show All 23 Lines def test_memory_tag_read_unsupported(self):
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line(self, "main.cpp", lldbutil.run_break_set_by_file_and_line(self, "main.cpp",
line_number('main.cpp', '// Breakpoint here'), line_number('main.cpp', '// Breakpoint here'),
num_expected_locations=1) num_expected_locations=1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
# If you're on AArch64 you could have MTE but the remote process # If you're on AArch64 you could have MTE but the remote process
# must also support it. If you're on any other arhcitecture you # must also support it. If you're on any other architecture you
# won't have any tagging at all. So the error message is different. # won't have any tagging at all. So the error message is different.
if self.isAArch64(): if self.isAArch64():
expected = "error: Process does not support memory tagging" expected = "error: Process does not support memory tagging"
else: else:
expected = "error: This architecture does not support memory tagging" expected = "error: This architecture does not support memory tagging"
self.expect("memory tag read 0 1", substrs=[expected], error=True) self.expect("memory tag read 0 1", substrs=[expected], error=True)
self.expect("memory tag write 0 1 2", substrs=[expected], error=True) self.expect("memory tag write 0 1 2", substrs=[expected], error=True)

lldb/test/API/functionalities/module_cache/bsd/TestModuleCacheBSD.py

Show First 20 Lines • Show All 71 Lines • ▼ Show 20 Lines def test(self):
We do this to test that we can correctly cache duplicate .o files We do this to test that we can correctly cache duplicate .o files
that appear in .a files. that appear in .a files.
This test only works on darwin because of the way DWARF is stored This test only works on darwin because of the way DWARF is stored
where the debug map will refer to .o files inside of .a files. where the debug map will refer to .o files inside of .a files.
""" """
exe = self.getBuildArtifact("a.out") exe = self.getBuildArtifact("a.out")
# Create a module with no depedencies. # Create a module with no dependencies.
target = self.createTestTarget(load_dependent_modules=False) target = self.createTestTarget(load_dependent_modules=False)
self.runCmd('breakpoint set -f a.c -l %d' % (self.line_a)) self.runCmd('breakpoint set -f a.c -l %d' % (self.line_a))
self.runCmd('breakpoint set -f b.c -l %d' % (self.line_b)) self.runCmd('breakpoint set -f b.c -l %d' % (self.line_b))
self.runCmd('breakpoint set -f c.c -l %d' % (self.line_c)) self.runCmd('breakpoint set -f c.c -l %d' % (self.line_c))
# Get the executable module and get the number of symbols to make # Get the executable module and get the number of symbols to make
# sure the symbol table gets parsed and cached. The module cache is # sure the symbol table gets parsed and cached. The module cache is
Show All 24 Lines

lldb/test/API/functionalities/module_cache/simple_exe/TestModuleCacheSimple.py

Show All 38 Lines def test(self):
corresponding index cache entry for the symbol table for the corresponding index cache entry for the symbol table for the
executable. It also removes the executable, rebuilds so that the executable. It also removes the executable, rebuilds so that the
modification time of the binary gets updated, and then creates a new modification time of the binary gets updated, and then creates a new
target and should cause the cache to get updated so the cache file target and should cause the cache to get updated so the cache file
should get an updated modification time. should get an updated modification time.
""" """
exe = self.getBuildArtifact("a.out") exe = self.getBuildArtifact("a.out")
# Create a module with no depedencies. # Create a module with no dependencies.
target = self.createTestTarget(load_dependent_modules=False) target = self.createTestTarget(load_dependent_modules=False)
# Get the executable module and get the number of symbols to make # Get the executable module and get the number of symbols to make
# sure the symbol table gets parsed and cached. The module cache is # sure the symbol table gets parsed and cached. The module cache is
# enabled in the setUp() function. # enabled in the setUp() function.
main_module = target.GetModuleAtIndex(0) main_module = target.GetModuleAtIndex(0)
self.assertTrue(main_module.IsValid()) self.assertTrue(main_module.IsValid())
# Make sure the symbol table gets loaded and cached # Make sure the symbol table gets loaded and cached
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

lldb/test/API/functionalities/module_cache/universal/TestModuleCacheUniversal.py

Show All 37 Lines def test(self):
""" """
exe_basename = "testit" exe_basename = "testit"
src_dir = self.getSourceDir() src_dir = self.getSourceDir()
yaml_path = os.path.join(src_dir, "universal.yaml") yaml_path = os.path.join(src_dir, "universal.yaml")
yaml_base, ext = os.path.splitext(yaml_path) yaml_base, ext = os.path.splitext(yaml_path)
exe = self.getBuildArtifact(exe_basename) exe = self.getBuildArtifact(exe_basename)
self.yaml2obj(yaml_path, exe) self.yaml2obj(yaml_path, exe)
self.assertTrue(os.path.exists(exe)) self.assertTrue(os.path.exists(exe))
# Create a module with no depedencies. # Create a module with no dependencies.
self.runCmd('target create -d --arch x86_64 %s' % (exe)) self.runCmd('target create -d --arch x86_64 %s' % (exe))
self.runCmd('image dump symtab %s' % (exe_basename)) self.runCmd('image dump symtab %s' % (exe_basename))
self.runCmd('target create -d --arch arm64 %s' % (exe)) self.runCmd('target create -d --arch arm64 %s' % (exe))
self.runCmd('image dump symtab %s' % (exe_basename)) self.runCmd('image dump symtab %s' % (exe_basename))
cache_files = self.get_module_cache_files(exe_basename) cache_files = self.get_module_cache_files(exe_basename)
self.assertEqual(len(cache_files), 2, self.assertEqual(len(cache_files), 2,
"make sure there are two files in the module cache directory (%s) for %s" % (self.cache_dir, exe_basename)) "make sure there are two files in the module cache directory (%s) for %s" % (self.cache_dir, exe_basename))

lldb/test/API/functionalities/postmortem/elf-core/TestLinuxCore.py

Show First 20 Lines • Show All 463 Lines • ▼ Show 20 Lines def test_aarch64_sve_regs_full(self):
for regname, value in values.items(): for regname, value in values.items():
self.expect("register read {}".format(regname), self.expect("register read {}".format(regname),
substrs=["{} = {}".format(regname, value)]) substrs=["{} = {}".format(regname, value)])
self.expect("register read --all") self.expect("register read --all")
@skipIfLLVMTargetMissing("AArch64") @skipIfLLVMTargetMissing("AArch64")
def test_aarch64_pac_regs(self): def test_aarch64_pac_regs(self):
# Test AArch64/Linux Pointer Authenication register read # Test AArch64/Linux Pointer Authentication register read
target = self.dbg.CreateTarget(None) target = self.dbg.CreateTarget(None)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
process = target.LoadCore("linux-aarch64-pac.core") process = target.LoadCore("linux-aarch64-pac.core")
values = {"data_mask": "0x007f00000000000", "code_mask": "0x007f00000000000"} values = {"data_mask": "0x007f00000000000", "code_mask": "0x007f00000000000"}
for regname, value in values.items(): for regname, value in values.items():
self.expect("register read {}".format(regname), self.expect("register read {}".format(regname),
▲ Show 20 Lines • Show All 173 Lines • Show Last 20 Lines

lldb/test/API/functionalities/postmortem/minidump-new/makefile.txt

# This makefile aims to make the binaries as small as possible, for us not to # This makefile aims to make the binaries as small as possible, for us not to
# upload huge binary blobs in the repo. # upload huge binary blobs in the repo.
# The binary should have debug symbols because stack unwinding doesn't work # The binary should have debug symbols because stack unwinding doesn't work
# correctly using the information in the Minidump only. Also we want to evaluate # correctly using the information in the Minidump only. Also we want to evaluate
# local variables, etc. # local variables, etc.
# Breakpad compiles as a static library, so statically linking againts it # Breakpad compiles as a static library, so statically linking against it
# makes the binary huge. # makes the binary huge.
# Dynamically linking to it does improve things, but we are still #include-ing # Dynamically linking to it does improve things, but we are still #include-ing
# breakpad headers (which is a lot of source code for which we generate debug # breakpad headers (which is a lot of source code for which we generate debug
# symbols) # symbols)
# So, install_breakpad.cpp does the #include-ing and defines a global function # So, install_breakpad.cpp does the #include-ing and defines a global function
# "InstallBreakpad" that does all the exception handler registration. # "InstallBreakpad" that does all the exception handler registration.
# We compile install_breakpad to object file and then link it, alongside the # We compile install_breakpad to object file and then link it, alongside the
# static libbreakpad, into a shared library. # static libbreakpad, into a shared library.
Show All 15 Lines

lldb/tools/debugserver/source/DNBTimer.h

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Linespublic:
~DNBTimer() {} ~DNBTimer() {}
bool IsThreadSafe() const { return m_mutexAP.get() != NULL; } bool IsThreadSafe() const { return m_mutexAP.get() != NULL; }
// Reset the time value to now // Reset the time value to now
void Reset() { void Reset() {
PTHREAD_MUTEX_LOCKER(locker, m_mutexAP.get()); PTHREAD_MUTEX_LOCKER(locker, m_mutexAP.get());
gettimeofday(&m_timeval, NULL); gettimeofday(&m_timeval, NULL);
} }
// Get the total mircoseconds since Jan 1, 1970 // Get the total microseconds since Jan 1, 1970
uint64_t TotalMicroSeconds() const { uint64_t TotalMicroSeconds() const {
PTHREAD_MUTEX_LOCKER(locker, m_mutexAP.get()); PTHREAD_MUTEX_LOCKER(locker, m_mutexAP.get());
return (uint64_t)(m_timeval.tv_sec) * 1000000ull + return (uint64_t)(m_timeval.tv_sec) * 1000000ull +
(uint64_t)m_timeval.tv_usec; (uint64_t)m_timeval.tv_usec;
} }
void GetTime(uint64_t &sec, uint32_t &usec) const { void GetTime(uint64_t &sec, uint32_t &usec) const {
PTHREAD_MUTEX_LOCKER(locker, m_mutexAP.get()); PTHREAD_MUTEX_LOCKER(locker, m_mutexAP.get());
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

lldb/tools/debugserver/source/JSON.h

Show First 20 Lines • Show All 65 Lines • ▼ Show 20 Linesprivate:
std::string m_data; std::string m_data;
}; };
class JSONNumber : public JSONValue { class JSONNumber : public JSONValue {
public: public:
typedef std::shared_ptr<JSONNumber> SP; typedef std::shared_ptr<JSONNumber> SP;
// We cretae a constructor for all integer and floating point type with using // We create a constructor for all integer and floating point type with using
// templates and // templates and
// SFINAE to avoid having ambiguous overloads because of the implicit type // SFINAE to avoid having ambiguous overloads because of the implicit type
// promotion. If we // promotion. If we
// would have constructors only with int64_t, uint64_t and double types then // would have constructors only with int64_t, uint64_t and double types then
// constructing a // constructing a
// JSONNumber from an int32_t (or any other similar type) would fail to // JSONNumber from an int32_t (or any other similar type) would fail to
// compile. // compile.
▲ Show 20 Lines • Show All 220 Lines • Show Last 20 Lines

lldb/tools/debugserver/source/MacOSX/Genealogy.cpp

Show First 20 Lines • Show All 123 Lines • ▼ Show 20 Lines if (m_os_activity_diagnostic_for_pid(
bc.activity_id = breadcrumb->activity_id; bc.activity_id = breadcrumb->activity_id;
bc.timestamp = breadcrumb->timestamp; bc.timestamp = breadcrumb->timestamp;
if (breadcrumb->name) if (breadcrumb->name)
bc.name = breadcrumb->name; bc.name = breadcrumb->name;
breadcrumbs.push_back(bc); breadcrumbs.push_back(bc);
return true; return true;
}); });
// Collect all the Activites // Collect all the Activities
m_os_activity_iterate_activities( m_os_activity_iterate_activities(
process_info->activities, process_info, process_info->activities, process_info,
^bool(os_activity_entry_t activity) { ^bool(os_activity_entry_t activity) {
Activity ac; Activity ac;
ac.activity_start = activity->activity_start; ac.activity_start = activity->activity_start;
ac.activity_id = activity->activity_id; ac.activity_id = activity->activity_id;
ac.parent_id = activity->parent_id; ac.parent_id = activity->parent_id;
if (activity->activity_name) if (activity->activity_name)
▲ Show 20 Lines • Show All 175 Lines • Show Last 20 Lines

lldb/unittests/Utility/UUIDTest.cpp

Show First 20 Lines • Show All 77 Lines • ▼ Show 20 LinesTEST(UUIDTest, SetFromStringRef) {
EXPECT_EQ(UUID::fromData("@ABCDEFGHIJKLMNOPQRS", 20), u); EXPECT_EQ(UUID::fromData("@ABCDEFGHIJKLMNOPQRS", 20), u);
EXPECT_TRUE(u.SetFromStringRef("40414243")); EXPECT_TRUE(u.SetFromStringRef("40414243"));
EXPECT_EQ(UUID::fromData("@ABCD", 4), u); EXPECT_EQ(UUID::fromData("@ABCD", 4), u);
EXPECT_FALSE(u.SetFromStringRef("4")); EXPECT_FALSE(u.SetFromStringRef("4"));
} }
TEST(UUIDTest, StringConverion) { TEST(UUIDTest, StringConversion) {
EXPECT_EQ("40414243", UUID::fromData("@ABC", 4).GetAsString()); EXPECT_EQ("40414243", UUID::fromData("@ABC", 4).GetAsString());
EXPECT_EQ("40414243-4445-4647", UUID::fromData("@ABCDEFG", 8).GetAsString()); EXPECT_EQ("40414243-4445-4647", UUID::fromData("@ABCDEFG", 8).GetAsString());
EXPECT_EQ("40414243-4445-4647-4849-4A4B", EXPECT_EQ("40414243-4445-4647-4849-4A4B",
UUID::fromData("@ABCDEFGHIJK", 12).GetAsString()); UUID::fromData("@ABCDEFGHIJK", 12).GetAsString());
EXPECT_EQ("40414243-4445-4647-4849-4A4B4C4D4E4F", EXPECT_EQ("40414243-4445-4647-4849-4A4B4C4D4E4F",
UUID::fromData("@ABCDEFGHIJKLMNO", 16).GetAsString()); UUID::fromData("@ABCDEFGHIJKLMNO", 16).GetAsString());
EXPECT_EQ("40414243-4445-4647-4849-4A4B4C4D4E4F-50515253", EXPECT_EQ("40414243-4445-4647-4849-4A4B4C4D4E4F-50515253",
UUID::fromData("@ABCDEFGHIJKLMNOPQRS", 20).GetAsString()); UUID::fromData("@ABCDEFGHIJKLMNOPQRS", 20).GetAsString());
} }

llvm/cmake/config.guess

#! /bin/sh #! /bin/sh
# Attempt to guess a canonical system name. # Attempt to guess a canonical system name.
# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, # Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
# 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, # 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
# 2011 Free Software Foundation, Inc. # 2011 Free Software Foundation, Inc.
timestamp='2011-08-20' timestamp='2022-07-29'
# This file is free software; you can redistribute it and/or modify it # This file is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by # under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or # the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version. # (at your option) any later version.
# #
# This program is distributed in the hope that it will be useful, but # This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of # WITHOUT ANY WARRANTY; without even the implied warranty of
▲ Show 20 Lines • Show All 1,077 Lines • ▼ Show 20 Lines else
echo ${UNAME_MACHINE}-pc-sysv32 echo ${UNAME_MACHINE}-pc-sysv32
fi fi
exit ;; exit ;;
pc:*:*:*) pc:*:*:*)
# Left here for compatibility: # Left here for compatibility:
# uname -m prints for DJGPP always 'pc', but it prints nothing about # uname -m prints for DJGPP always 'pc', but it prints nothing about
# the processor, so we play safe by assuming i586. # the processor, so we play safe by assuming i586.
# Note: whatever this is, it MUST be the same as what config.sub # Note: whatever this is, it MUST be the same as what config.sub
# prints for the "djgpp" host, or else GDB configury will decide that # prints for the "djgpp" host, or else GDB configure will decide that
# this is a cross-build. # this is a cross-build.
echo i586-pc-msdosdjgpp echo i586-pc-msdosdjgpp
exit ;; exit ;;
Intel:Mach:3*:*) Intel:Mach:3*:*)
echo i386-pc-mach3 echo i386-pc-mach3
exit ;; exit ;;
paragon:*:*:*) paragon:*:*:*)
echo i860-intel-osf1 echo i860-intel-osf1
▲ Show 20 Lines • Show All 463 Lines • Show Last 20 Lines

llvm/cmake/modules/AddLLVM.cmake

Show First 20 Lines • Show All 500 Lines • ▼ Show 20 Lines if((ARG_SHARED AND ARG_STATIC) OR ARG_OBJECT)
# Bring in the target include directories from our original target. # Bring in the target include directories from our original target.
target_include_directories(${obj_name} PRIVATE $<TARGET_PROPERTY:${name},INCLUDE_DIRECTORIES>) target_include_directories(${obj_name} PRIVATE $<TARGET_PROPERTY:${name},INCLUDE_DIRECTORIES>)
set_target_properties(${obj_name} PROPERTIES FOLDER "Object Libraries") set_target_properties(${obj_name} PROPERTIES FOLDER "Object Libraries")
if(ARG_DEPENDS) if(ARG_DEPENDS)
add_dependencies(${obj_name} ${ARG_DEPENDS}) add_dependencies(${obj_name} ${ARG_DEPENDS})
endif() endif()
# Treat link libraries like PUBLIC dependencies. LINK_LIBS might # Treat link libraries like PUBLIC dependencies. LINK_LIBS might
# result in generating header files. Add a dependendency so that # result in generating header files. Add a dependency so that
# the generated header is created before this object library. # the generated header is created before this object library.
if(ARG_LINK_LIBS) if(ARG_LINK_LIBS)
cmake_parse_arguments(LINK_LIBS_ARG cmake_parse_arguments(LINK_LIBS_ARG
"" ""
"" ""
"PUBLIC;PRIVATE" "PUBLIC;PRIVATE"
${ARG_LINK_LIBS}) ${ARG_LINK_LIBS})
foreach(link_lib ${LINK_LIBS_ARG_PUBLIC}) foreach(link_lib ${LINK_LIBS_ARG_PUBLIC})
▲ Show 20 Lines • Show All 259 Lines • ▼ Show 20 Lines
# An LLVM component is a cmake target with the following cmake properties # An LLVM component is a cmake target with the following cmake properties
# eventually set: # eventually set:
# - LLVM_COMPONENT_NAME: the name of the component, which can be the name of # - LLVM_COMPONENT_NAME: the name of the component, which can be the name of
# the associated library or the one specified through COMPONENT_NAME # the associated library or the one specified through COMPONENT_NAME
# - LLVM_LINK_COMPONENTS: a list of component this component depends on # - LLVM_LINK_COMPONENTS: a list of component this component depends on
# - COMPONENT_HAS_JIT: (only for group component) whether this target group # - COMPONENT_HAS_JIT: (only for group component) whether this target group
# supports JIT compilation # supports JIT compilation
# Additionnaly, the ADD_TO_COMPONENT <component> option make it possible to add this # Additionally, the ADD_TO_COMPONENT <component> option make it possible to add this
# component to the LLVM_LINK_COMPONENTS of <component>. # component to the LLVM_LINK_COMPONENTS of <component>.
function(add_llvm_component_library name) function(add_llvm_component_library name)
cmake_parse_arguments(ARG cmake_parse_arguments(ARG
"" ""
"COMPONENT_NAME;ADD_TO_COMPONENT" "COMPONENT_NAME;ADD_TO_COMPONENT"
"" ""
${ARGN}) ${ARGN})
add_llvm_library(${name} COMPONENT_LIB ${ARG_UNPARSED_ARGUMENTS}) add_llvm_library(${name} COMPONENT_LIB ${ARG_UNPARSED_ARGUMENTS})
▲ Show 20 Lines • Show All 1,564 Lines • Show Last 20 Lines

llvm/cmake/modules/CoverageReport.cmake

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines
# This isn't connected to any dependencies because it is a bit finacky to get # This isn't connected to any dependencies because it is a bit finacky to get
# working exactly how a user might want. # working exactly how a user might want.
add_custom_target(clear-profile-data add_custom_target(clear-profile-data
COMMAND ${CMAKE_COMMAND} -E COMMAND ${CMAKE_COMMAND} -E
remove_directory ${LLVM_PROFILE_DATA_DIR}) remove_directory ${LLVM_PROFILE_DATA_DIR})
# This currently only works for LLVM, but could be expanded to work for all # This currently only works for LLVM, but could be expanded to work for all
# sub-projects. The current limitation is based on not having a good way to # sub-projects. The current limitation is based on not having a good way to
# automaticall plumb through the targets that we want to run coverage against. # automatically plumb through the targets that we want to run coverage against.
add_custom_target(generate-coverage-report add_custom_target(generate-coverage-report
COMMAND ${Python3_EXECUTABLE} ${PREPARE_CODE_COV_ARTIFACT} COMMAND ${Python3_EXECUTABLE} ${PREPARE_CODE_COV_ARTIFACT}
${LLVM_PROFDATA} ${LLVM_COV} ${LLVM_PROFILE_DATA_DIR} ${LLVM_PROFDATA} ${LLVM_COV} ${LLVM_PROFILE_DATA_DIR}
${REPORT_DIR} ${coverage_binaries} ${REPORT_DIR} ${coverage_binaries}
--unified-report ${restrict_flags} --unified-report ${restrict_flags}
WORKING_DIRECTORY ${CMAKE_BINARY_DIR} WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
DEPENDS check-llvm) # Run tests DEPENDS check-llvm) # Run tests

llvm/docs/GlobalISel/GMIR.rst

Show First 20 Lines • Show All 189 Lines • ▼ Show 20 Lines
Rationale: instructions already encode a specific interpretation of types Rationale: instructions already encode a specific interpretation of types
(e.g., ``add`` vs. ``fadd``, or ``sdiv`` vs. ``udiv``). Also encoding that (e.g., ``add`` vs. ``fadd``, or ``sdiv`` vs. ``udiv``). Also encoding that
information in the type system requires introducing bitcast with no real information in the type system requires introducing bitcast with no real
advantage for the selector. advantage for the selector.
Pointer types are distinguished by address space. This matches IR, as opposed Pointer types are distinguished by address space. This matches IR, as opposed
to SelectionDAG where address space is an attribute on operations. to SelectionDAG where address space is an attribute on operations.
This representation better supports pointers having different sizes depending This representation better supports pointers having different sizes depending
on their addressspace. on their address space.
.. note:: .. note::
.. caution:: .. caution::
Is this still true? I thought we'd removed the 1-element vector concept. Is this still true? I thought we'd removed the 1-element vector concept.
Hypothetically, it could be distinct from a scalar but I think we failed to Hypothetically, it could be distinct from a scalar but I think we failed to
find a real occurrence. find a real occurrence.
Show All 13 Lines

llvm/docs/LangRef.rst

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 3,984 Lines • ▼ Show 20 Lines
The string '``undef``' can be used anywhere a constant is expected, and The string '``undef``' can be used anywhere a constant is expected, and
indicates that the user of the value may receive an unspecified indicates that the user of the value may receive an unspecified
bit-pattern. Undefined values may be of any type (other than '``label``' bit-pattern. Undefined values may be of any type (other than '``label``'
or '``void``') and be used anywhere a constant is permitted. or '``void``') and be used anywhere a constant is permitted.
.. note:: .. note::
A '``poison``' value (decribed in the next section) should be used instead of A '``poison``' value (described in the next section) should be used instead of
'``undef``' whenever possible. Poison values are stronger than undef, and '``undef``' whenever possible. Poison values are stronger than undef, and
enable more optimizations. Just the existence of '``undef``' blocks certain enable more optimizations. Just the existence of '``undef``' blocks certain
optimizations (see the examples below). optimizations (see the examples below).
Undefined values are useful because they indicate to the compiler that Undefined values are useful because they indicate to the compiler that
the program is well defined no matter what value is used. This gives the the program is well defined no matter what value is used. This gives the
compiler more freedom to optimize. Here are some examples of compiler more freedom to optimize. Here are some examples of
(potentially surprising) transformations that are valid (in pseudo IR): (potentially surprising) transformations that are valid (in pseudo IR):
▲ Show 20 Lines • Show All 21,234 Lines • Show Last 20 Lines

llvm/docs/MemorySSA.rst

Show First 20 Lines • Show All 464 Lines • ▼ Show 20 Lines
Precision in practice Precision in practice
^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^
In practice, there are implementation details in LLVM that also affect the In practice, there are implementation details in LLVM that also affect the
results' precision provided by ``MemorySSA``. For example, AliasAnalysis has various results' precision provided by ``MemorySSA``. For example, AliasAnalysis has various
caps, or restrictions on looking through phis which can affect what ``MemorySSA`` caps, or restrictions on looking through phis which can affect what ``MemorySSA``
can infer. Changes made by different passes may make MemorySSA either "overly can infer. Changes made by different passes may make MemorySSA either "overly
optimized" (it can provide a more acccurate result than if it were recomputed optimized" (it can provide a more accurate result than if it were recomputed
from scratch), or "under optimized" (it could infer more if it were recomputed). from scratch), or "under optimized" (it could infer more if it were recomputed).
This can lead to challenges to reproduced results in isolation with a single pass This can lead to challenges to reproduced results in isolation with a single pass
when the result relies on the state aquired by ``MemorySSA`` due to being updated by when the result relies on the state acquired by ``MemorySSA`` due to being updated by
multiple subsequent passes. multiple subsequent passes.
Passes that use and update ``MemorySSA`` should do so through the APIs provided by the Passes that use and update ``MemorySSA`` should do so through the APIs provided by the
``MemorySSAUpdater``, or through calls on the Walker. ``MemorySSAUpdater``, or through calls on the Walker.
Direct optimizations to ``MemorySSA`` are not permitted. Direct optimizations to ``MemorySSA`` are not permitted.
There is currently a single, narrowly scoped exception where DSE (DeadStoreElimination) There is currently a single, narrowly scoped exception where DSE (DeadStoreElimination)
updates an optimized access of a store, after a traversal that guarantees the updates an optimized access of a store, after a traversal that guarantees the
optimization is correct. This is solely allowed due to the traversals and inferences optimization is correct. This is solely allowed due to the traversals and inferences
being beyond what ``MemorySSA`` does and them being "free" (i.e. DSE does them anyway). being beyond what ``MemorySSA`` does and them being "free" (i.e. DSE does them anyway).
Show All 9 Lines

llvm/include/llvm-c/Object.h

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Lines
/** /**
* Create a binary file from the given memory buffer. * Create a binary file from the given memory buffer.
* *
* The exact type of the binary file will be inferred automatically, and the * The exact type of the binary file will be inferred automatically, and the
* appropriate implementation selected. The context may be NULL except if * appropriate implementation selected. The context may be NULL except if
* the resulting file is an LLVM IR file. * the resulting file is an LLVM IR file.
* *
* The memory buffer is not consumed by this function. It is the responsibilty * The memory buffer is not consumed by this function. It is the responsibility
* of the caller to free it with \c LLVMDisposeMemoryBuffer. * of the caller to free it with \c LLVMDisposeMemoryBuffer.
* *
* If NULL is returned, the \p ErrorMessage parameter is populated with the * If NULL is returned, the \p ErrorMessage parameter is populated with the
* error's description. It is then the caller's responsibility to free this * error's description. It is then the caller's responsibility to free this
* message by calling \c LLVMDisposeMessage. * message by calling \c LLVMDisposeMessage.
* *
* @see llvm::object::createBinary * @see llvm::object::createBinary
*/ */
LLVMBinaryRef LLVMCreateBinary(LLVMMemoryBufferRef MemBuf, LLVMBinaryRef LLVMCreateBinary(LLVMMemoryBufferRef MemBuf,
LLVMContextRef Context, LLVMContextRef Context,
char **ErrorMessage); char **ErrorMessage);
/** /**
* Dispose of a binary file. * Dispose of a binary file.
* *
* The binary file does not own its backing buffer. It is the responsibilty * The binary file does not own its backing buffer. It is the responsibility
* of the caller to free it with \c LLVMDisposeMemoryBuffer. * of the caller to free it with \c LLVMDisposeMemoryBuffer.
*/ */
void LLVMDisposeBinary(LLVMBinaryRef BR); void LLVMDisposeBinary(LLVMBinaryRef BR);
/** /**
* Retrieves a copy of the memory buffer associated with this object file. * Retrieves a copy of the memory buffer associated with this object file.
* *
* The returned buffer is merely a shallow copy and does not own the actual * The returned buffer is merely a shallow copy and does not own the actual
▲ Show 20 Lines • Show All 141 Lines • Show Last 20 Lines

llvm/include/llvm-c/Orc.h

Show First 20 Lines • Show All 833 Lines • ▼ Show 20 Lines
*/ */
LLVMErrorRef LLVMOrcMaterializationResponsibilityDefineMaterializing( LLVMErrorRef LLVMOrcMaterializationResponsibilityDefineMaterializing(
LLVMOrcMaterializationResponsibilityRef MR, LLVMOrcMaterializationResponsibilityRef MR,
LLVMOrcCSymbolFlagsMapPairs Pairs, size_t NumPairs); LLVMOrcCSymbolFlagsMapPairs Pairs, size_t NumPairs);
/** /**
* Notify all not-yet-emitted covered by this MaterializationResponsibility * Notify all not-yet-emitted covered by this MaterializationResponsibility
* instance that an error has occurred. * instance that an error has occurred.
* This will remove all symbols covered by this MaterializationResponsibilty * This will remove all symbols covered by this MaterializationResponsibility
* from the target JITDylib, and send an error to any queries waiting on * from the target JITDylib, and send an error to any queries waiting on
* these symbols. * these symbols.
*/ */
void LLVMOrcMaterializationResponsibilityFailMaterialization( void LLVMOrcMaterializationResponsibilityFailMaterialization(
LLVMOrcMaterializationResponsibilityRef MR); LLVMOrcMaterializationResponsibilityRef MR);
/** /**
* Transfers responsibility to the given MaterializationUnit for all * Transfers responsibility to the given MaterializationUnit for all
▲ Show 20 Lines • Show All 442 Lines • Show Last 20 Lines

llvm/include/llvm/Analysis/BranchProbabilityInfo.h

//===- BranchProbabilityInfo.h - Branch Probability Analysis ----*- C++ -*-===// //===- BranchProbabilityInfo.h - Branch Probability Analysis ----*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This pass is used to evaluate branch probabilties. // This pass is used to evaluate branch probabilities.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_ANALYSIS_BRANCHPROBABILITYINFO_H #ifndef LLVM_ANALYSIS_BRANCHPROBABILITYINFO_H
#define LLVM_ANALYSIS_BRANCHPROBABILITYINFO_H #define LLVM_ANALYSIS_BRANCHPROBABILITYINFO_H
#include "llvm/ADT/DenseMap.h" #include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/DenseMapInfo.h" #include "llvm/ADT/DenseMapInfo.h"
▲ Show 20 Lines • Show All 440 Lines • Show Last 20 Lines

llvm/include/llvm/Analysis/LoopAccessAnalysis.h

Show First 20 Lines • Show All 97 Lines • ▼ Show 20 Lines enum class VectorizationSafetyStatus {
// safe. // safe.
Safe, Safe,
// Can possibly vectorize with RT checks to overcome unknown dependencies. // Can possibly vectorize with RT checks to overcome unknown dependencies.
PossiblySafeWithRtChecks, PossiblySafeWithRtChecks,
// Cannot vectorize due to known unsafe dependencies. // Cannot vectorize due to known unsafe dependencies.
Unsafe, Unsafe,
}; };
/// Dependece between memory access instructions. /// Dependence between memory access instructions.
struct Dependence { struct Dependence {
/// The type of the dependence. /// The type of the dependence.
enum DepType { enum DepType {
// No dependence. // No dependence.
NoDep, NoDep,
// We couldn't determine the direction or the distance. // We couldn't determine the direction or the distance.
Unknown, Unknown,
// Lexically forward. // Lexically forward.
▲ Show 20 Lines • Show All 384 Lines • ▼ Show 20 Lines const PointerInfo &getPointerInfo(unsigned PtrIdx) const {
return Pointers[PtrIdx]; return Pointers[PtrIdx];
} }
ScalarEvolution *getSE() const { return SE; } ScalarEvolution *getSE() const { return SE; }
private: private:
/// Groups pointers such that a single memcheck is required /// Groups pointers such that a single memcheck is required
/// between two different groups. This will clear the CheckingGroups vector /// between two different groups. This will clear the CheckingGroups vector
/// and re-compute it. We will only group dependecies if \p UseDependencies /// and re-compute it. We will only group dependencies if \p UseDependencies
/// is true, otherwise we will create a separate group for each pointer. /// is true, otherwise we will create a separate group for each pointer.
void groupChecks(MemoryDepChecker::DepCandidates &DepCands, void groupChecks(MemoryDepChecker::DepCandidates &DepCands,
bool UseDependencies); bool UseDependencies);
/// Generate the checks and return them. /// Generate the checks and return them.
SmallVector<RuntimePointerCheck, 4> generateChecks(); SmallVector<RuntimePointerCheck, 4> generateChecks();
/// Try to create add a new (pointer-difference, access size) pair to /// Try to create add a new (pointer-difference, access size) pair to
▲ Show 20 Lines • Show All 321 Lines • Show Last 20 Lines

llvm/include/llvm/Analysis/LoopAnalysisManager.h

Show First 20 Lines • Show All 84 Lines • ▼ Show 20 Lines
/// cached in the \c LoopAnalysisManager. /// cached in the \c LoopAnalysisManager.
template <> class LoopAnalysisManagerFunctionProxy::Result { template <> class LoopAnalysisManagerFunctionProxy::Result {
public: public:
explicit Result(LoopAnalysisManager &InnerAM, LoopInfo &LI) explicit Result(LoopAnalysisManager &InnerAM, LoopInfo &LI)
: InnerAM(&InnerAM), LI(&LI) {} : InnerAM(&InnerAM), LI(&LI) {}
Result(Result &&Arg) Result(Result &&Arg)
: InnerAM(std::move(Arg.InnerAM)), LI(Arg.LI), MSSAUsed(Arg.MSSAUsed) { : InnerAM(std::move(Arg.InnerAM)), LI(Arg.LI), MSSAUsed(Arg.MSSAUsed) {
// We have to null out the analysis manager in the moved-from state // We have to null out the analysis manager in the moved-from state
// because we are taking ownership of the responsibilty to clear the // because we are taking ownership of the responsibility to clear the
// analysis state. // analysis state.
Arg.InnerAM = nullptr; Arg.InnerAM = nullptr;
} }
Result &operator=(Result &&RHS) { Result &operator=(Result &&RHS) {
InnerAM = RHS.InnerAM; InnerAM = RHS.InnerAM;
LI = RHS.LI; LI = RHS.LI;
MSSAUsed = RHS.MSSAUsed; MSSAUsed = RHS.MSSAUsed;
// We have to null out the analysis manager in the moved-from state // We have to null out the analysis manager in the moved-from state
// because we are taking ownership of the responsibilty to clear the // because we are taking ownership of the responsibility to clear the
// analysis state. // analysis state.
RHS.InnerAM = nullptr; RHS.InnerAM = nullptr;
return *this; return *this;
} }
~Result() { ~Result() {
// InnerAM is cleared in a moved from state where there is nothing to do. // InnerAM is cleared in a moved from state where there is nothing to do.
if (!InnerAM) if (!InnerAM)
return; return;
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

llvm/include/llvm/Analysis/LoopCacheAnalysis.h

Show First 20 Lines • Show All 160 Lines • ▼ Show 20 Lines
/// 2. they have a loop carried dependence with a small dependence distance /// 2. they have a loop carried dependence with a small dependence distance
/// (e.g. less than 2) carried by the inner loop, or /// (e.g. less than 2) carried by the inner loop, or
/// 3. they refer to the same array, and the subscript in their innermost /// 3. they refer to the same array, and the subscript in their innermost
/// dimension is less than or equal to 'd' (where 'd' is less than the cache /// dimension is less than or equal to 'd' (where 'd' is less than the cache
/// line size) /// line size)
/// ///
/// Intuitively a reference group represents memory references that access /// Intuitively a reference group represents memory references that access
/// the same cache line. Conditions 1,2 above account for temporal reuse, while /// the same cache line. Conditions 1,2 above account for temporal reuse, while
/// contition 3 accounts for spacial reuse. /// condition 3 accounts for spacial reuse.
using ReferenceGroupTy = SmallVector<std::unique_ptr<IndexedReference>, 8>; using ReferenceGroupTy = SmallVector<std::unique_ptr<IndexedReference>, 8>;
using ReferenceGroupsTy = SmallVector<ReferenceGroupTy, 8>; using ReferenceGroupsTy = SmallVector<ReferenceGroupTy, 8>;
/// \c CacheCost represents the estimated cost of a inner loop as the number of /// \c CacheCost represents the estimated cost of a inner loop as the number of
/// cache lines used by the memory references it contains. /// cache lines used by the memory references it contains.
/// The 'cache cost' of a loop 'L' in a loop nest 'LN' is computed as the sum of /// The 'cache cost' of a loop 'L' in a loop nest 'LN' is computed as the sum of
/// the cache costs of all of its reference groups when the loop is considered /// the cache costs of all of its reference groups when the loop is considered
/// to be in the innermost position in the nest. /// to be in the innermost position in the nest.
▲ Show 20 Lines • Show All 120 Lines • Show Last 20 Lines

llvm/include/llvm/Analysis/MLModelRunner.h

Show All 12 Lines
#include "llvm/Analysis/TensorSpec.h" #include "llvm/Analysis/TensorSpec.h"
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace llvm { namespace llvm {
class LLVMContext; class LLVMContext;
/// MLModelRunner interface: abstraction of a mechanism for evaluating a /// MLModelRunner interface: abstraction of a mechanism for evaluating a
/// tensorflow "saved model". /// tensorflow "saved model".
/// NOTE: feature indices are expected to be consistent all accross /// NOTE: feature indices are expected to be consistent all across
/// MLModelRunners (pertaining to the same model), and also Loggers (see /// MLModelRunners (pertaining to the same model), and also Loggers (see
/// TFUtils.h) /// TFUtils.h)
class MLModelRunner { class MLModelRunner {
public: public:
// Disallows copy and assign. // Disallows copy and assign.
MLModelRunner(const MLModelRunner &) = delete; MLModelRunner(const MLModelRunner &) = delete;
MLModelRunner &operator=(const MLModelRunner &) = delete; MLModelRunner &operator=(const MLModelRunner &) = delete;
virtual ~MLModelRunner() = default; virtual ~MLModelRunner() = default;
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

llvm/include/llvm/Analysis/RegionInfo.h

Show First 20 Lines • Show All 541 Lines • ▼ Show 20 Lines#endif
/// Check if this is a correctly build Region. This is an expensive check, as /// Check if this is a correctly build Region. This is an expensive check, as
/// the complete CFG of the Region will be walked. /// the complete CFG of the Region will be walked.
void verifyRegion() const; void verifyRegion() const;
/// Clear the cache for BB RegionNodes. /// Clear the cache for BB RegionNodes.
/// ///
/// After calling this function the BasicBlock RegionNodes will be stored at /// After calling this function the BasicBlock RegionNodes will be stored at
/// different memory locations. RegionNodes obtained before this function is /// different memory locations. RegionNodes obtained before this function is
/// called are therefore not comparable to RegionNodes abtained afterwords. /// called are therefore not comparable to RegionNodes obtained afterwords.
void clearNodeCache(); void clearNodeCache();
/// @name Subregion Iterators /// @name Subregion Iterators
/// ///
/// These iterators iterator over all subregions of this Region. /// These iterators iterator over all subregions of this Region.
//@{ //@{
using iterator = typename RegionSet::iterator; using iterator = typename RegionSet::iterator;
using const_iterator = typename RegionSet::const_iterator; using const_iterator = typename RegionSet::const_iterator;
▲ Show 20 Lines • Show All 470 Lines • Show Last 20 Lines

llvm/include/llvm/CodeGen/BasicTTIImpl.h

Show First 20 Lines • Show All 464 Lines • ▼ Show 20 Linespublic:
bool shouldBuildRelLookupTables() const { bool shouldBuildRelLookupTables() const {
const TargetMachine &TM = getTLI()->getTargetMachine(); const TargetMachine &TM = getTLI()->getTargetMachine();
// If non-PIC mode, do not generate a relative lookup table. // If non-PIC mode, do not generate a relative lookup table.
if (!TM.isPositionIndependent()) if (!TM.isPositionIndependent())
return false; return false;
/// Relative lookup table entries consist of 32-bit offsets. /// Relative lookup table entries consist of 32-bit offsets.
/// Do not generate relative lookup tables for large code models /// Do not generate relative lookup tables for large code models
/// in 64-bit achitectures where 32-bit offsets might not be enough. /// in 64-bit architectures where 32-bit offsets might not be enough.
if (TM.getCodeModel() == CodeModel::Medium || if (TM.getCodeModel() == CodeModel::Medium ||
TM.getCodeModel() == CodeModel::Large) TM.getCodeModel() == CodeModel::Large)
return false; return false;
Triple TargetTriple = TM.getTargetTriple(); Triple TargetTriple = TM.getTargetTriple();
if (!TargetTriple.isArch64Bit()) if (!TargetTriple.isArch64Bit())
return false; return false;
▲ Show 20 Lines • Show All 1,885 Lines • Show Last 20 Lines

llvm/include/llvm/CodeGen/DFAPacketizer.h

Show First 20 Lines • Show All 172 Lines • ▼ Show 20 Linespublic:
// and the instruction will be added to the next packet. // and the instruction will be added to the next packet.
virtual bool shouldAddToPacket(const MachineInstr &MI) { return true; } virtual bool shouldAddToPacket(const MachineInstr &MI) { return true; }
// Check if it is legal to packetize SUI and SUJ together. // Check if it is legal to packetize SUI and SUJ together.
virtual bool isLegalToPacketizeTogether(SUnit *SUI, SUnit *SUJ) { virtual bool isLegalToPacketizeTogether(SUnit *SUI, SUnit *SUJ) {
return false; return false;
} }
// Check if it is legal to prune dependece between SUI and SUJ. // Check if it is legal to prune dependence between SUI and SUJ.
virtual bool isLegalToPruneDependencies(SUnit *SUI, SUnit *SUJ) { virtual bool isLegalToPruneDependencies(SUnit *SUI, SUnit *SUJ) {
return false; return false;
} }
// Add a DAG mutation to be done before the packetization begins. // Add a DAG mutation to be done before the packetization begins.
void addMutation(std::unique_ptr<ScheduleDAGMutation> Mutation); void addMutation(std::unique_ptr<ScheduleDAGMutation> Mutation);
bool alias(const MachineInstr &MI1, const MachineInstr &MI2, bool alias(const MachineInstr &MI1, const MachineInstr &MI2,
Show All 10 Lines

llvm/include/llvm/CodeGen/LiveRangeCalc.h

Show First 20 Lines • Show All 80 Lines • ▼ Show 20 Linesclass LiveRangeCalc {
/// ///
/// For every basic block, MBB, one of these conditions shall be true: /// For every basic block, MBB, one of these conditions shall be true:
/// ///
/// 1. !Seen.count(MBB->getNumber()) /// 1. !Seen.count(MBB->getNumber())
/// Blocks without a Seen bit are ignored. /// Blocks without a Seen bit are ignored.
/// 2. LiveOut[MBB].second.getNode() == MBB /// 2. LiveOut[MBB].second.getNode() == MBB
/// The live-out value is defined in MBB. /// The live-out value is defined in MBB.
/// 3. forall P in preds(MBB): LiveOut[P] == LiveOut[MBB] /// 3. forall P in preds(MBB): LiveOut[P] == LiveOut[MBB]
/// The live-out value passses through MBB. All predecessors must carry /// The live-out value passes through MBB. All predecessors must carry
/// the same value. /// the same value.
/// ///
/// The domtree node may be null, it can be computed. /// The domtree node may be null, it can be computed.
/// ///
/// The map can be shared by multiple live ranges as long as no two are /// The map can be shared by multiple live ranges as long as no two are
/// live-out of the same block. /// live-out of the same block.
LiveOutMap Map; LiveOutMap Map;
▲ Show 20 Lines • Show All 172 Lines • Show Last 20 Lines

llvm/include/llvm/CodeGen/MIRPrinter.h

Show All 28 Lines
/// output stream. /// output stream.
void printMIR(raw_ostream &OS, const MachineFunction &MF); void printMIR(raw_ostream &OS, const MachineFunction &MF);
/// Determine a possible list of successors of a basic block based on the /// Determine a possible list of successors of a basic block based on the
/// basic block machine operand being used inside the block. This should give /// basic block machine operand being used inside the block. This should give
/// you the correct list of successor blocks in most cases except for things /// you the correct list of successor blocks in most cases except for things
/// like jump tables where the basic block references can't easily be found. /// like jump tables where the basic block references can't easily be found.
/// The MIRPRinter will skip printing successors if they match the result of /// The MIRPRinter will skip printing successors if they match the result of
/// this funciton and the parser will use this function to construct a list if /// this function and the parser will use this function to construct a list if
/// it is missing. /// it is missing.
void guessSuccessors(const MachineBasicBlock &MBB, void guessSuccessors(const MachineBasicBlock &MBB,
SmallVectorImpl<MachineBasicBlock*> &Result, SmallVectorImpl<MachineBasicBlock*> &Result,
bool &IsFallthrough); bool &IsFallthrough);
} // end namespace llvm } // end namespace llvm
#endif #endif

llvm/include/llvm/CodeGen/MachineBranchProbabilityInfo.h

//=- MachineBranchProbabilityInfo.h - Branch Probability Analysis -*- C++ -*-=// //=- MachineBranchProbabilityInfo.h - Branch Probability Analysis -*- C++ -*-=//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This pass is used to evaluate branch probabilties on machine basic blocks. // This pass is used to evaluate branch probabilities on machine basic blocks.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_CODEGEN_MACHINEBRANCHPROBABILITYINFO_H #ifndef LLVM_CODEGEN_MACHINEBRANCHPROBABILITYINFO_H
#define LLVM_CODEGEN_MACHINEBRANCHPROBABILITYINFO_H #define LLVM_CODEGEN_MACHINEBRANCHPROBABILITYINFO_H
#include "llvm/CodeGen/MachineBasicBlock.h" #include "llvm/CodeGen/MachineBasicBlock.h"
#include "llvm/Pass.h" #include "llvm/Pass.h"
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

llvm/include/llvm/CodeGen/RegisterBankInfo.h

Show First 20 Lines • Show All 71 Lines • ▼ Show 20 Lines struct PartialMapping {
/// Print this partial mapping on dbgs() stream. /// Print this partial mapping on dbgs() stream.
void dump() const; void dump() const;
/// Print this partial mapping on \p OS; /// Print this partial mapping on \p OS;
void print(raw_ostream &OS) const; void print(raw_ostream &OS) const;
/// Check that the Mask is compatible with the RegBank. /// Check that the Mask is compatible with the RegBank.
/// Indeed, if the RegBank cannot accomadate the "active bits" of the mask, /// Indeed, if the RegBank cannot accomodate the "active bits" of the mask,
/// there is no way this mapping is valid. /// there is no way this mapping is valid.
/// ///
/// \note This method does not check anything when assertions are disabled. /// \note This method does not check anything when assertions are disabled.
/// ///
/// \return True is the check was successful. /// \return True is the check was successful.
bool verify() const; bool verify() const;
}; };
▲ Show 20 Lines • Show All 687 Lines • Show Last 20 Lines

llvm/include/llvm/CodeGen/RegisterPressure.h

Show First 20 Lines • Show All 361 Lines • ▼ Show 20 Linesclass RegPressureTracker {
const LiveIntervals *LIS = nullptr; const LiveIntervals *LIS = nullptr;
/// We currently only allow pressure tracking within a block. /// We currently only allow pressure tracking within a block.
const MachineBasicBlock *MBB = nullptr; const MachineBasicBlock *MBB = nullptr;
/// Track the max pressure within the region traversed so far. /// Track the max pressure within the region traversed so far.
RegisterPressure &P; RegisterPressure &P;
/// Run in two modes dependending on whether constructed with IntervalPressure /// Run in two modes depending on whether constructed with IntervalPressure
/// or RegisterPressure. If requireIntervals is false, LIS are ignored. /// or RegisterPressure. If requireIntervals is false, LIS are ignored.
bool RequireIntervals; bool RequireIntervals;
/// True if UntiedDefs will be populated. /// True if UntiedDefs will be populated.
bool TrackUntiedDefs = false; bool TrackUntiedDefs = false;
/// True if lanemasks should be tracked. /// True if lanemasks should be tracked.
bool TrackLaneMasks = false; bool TrackLaneMasks = false;
▲ Show 20 Lines • Show All 195 Lines • Show Last 20 Lines

llvm/include/llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h

Show First 20 Lines • Show All 175 Lines • ▼ Show 20 Lines
private: private:
void clear(); void clear();
/// A helper structure that can quickly determine the size in bytes of an /// A helper structure that can quickly determine the size in bytes of an
/// abbreviation declaration. /// abbreviation declaration.
struct FixedSizeInfo { struct FixedSizeInfo {
/// The fixed byte size for fixed size forms. /// The fixed byte size for fixed size forms.
uint16_t NumBytes = 0; uint16_t NumBytes = 0;
/// Number of DW_FORM_address forms in this abbrevation declaration. /// Number of DW_FORM_address forms in this abbreviation declaration.
uint8_t NumAddrs = 0; uint8_t NumAddrs = 0;
/// Number of DW_FORM_ref_addr forms in this abbrevation declaration. /// Number of DW_FORM_ref_addr forms in this abbreviation declaration.
uint8_t NumRefAddrs = 0; uint8_t NumRefAddrs = 0;
/// Number of 4 byte in DWARF32 and 8 byte in DWARF64 forms. /// Number of 4 byte in DWARF32 and 8 byte in DWARF64 forms.
uint8_t NumDwarfOffsets = 0; uint8_t NumDwarfOffsets = 0;
FixedSizeInfo() = default; FixedSizeInfo() = default;
/// Calculate the fixed size in bytes given a DWARFUnit. /// Calculate the fixed size in bytes given a DWARFUnit.
/// ///
Show All 20 Lines

llvm/include/llvm/ExecutionEngine/Orc/Core.h

Show First 20 Lines • Show All 607 Lines • ▼ Show 20 Linespublic:
/// initializer symbols: Queries using /// initializer symbols: Queries using
/// SymbolLookupFlags::WeaklyReferencedSymbol can be used to trigger their /// SymbolLookupFlags::WeaklyReferencedSymbol can be used to trigger their
/// emission, and this method can be used to remove them from the JITDylib /// emission, and this method can be used to remove them from the JITDylib
/// once materialization is complete. /// once materialization is complete.
void defineNonExistent(ArrayRef<SymbolStringPtr> Symbols); void defineNonExistent(ArrayRef<SymbolStringPtr> Symbols);
/// Notify all not-yet-emitted covered by this MaterializationResponsibility /// Notify all not-yet-emitted covered by this MaterializationResponsibility
/// instance that an error has occurred. /// instance that an error has occurred.
/// This will remove all symbols covered by this MaterializationResponsibilty /// This will remove all symbols covered by this MaterializationResponsibility
/// from the target JITDylib, and send an error to any queries waiting on /// from the target JITDylib, and send an error to any queries waiting on
/// these symbols. /// these symbols.
void failMaterialization(); void failMaterialization();
/// Transfers responsibility to the given MaterializationUnit for all /// Transfers responsibility to the given MaterializationUnit for all
/// symbols defined by that MaterializationUnit. This allows /// symbols defined by that MaterializationUnit. This allows
/// materializers to break up work based on run-time information (e.g. /// materializers to break up work based on run-time information (e.g.
/// by introspecting which symbols have actually been looked up and /// by introspecting which symbols have actually been looked up and
▲ Show 20 Lines • Show All 1,337 Lines • Show Last 20 Lines

llvm/include/llvm/ExecutionEngine/Orc/DebugUtils.h

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Lines
/// Render a SymbolMap. /// Render a SymbolMap.
raw_ostream &operator<<(raw_ostream &OS, const SymbolMap &Symbols); raw_ostream &operator<<(raw_ostream &OS, const SymbolMap &Symbols);
/// Render a SymbolDependenceMap entry. /// Render a SymbolDependenceMap entry.
raw_ostream &operator<<(raw_ostream &OS, raw_ostream &operator<<(raw_ostream &OS,
const SymbolDependenceMap::value_type &KV); const SymbolDependenceMap::value_type &KV);
/// Render a SymbolDependendeMap. /// Render a SymbolDependenceMap.
raw_ostream &operator<<(raw_ostream &OS, const SymbolDependenceMap &Deps); raw_ostream &operator<<(raw_ostream &OS, const SymbolDependenceMap &Deps);
/// Render a MaterializationUnit. /// Render a MaterializationUnit.
raw_ostream &operator<<(raw_ostream &OS, const MaterializationUnit &MU); raw_ostream &operator<<(raw_ostream &OS, const MaterializationUnit &MU);
//// Render a JITDylibLookupFlags instance. //// Render a JITDylibLookupFlags instance.
raw_ostream &operator<<(raw_ostream &OS, raw_ostream &operator<<(raw_ostream &OS,
const JITDylibLookupFlags &JDLookupFlags); const JITDylibLookupFlags &JDLookupFlags);
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

llvm/include/llvm/ExecutionEngine/Orc/EPCEHFrameRegistrar.h

Show All 21 Lines
class ExecutionSession; class ExecutionSession;
/// Register/Deregisters EH frames in a remote process via a /// Register/Deregisters EH frames in a remote process via a
/// ExecutorProcessControl instance. /// ExecutorProcessControl instance.
class EPCEHFrameRegistrar : public jitlink::EHFrameRegistrar { class EPCEHFrameRegistrar : public jitlink::EHFrameRegistrar {
public: public:
/// Create from a ExecutorProcessControl instance alone. This will use /// Create from a ExecutorProcessControl instance alone. This will use
/// the EPC's lookupSymbols method to find the registration/deregistration /// the EPC's lookupSymbols method to find the registration/deregistration
/// funciton addresses by name. /// function addresses by name.
static Expected<std::unique_ptr<EPCEHFrameRegistrar>> static Expected<std::unique_ptr<EPCEHFrameRegistrar>>
Create(ExecutionSession &ES); Create(ExecutionSession &ES);
/// Create a EPCEHFrameRegistrar with the given ExecutorProcessControl /// Create a EPCEHFrameRegistrar with the given ExecutorProcessControl
/// object and registration/deregistration function addresses. /// object and registration/deregistration function addresses.
EPCEHFrameRegistrar(ExecutionSession &ES, EPCEHFrameRegistrar(ExecutionSession &ES,
ExecutorAddr RegisterEHFrameWrapperFnAddr, ExecutorAddr RegisterEHFrameWrapperFnAddr,
ExecutorAddr DeregisterEHFRameWrapperFnAddr) ExecutorAddr DeregisterEHFRameWrapperFnAddr)
Show All 16 Lines

llvm/include/llvm/ExecutionEngine/RuntimeDyld.h

Show First 20 Lines • Show All 138 Lines • ▼ Show 20 Lines virtual void reserveAllocationSpace(uintptr_t CodeSize, uint32_t CodeAlign,
uint32_t RODataAlign, uint32_t RODataAlign,
uintptr_t RWDataSize, uintptr_t RWDataSize,
uint32_t RWDataAlign) {} uint32_t RWDataAlign) {}
/// Override to return true to enable the reserveAllocationSpace callback. /// Override to return true to enable the reserveAllocationSpace callback.
virtual bool needsToReserveAllocationSpace() { return false; } virtual bool needsToReserveAllocationSpace() { return false; }
/// Override to return false to tell LLVM no stub space will be needed. /// Override to return false to tell LLVM no stub space will be needed.
/// This requires some guarantees depending on architecuture, but when /// This requires some guarantees depending on architecture, but when
/// you know what you are doing it saves allocated space. /// you know what you are doing it saves allocated space.
virtual bool allowStubAllocation() const { return true; } virtual bool allowStubAllocation() const { return true; }
/// Register the EH frames with the runtime so that c++ exceptions work. /// Register the EH frames with the runtime so that c++ exceptions work.
/// ///
/// \p Addr parameter provides the local address of the EH frame section /// \p Addr parameter provides the local address of the EH frame section
/// data, while \p LoadAddr provides the address of the data in the target /// data, while \p LoadAddr provides the address of the data in the target
/// address space. If the section has not been remapped (which will usually /// address space. If the section has not been remapped (which will usually
▲ Show 20 Lines • Show All 173 Lines • Show Last 20 Lines

llvm/include/llvm/Frontend/OpenMP/OMPConstants.h

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Lines
#include "llvm/Frontend/OpenMP/OMPKinds.def" #include "llvm/Frontend/OpenMP/OMPKinds.def"
}; };
#define OMP_DEFAULT_KIND(Enum, ...) \ #define OMP_DEFAULT_KIND(Enum, ...) \
constexpr auto Enum = omp::DefaultKind::Enum; constexpr auto Enum = omp::DefaultKind::Enum;
#include "llvm/Frontend/OpenMP/OMPKinds.def" #include "llvm/Frontend/OpenMP/OMPKinds.def"
/// IDs for all omp runtime library ident_t flag encodings (see /// IDs for all omp runtime library ident_t flag encodings (see
/// their defintion in openmp/runtime/src/kmp.h). /// their definition in openmp/runtime/src/kmp.h).
enum class IdentFlag { enum class IdentFlag {
#define OMP_IDENT_FLAG(Enum, Str, Value) Enum = Value, #define OMP_IDENT_FLAG(Enum, Str, Value) Enum = Value,
#include "llvm/Frontend/OpenMP/OMPKinds.def" #include "llvm/Frontend/OpenMP/OMPKinds.def"
LLVM_MARK_AS_BITMASK_ENUM(0x7FFFFFFF) LLVM_MARK_AS_BITMASK_ENUM(0x7FFFFFFF)
}; };
#define OMP_IDENT_FLAG(Enum, ...) constexpr auto Enum = omp::IdentFlag::Enum; #define OMP_IDENT_FLAG(Enum, ...) constexpr auto Enum = omp::IdentFlag::Enum;
#include "llvm/Frontend/OpenMP/OMPKinds.def" #include "llvm/Frontend/OpenMP/OMPKinds.def"
▲ Show 20 Lines • Show All 141 Lines • Show Last 20 Lines

llvm/include/llvm/Frontend/OpenMP/OMPContext.h

Show First 20 Lines • Show All 109 Lines • ▼ Show 20 Lines
/// Return true if \p Property can be nested in \p Selector and \p Set. /// Return true if \p Property can be nested in \p Selector and \p Set.
bool isValidTraitPropertyForTraitSetAndSelector(TraitProperty Property, bool isValidTraitPropertyForTraitSetAndSelector(TraitProperty Property,
TraitSelector Selector, TraitSelector Selector,
TraitSet Set); TraitSet Set);
/// Variant match information describes the required traits and how they are /// Variant match information describes the required traits and how they are
/// scored (via the ScoresMap). In addition, the required consturct nesting is /// scored (via the ScoresMap). In addition, the required consturct nesting is
/// decribed as well. /// described as well.
struct VariantMatchInfo { struct VariantMatchInfo {
/// Add the trait \p Property to the required trait set. \p RawString is the /// Add the trait \p Property to the required trait set. \p RawString is the
/// string we parsed and derived \p Property from. If \p Score is not null, it /// string we parsed and derived \p Property from. If \p Score is not null, it
/// recorded as well. If \p Property is in the `construct` set it is recorded /// recorded as well. If \p Property is in the `construct` set it is recorded
/// in-order in the ConstructTraits as well. /// in-order in the ConstructTraits as well.
void addTrait(TraitProperty Property, StringRef RawString, void addTrait(TraitProperty Property, StringRef RawString,
APInt *Score = nullptr) { APInt *Score = nullptr) {
addTrait(getOpenMPContextTraitSetForProperty(Property), Property, RawString, addTrait(getOpenMPContextTraitSetForProperty(Property), Property, RawString,
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

llvm/include/llvm/IR/GlobalValue.h

Show First 20 Lines • Show All 466 Lines • ▼ Show 20 Linespublic:
/// Inlining is okay across non-exact linkage types as long as they're not /// Inlining is okay across non-exact linkage types as long as they're not
/// interposable (see \c isInterposable), since in such cases the currently /// interposable (see \c isInterposable), since in such cases the currently
/// visible variant is *a* correct implementation of the original source /// visible variant is *a* correct implementation of the original source
/// function; it just isn't the *only* correct implementation. /// function; it just isn't the *only* correct implementation.
bool isDefinitionExact() const { bool isDefinitionExact() const {
return !mayBeDerefined(); return !mayBeDerefined();
} }
/// Return true if this global has an exact defintion. /// Return true if this global has an exact definition.
bool hasExactDefinition() const { bool hasExactDefinition() const {
// While this computes exactly the same thing as // While this computes exactly the same thing as
// isStrongDefinitionForLinker, the intended uses are different. This // isStrongDefinitionForLinker, the intended uses are different. This
// function is intended to help decide if specific inter-procedural // function is intended to help decide if specific inter-procedural
// transforms are correct, while isStrongDefinitionForLinker's intended use // transforms are correct, while isStrongDefinitionForLinker's intended use
// is in low level code generation. // is in low level code generation.
return !isDeclaration() && isDefinitionExact(); return !isDeclaration() && isDefinitionExact();
} }
▲ Show 20 Lines • Show All 174 Lines • Show Last 20 Lines

llvm/include/llvm/IR/IntrinsicsAMDGPU.td

Show First 20 Lines • Show All 229 Lines • ▼ Show 20 Lines
// scheduled across SCHED_BARRIER, i.e. allow ALU instructions to pass. // scheduled across SCHED_BARRIER, i.e. allow ALU instructions to pass.
// MASK = 0x0000 0002: VALU instructions may be scheduled across SCHED_BARRIER. // MASK = 0x0000 0002: VALU instructions may be scheduled across SCHED_BARRIER.
// MASK = 0x0000 0004: SALU instructions may be scheduled across SCHED_BARRIER. // MASK = 0x0000 0004: SALU instructions may be scheduled across SCHED_BARRIER.
// MASK = 0x0000 0008: MFMA instructions may be scheduled across SCHED_BARRIER. // MASK = 0x0000 0008: MFMA instructions may be scheduled across SCHED_BARRIER.
// MASK = 0x0000 0010: ALL VMEM instructions may be scheduled across SCHED_BARRIER. // MASK = 0x0000 0010: ALL VMEM instructions may be scheduled across SCHED_BARRIER.
// MASK = 0x0000 0020: VMEM read instructions may be scheduled across SCHED_BARRIER. // MASK = 0x0000 0020: VMEM read instructions may be scheduled across SCHED_BARRIER.
// MASK = 0x0000 0040: VMEM write instructions may be scheduled across SCHED_BARRIER. // MASK = 0x0000 0040: VMEM write instructions may be scheduled across SCHED_BARRIER.
// MASK = 0x0000 0080: ALL DS instructions may be scheduled across SCHED_BARRIER. // MASK = 0x0000 0080: ALL DS instructions may be scheduled across SCHED_BARRIER.
// MASK = 0x0000 0100: ALL DS read instructions may be scheduled accoss SCHED_BARRIER. // MASK = 0x0000 0100: ALL DS read instructions may be scheduled across SCHED_BARRIER.
// MASK = 0x0000 0200: ALL DS write instructions may be scheduled across SCHED_BARRIER. // MASK = 0x0000 0200: ALL DS write instructions may be scheduled across SCHED_BARRIER.
def int_amdgcn_sched_barrier : ClangBuiltin<"__builtin_amdgcn_sched_barrier">, def int_amdgcn_sched_barrier : ClangBuiltin<"__builtin_amdgcn_sched_barrier">,
Intrinsic<[], [llvm_i32_ty], [ImmArg<ArgIndex<0>>, IntrNoMem, IntrHasSideEffects, IntrConvergent, Intrinsic<[], [llvm_i32_ty], [ImmArg<ArgIndex<0>>, IntrNoMem, IntrHasSideEffects, IntrConvergent,
IntrWillReturn]>; IntrWillReturn]>;
// The first parameter is a mask that determines the types of instructions that // The first parameter is a mask that determines the types of instructions that
// you would like to synchronize around and add to a scheduling group. The // you would like to synchronize around and add to a scheduling group. The
// values of the mask are defined above for sched_barrier. These instructions // values of the mask are defined above for sched_barrier. These instructions
▲ Show 20 Lines • Show All 2,207 Lines • Show Last 20 Lines

llvm/include/llvm/IR/PassManager.h

Show First 20 Lines • Show All 674 Lines • ▼ Show 20 Lines public:
/// invalidate method should in turn be provided to this routine. /// invalidate method should in turn be provided to this routine.
/// ///
/// The first time this is called for a given analysis pass, it will call /// The first time this is called for a given analysis pass, it will call
/// the corresponding result's \c invalidate method. Subsequent calls will /// the corresponding result's \c invalidate method. Subsequent calls will
/// use a cache of the results of that initial call. It is an error to form /// use a cache of the results of that initial call. It is an error to form
/// cyclic dependencies between analysis results. /// cyclic dependencies between analysis results.
/// ///
/// This returns true if the given analysis's result is invalid. Any /// This returns true if the given analysis's result is invalid. Any
/// dependecies on it will become invalid as a result. /// dependencies on it will become invalid as a result.
template <typename PassT> template <typename PassT>
bool invalidate(IRUnitT &IR, const PreservedAnalyses &PA) { bool invalidate(IRUnitT &IR, const PreservedAnalyses &PA) {
using ResultModelT = using ResultModelT =
detail::AnalysisResultModel<IRUnitT, PassT, typename PassT::Result, detail::AnalysisResultModel<IRUnitT, PassT, typename PassT::Result,
PreservedAnalyses, Invalidator>; PreservedAnalyses, Invalidator>;
return invalidateImpl<ResultModelT>(PassT::ID(), IR, PA); return invalidateImpl<ResultModelT>(PassT::ID(), IR, PA);
} }
▲ Show 20 Lines • Show All 247 Lines • ▼ Show 20 Lines : public AnalysisInfoMixin<
InnerAnalysisManagerProxy<AnalysisManagerT, IRUnitT>> { InnerAnalysisManagerProxy<AnalysisManagerT, IRUnitT>> {
public: public:
class Result { class Result {
public: public:
explicit Result(AnalysisManagerT &InnerAM) : InnerAM(&InnerAM) {} explicit Result(AnalysisManagerT &InnerAM) : InnerAM(&InnerAM) {}
Result(Result &&Arg) : InnerAM(std::move(Arg.InnerAM)) { Result(Result &&Arg) : InnerAM(std::move(Arg.InnerAM)) {
// We have to null out the analysis manager in the moved-from state // We have to null out the analysis manager in the moved-from state
// because we are taking ownership of the responsibilty to clear the // because we are taking ownership of the responsibility to clear the
// analysis state. // analysis state.
Arg.InnerAM = nullptr; Arg.InnerAM = nullptr;
} }
~Result() { ~Result() {
// InnerAM is cleared in a moved from state where there is nothing to do. // InnerAM is cleared in a moved from state where there is nothing to do.
if (!InnerAM) if (!InnerAM)
return; return;
// Clear out the analysis manager if we're being destroyed -- it means we // Clear out the analysis manager if we're being destroyed -- it means we
// didn't even see an invalidate call when we got invalidated. // didn't even see an invalidate call when we got invalidated.
InnerAM->clear(); InnerAM->clear();
} }
Result &operator=(Result &&RHS) { Result &operator=(Result &&RHS) {
InnerAM = RHS.InnerAM; InnerAM = RHS.InnerAM;
// We have to null out the analysis manager in the moved-from state // We have to null out the analysis manager in the moved-from state
// because we are taking ownership of the responsibilty to clear the // because we are taking ownership of the responsibility to clear the
// analysis state. // analysis state.
RHS.InnerAM = nullptr; RHS.InnerAM = nullptr;
return *this; return *this;
} }
/// Accessor for the analysis manager. /// Accessor for the analysis manager.
AnalysisManagerT &getManager() { return *InnerAM; } AnalysisManagerT &getManager() { return *InnerAM; }
▲ Show 20 Lines • Show All 392 Lines • Show Last 20 Lines

llvm/include/llvm/LTO/legacy/ThinLTOCodeGenerator.h

Show First 20 Lines • Show All 100 Lines • ▼ Show 20 Linespublic:
* \defgroup Options setters * \defgroup Options setters
* @{ * @{
*/ */
/** /**
* \defgroup Cache controlling options * \defgroup Cache controlling options
* *
* These entry points control the ThinLTO cache. The cache is intended to * These entry points control the ThinLTO cache. The cache is intended to
* support incremental build, and thus needs to be persistent accross build. * support incremental build, and thus needs to be persistent across build.
* The client enabled the cache by supplying a path to an existing directory. * The client enabled the cache by supplying a path to an existing directory.
* The code generator will use this to store objects files that may be reused * The code generator will use this to store objects files that may be reused
* during a subsequent build. * during a subsequent build.
* To avoid filling the disk space, a few knobs are provided: * To avoid filling the disk space, a few knobs are provided:
* - The pruning interval limit the frequency at which the garbage collector * - The pruning interval limit the frequency at which the garbage collector
* will try to scan the cache directory to prune it from expired entries. * will try to scan the cache directory to prune it from expired entries.
* Setting to -1 disable the pruning (default). Setting to 0 will force * Setting to -1 disable the pruning (default). Setting to 0 will force
* pruning to occur. * pruning to occur.
▲ Show 20 Lines • Show All 235 Lines • Show Last 20 Lines

llvm/include/llvm/MC/MCStreamer.h

Show First 20 Lines • Show All 883 Lines • ▼ Show 20 Lines virtual void emitValueToOffset(const MCExpr *Offset, unsigned char Value,
SMLoc Loc); SMLoc Loc);
/// @} /// @}
/// Switch to a new logical file. This is used to implement the '.file /// Switch to a new logical file. This is used to implement the '.file
/// "foo.c"' assembler directive. /// "foo.c"' assembler directive.
virtual void emitFileDirective(StringRef Filename); virtual void emitFileDirective(StringRef Filename);
/// Emit ".file assembler diretive with additioal info. /// Emit ".file assembler diretive with additional info.
virtual void emitFileDirective(StringRef Filename, StringRef CompilerVerion, virtual void emitFileDirective(StringRef Filename, StringRef CompilerVerion,
StringRef TimeStamp, StringRef Description); StringRef TimeStamp, StringRef Description);
/// Emit the "identifiers" directive. This implements the /// Emit the "identifiers" directive. This implements the
/// '.ident "version foo"' assembler directive. /// '.ident "version foo"' assembler directive.
virtual void emitIdent(StringRef IdentString) {} virtual void emitIdent(StringRef IdentString) {}
/// Associate a filename with a specified logical file number. This /// Associate a filename with a specified logical file number. This
▲ Show 20 Lines • Show All 263 Lines • Show Last 20 Lines

llvm/include/llvm/Support/BranchProbability.h

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Linespublic:
static BranchProbability getUnknown() { return BranchProbability(UnknownN); } static BranchProbability getUnknown() { return BranchProbability(UnknownN); }
// Create a BranchProbability object with the given numerator and 1<<31 // Create a BranchProbability object with the given numerator and 1<<31
// as denominator. // as denominator.
static BranchProbability getRaw(uint32_t N) { return BranchProbability(N); } static BranchProbability getRaw(uint32_t N) { return BranchProbability(N); }
// Create a BranchProbability object from 64-bit integers. // Create a BranchProbability object from 64-bit integers.
static BranchProbability getBranchProbability(uint64_t Numerator, static BranchProbability getBranchProbability(uint64_t Numerator,
uint64_t Denominator); uint64_t Denominator);
// Normalize given probabilties so that the sum of them becomes approximate // Normalize given probabilities so that the sum of them becomes approximate
// one. // one.
template <class ProbabilityIter> template <class ProbabilityIter>
static void normalizeProbabilities(ProbabilityIter Begin, static void normalizeProbabilities(ProbabilityIter Begin,
ProbabilityIter End); ProbabilityIter End);
uint32_t getNumerator() const { return N; } uint32_t getNumerator() const { return N; }
static uint32_t getDenominator() { return D; } static uint32_t getDenominator() { return D; }
▲ Show 20 Lines • Show All 181 Lines • Show Last 20 Lines

llvm/include/llvm/Support/RWMutex.h

Show All 13 Lines
#define LLVM_SUPPORT_RWMUTEX_H #define LLVM_SUPPORT_RWMUTEX_H
#include "llvm/Config/llvm-config.h" #include "llvm/Config/llvm-config.h"
#include "llvm/Support/Threading.h" #include "llvm/Support/Threading.h"
#include <cassert> #include <cassert>
#include <mutex> #include <mutex>
#include <shared_mutex> #include <shared_mutex>
// std::shared_timed_mutex is only availble on macOS 10.12 and later. // std::shared_timed_mutex is only available on macOS 10.12 and later.
#if defined(__APPLE__) && defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) #if defined(__APPLE__) && defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__)
#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 101200 #if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 101200
#define LLVM_USE_RW_MUTEX_IMPL #define LLVM_USE_RW_MUTEX_IMPL
#endif #endif
#endif #endif
namespace llvm { namespace llvm {
namespace sys { namespace sys {
▲ Show 20 Lines • Show All 171 Lines • Show Last 20 Lines

llvm/include/llvm/Support/TypeName.h

Show All 12 Lines
namespace llvm { namespace llvm {
/// We provide a function which tries to compute the (demangled) name of a type /// We provide a function which tries to compute the (demangled) name of a type
/// statically. /// statically.
/// ///
/// This routine may fail on some platforms or for particularly unusual types. /// This routine may fail on some platforms or for particularly unusual types.
/// Do not use it for anything other than logging and debugging aids. It isn't /// Do not use it for anything other than logging and debugging aids. It isn't
/// portable or dependendable in any real sense. /// portable or dependable in any real sense.
/// ///
/// The returned StringRef will point into a static storage duration string. /// The returned StringRef will point into a static storage duration string.
/// However, it may not be null terminated and may be some strangely aligned /// However, it may not be null terminated and may be some strangely aligned
/// inner substring of a larger string. /// inner substring of a larger string.
template <typename DesiredTypeName> template <typename DesiredTypeName>
inline StringRef getTypeName() { inline StringRef getTypeName() {
#if defined(__clang__) || defined(__GNUC__) #if defined(__clang__) || defined(__GNUC__)
StringRef Name = __PRETTY_FUNCTION__; StringRef Name = __PRETTY_FUNCTION__;
Show All 35 Lines

llvm/include/llvm/Transforms/IPO/Attributor.h

Show First 20 Lines • Show All 2,272 Lines • ▼ Show 20 Linesstruct AbstractState {
virtual ChangeStatus indicatePessimisticFixpoint() = 0; virtual ChangeStatus indicatePessimisticFixpoint() = 0;
}; };
/// Simple state with integers encoding. /// Simple state with integers encoding.
/// ///
/// The interface ensures that the assumed bits are always a subset of the known /// The interface ensures that the assumed bits are always a subset of the known
/// bits. Users can only add known bits and, except through adding known bits, /// bits. Users can only add known bits and, except through adding known bits,
/// they can only remove assumed bits. This should guarantee monotoniticy and /// they can only remove assumed bits. This should guarantee monotoniticy and
/// thereby the existence of a fixpoint (if used corretly). The fixpoint is /// thereby the existence of a fixpoint (if used correctly). The fixpoint is
/// reached when the assumed and known state/bits are equal. Users can /// reached when the assumed and known state/bits are equal. Users can
/// force/inidicate a fixpoint. If an optimistic one is indicated, the known /// force/inidicate a fixpoint. If an optimistic one is indicated, the known
/// state will catch up with the assumed one, for a pessimistic fixpoint it is /// state will catch up with the assumed one, for a pessimistic fixpoint it is
/// the other way around. /// the other way around.
template <typename base_ty, base_ty BestState, base_ty WorstState> template <typename base_ty, base_ty BestState, base_ty WorstState>
struct IntegerStateBase : public AbstractState { struct IntegerStateBase : public AbstractState {
using base_t = base_ty; using base_t = base_ty;
▲ Show 20 Lines • Show All 241 Lines • ▼ Show 20 Linesstruct BooleanState : public IntegerStateBase<bool, true, false> {
using base_t = IntegerStateBase::base_t; using base_t = IntegerStateBase::base_t;
BooleanState() = default; BooleanState() = default;
BooleanState(base_t Assumed) : super(Assumed) {} BooleanState(base_t Assumed) : super(Assumed) {}
/// Set the assumed value to \p Value but never below the known one. /// Set the assumed value to \p Value but never below the known one.
void setAssumed(bool Value) { Assumed &= (Known | Value); } void setAssumed(bool Value) { Assumed &= (Known | Value); }
/// Set the known and asssumed value to \p Value. /// Set the known and assumed value to \p Value.
void setKnown(bool Value) { void setKnown(bool Value) {
Known |= Value; Known |= Value;
Assumed |= Value; Assumed |= Value;
} }
/// Return true if the state is assumed to hold. /// Return true if the state is assumed to hold.
bool isAssumed() const { return getAssumed(); } bool isAssumed() const { return getAssumed(); }
▲ Show 20 Lines • Show All 1,015 Lines • ▼ Show 20 Linesstruct DerefState : AbstractState {
/// int f(int *A){ /// int f(int *A){
/// *A = 0; /// *A = 0;
/// *(A+2) = 2; /// *(A+2) = 2;
/// *(A+1) = 1; /// *(A+1) = 1;
/// *(A+10) = 10; /// *(A+10) = 10;
/// } /// }
/// ``` /// ```
/// In that case, AccessedBytesMap is `{0:4, 4:4, 8:4, 40:4}`. /// In that case, AccessedBytesMap is `{0:4, 4:4, 8:4, 40:4}`.
/// AccessedBytesMap is std::map so it is iterated in accending order on /// AccessedBytesMap is std::map so it is iterated in ascending order on
/// key(Offset). So KnownBytes will be updated like this: /// key(Offset). So KnownBytes will be updated like this:
/// ///
/// |Access | KnownBytes /// |Access | KnownBytes
/// |(0, 4)| 0 -> 4 /// |(0, 4)| 0 -> 4
/// |(4, 4)| 4 -> 8 /// |(4, 4)| 4 -> 8
/// |(8, 4)| 8 -> 12 /// |(8, 4)| 8 -> 12
/// |(40, 4) | 12 (break) /// |(40, 4) | 12 (break)
void computeKnownDerefBytesFromAccessedMap() { void computeKnownDerefBytesFromAccessedMap() {
▲ Show 20 Lines • Show All 1,569 Lines • Show Last 20 Lines

llvm/include/llvm/Transforms/IPO/FunctionAttrs.h

Show All 36 Lines
bool thinLTOPropagateFunctionAttrs( bool thinLTOPropagateFunctionAttrs(
ModuleSummaryIndex &Index, ModuleSummaryIndex &Index,
function_ref<bool(GlobalValue::GUID, const GlobalValueSummary *)> function_ref<bool(GlobalValue::GUID, const GlobalValueSummary *)>
isPrevailing); isPrevailing);
/// Computes function attributes in post-order over the call graph. /// Computes function attributes in post-order over the call graph.
/// ///
/// By operating in post-order, this pass computes precise attributes for /// By operating in post-order, this pass computes precise attributes for
/// called functions prior to processsing their callers. This "bottom-up" /// called functions prior to processing their callers. This "bottom-up"
/// approach allows powerful interprocedural inference of function attributes /// approach allows powerful interprocedural inference of function attributes
/// like memory access patterns, etc. It can discover functions that do not /// like memory access patterns, etc. It can discover functions that do not
/// access memory, or only read memory, and give them the readnone/readonly /// access memory, or only read memory, and give them the readnone/readonly
/// attribute. It also discovers function arguments that are not captured by /// attribute. It also discovers function arguments that are not captured by
/// the function and marks them with the nocapture attribute. /// the function and marks them with the nocapture attribute.
struct PostOrderFunctionAttrsPass : PassInfoMixin<PostOrderFunctionAttrsPass> { struct PostOrderFunctionAttrsPass : PassInfoMixin<PostOrderFunctionAttrsPass> {
PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM, PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM,
LazyCallGraph &CG, CGSCCUpdateResult &UR); LazyCallGraph &CG, CGSCCUpdateResult &UR);
Show All 25 Lines

llvm/include/llvm/Transforms/Scalar/LoopPassManager.h

Show First 20 Lines • Show All 411 Lines • ▼ Show 20 Lines
/// FunctionPassManager. Note that if this pass is constructed with a \c /// FunctionPassManager. Note that if this pass is constructed with a \c
/// FunctionAnalysisManager it will run the \c LoopAnalysisManagerFunctionProxy /// FunctionAnalysisManager it will run the \c LoopAnalysisManagerFunctionProxy
/// analysis prior to running the loop passes over the function to enable a \c /// analysis prior to running the loop passes over the function to enable a \c
/// LoopAnalysisManager to be used within this run safely. /// LoopAnalysisManager to be used within this run safely.
/// ///
/// The adaptor comes with two modes: the loop mode and the loop-nest mode, and /// The adaptor comes with two modes: the loop mode and the loop-nest mode, and
/// the worklist updater lived inside will be in the same mode as the adaptor /// the worklist updater lived inside will be in the same mode as the adaptor
/// (refer to the documentation of \c LPMUpdater for more detailed explanation). /// (refer to the documentation of \c LPMUpdater for more detailed explanation).
/// Specifically, in loop mode, all loops in the funciton will be pushed into /// Specifically, in loop mode, all loops in the function will be pushed into
/// the worklist and processed by \p Pass, while only top-level loops are /// the worklist and processed by \p Pass, while only top-level loops are
/// processed in loop-nest mode. Please refer to the various specializations of /// processed in loop-nest mode. Please refer to the various specializations of
/// \fn createLoopFunctionToLoopPassAdaptor to see when loop mode and loop-nest /// \fn createLoopFunctionToLoopPassAdaptor to see when loop mode and loop-nest
/// mode are used. /// mode are used.
class FunctionToLoopPassAdaptor class FunctionToLoopPassAdaptor
: public PassInfoMixin<FunctionToLoopPassAdaptor> { : public PassInfoMixin<FunctionToLoopPassAdaptor> {
public: public:
using PassConceptT = using PassConceptT =
▲ Show 20 Lines • Show All 117 Lines • Show Last 20 Lines

llvm/lib/Analysis/BasicAliasAnalysis.cpp

Show First 20 Lines • Show All 1,251 Lines • ▼ Show 20 LinesAliasResult BasicAAResult::aliasGEP(
APInt ModOffset = DecompGEP1.Offset.srem(GCD); APInt ModOffset = DecompGEP1.Offset.srem(GCD);
if (ModOffset.isNegative()) if (ModOffset.isNegative())
ModOffset += GCD; // We want mod, not rem. ModOffset += GCD; // We want mod, not rem.
if (ModOffset.uge(V2Size.getValue()) && if (ModOffset.uge(V2Size.getValue()) &&
(GCD - ModOffset).uge(V1Size.getValue())) (GCD - ModOffset).uge(V1Size.getValue()))
return AliasResult::NoAlias; return AliasResult::NoAlias;
// Compute ranges of potentially accessed bytes for both accesses. If the // Compute ranges of potentially accessed bytes for both accesses. If the
// interseciton is empty, there can be no overlap. // intersection is empty, there can be no overlap.
unsigned BW = OffsetRange.getBitWidth(); unsigned BW = OffsetRange.getBitWidth();
ConstantRange Range1 = OffsetRange.add( ConstantRange Range1 = OffsetRange.add(
ConstantRange(APInt(BW, 0), APInt(BW, V1Size.getValue()))); ConstantRange(APInt(BW, 0), APInt(BW, V1Size.getValue())));
ConstantRange Range2 = ConstantRange Range2 =
ConstantRange(APInt(BW, 0), APInt(BW, V2Size.getValue())); ConstantRange(APInt(BW, 0), APInt(BW, V2Size.getValue()));
if (Range1.intersectWith(Range2).isEmptySet()) if (Range1.intersectWith(Range2).isEmptySet())
return AliasResult::NoAlias; return AliasResult::NoAlias;
▲ Show 20 Lines • Show All 651 Lines • Show Last 20 Lines

llvm/lib/Analysis/DependenceAnalysis.cpp

Show First 20 Lines • Show All 640 Lines • ▼ Show 20 Lines else {
if (Splitable) if (Splitable)
OS << " splitable"; OS << " splitable";
} }
OS << "!\n"; OS << "!\n";
} }
// Returns NoAlias/MayAliass/MustAlias for two memory locations based upon their // Returns NoAlias/MayAliass/MustAlias for two memory locations based upon their
// underlaying objects. If LocA and LocB are known to not alias (for any reason: // underlaying objects. If LocA and LocB are known to not alias (for any reason:
// tbaa, non-overlapping regions etc), then it is known there is no dependecy. // tbaa, non-overlapping regions etc), then it is known there is no dependency.
// Otherwise the underlying objects are checked to see if they point to // Otherwise the underlying objects are checked to see if they point to
// different identifiable objects. // different identifiable objects.
static AliasResult underlyingObjectsAlias(AAResults *AA, static AliasResult underlyingObjectsAlias(AAResults *AA,
const DataLayout &DL, const DataLayout &DL,
const MemoryLocation &LocA, const MemoryLocation &LocA,
const MemoryLocation &LocB) { const MemoryLocation &LocB) {
// Check the original locations (minus size) for noalias, which can happen for // Check the original locations (minus size) for noalias, which can happen for
// tbaa, incompatible underlying object locations, etc. // tbaa, incompatible underlying object locations, etc.
▲ Show 20 Lines • Show All 3,481 Lines • Show Last 20 Lines

llvm/lib/Analysis/InstructionSimplify.cpp

Show First 20 Lines • Show All 2,683 Lines • ▼ Show 20 Lines if (isa<ConstantPointerNull>(RHS) && ICmpInst::isEquality(Pred) &&
IIQ.UseInstrInfo)) IIQ.UseInstrInfo))
return ConstantInt::get(getCompareTy(LHS), !CmpInst::isTrueWhenEqual(Pred)); return ConstantInt::get(getCompareTy(LHS), !CmpInst::isTrueWhenEqual(Pred));
// We can only fold certain predicates on pointer comparisons. // We can only fold certain predicates on pointer comparisons.
switch (Pred) { switch (Pred) {
default: default:
return nullptr; return nullptr;
// Equality comaprisons are easy to fold. // Equality comparisons are easy to fold.
case CmpInst::ICMP_EQ: case CmpInst::ICMP_EQ:
case CmpInst::ICMP_NE: case CmpInst::ICMP_NE:
break; break;
// We can only handle unsigned relational comparisons because 'inbounds' on // We can only handle unsigned relational comparisons because 'inbounds' on
// a GEP only protects against unsigned wrapping. // a GEP only protects against unsigned wrapping.
case CmpInst::ICMP_UGT: case CmpInst::ICMP_UGT:
case CmpInst::ICMP_UGE: case CmpInst::ICMP_UGE:
▲ Show 20 Lines • Show All 3,872 Lines • Show Last 20 Lines

llvm/lib/Analysis/LazyCallGraph.cpp

Show First 20 Lines • Show All 536 Lines • ▼ Show 20 Lines for (int i = SourceIdx, e = TargetIdx + 1; i < e; ++i)
SCCIndices.find(SCCs[i])->second = i; SCCIndices.find(SCCs[i])->second = i;
// If the target doesn't connect to the source, then we've corrected the // If the target doesn't connect to the source, then we've corrected the
// post-order and there are no cycles formed. // post-order and there are no cycles formed.
if (!ConnectedSet.count(&TargetSCC)) { if (!ConnectedSet.count(&TargetSCC)) {
assert(SourceI > (SCCs.begin() + SourceIdx) && assert(SourceI > (SCCs.begin() + SourceIdx) &&
"Must have moved the source to fix the post-order."); "Must have moved the source to fix the post-order.");
assert(*std::prev(SourceI) == &TargetSCC && assert(*std::prev(SourceI) == &TargetSCC &&
"Last SCC to move should have bene the target."); "Last SCC to move should have been the target.");
// Return an empty range at the target SCC indicating there is nothing to // Return an empty range at the target SCC indicating there is nothing to
// merge. // merge.
return make_range(std::prev(SourceI), std::prev(SourceI)); return make_range(std::prev(SourceI), std::prev(SourceI));
} }
assert(SCCs[TargetIdx] == &TargetSCC && assert(SCCs[TargetIdx] == &TargetSCC &&
"Should not have moved target if connected!"); "Should not have moved target if connected!");
▲ Show 20 Lines • Show All 1,499 Lines • Show Last 20 Lines

llvm/lib/Analysis/TFUtils.cpp

Show First 20 Lines • Show All 147 Lines • ▼ Show 20 Linespublic:
void initInput(size_t Index, TF_DataType Type, void initInput(size_t Index, TF_DataType Type,
const std::vector<int64_t> &Dimensions); const std::vector<int64_t> &Dimensions);
const std::vector<TF_Tensor *> &getInput() const { return Input; } const std::vector<TF_Tensor *> &getInput() const { return Input; }
~TFModelEvaluatorImpl(); ~TFModelEvaluatorImpl();
private: private:
/// The objects necessary for carrying out an evaluation of the SavedModel. /// The objects necessary for carrying out an evaluation of the SavedModel.
/// They are expensive to set up, and we maintain them accross all the /// They are expensive to set up, and we maintain them across all the
/// evaluations of the model. /// evaluations of the model.
TF_Session *Session = nullptr; TF_Session *Session = nullptr;
TFGraphPtr Graph; TFGraphPtr Graph;
TFSessionOptionsPtr Options; TFSessionOptionsPtr Options;
/// The specification of the input nodes. /// The specification of the input nodes.
std::vector<TF_Output> InputFeed; std::vector<TF_Output> InputFeed;
▲ Show 20 Lines • Show All 359 Lines • Show Last 20 Lines

llvm/lib/Analysis/VectorUtils.cpp

Show First 20 Lines • Show All 1,366 Lines • ▼ Show 20 Lines for (auto *Group : LoadGroups) {
// nullptr even without the transformation. // nullptr even without the transformation.
if (Group->getNumMembers() == Group->getFactor()) if (Group->getNumMembers() == Group->getFactor())
continue; continue;
// Case 2: If first and last members of the group don't wrap this implies // Case 2: If first and last members of the group don't wrap this implies
// that all the pointers in the group don't wrap. // that all the pointers in the group don't wrap.
// So we check only group member 0 (which is always guaranteed to exist), // So we check only group member 0 (which is always guaranteed to exist),
// and group member Factor - 1; If the latter doesn't exist we rely on // and group member Factor - 1; If the latter doesn't exist we rely on
// peeling (if it is a non-reversed accsess -- see Case 3). // peeling (if it is a non-reversed access -- see Case 3).
if (InvalidateGroupIfMemberMayWrap(Group, 0, std::string("first"))) if (InvalidateGroupIfMemberMayWrap(Group, 0, std::string("first")))
continue; continue;
if (Group->getMember(Group->getFactor() - 1)) if (Group->getMember(Group->getFactor() - 1))
InvalidateGroupIfMemberMayWrap(Group, Group->getFactor() - 1, InvalidateGroupIfMemberMayWrap(Group, Group->getFactor() - 1,
std::string("last")); std::string("last"));
else { else {
// Case 3: A non-reversed interleaved load group with gaps: We need // Case 3: A non-reversed interleaved load group with gaps: We need
// to execute at least one scalar epilogue iteration. This will ensure // to execute at least one scalar epilogue iteration. This will ensure
▲ Show 20 Lines • Show All 171 Lines • Show Last 20 Lines

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

Show First 20 Lines • Show All 1,330 Lines • ▼ Show 20 Linesvoid AsmPrinter::emitBBAddrMapSection(const MachineFunction &MF) {
OutStreamer->emitInt8(OutStreamer->getContext().getBBAddrMapVersion()); OutStreamer->emitInt8(OutStreamer->getContext().getBBAddrMapVersion());
OutStreamer->AddComment("feature"); OutStreamer->AddComment("feature");
OutStreamer->emitInt8(0); OutStreamer->emitInt8(0);
OutStreamer->AddComment("function address"); OutStreamer->AddComment("function address");
OutStreamer->emitSymbolValue(FunctionSymbol, getPointerSize()); OutStreamer->emitSymbolValue(FunctionSymbol, getPointerSize());
OutStreamer->AddComment("number of basic blocks"); OutStreamer->AddComment("number of basic blocks");
OutStreamer->emitULEB128IntValue(MF.size()); OutStreamer->emitULEB128IntValue(MF.size());
const MCSymbol *PrevMBBEndSymbol = FunctionSymbol; const MCSymbol *PrevMBBEndSymbol = FunctionSymbol;
// Emit BB Information for each basic block in the funciton. // Emit BB Information for each basic block in the function.
for (const MachineBasicBlock &MBB : MF) { for (const MachineBasicBlock &MBB : MF) {
const MCSymbol *MBBSymbol = const MCSymbol *MBBSymbol =
MBB.isEntryBlock() ? FunctionSymbol : MBB.getSymbol(); MBB.isEntryBlock() ? FunctionSymbol : MBB.getSymbol();
// Emit the basic block offset relative to the end of the previous block. // Emit the basic block offset relative to the end of the previous block.
// This is zero unless the block is padded due to alignment. // This is zero unless the block is padded due to alignment.
emitLabelDifferenceAsULEB128(MBBSymbol, PrevMBBEndSymbol); emitLabelDifferenceAsULEB128(MBBSymbol, PrevMBBEndSymbol);
// Emit the basic block size. When BBs have alignments, their size cannot // Emit the basic block size. When BBs have alignments, their size cannot
// always be computed from their offsets. // always be computed from their offsets.
▲ Show 20 Lines • Show All 2,556 Lines • Show Last 20 Lines

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

Show First 20 Lines • Show All 2,146 Lines • ▼ Show 20 Linesstatic TypeRecordKind getRecordKind(const DICompositeType *Ty) {
case dwarf::DW_TAG_structure_type: case dwarf::DW_TAG_structure_type:
return TypeRecordKind::Struct; return TypeRecordKind::Struct;
default: default:
llvm_unreachable("unexpected tag"); llvm_unreachable("unexpected tag");
} }
} }
/// Return ClassOptions that should be present on both the forward declaration /// Return ClassOptions that should be present on both the forward declaration
/// and the defintion of a tag type. /// and the definition of a tag type.
static ClassOptions getCommonClassOptions(const DICompositeType *Ty) { static ClassOptions getCommonClassOptions(const DICompositeType *Ty) {
ClassOptions CO = ClassOptions::None; ClassOptions CO = ClassOptions::None;
// MSVC always sets this flag, even for local types. Clang doesn't always // MSVC always sets this flag, even for local types. Clang doesn't always
// appear to give every type a linkage name, which may be problematic for us. // appear to give every type a linkage name, which may be problematic for us.
// FIXME: Investigate the consequences of not following them here. // FIXME: Investigate the consequences of not following them here.
if (!Ty->getIdentifier().empty()) if (!Ty->getIdentifier().empty())
CO |= ClassOptions::HasUniqueName; CO |= ClassOptions::HasUniqueName;
▲ Show 20 Lines • Show All 1,235 Lines • Show Last 20 Lines

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

Show First 20 Lines • Show All 1,145 Lines • ▼ Show 20 Linesvoid DwarfDebug::beginModule(Module *M) {
if (!Asm || !MMI->hasDebugInfo()) if (!Asm || !MMI->hasDebugInfo())
return; return;
unsigned NumDebugCUs = std::distance(M->debug_compile_units_begin(), unsigned NumDebugCUs = std::distance(M->debug_compile_units_begin(),
M->debug_compile_units_end()); M->debug_compile_units_end());
assert(NumDebugCUs > 0 && "Asm unexpectedly initialized"); assert(NumDebugCUs > 0 && "Asm unexpectedly initialized");
assert(MMI->hasDebugInfo() && assert(MMI->hasDebugInfo() &&
"DebugInfoAvailabilty unexpectedly not initialized"); "DebugInfoAvailability unexpectedly not initialized");
SingleCU = NumDebugCUs == 1; SingleCU = NumDebugCUs == 1;
DenseMap<DIGlobalVariable *, SmallVector<DwarfCompileUnit::GlobalExpr, 1>> DenseMap<DIGlobalVariable *, SmallVector<DwarfCompileUnit::GlobalExpr, 1>>
GVMap; GVMap;
for (const GlobalVariable &Global : M->globals()) { for (const GlobalVariable &Global : M->globals()) {
SmallVector<DIGlobalVariableExpression *, 1> GVs; SmallVector<DIGlobalVariableExpression *, 1> GVs;
Global.getDebugInfo(GVs); Global.getDebugInfo(GVs);
for (auto *GVE : GVs) for (auto *GVE : GVs)
GVMap[GVE->getVariable()].push_back({&Global, GVE->getExpression()}); GVMap[GVE->getVariable()].push_back({&Global, GVE->getExpression()});
▲ Show 20 Lines • Show All 555 Lines • ▼ Show 20 Lines if (StartLabel == EndLabel) {
LLVM_DEBUG(dbgs() << "Omitting location list entry with empty range.\n"); LLVM_DEBUG(dbgs() << "Omitting location list entry with empty range.\n");
continue; continue;
} }
SmallVector<DbgValueLoc, 4> Values; SmallVector<DbgValueLoc, 4> Values;
for (auto &R : OpenRanges) for (auto &R : OpenRanges)
Values.push_back(R.second); Values.push_back(R.second);
// With Basic block sections, it is posssible that the StartLabel and the // With Basic block sections, it is possible that the StartLabel and the
// Instr are not in the same section. This happens when the StartLabel is // Instr are not in the same section. This happens when the StartLabel is
// the function begin label and the dbg value appears in a basic block // the function begin label and the dbg value appears in a basic block
// that is not the entry. In this case, the range needs to be split to // that is not the entry. In this case, the range needs to be split to
// span each individual section in the range from StartLabel to EndLabel. // span each individual section in the range from StartLabel to EndLabel.
if (Asm->MF->hasBBSections() && StartLabel == Asm->getFunctionBegin() && if (Asm->MF->hasBBSections() && StartLabel == Asm->getFunctionBegin() &&
!Instr->getParent()->sameSection(&Asm->MF->front())) { !Instr->getParent()->sameSection(&Asm->MF->front())) {
const MCSymbol *BeginSectionLabel = StartLabel; const MCSymbol *BeginSectionLabel = StartLabel;
▲ Show 20 Lines • Show All 1,814 Lines • Show Last 20 Lines

llvm/lib/CodeGen/AsmPrinter/EHStreamer.cpp

Show First 20 Lines • Show All 392 Lines • ▼ Show 20 LinesMCSymbol *EHStreamer::emitExceptionTable() {
// Compute the actions table and gather the first action index for each // Compute the actions table and gather the first action index for each
// landing pad site. // landing pad site.
SmallVector<ActionEntry, 32> Actions; SmallVector<ActionEntry, 32> Actions;
SmallVector<unsigned, 64> FirstActions; SmallVector<unsigned, 64> FirstActions;
computeActionsTable(LandingPads, Actions, FirstActions); computeActionsTable(LandingPads, Actions, FirstActions);
// Compute the call-site table and call-site ranges. Normally, there is only // Compute the call-site table and call-site ranges. Normally, there is only
// one call-site-range which covers the whole funciton. With // one call-site-range which covers the whole function. With
// -basic-block-sections, there is one call-site-range per basic block // -basic-block-sections, there is one call-site-range per basic block
// section. // section.
SmallVector<CallSiteEntry, 64> CallSites; SmallVector<CallSiteEntry, 64> CallSites;
SmallVector<CallSiteRange, 4> CallSiteRanges; SmallVector<CallSiteRange, 4> CallSiteRanges;
computeCallSiteTable(CallSites, CallSiteRanges, LandingPads, FirstActions); computeCallSiteTable(CallSites, CallSiteRanges, LandingPads, FirstActions);
bool IsSJLJ = Asm->MAI->getExceptionHandlingType() == ExceptionHandling::SjLj; bool IsSJLJ = Asm->MAI->getExceptionHandlingType() == ExceptionHandling::SjLj;
bool IsWasm = Asm->MAI->getExceptionHandlingType() == ExceptionHandling::Wasm; bool IsWasm = Asm->MAI->getExceptionHandlingType() == ExceptionHandling::Wasm;
▲ Show 20 Lines • Show All 428 Lines • Show Last 20 Lines

llvm/lib/CodeGen/BasicBlockSections.cpp

//===-- BasicBlockSections.cpp ---=========--------------------------------===// //===-- BasicBlockSections.cpp ---=========--------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// BasicBlockSections implementation. // BasicBlockSections implementation.
// //
// The purpose of this pass is to assign sections to basic blocks when // The purpose of this pass is to assign sections to basic blocks when
// -fbasic-block-sections= option is used. Further, with profile information // -fbasic-block-sections= option is used. Further, with profile information
// only the subset of basic blocks with profiles are placed in separate sections // only the subset of basic blocks with profiles are placed in separate sections
// and the rest are grouped in a cold section. The exception handling blocks are // and the rest are grouped in a cold section. The exception handling blocks are
// treated specially to ensure they are all in one seciton. // treated specially to ensure they are all in one section.
// //
// Basic Block Sections // Basic Block Sections
// ==================== // ====================
// //
// With option, -fbasic-block-sections=list, every function may be split into // With option, -fbasic-block-sections=list, every function may be split into
// clusters of basic blocks. Every cluster will be emitted into a separate // clusters of basic blocks. Every cluster will be emitted into a separate
// section with its basic blocks sequenced in the given order. To get the // section with its basic blocks sequenced in the given order. To get the
// optimized performance, the clusters must form an optimal BB layout for the // optimized performance, the clusters must form an optimal BB layout for the
▲ Show 20 Lines • Show All 369 Lines • Show Last 20 Lines

llvm/lib/CodeGen/BreakFalseDeps.cpp

Show First 20 Lines • Show All 130 Lines • ▼ Show 20 Lines for (MCRegUnitRootIterator Root(*Unit, TRI); Root.isValid(); ++Root) {
return false; return false;
} }
} }
// Get the undef operand's register class // Get the undef operand's register class
const TargetRegisterClass *OpRC = const TargetRegisterClass *OpRC =
TII->getRegClass(MI->getDesc(), OpIdx, TRI, *MF); TII->getRegClass(MI->getDesc(), OpIdx, TRI, *MF);
// If the instruction has a true dependency, we can hide the false depdency // If the instruction has a true dependency, we can hide the false dependency
// behind it. // behind it.
for (MachineOperand &CurrMO : MI->operands()) { for (MachineOperand &CurrMO : MI->operands()) {
if (!CurrMO.isReg() || CurrMO.isDef() || CurrMO.isUndef() || if (!CurrMO.isReg() || CurrMO.isDef() || CurrMO.isUndef() ||
!OpRC->contains(CurrMO.getReg())) !OpRC->contains(CurrMO.getReg()))
continue; continue;
// We found a true dependency - replace the undef register with the true // We found a true dependency - replace the undef register with the true
// dependency. // dependency.
MO.setReg(CurrMO.getReg()); MO.setReg(CurrMO.getReg());
▲ Show 20 Lines • Show All 151 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 7,707 Lines • ▼ Show 20 Lines
// ... // ...
// %UGEPI = gep %GEPI, (UIdx-Idx) // %UGEPI = gep %GEPI, (UIdx-Idx)
// ... // ...
// --------------------------- // ---------------------------
// //
// The register pressure on the IndirectBr edges is reduced because %GEPIOp is // The register pressure on the IndirectBr edges is reduced because %GEPIOp is
// no longer alive on them. // no longer alive on them.
// //
// We try to unmerge GEPs here in CodGenPrepare, as opposed to limiting merging // We try to unmerge GEPs here in CodeGenPrepare, as opposed to limiting merging
// of GEPs in the first place in InstCombiner::visitGetElementPtrInst() so as // of GEPs in the first place in InstCombiner::visitGetElementPtrInst() so as
// not to disable further simplications and optimizations as a result of GEP // not to disable further simplications and optimizations as a result of GEP
// merging. // merging.
// //
// Note this unmerging may increase the length of the data flow critical path // Note this unmerging may increase the length of the data flow critical path
// (the path from %GEPIOp to %UGEPI would go through %GEPI), which is a tradeoff // (the path from %GEPIOp to %UGEPI would go through %GEPI), which is a tradeoff
// between the register pressure and the length of data-flow critical // between the register pressure and the length of data-flow critical
// path. Restricting this to the uncommon IndirectBr case would minimize the // path. Restricting this to the uncommon IndirectBr case would minimize the
▲ Show 20 Lines • Show All 696 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 1,646 Lines • ▼ Show 20 Lines if (WideTy.getSizeInBits() >= SrcTy.getSizeInBits()) {
// Widen SrcTy to WideTy. This does not affect the result, but since the // Widen SrcTy to WideTy. This does not affect the result, but since the
// user requested this size, it is probably better handled than SrcTy and // user requested this size, it is probably better handled than SrcTy and
// should reduce the total number of legalization artifacts. // should reduce the total number of legalization artifacts.
if (WideTy.getSizeInBits() > SrcTy.getSizeInBits()) { if (WideTy.getSizeInBits() > SrcTy.getSizeInBits()) {
SrcTy = WideTy; SrcTy = WideTy;
SrcReg = MIRBuilder.buildAnyExt(WideTy, SrcReg).getReg(0); SrcReg = MIRBuilder.buildAnyExt(WideTy, SrcReg).getReg(0);
} }
// Theres no unmerge type to target. Directly extract the bits from the // There's no unmerge type to target. Directly extract the bits from the
// source type // source type
unsigned DstSize = DstTy.getSizeInBits(); unsigned DstSize = DstTy.getSizeInBits();
MIRBuilder.buildTrunc(Dst0Reg, SrcReg); MIRBuilder.buildTrunc(Dst0Reg, SrcReg);
for (int I = 1; I != NumDst; ++I) { for (int I = 1; I != NumDst; ++I) {
auto ShiftAmt = MIRBuilder.buildConstant(SrcTy, DstSize * I); auto ShiftAmt = MIRBuilder.buildConstant(SrcTy, DstSize * I);
auto Shr = MIRBuilder.buildLShr(SrcTy, SrcReg, ShiftAmt); auto Shr = MIRBuilder.buildLShr(SrcTy, SrcReg, ShiftAmt);
MIRBuilder.buildTrunc(MI.getOperand(I), Shr); MIRBuilder.buildTrunc(MI.getOperand(I), Shr);
▲ Show 20 Lines • Show All 6,211 Lines • Show Last 20 Lines

llvm/lib/CodeGen/GlobalISel/RegBankSelect.cpp

Show First 20 Lines • Show All 347 Lines • ▼ Show 20 Lines if (MI.isTerminator()) {
// therefore there is no need to split. // therefore there is no need to split.
if (ValMapping.NumBreakDowns == 1) if (ValMapping.NumBreakDowns == 1)
// This is a already a copy, there is nothing to do. // This is a already a copy, there is nothing to do.
RepairPt.switchTo(RepairingPlacement::RepairingKind::Reassign); RepairPt.switchTo(RepairingPlacement::RepairingKind::Reassign);
} }
return; return;
} }
// At this point, we need to repair a defintion of a terminator. // At this point, we need to repair a definition of a terminator.
// Technically we need to fix the def of MI on all outgoing // Technically we need to fix the def of MI on all outgoing
// edges of MI to keep the repairing local. In other words, we // edges of MI to keep the repairing local. In other words, we
// will create several definitions of the same register. This // will create several definitions of the same register. This
// does not work for SSA unless that definition is a physical // does not work for SSA unless that definition is a physical
// register. // register.
// However, there are other cases where we can get away with // However, there are other cases where we can get away with
// that while still keeping the repairing local. // that while still keeping the repairing local.
▲ Show 20 Lines • Show All 729 Lines • Show Last 20 Lines

llvm/lib/CodeGen/LiveVariables.cpp

Show First 20 Lines • Show All 820 Lines • ▼ Show 20 Lines for (const MachineBasicBlock *SuccMBB : MBB.successors()) {
// Or is it live because there is a use in a successor that kills it? // Or is it live because there is a use in a successor that kills it?
if (Kills.count(SuccMBB)) if (Kills.count(SuccMBB))
return true; return true;
} }
return false; return false;
} }
/// addNewBlock - Add a new basic block BB as an empty succcessor to DomBB. All /// addNewBlock - Add a new basic block BB as an empty successor to DomBB. All
/// variables that are live out of DomBB will be marked as passing live through /// variables that are live out of DomBB will be marked as passing live through
/// BB. /// BB.
void LiveVariables::addNewBlock(MachineBasicBlock *BB, void LiveVariables::addNewBlock(MachineBasicBlock *BB,
MachineBasicBlock *DomBB, MachineBasicBlock *DomBB,
MachineBasicBlock *SuccBB) { MachineBasicBlock *SuccBB) {
const unsigned NumNew = BB->getNumber(); const unsigned NumNew = BB->getNumber();
DenseSet<unsigned> Defs, Kills; DenseSet<unsigned> Defs, Kills;
Show All 32 Lines for (unsigned i = 0, e = MRI->getNumVirtRegs(); i != e; ++i) {
// If the register is either killed in or live through SuccBB it's also live // If the register is either killed in or live through SuccBB it's also live
// through BB. // through BB.
VarInfo &VI = getVarInfo(Reg); VarInfo &VI = getVarInfo(Reg);
if (Kills.count(Reg) || VI.AliveBlocks.test(SuccBB->getNumber())) if (Kills.count(Reg) || VI.AliveBlocks.test(SuccBB->getNumber()))
VI.AliveBlocks.set(NumNew); VI.AliveBlocks.set(NumNew);
} }
} }
/// addNewBlock - Add a new basic block BB as an empty succcessor to DomBB. All /// addNewBlock - Add a new basic block BB as an empty successor to DomBB. All
/// variables that are live out of DomBB will be marked as passing live through /// variables that are live out of DomBB will be marked as passing live through
/// BB. LiveInSets[BB] is *not* updated (because it is not needed during /// BB. LiveInSets[BB] is *not* updated (because it is not needed during
/// PHIElimination). /// PHIElimination).
void LiveVariables::addNewBlock(MachineBasicBlock *BB, void LiveVariables::addNewBlock(MachineBasicBlock *BB,
MachineBasicBlock *DomBB, MachineBasicBlock *DomBB,
MachineBasicBlock *SuccBB, MachineBasicBlock *SuccBB,
std::vector<SparseBitVector<>> &LiveInSets) { std::vector<SparseBitVector<>> &LiveInSets) {
const unsigned NumNew = BB->getNumber(); const unsigned NumNew = BB->getNumber();
Show All 18 Lines

llvm/lib/CodeGen/MachineVerifier.cpp

Show First 20 Lines • Show All 2,764 Lines • ▼ Show 20 Linesvoid MachineVerifier::visitMachineFunctionAfter() {
if (LiveVars) if (LiveVars)
verifyLiveVariables(); verifyLiveVariables();
if (LiveInts) if (LiveInts)
verifyLiveIntervals(); verifyLiveIntervals();
// Check live-in list of each MBB. If a register is live into MBB, check // Check live-in list of each MBB. If a register is live into MBB, check
// that the register is in regsLiveOut of each predecessor block. Since // that the register is in regsLiveOut of each predecessor block. Since
// this must come from a definition in the predecesssor or its live-in // this must come from a definition in the predecessor or its live-in
// list, this will catch a live-through case where the predecessor does not // list, this will catch a live-through case where the predecessor does not
// have the register in its live-in list. This currently only checks // have the register in its live-in list. This currently only checks
// registers that have no aliases, are not allocatable and are not // registers that have no aliases, are not allocatable and are not
// reserved, which could mean a condition code register for instance. // reserved, which could mean a condition code register for instance.
if (MRI->tracksLiveness()) if (MRI->tracksLiveness())
for (const auto &MBB : *MF) for (const auto &MBB : *MF)
for (MachineBasicBlock::RegisterMaskPair P : MBB.liveins()) { for (MachineBasicBlock::RegisterMaskPair P : MBB.liveins()) {
MCPhysReg LiveInReg = P.PhysReg; MCPhysReg LiveInReg = P.PhysReg;
▲ Show 20 Lines • Show All 577 Lines • Show Last 20 Lines

llvm/lib/CodeGen/ModuloSchedule.cpp

Show First 20 Lines • Show All 1,021 Lines • ▼ Show 20 Lines if (MO.isDef()) {
if (LastDef) if (LastDef)
replaceRegUsesAfterLoop(reg, NewReg, BB, MRI, LIS); replaceRegUsesAfterLoop(reg, NewReg, BB, MRI, LIS);
} else if (MO.isUse()) { } else if (MO.isUse()) {
MachineInstr *Def = MRI.getVRegDef(reg); MachineInstr *Def = MRI.getVRegDef(reg);
// Compute the stage that contains the last definition for instruction. // Compute the stage that contains the last definition for instruction.
int DefStageNum = Schedule.getStage(Def); int DefStageNum = Schedule.getStage(Def);
unsigned StageNum = CurStageNum; unsigned StageNum = CurStageNum;
if (DefStageNum != -1 && (int)InstrStageNum > DefStageNum) { if (DefStageNum != -1 && (int)InstrStageNum > DefStageNum) {
// Compute the difference in stages between the defintion and the use. // Compute the difference in stages between the definition and the use.
unsigned StageDiff = (InstrStageNum - DefStageNum); unsigned StageDiff = (InstrStageNum - DefStageNum);
// Make an adjustment to get the last definition. // Make an adjustment to get the last definition.
StageNum -= StageDiff; StageNum -= StageDiff;
} }
if (VRMap[StageNum].count(reg)) if (VRMap[StageNum].count(reg))
MO.setReg(VRMap[StageNum][reg]); MO.setReg(VRMap[StageNum][reg]);
} }
} }
▲ Show 20 Lines • Show All 1,154 Lines • Show Last 20 Lines

llvm/lib/CodeGen/PrologEpilogInserter.cpp

Show First 20 Lines • Show All 1,088 Lines • ▼ Show 20 Lines else
StackAlign = TFI.getTransientStackAlign(); StackAlign = TFI.getTransientStackAlign();
// If the frame pointer is eliminated, all frame offsets will be relative to // If the frame pointer is eliminated, all frame offsets will be relative to
// SP not FP. Align to MaxAlign so this works. // SP not FP. Align to MaxAlign so this works.
StackAlign = std::max(StackAlign, MaxAlign); StackAlign = std::max(StackAlign, MaxAlign);
int64_t OffsetBeforeAlignment = Offset; int64_t OffsetBeforeAlignment = Offset;
Offset = alignTo(Offset, StackAlign, Skew); Offset = alignTo(Offset, StackAlign, Skew);
// If we have increased the offset to fulfill the alignment constrants, // If we have increased the offset to fulfill the alignment constraints,
// then the scavenging spill slots may become harder to reach from the // then the scavenging spill slots may become harder to reach from the
// stack pointer, float them so they stay close. // stack pointer, float them so they stay close.
if (StackGrowsDown && OffsetBeforeAlignment != Offset && RS && if (StackGrowsDown && OffsetBeforeAlignment != Offset && RS &&
!EarlyScavengingSlots) { !EarlyScavengingSlots) {
SmallVector<int, 2> SFIs; SmallVector<int, 2> SFIs;
RS->getScavengingFrameIndices(SFIs); RS->getScavengingFrameIndices(SFIs);
LLVM_DEBUG(if (!SFIs.empty()) llvm::dbgs() LLVM_DEBUG(if (!SFIs.empty()) llvm::dbgs()
<< "Adjusting emergency spill slots!\n";); << "Adjusting emergency spill slots!\n";);
▲ Show 20 Lines • Show All 364 Lines • Show Last 20 Lines

llvm/lib/CodeGen/RegisterCoalescer.cpp

Show First 20 Lines • Show All 107 Lines • ▼ Show 20 Lines
static cl::opt<unsigned> LargeIntervalSizeThreshold( static cl::opt<unsigned> LargeIntervalSizeThreshold(
"large-interval-size-threshold", cl::Hidden, "large-interval-size-threshold", cl::Hidden,
cl::desc("If the valnos size of an interval is larger than the threshold, " cl::desc("If the valnos size of an interval is larger than the threshold, "
"it is regarded as a large interval. "), "it is regarded as a large interval. "),
cl::init(100)); cl::init(100));
static cl::opt<unsigned> LargeIntervalFreqThreshold( static cl::opt<unsigned> LargeIntervalFreqThreshold(
"large-interval-freq-threshold", cl::Hidden, "large-interval-freq-threshold", cl::Hidden,
cl::desc("For a large interval, if it is coalesed with other live " cl::desc("For a large interval, if it is coalesced with other live "
"intervals many times more than the threshold, stop its " "intervals many times more than the threshold, stop its "
"coalescing to control the compile time. "), "coalescing to control the compile time. "),
cl::init(100)); cl::init(100));
namespace { namespace {
class JoinVals; class JoinVals;
▲ Show 20 Lines • Show All 4,092 Lines • Show Last 20 Lines

llvm/lib/CodeGen/ScheduleDAGInstrs.cpp

Show First 20 Lines • Show All 914 Lines • ▼ Show 20 Lines if (MI.mayRaiseFPException()) {
} }
} }
// If it's not a store or a variant load, we're done. // If it's not a store or a variant load, we're done.
if (!MI.mayStore() && if (!MI.mayStore() &&
!(MI.mayLoad() && !MI.isDereferenceableInvariantLoad())) !(MI.mayLoad() && !MI.isDereferenceableInvariantLoad()))
continue; continue;
// Always add dependecy edge to BarrierChain if present. // Always add dependency edge to BarrierChain if present.
if (BarrierChain) if (BarrierChain)
BarrierChain->addPredBarrier(SU); BarrierChain->addPredBarrier(SU);
// Find the underlying objects for MI. The Objs vector is either // Find the underlying objects for MI. The Objs vector is either
// empty, or filled with the Values of memory locations which this // empty, or filled with the Values of memory locations which this
// SU depends on. // SU depends on.
UnderlyingObjectsVector Objs; UnderlyingObjectsVector Objs;
bool ObjsFound = getUnderlyingObjectsForInstr(&MI, MFI, Objs, bool ObjsFound = getUnderlyingObjectsForInstr(&MI, MFI, Objs,
▲ Show 20 Lines • Show All 589 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 11,113 Lines • ▼ Show 20 Lines CaseBlock CB(ISD::SETLT, Cond, Pivot, nullptr, LeftMBB, RightMBB, W.MBB,
getCurSDLoc(), LeftProb, RightProb); getCurSDLoc(), LeftProb, RightProb);
if (W.MBB == SwitchMBB) if (W.MBB == SwitchMBB)
visitSwitchCase(CB, SwitchMBB); visitSwitchCase(CB, SwitchMBB);
else else
SL->SwitchCases.push_back(CB); SL->SwitchCases.push_back(CB);
} }
// Scale CaseProb after peeling a case with the probablity of PeeledCaseProb // Scale CaseProb after peeling a case with the probability of PeeledCaseProb
// from the swith statement. // from the swith statement.
static BranchProbability scaleCaseProbality(BranchProbability CaseProb, static BranchProbability scaleCaseProbality(BranchProbability CaseProb,
BranchProbability PeeledCaseProb) { BranchProbability PeeledCaseProb) {
if (PeeledCaseProb == BranchProbability::getOne()) if (PeeledCaseProb == BranchProbability::getOne())
return BranchProbability::getZero(); return BranchProbability::getZero();
BranchProbability SwitchProb = PeeledCaseProb.getCompl(); BranchProbability SwitchProb = PeeledCaseProb.getCompl();
uint32_t Numerator = CaseProb.getNumerator(); uint32_t Numerator = CaseProb.getNumerator();
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 LinesMachineBasicBlock *SelectionDAGBuilder::peelDominantCaseCluster(
auto PeeledCaseIt = Clusters.begin() + PeeledCaseIndex; auto PeeledCaseIt = Clusters.begin() + PeeledCaseIndex;
SwitchWorkListItem W = {SwitchMBB, PeeledCaseIt, PeeledCaseIt, SwitchWorkListItem W = {SwitchMBB, PeeledCaseIt, PeeledCaseIt,
nullptr, nullptr, TopCaseProb.getCompl()}; nullptr, nullptr, TopCaseProb.getCompl()};
lowerWorkItem(W, SI.getCondition(), SwitchMBB, PeeledSwitchMBB); lowerWorkItem(W, SI.getCondition(), SwitchMBB, PeeledSwitchMBB);
Clusters.erase(PeeledCaseIt); Clusters.erase(PeeledCaseIt);
for (CaseCluster &CC : Clusters) { for (CaseCluster &CC : Clusters) {
LLVM_DEBUG( LLVM_DEBUG(
dbgs() << "Scale the probablity for one cluster, before scaling: " dbgs() << "Scale the probability for one cluster, before scaling: "
<< CC.Prob << "\n"); << CC.Prob << "\n");
CC.Prob = scaleCaseProbality(CC.Prob, TopCaseProb); CC.Prob = scaleCaseProbality(CC.Prob, TopCaseProb);
LLVM_DEBUG(dbgs() << "After scaling: " << CC.Prob << "\n"); LLVM_DEBUG(dbgs() << "After scaling: " << CC.Prob << "\n");
} }
PeeledCaseProb = TopCaseProb; PeeledCaseProb = TopCaseProb;
return PeeledSwitchMBB; return PeeledSwitchMBB;
} }
Show All 13 Linesvoid SelectionDAGBuilder::visitSwitch(const SwitchInst &SI) {
MachineBasicBlock *DefaultMBB = FuncInfo.MBBMap[SI.getDefaultDest()]; MachineBasicBlock *DefaultMBB = FuncInfo.MBBMap[SI.getDefaultDest()];
// Cluster adjacent cases with the same destination. We do this at all // Cluster adjacent cases with the same destination. We do this at all
// optimization levels because it's cheap to do and will make codegen faster // optimization levels because it's cheap to do and will make codegen faster
// if there are many clusters. // if there are many clusters.
sortAndRangeify(Clusters); sortAndRangeify(Clusters);
// The branch probablity of the peeled case. // The branch probability of the peeled case.
BranchProbability PeeledCaseProb = BranchProbability::getZero(); BranchProbability PeeledCaseProb = BranchProbability::getZero();
MachineBasicBlock *PeeledSwitchMBB = MachineBasicBlock *PeeledSwitchMBB =
peelDominantCaseCluster(SI, Clusters, PeeledCaseProb); peelDominantCaseCluster(SI, Clusters, PeeledCaseProb);
// If there is only the default destination, jump there directly. // If there is only the default destination, jump there directly.
MachineBasicBlock *SwitchMBB = FuncInfo.MBB; MachineBasicBlock *SwitchMBB = FuncInfo.MBB;
if (Clusters.empty()) { if (Clusters.empty()) {
assert(PeeledSwitchMBB == SwitchMBB); assert(PeeledSwitchMBB == SwitchMBB);
▲ Show 20 Lines • Show All 132 Lines • Show Last 20 Lines

llvm/lib/CodeGen/StackMapLivenessAnalysis.cpp

Show All 40 Lines
namespace { namespace {
/// This pass calculates the liveness information for each basic block in /// This pass calculates the liveness information for each basic block in
/// a function and attaches the register live-out information to a patchpoint /// a function and attaches the register live-out information to a patchpoint
/// intrinsic if present. /// intrinsic if present.
/// ///
/// This pass can be disabled via the -enable-patchpoint-liveness=false flag. /// This pass can be disabled via the -enable-patchpoint-liveness=false flag.
/// The pass skips functions that don't have any patchpoint intrinsics. The /// The pass skips functions that don't have any patchpoint intrinsics. The
/// information provided by this pass is optional and not required by the /// information provided by this pass is optional and not required by the
/// aformentioned intrinsic to function. /// aforementioned intrinsic to function.
class StackMapLiveness : public MachineFunctionPass { class StackMapLiveness : public MachineFunctionPass {
const TargetRegisterInfo *TRI; const TargetRegisterInfo *TRI;
LivePhysRegs LiveRegs; LivePhysRegs LiveRegs;
public: public:
static char ID; static char ID;
/// Default construct and initialize the pass. /// Default construct and initialize the pass.
▲ Show 20 Lines • Show All 114 Lines • Show Last 20 Lines

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

Show First 20 Lines • Show All 2,369 Lines • ▼ Show 20 Lines if (Kind.isText()) {
return TextSection; return TextSection;
} }
// TODO: We may put Kind.isReadOnlyWithRel() under option control, because // TODO: We may put Kind.isReadOnlyWithRel() under option control, because
// user may want to have read-only data with relocations placed into a // user may want to have read-only data with relocations placed into a
// read-only section by the compiler. // read-only section by the compiler.
// For BSS kind, zero initialized data must be emitted to the .data section // For BSS kind, zero initialized data must be emitted to the .data section
// because external linkage control sections that get mapped to the .bss // because external linkage control sections that get mapped to the .bss
// section will be linked as tentative defintions, which is only appropriate // section will be linked as tentative definitions, which is only appropriate
// for SectionKind::Common. // for SectionKind::Common.
if (Kind.isData() || Kind.isReadOnlyWithRel() || Kind.isBSS()) { if (Kind.isData() || Kind.isReadOnlyWithRel() || Kind.isBSS()) {
if (TM.getDataSections()) { if (TM.getDataSections()) {
SmallString<128> Name; SmallString<128> Name;
getNameWithPrefix(Name, GO, TM); getNameWithPrefix(Name, GO, TM);
return getContext().getXCOFFSection( return getContext().getXCOFFSection(
Name, SectionKind::getData(), Name, SectionKind::getData(),
XCOFF::CsectProperties(XCOFF::XMC_RW, XCOFF::XTY_SD)); XCOFF::CsectProperties(XCOFF::XMC_RW, XCOFF::XTY_SD));
▲ Show 20 Lines • Show All 214 Lines • Show Last 20 Lines

llvm/lib/CodeGen/TwoAddressInstructionPass.cpp

Show First 20 Lines • Show All 1,051 Lines • ▼ Show 20 Lines if (MO.isUse()) {
Kills.push_back(MOReg); Kills.push_back(MOReg);
} else if (MOReg.isPhysical()) { } else if (MOReg.isPhysical()) {
Defs.push_back(MOReg); Defs.push_back(MOReg);
if (!MO.isDead()) if (!MO.isDead())
LiveDefs.push_back(MOReg); LiveDefs.push_back(MOReg);
} }
} }
// Check if the reschedule will not break depedencies. // Check if the reschedule will not break dependencies.
unsigned NumVisited = 0; unsigned NumVisited = 0;
for (MachineInstr &OtherMI : for (MachineInstr &OtherMI :
make_range(mi, MachineBasicBlock::iterator(KillMI))) { make_range(mi, MachineBasicBlock::iterator(KillMI))) {
// Debug or pseudo instructions cannot be counted against the limit. // Debug or pseudo instructions cannot be counted against the limit.
if (OtherMI.isDebugOrPseudoInstr()) if (OtherMI.isDebugOrPseudoInstr())
continue; continue;
if (NumVisited > 10) // FIXME: Arbitrary limit to reduce compile time cost. if (NumVisited > 10) // FIXME: Arbitrary limit to reduce compile time cost.
return false; return false;
▲ Show 20 Lines • Show All 867 Lines • Show Last 20 Lines

llvm/lib/DebugInfo/DWARF/DWARFAbbreviationDeclaration.cpp

Show First 20 Lines • Show All 64 Lines • ▼ Show 20 Lines while (true) {
if (A && F) { if (A && F) {
bool IsImplicitConst = (F == DW_FORM_implicit_const); bool IsImplicitConst = (F == DW_FORM_implicit_const);
if (IsImplicitConst) { if (IsImplicitConst) {
int64_t V = Data.getSLEB128(OffsetPtr); int64_t V = Data.getSLEB128(OffsetPtr);
AttributeSpecs.push_back(AttributeSpec(A, F, V)); AttributeSpecs.push_back(AttributeSpec(A, F, V));
continue; continue;
} }
Optional<uint8_t> ByteSize; Optional<uint8_t> ByteSize;
// If this abbrevation still has a fixed byte size, then update the // If this abbreviation still has a fixed byte size, then update the
// FixedAttributeSize as needed. // FixedAttributeSize as needed.
switch (F) { switch (F) {
case DW_FORM_addr: case DW_FORM_addr:
if (FixedAttributeSize) if (FixedAttributeSize)
++FixedAttributeSize->NumAddrs; ++FixedAttributeSize->NumAddrs;
break; break;
case DW_FORM_ref_addr: case DW_FORM_ref_addr:
Show All 29 Lines if (A && F) {
AttributeSpecs.push_back(AttributeSpec(A, F, ByteSize)); AttributeSpecs.push_back(AttributeSpec(A, F, ByteSize));
} else if (A == 0 && F == 0) { } else if (A == 0 && F == 0) {
// We successfully reached the end of this abbreviation declaration // We successfully reached the end of this abbreviation declaration
// since both attribute and form are zero. // since both attribute and form are zero.
break; break;
} else { } else {
// Attribute and form pairs must either both be non-zero, in which case // Attribute and form pairs must either both be non-zero, in which case
// they are added to the abbreviation declaration, or both be zero to // they are added to the abbreviation declaration, or both be zero to
// terminate the abbrevation declaration. In this case only one was // terminate the abbreviation declaration. In this case only one was
// zero which is an error. // zero which is an error.
clear(); clear();
return false; return false;
} }
} }
return true; return true;
} }
▲ Show 20 Lines • Show All 104 Lines • Show Last 20 Lines

llvm/lib/DebugInfo/GSYM/FunctionInfo.cpp

Show First 20 Lines • Show All 154 Lines • ▼ Show 20 Linesllvm::Expected<LookupResult> FunctionInfo::lookup(DataExtractor &Data,
uint64_t FuncAddr, uint64_t FuncAddr,
uint64_t Addr) { uint64_t Addr) {
LookupResult LR; LookupResult LR;
LR.LookupAddr = Addr; LR.LookupAddr = Addr;
uint64_t Offset = 0; uint64_t Offset = 0;
LR.FuncRange = {FuncAddr, FuncAddr + Data.getU32(&Offset)}; LR.FuncRange = {FuncAddr, FuncAddr + Data.getU32(&Offset)};
uint32_t NameOffset = Data.getU32(&Offset); uint32_t NameOffset = Data.getU32(&Offset);
// The "lookup" functions doesn't report errors as accurately as the "decode" // The "lookup" functions doesn't report errors as accurately as the "decode"
// function as it is meant to be fast. For more accurage errors we could call // function as it is meant to be fast. For more accurate errors we could call
// "decode". // "decode".
if (!Data.isValidOffset(Offset)) if (!Data.isValidOffset(Offset))
return createStringError(std::errc::io_error, return createStringError(std::errc::io_error,
"FunctionInfo data is truncated"); "FunctionInfo data is truncated");
// This function will be called with the result of a binary search of the // This function will be called with the result of a binary search of the
// address table, we must still make sure the address does not fall into a // address table, we must still make sure the address does not fall into a
// gap between functions are after the last function. // gap between functions are after the last function.
if (LR.FuncRange.size() > 0 && !LR.FuncRange.contains(Addr)) if (LR.FuncRange.size() > 0 && !LR.FuncRange.contains(Addr))
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

llvm/lib/ExecutionEngine/GDBRegistrationListener.cpp

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Linesextern "C" {
extern "C" void __jit_debug_register_code(); extern "C" void __jit_debug_register_code();
} }
namespace { namespace {
// FIXME: lli aims to provide both, RuntimeDyld and JITLink, as the dynamic // FIXME: lli aims to provide both, RuntimeDyld and JITLink, as the dynamic
// loaders for it's JIT implementations. And they both offer debugging via the // loaders for it's JIT implementations. And they both offer debugging via the
// GDB JIT interface, which builds on the two well-known symbol names below. // GDB JIT interface, which builds on the two well-known symbol names below.
// As these symbols must be unique accross the linked executable, we can only // As these symbols must be unique across the linked executable, we can only
// define them in one of the libraries and make the other depend on it. // define them in one of the libraries and make the other depend on it.
// OrcTargetProcess is a minimal stub for embedding a JIT client in remote // OrcTargetProcess is a minimal stub for embedding a JIT client in remote
// executors. For the moment it seems reasonable to have the definition there // executors. For the moment it seems reasonable to have the definition there
// and let ExecutionEngine depend on it, until we find a better solution. // and let ExecutionEngine depend on it, until we find a better solution.
// //
LLVM_ATTRIBUTE_USED void requiredSymbolDefinitionsFromOrcTargetProcess() { LLVM_ATTRIBUTE_USED void requiredSymbolDefinitionsFromOrcTargetProcess() {
errs() << (void *)&__jit_debug_register_code errs() << (void *)&__jit_debug_register_code
<< (void *)&__jit_debug_descriptor; << (void *)&__jit_debug_descriptor;
▲ Show 20 Lines • Show All 183 Lines • Show Last 20 Lines

llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.cpp

//=--------- COFFLinkGraphBuilder.cpp - COFF LinkGraph builder ----------===// //=--------- COFFLinkGraphBuilder.cpp - COFF LinkGraph builder ----------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Generic COFF LinkGraph buliding code. // Generic COFF LinkGraph building code.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "COFFLinkGraphBuilder.h" #include "COFFLinkGraphBuilder.h"
#define DEBUG_TYPE "jitlink" #define DEBUG_TYPE "jitlink"
static const char *CommonSectionName = "__common"; static const char *CommonSectionName = "__common";
▲ Show 20 Lines • Show All 547 Lines • Show Last 20 Lines

llvm/lib/ExecutionEngine/JITLink/ELFLinkGraphBuilder.cpp

//=----------- ELFLinkGraphBuilder.cpp - ELF LinkGraph builder ------------===// //=----------- ELFLinkGraphBuilder.cpp - ELF LinkGraph builder ------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Generic ELF LinkGraph buliding code. // Generic ELF LinkGraph building code.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ELFLinkGraphBuilder.h" #include "ELFLinkGraphBuilder.h"
#define DEBUG_TYPE "jitlink" #define DEBUG_TYPE "jitlink"
static const char *DWSecNames[] = { static const char *DWSecNames[] = {
Show All 16 Lines

llvm/lib/ExecutionEngine/JITLink/ELF_aarch64.cpp

Show First 20 Lines • Show All 545 Lines • ▼ Show 20 Lines return ELFLinkGraphBuilder_aarch64<object::ELF64LE>((*ELFObj)->getFileName(),
.buildGraph(); .buildGraph();
} }
void link_ELF_aarch64(std::unique_ptr<LinkGraph> G, void link_ELF_aarch64(std::unique_ptr<LinkGraph> G,
std::unique_ptr<JITLinkContext> Ctx) { std::unique_ptr<JITLinkContext> Ctx) {
PassConfiguration Config; PassConfiguration Config;
const Triple &TT = G->getTargetTriple(); const Triple &TT = G->getTargetTriple();
if (Ctx->shouldAddDefaultTargetPasses(TT)) { if (Ctx->shouldAddDefaultTargetPasses(TT)) {
// Add eh-frame passses. // Add eh-frame passes.
Config.PrePrunePasses.push_back(DWARFRecordSectionSplitter(".eh_frame")); Config.PrePrunePasses.push_back(DWARFRecordSectionSplitter(".eh_frame"));
Config.PrePrunePasses.push_back(EHFrameEdgeFixer( Config.PrePrunePasses.push_back(EHFrameEdgeFixer(
".eh_frame", 8, aarch64::Pointer32, aarch64::Pointer64, ".eh_frame", 8, aarch64::Pointer32, aarch64::Pointer64,
aarch64::Delta32, aarch64::Delta64, aarch64::NegDelta32)); aarch64::Delta32, aarch64::Delta64, aarch64::NegDelta32));
// Add a mark-live pass. // Add a mark-live pass.
if (auto MarkLive = Ctx->getMarkLivePass(TT)) if (auto MarkLive = Ctx->getMarkLivePass(TT))
Config.PrePrunePasses.push_back(std::move(MarkLive)); Config.PrePrunePasses.push_back(std::move(MarkLive));
Show All 15 Lines

llvm/lib/ExecutionEngine/JITLink/MachOLinkGraphBuilder.cpp

//=--------- MachOLinkGraphBuilder.cpp - MachO LinkGraph builder ----------===// //=--------- MachOLinkGraphBuilder.cpp - MachO LinkGraph builder ----------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Generic MachO LinkGraph buliding code. // Generic MachO LinkGraph building code.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "MachOLinkGraphBuilder.h" #include "MachOLinkGraphBuilder.h"
#define DEBUG_TYPE "jitlink" #define DEBUG_TYPE "jitlink"
static const char *CommonSectionName = "__common"; static const char *CommonSectionName = "__common";
▲ Show 20 Lines • Show All 814 Lines • Show Last 20 Lines

llvm/lib/ExecutionEngine/JITLink/MachO_arm64.cpp

Show First 20 Lines • Show All 554 Lines • ▼ Show 20 Lines if (auto MarkLive = Ctx->getMarkLivePass(G->getTargetTriple()))
Config.PrePrunePasses.push_back(std::move(MarkLive)); Config.PrePrunePasses.push_back(std::move(MarkLive));
else else
Config.PrePrunePasses.push_back(markAllSymbolsLive); Config.PrePrunePasses.push_back(markAllSymbolsLive);
// Add compact unwind splitter pass. // Add compact unwind splitter pass.
Config.PrePrunePasses.push_back( Config.PrePrunePasses.push_back(
CompactUnwindSplitter("__LD,__compact_unwind")); CompactUnwindSplitter("__LD,__compact_unwind"));
// Add eh-frame passses. // Add eh-frame passes.
// FIXME: Prune eh-frames for which compact-unwind is available once // FIXME: Prune eh-frames for which compact-unwind is available once
// we support compact-unwind registration with libunwind. // we support compact-unwind registration with libunwind.
Config.PrePrunePasses.push_back( Config.PrePrunePasses.push_back(
DWARFRecordSectionSplitter("__TEXT,__eh_frame")); DWARFRecordSectionSplitter("__TEXT,__eh_frame"));
Config.PrePrunePasses.push_back(EHFrameEdgeFixer( Config.PrePrunePasses.push_back(EHFrameEdgeFixer(
"__TEXT,__eh_frame", 8, aarch64::Pointer32, aarch64::Pointer64, "__TEXT,__eh_frame", 8, aarch64::Pointer32, aarch64::Pointer64,
aarch64::Delta32, aarch64::Delta64, aarch64::NegDelta32)); aarch64::Delta32, aarch64::Delta64, aarch64::NegDelta32));
Show All 13 Lines

llvm/lib/ExecutionEngine/JITLink/MachO_x86_64.cpp

Show First 20 Lines • Show All 469 Lines • ▼ Show 20 Lines
} }
void link_MachO_x86_64(std::unique_ptr<LinkGraph> G, void link_MachO_x86_64(std::unique_ptr<LinkGraph> G,
std::unique_ptr<JITLinkContext> Ctx) { std::unique_ptr<JITLinkContext> Ctx) {
PassConfiguration Config; PassConfiguration Config;
if (Ctx->shouldAddDefaultTargetPasses(G->getTargetTriple())) { if (Ctx->shouldAddDefaultTargetPasses(G->getTargetTriple())) {
// Add eh-frame passses. // Add eh-frame passes.
Config.PrePrunePasses.push_back(createEHFrameSplitterPass_MachO_x86_64()); Config.PrePrunePasses.push_back(createEHFrameSplitterPass_MachO_x86_64());
Config.PrePrunePasses.push_back(createEHFrameEdgeFixerPass_MachO_x86_64()); Config.PrePrunePasses.push_back(createEHFrameEdgeFixerPass_MachO_x86_64());
// Add compact unwind splitter pass. // Add compact unwind splitter pass.
Config.PrePrunePasses.push_back( Config.PrePrunePasses.push_back(
CompactUnwindSplitter("__LD,__compact_unwind")); CompactUnwindSplitter("__LD,__compact_unwind"));
// Add a mark-live pass. // Add a mark-live pass.
Show All 31 Lines

llvm/lib/ExecutionEngine/Orc/Core.cpp

Show First 20 Lines • Show All 340 Lines • ▼ Show 20 Lines if (Err) {
// FIXME: Should this be reported / treated as failure to materialize? // FIXME: Should this be reported / treated as failure to materialize?
// Or should this be treated as a sanctioned bailing-out? // Or should this be treated as a sanctioned bailing-out?
ES.reportError(std::move(Err)); ES.reportError(std::move(Err));
R->failMaterialization(); R->failMaterialization();
return; return;
} }
} }
// The OnResolveInfo struct will hold the aliases and responsibilty for each // The OnResolveInfo struct will hold the aliases and responsibility for each
// query in the list. // query in the list.
struct OnResolveInfo { struct OnResolveInfo {
OnResolveInfo(std::unique_ptr<MaterializationResponsibility> R, OnResolveInfo(std::unique_ptr<MaterializationResponsibility> R,
SymbolAliasMap Aliases) SymbolAliasMap Aliases)
: R(std::move(R)), Aliases(std::move(Aliases)) {} : R(std::move(R)), Aliases(std::move(Aliases)) {}
std::unique_ptr<MaterializationResponsibility> R; std::unique_ptr<MaterializationResponsibility> R;
SymbolAliasMap Aliases; SymbolAliasMap Aliases;
▲ Show 20 Lines • Show All 557 Lines • ▼ Show 20 Lines for (auto &KV : Dependencies) {
DepsOnOtherJITDylib.insert(OtherSymbol); DepsOnOtherJITDylib.insert(OtherSymbol);
} }
} }
if (DepsOnOtherJITDylib.empty()) if (DepsOnOtherJITDylib.empty())
MI.UnemittedDependencies.erase(&OtherJITDylib); MI.UnemittedDependencies.erase(&OtherJITDylib);
} }
// If this symbol dependended on any symbols in the error state then move // If this symbol depended on any symbols in the error state then move
// this symbol to the error state too. // this symbol to the error state too.
if (DependsOnSymbolInErrorState) if (DependsOnSymbolInErrorState)
Symbols[Name].setFlags(Symbols[Name].getFlags() | Symbols[Name].setFlags(Symbols[Name].getFlags() |
JITSymbolFlags::HasError); JITSymbolFlags::HasError);
}); });
} }
Error JITDylib::resolve(MaterializationResponsibility &MR, Error JITDylib::resolve(MaterializationResponsibility &MR,
▲ Show 20 Lines • Show All 2,135 Lines • Show Last 20 Lines

llvm/lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp

Show First 20 Lines • Show All 226 Lines • ▼ Show 20 LinesError RTDyldObjectLinkingLayer::onObjLoad(
SymbolFlagsMap ExtraSymbolsToClaim; SymbolFlagsMap ExtraSymbolsToClaim;
SymbolMap Symbols; SymbolMap Symbols;
// Hack to support COFF constant pool comdats introduced during compilation: // Hack to support COFF constant pool comdats introduced during compilation:
// (See http://llvm.org/PR40074) // (See http://llvm.org/PR40074)
if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(&Obj)) { if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(&Obj)) {
auto &ES = getExecutionSession(); auto &ES = getExecutionSession();
// For all resolved symbols that are not already in the responsibilty set: // For all resolved symbols that are not already in the responsibility set:
// check whether the symbol is in a comdat section and if so mark it as // check whether the symbol is in a comdat section and if so mark it as
// weak. // weak.
for (auto &Sym : COFFObj->symbols()) { for (auto &Sym : COFFObj->symbols()) {
// getFlags() on COFF symbols can't fail. // getFlags() on COFF symbols can't fail.
uint32_t SymFlags = cantFail(Sym.getFlags()); uint32_t SymFlags = cantFail(Sym.getFlags());
if (SymFlags & object::BasicSymbolRef::SF_Undefined) if (SymFlags & object::BasicSymbolRef::SF_Undefined)
continue; continue;
auto Name = Sym.getName(); auto Name = Sym.getName();
▲ Show 20 Lines • Show All 147 Lines • Show Last 20 Lines

llvm/lib/ExecutionEngine/Orc/SimpleRemoteEPC.cpp

Show First 20 Lines • Show All 243 Lines • ▼ Show 20 LinesError SimpleRemoteEPC::handleSetup(uint64_t SeqNo, ExecutorAddr TagAddr,
if (TagAddr) if (TagAddr)
return make_error<StringError>("Setup packet TagAddr not zero", return make_error<StringError>("Setup packet TagAddr not zero",
inconvertibleErrorCode()); inconvertibleErrorCode());
std::lock_guard<std::mutex> Lock(SimpleRemoteEPCMutex); std::lock_guard<std::mutex> Lock(SimpleRemoteEPCMutex);
auto I = PendingCallWrapperResults.find(0); auto I = PendingCallWrapperResults.find(0);
assert(PendingCallWrapperResults.size() == 1 && assert(PendingCallWrapperResults.size() == 1 &&
I != PendingCallWrapperResults.end() && I != PendingCallWrapperResults.end() &&
"Setup message handler not connectly set up"); "Setup message handler not correctly set up");
auto SetupMsgHandler = std::move(I->second); auto SetupMsgHandler = std::move(I->second);
PendingCallWrapperResults.erase(I); PendingCallWrapperResults.erase(I);
auto WFR = auto WFR =
shared::WrapperFunctionResult::copyFrom(ArgBytes.data(), ArgBytes.size()); shared::WrapperFunctionResult::copyFrom(ArgBytes.data(), ArgBytes.size());
SetupMsgHandler(std::move(WFR)); SetupMsgHandler(std::move(WFR));
return Error::success(); return Error::success();
} }
▲ Show 20 Lines • Show All 146 Lines • Show Last 20 Lines

llvm/lib/IR/Attributes.cpp

Show First 20 Lines • Show All 1,798 Lines • ▼ Show 20 Linesbool AttrBuilder::hasAlignmentAttr() const {
return getRawIntAttr(Attribute::Alignment) != 0; return getRawIntAttr(Attribute::Alignment) != 0;
} }
bool AttrBuilder::operator==(const AttrBuilder &B) const { bool AttrBuilder::operator==(const AttrBuilder &B) const {
return Attrs == B.Attrs; return Attrs == B.Attrs;
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// AttributeFuncs Function Defintions // AttributeFuncs Function Definitions
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// Which attributes cannot be applied to a type. /// Which attributes cannot be applied to a type.
AttributeMask AttributeFuncs::typeIncompatible(Type *Ty, AttributeMask AttributeFuncs::typeIncompatible(Type *Ty,
AttributeSafetyKind ASK) { AttributeSafetyKind ASK) {
AttributeMask Incompatible; AttributeMask Incompatible;
if (!Ty->isIntegerTy()) { if (!Ty->isIntegerTy()) {
▲ Show 20 Lines • Show All 262 Lines • Show Last 20 Lines

llvm/lib/IR/BuiltinGCs.cpp

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines
class ShadowStackGC : public GCStrategy { class ShadowStackGC : public GCStrategy {
public: public:
ShadowStackGC() = default; ShadowStackGC() = default;
}; };
/// A GCStrategy which serves as an example for the usage of a statepoint based /// A GCStrategy which serves as an example for the usage of a statepoint based
/// lowering strategy. This GCStrategy is intended to suitable as a default /// lowering strategy. This GCStrategy is intended to suitable as a default
/// implementation usable with any collector which can consume the standard /// implementation usable with any collector which can consume the standard
/// stackmap format generated by statepoints, uses the default addrespace to /// stackmap format generated by statepoints, uses the default addresspace to
/// distinguish between gc managed and non-gc managed pointers, and has /// distinguish between gc managed and non-gc managed pointers, and has
/// reasonable relocation semantics. /// reasonable relocation semantics.
class StatepointGC : public GCStrategy { class StatepointGC : public GCStrategy {
public: public:
StatepointGC() { StatepointGC() {
UseStatepoints = true; UseStatepoints = true;
// These options are all gc.root specific, we specify them so that the // These options are all gc.root specific, we specify them so that the
// gc.root lowering code doesn't run. // gc.root lowering code doesn't run.
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

llvm/lib/IR/PassManager.cpp

//===- PassManager.cpp - Infrastructure for managing & running IR passes --===// //===- PassManager.cpp - Infrastructure for managing & running IR passes --===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
#include "llvm/ADT/DenseMapInfo.h" #include "llvm/ADT/DenseMapInfo.h"
#include "llvm/ADT/Optional.h" #include "llvm/ADT/Optional.h"
#include "llvm/IR/PassManagerImpl.h" #include "llvm/IR/PassManagerImpl.h"
using namespace llvm; using namespace llvm;
namespace llvm { namespace llvm {
// Explicit template instantiations and specialization defininitions for core // Explicit template instantiations and specialization definitions for core
// template typedefs. // template typedefs.
template class AllAnalysesOn<Module>; template class AllAnalysesOn<Module>;
template class AllAnalysesOn<Function>; template class AllAnalysesOn<Function>;
template class PassManager<Module>; template class PassManager<Module>;
template class PassManager<Function>; template class PassManager<Function>;
template class AnalysisManager<Module>; template class AnalysisManager<Module>;
template class AnalysisManager<Function>; template class AnalysisManager<Function>;
template class InnerAnalysisManagerProxy<FunctionAnalysisManager, Module>; template class InnerAnalysisManagerProxy<FunctionAnalysisManager, Module>;
▲ Show 20 Lines • Show All 129 Lines • Show Last 20 Lines

llvm/lib/IR/ReplaceConstant.cpp

Show First 20 Lines • Show All 66 Lines • ▼ Show 20 Lines for (auto &Path : Paths) {
// Mark CE as visited by mapping CE to NI. // Mark CE as visited by mapping CE to NI.
Visited[CE] = NI; Visited[CE] = NI;
// If required collect NI. // If required collect NI.
if (Insts) if (Insts)
Insts->insert(NI); Insts->insert(NI);
} else { } else {
// We had already encountered CE, the correponding instruction already // We had already encountered CE, the corresponding instruction
// exist, use it to replace CE. // already exist, use it to replace CE.
NI = Visited[CE]; NI = Visited[CE];
} }
assert(NI && "Expected an instruction corresponding to constant " assert(NI && "Expected an instruction corresponding to constant "
"expression."); "expression.");
// Replace all uses of constant expression CE by the corresponding // Replace all uses of constant expression CE by the corresponding
// instruction NI within the current parent instruction. // instruction NI within the current parent instruction.
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

llvm/lib/MC/ELFObjectWriter.cpp

Show First 20 Lines • Show All 588 Lines • ▼ Show 20 Linesbool ELFWriter::isInSymtab(const MCAsmLayout &Layout, const MCSymbolELF &Symbol,
if (Used) if (Used)
return true; return true;
if (Renamed) if (Renamed)
return false; return false;
if (Symbol.isVariable() && Symbol.isUndefined()) { if (Symbol.isVariable() && Symbol.isUndefined()) {
// FIXME: this is here just to diagnose the case of a var = commmon_sym. // FIXME: this is here just to diagnose the case of a var = common_sym.
Layout.getBaseSymbol(Symbol); Layout.getBaseSymbol(Symbol);
return false; return false;
} }
if (Symbol.isTemporary()) if (Symbol.isTemporary())
return false; return false;
if (Symbol.getType() == ELF::STT_SECTION) if (Symbol.getType() == ELF::STT_SECTION)
▲ Show 20 Lines • Show All 905 Lines • Show Last 20 Lines

llvm/lib/MC/MCParser/AsmLexer.cpp

Show First 20 Lines • Show All 710 Lines • ▼ Show 20 Linesbool AsmLexer::isAtStartOfComment(const char *Ptr) {
if (MAI.getRestrictCommentStringToStartOfStatement() && !IsAtStartOfStatement) if (MAI.getRestrictCommentStringToStartOfStatement() && !IsAtStartOfStatement)
return false; return false;
StringRef CommentString = MAI.getCommentString(); StringRef CommentString = MAI.getCommentString();
if (CommentString.size() == 1) if (CommentString.size() == 1)
return CommentString[0] == Ptr[0]; return CommentString[0] == Ptr[0];
// Allow # preprocessor commments also be counted as comments for "##" cases // Allow # preprocessor comments also be counted as comments for "##" cases
if (CommentString[1] == '#') if (CommentString[1] == '#')
return CommentString[0] == Ptr[0]; return CommentString[0] == Ptr[0];
return strncmp(Ptr, CommentString.data(), CommentString.size()) == 0; return strncmp(Ptr, CommentString.data(), CommentString.size()) == 0;
} }
bool AsmLexer::isAtStatementSeparator(const char *Ptr) { bool AsmLexer::isAtStatementSeparator(const char *Ptr) {
return strncmp(Ptr, MAI.getSeparatorString(), return strncmp(Ptr, MAI.getSeparatorString(),
▲ Show 20 Lines • Show All 231 Lines • Show Last 20 Lines

llvm/lib/MC/MCParser/AsmParser.cpp

Show First 20 Lines • Show All 3,125 Lines • ▼ Show 20 Lines
// ::= .ascii [ "string"+ ( , "string"+ )* ] // ::= .ascii [ "string"+ ( , "string"+ )* ]
/// ::= ( .asciz | .string ) [ "string" ( , "string" )* ] /// ::= ( .asciz | .string ) [ "string" ( , "string" )* ]
bool AsmParser::parseDirectiveAscii(StringRef IDVal, bool ZeroTerminated) { bool AsmParser::parseDirectiveAscii(StringRef IDVal, bool ZeroTerminated) {
auto parseOp = [&]() -> bool { auto parseOp = [&]() -> bool {
std::string Data; std::string Data;
if (checkForValidSection()) if (checkForValidSection())
return true; return true;
// Only support spaces as separators for .ascii directive for now. See the // Only support spaces as separators for .ascii directive for now. See the
// discusssion at https://reviews.llvm.org/D91460 for more details. // discussion at https://reviews.llvm.org/D91460 for more details.
do { do {
if (parseEscapedString(Data)) if (parseEscapedString(Data))
return true; return true;
getStreamer().emitBytes(Data); getStreamer().emitBytes(Data);
} while (!ZeroTerminated && getTok().is(AsmToken::String)); } while (!ZeroTerminated && getTok().is(AsmToken::String));
if (ZeroTerminated) if (ZeroTerminated)
getStreamer().emitBytes(StringRef("\0", 1)); getStreamer().emitBytes(StringRef("\0", 1));
return false; return false;
▲ Show 20 Lines • Show All 3,302 Lines • Show Last 20 Lines

llvm/lib/MC/MCParser/ELFAsmParser.cpp

Show First 20 Lines • Show All 483 Lines • ▼ Show 20 Lines if (L.isNot(AsmToken::Comma))
return false; return false;
Lex(); Lex();
StringRef UniqueStr; StringRef UniqueStr;
if (getParser().parseIdentifier(UniqueStr)) if (getParser().parseIdentifier(UniqueStr))
return TokError("expected identifier in directive"); return TokError("expected identifier in directive");
if (UniqueStr != "unique") if (UniqueStr != "unique")
return TokError("expected 'unique'"); return TokError("expected 'unique'");
if (L.isNot(AsmToken::Comma)) if (L.isNot(AsmToken::Comma))
return TokError("expected commma"); return TokError("expected comma");
Lex(); Lex();
if (getParser().parseAbsoluteExpression(UniqueID)) if (getParser().parseAbsoluteExpression(UniqueID))
return true; return true;
if (UniqueID < 0) if (UniqueID < 0)
return TokError("unique id must be positive"); return TokError("unique id must be positive");
if (!isUInt<32>(UniqueID) || UniqueID == ~0U) if (!isUInt<32>(UniqueID) || UniqueID == ~0U)
return TokError("unique id is too large"); return TokError("unique id is too large");
return false; return false;
▲ Show 20 Lines • Show All 429 Lines • Show Last 20 Lines

llvm/lib/MC/WasmObjectWriter.cpp

Show First 20 Lines • Show All 1,542 Lines • ▼ Show 20 Lines if (Section.isWasmData()) {
} }
if (Name == "target_features") { if (Name == "target_features") {
TargetFeaturesSection = TargetFeaturesSection =
std::make_unique<WasmCustomSection>(Name, &Section); std::make_unique<WasmCustomSection>(Name, &Section);
continue; continue;
} }
// Custom sections can also belong to COMDAT groups. In this case the // Custom sections can also belong to COMDAT groups. In this case the
// decriptor's "index" field is the section index (in the final object // descriptor's "index" field is the section index (in the final object
// file), but that is not known until after layout, so it must be fixed up // file), but that is not known until after layout, so it must be fixed up
// later // later
if (const MCSymbolWasm *C = Section.getGroup()) { if (const MCSymbolWasm *C = Section.getGroup()) {
Comdats[C->getName()].emplace_back( Comdats[C->getName()].emplace_back(
WasmComdatEntry{wasm::WASM_COMDAT_SECTION, WasmComdatEntry{wasm::WASM_COMDAT_SECTION,
static_cast<uint32_t>(CustomSections.size())}); static_cast<uint32_t>(CustomSections.size())});
} }
▲ Show 20 Lines • Show All 425 Lines • Show Last 20 Lines

llvm/lib/Option/OptTable.cpp

Show First 20 Lines • Show All 505 Lines • ▼ Show 20 LinesInputArgList OptTable::ParseArgs(ArrayRef<const char *> ArgArr,
return Args; return Args;
} }
InputArgList OptTable::parseArgs(int Argc, char *const *Argv, InputArgList OptTable::parseArgs(int Argc, char *const *Argv,
OptSpecifier Unknown, StringSaver &Saver, OptSpecifier Unknown, StringSaver &Saver,
function_ref<void(StringRef)> ErrorFn) const { function_ref<void(StringRef)> ErrorFn) const {
SmallVector<const char *, 0> NewArgv; SmallVector<const char *, 0> NewArgv;
// The environment variable specifies initial options which can be overridden // The environment variable specifies initial options which can be overridden
// by commnad line options. // by command line options.
cl::expandResponseFiles(Argc, Argv, EnvVar, Saver, NewArgv); cl::expandResponseFiles(Argc, Argv, EnvVar, Saver, NewArgv);
unsigned MAI, MAC; unsigned MAI, MAC;
opt::InputArgList Args = ParseArgs(makeArrayRef(NewArgv), MAI, MAC); opt::InputArgList Args = ParseArgs(makeArrayRef(NewArgv), MAI, MAC);
if (MAC) if (MAC)
ErrorFn((Twine(Args.getArgString(MAI)) + ": missing argument").str()); ErrorFn((Twine(Args.getArgString(MAI)) + ": missing argument").str());
// For each unknwon option, call ErrorFn with a formatted error message. The // For each unknwon option, call ErrorFn with a formatted error message. The
▲ Show 20 Lines • Show All 162 Lines • Show Last 20 Lines

llvm/lib/ProfileData/MemProf.cpp

Show First 20 Lines • Show All 95 Lines • ▼ Show 20 LinesExpected<MemProfSchema> readMemProfSchema(const unsigned char *&Buffer) {
for (size_t I = 0; I < NumSchemaIds; I++) { for (size_t I = 0; I < NumSchemaIds; I++) {
const uint64_t Tag = endian::readNext<uint64_t, little, unaligned>(Ptr); const uint64_t Tag = endian::readNext<uint64_t, little, unaligned>(Ptr);
if (Tag >= static_cast<uint64_t>(Meta::Size)) { if (Tag >= static_cast<uint64_t>(Meta::Size)) {
return make_error<InstrProfError>(instrprof_error::malformed, return make_error<InstrProfError>(instrprof_error::malformed,
"memprof schema invalid"); "memprof schema invalid");
} }
Result.push_back(static_cast<Meta>(Tag)); Result.push_back(static_cast<Meta>(Tag));
} }
// Advace the buffer to one past the schema if we succeeded. // Advance the buffer to one past the schema if we succeeded.
Buffer = Ptr; Buffer = Ptr;
return Result; return Result;
} }
} // namespace memprof } // namespace memprof
} // namespace llvm } // namespace llvm

llvm/lib/Support/FileUtilities.cpp

Show First 20 Lines • Show All 162 Lines • ▼ Show 20 Linesstatic bool CompareNumbers(const char *&F1P, const char *&F2P,
// Otherwise, advance our read pointers to the end of the numbers. // Otherwise, advance our read pointers to the end of the numbers.
F1P = F1NumEnd; F2P = F2NumEnd; F1P = F1NumEnd; F2P = F2NumEnd;
return false; return false;
} }
/// DiffFilesWithTolerance - Compare the two files specified, returning 0 if the /// DiffFilesWithTolerance - Compare the two files specified, returning 0 if the
/// files match, 1 if they are different, and 2 if there is a file error. This /// files match, 1 if they are different, and 2 if there is a file error. This
/// function differs from DiffFiles in that you can specify an absolete and /// function differs from DiffFiles in that you can specify an absolute and
/// relative FP error that is allowed to exist. If you specify a string to fill /// relative FP error that is allowed to exist. If you specify a string to fill
/// in for the error option, it will set the string to an error message if an /// in for the error option, it will set the string to an error message if an
/// error occurs, allowing the caller to distinguish between a failed diff and a /// error occurs, allowing the caller to distinguish between a failed diff and a
/// file system error. /// file system error.
/// ///
int llvm::DiffFilesWithTolerance(StringRef NameA, int llvm::DiffFilesWithTolerance(StringRef NameA,
StringRef NameB, StringRef NameB,
double AbsTol, double RelTol, double AbsTol, double RelTol,
▲ Show 20 Lines • Show All 213 Lines • Show Last 20 Lines

llvm/lib/Support/Triple.cpp

Show First 20 Lines • Show All 627 Lines • ▼ Show 20 Lines return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
.StartsWith("callable", Triple::Callable) .StartsWith("callable", Triple::Callable)
.StartsWith("mesh", Triple::Mesh) .StartsWith("mesh", Triple::Mesh)
.StartsWith("amplification", Triple::Amplification) .StartsWith("amplification", Triple::Amplification)
.Default(Triple::UnknownEnvironment); .Default(Triple::UnknownEnvironment);
} }
static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) { static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) {
return StringSwitch<Triple::ObjectFormatType>(EnvironmentName) return StringSwitch<Triple::ObjectFormatType>(EnvironmentName)
// "xcoff" must come before "coff" because of the order-dependendent // "xcoff" must come before "coff" because of the order-dependent
// pattern matching. // pattern matching.
.EndsWith("xcoff", Triple::XCOFF) .EndsWith("xcoff", Triple::XCOFF)
.EndsWith("coff", Triple::COFF) .EndsWith("coff", Triple::COFF)
.EndsWith("elf", Triple::ELF) .EndsWith("elf", Triple::ELF)
.EndsWith("goff", Triple::GOFF) .EndsWith("goff", Triple::GOFF)
.EndsWith("macho", Triple::MachO) .EndsWith("macho", Triple::MachO)
.EndsWith("wasm", Triple::Wasm) .EndsWith("wasm", Triple::Wasm)
.EndsWith("spirv", Triple::SPIRV) .EndsWith("spirv", Triple::SPIRV)
▲ Show 20 Lines • Show All 1,319 Lines • Show Last 20 Lines

llvm/lib/Support/Unix/Path.inc

Show First 20 Lines • Show All 1,132 Lines • ▼ Show 20 Linesstd::error_code openFileForRead(const Twine &Name, int &ResultFD,
if (EC) if (EC)
return EC; return EC;
// Attempt to get the real name of the file, if the user asked // Attempt to get the real name of the file, if the user asked
if(!RealPath) if(!RealPath)
return std::error_code(); return std::error_code();
RealPath->clear(); RealPath->clear();
#if defined(F_GETPATH) #if defined(F_GETPATH)
// When F_GETPATH is availble, it is the quickest way to get // When F_GETPATH is available, it is the quickest way to get
// the real path name. // the real path name.
char Buffer[PATH_MAX]; char Buffer[PATH_MAX];
if (::fcntl(ResultFD, F_GETPATH, Buffer) != -1) if (::fcntl(ResultFD, F_GETPATH, Buffer) != -1)
RealPath->append(Buffer, Buffer + strlen(Buffer)); RealPath->append(Buffer, Buffer + strlen(Buffer));
#else #else
char Buffer[PATH_MAX]; char Buffer[PATH_MAX];
#if defined(TRY_PROC_SELF_FD) #if defined(TRY_PROC_SELF_FD)
if (hasProcSelfFD()) { if (hasProcSelfFD()) {
▲ Show 20 Lines • Show All 367 Lines • Show Last 20 Lines

llvm/lib/TableGen/Record.cpp

Show First 20 Lines • Show All 1,693 Lines • ▼ Show 20 Lines if (StringInit *Name = dyn_cast<StringInit>(Expr)) {
// the final resolve to ensure that we get the correct type for them. // the final resolve to ensure that we get the correct type for them.
auto *Anonymous = dyn_cast<AnonymousNameInit>(CurRec->getNameInit()); auto *Anonymous = dyn_cast<AnonymousNameInit>(CurRec->getNameInit());
if (Name == CurRec->getNameInit() || if (Name == CurRec->getNameInit() ||
(Anonymous && Name == Anonymous->getNameInit())) { (Anonymous && Name == Anonymous->getNameInit())) {
if (!IsFinal) if (!IsFinal)
return const_cast<ExistsOpInit *>(this); return const_cast<ExistsOpInit *>(this);
// No doubt that there exists a record, so we should check if types are // No doubt that there exists a record, so we should check if types are
// compatiable. // compatible.
return IntInit::get(getRecordKeeper(), return IntInit::get(getRecordKeeper(),
CurRec->getType()->typeIsA(CheckType)); CurRec->getType()->typeIsA(CheckType));
} }
// Look up all defined records to see if we can find one. // Look up all defined records to see if we can find one.
Record *D = CheckType->getRecordKeeper().getDef(Name->getValue()); Record *D = CheckType->getRecordKeeper().getDef(Name->getValue());
if (!D) { if (!D) {
if (IsFinal) if (IsFinal)
return IntInit::get(getRecordKeeper(), 0); return IntInit::get(getRecordKeeper(), 0);
return const_cast<ExistsOpInit *>(this); return const_cast<ExistsOpInit *>(this);
} }
// Check if types are compatiable. // Check if types are compatible.
return IntInit::get(getRecordKeeper(), return IntInit::get(getRecordKeeper(),
DefInit::get(D)->getType()->typeIsA(CheckType)); DefInit::get(D)->getType()->typeIsA(CheckType));
} }
return const_cast<ExistsOpInit *>(this); return const_cast<ExistsOpInit *>(this);
} }
Init *ExistsOpInit::resolveReferences(Resolver &R) const { Init *ExistsOpInit::resolveReferences(Resolver &R) const {
Init *NewExpr = Expr->resolveReferences(R); Init *NewExpr = Expr->resolveReferences(R);
▲ Show 20 Lines • Show All 1,259 Lines • Show Last 20 Lines

llvm/lib/Target/AArch64/AArch64ConditionalCompares.cpp

Show First 20 Lines • Show All 569 Lines • ▼ Show 20 Linesvoid SSACCmpConv::convert(SmallVectorImpl<MachineBasicBlock *> &RemovedBlocks) {
LLVM_DEBUG(dbgs() << "Merging " << printMBBReference(*CmpBB) << " into " LLVM_DEBUG(dbgs() << "Merging " << printMBBReference(*CmpBB) << " into "
<< printMBBReference(*Head) << ":\n" << printMBBReference(*Head) << ":\n"
<< *CmpBB); << *CmpBB);
// All CmpBB instructions are moved into Head, and CmpBB is deleted. // All CmpBB instructions are moved into Head, and CmpBB is deleted.
// Update the CFG first. // Update the CFG first.
updateTailPHIs(); updateTailPHIs();
// Save successor probabilties before removing CmpBB and Tail from their // Save successor probabilities before removing CmpBB and Tail from their
// parents. // parents.
BranchProbability Head2CmpBB = MBPI->getEdgeProbability(Head, CmpBB); BranchProbability Head2CmpBB = MBPI->getEdgeProbability(Head, CmpBB);
BranchProbability CmpBB2Tail = MBPI->getEdgeProbability(CmpBB, Tail); BranchProbability CmpBB2Tail = MBPI->getEdgeProbability(CmpBB, Tail);
Head->removeSuccessor(CmpBB); Head->removeSuccessor(CmpBB);
CmpBB->removeSuccessor(Tail); CmpBB->removeSuccessor(Tail);
// If Head and CmpBB had successor probabilties, udpate the probabilities to // If Head and CmpBB had successor probabilities, udpate the probabilities to
// reflect the ccmp-conversion. // reflect the ccmp-conversion.
if (Head->hasSuccessorProbabilities() && CmpBB->hasSuccessorProbabilities()) { if (Head->hasSuccessorProbabilities() && CmpBB->hasSuccessorProbabilities()) {
// Head is allowed two successors. We've removed CmpBB, so the remaining // Head is allowed two successors. We've removed CmpBB, so the remaining
// successor is Tail. We need to increase the successor probability for // successor is Tail. We need to increase the successor probability for
// Tail to account for the CmpBB path we removed. // Tail to account for the CmpBB path we removed.
// //
// Pr(Tail|Head) += Pr(CmpBB|Head) * Pr(Tail|CmpBB). // Pr(Tail|Head) += Pr(CmpBB|Head) * Pr(Tail|CmpBB).
▲ Show 20 Lines • Show All 364 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 10,701 Lines • ▼ Show 20 LinesSDValue AArch64TargetLowering::LowerDUPQLane(SDValue Op,
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
if (!isTypeLegal(VT) || !VT.isScalableVector()) if (!isTypeLegal(VT) || !VT.isScalableVector())
return SDValue(); return SDValue();
// Current lowering only supports the SVE-ACLE types. // Current lowering only supports the SVE-ACLE types.
if (VT.getSizeInBits().getKnownMinSize() != AArch64::SVEBitsPerBlock) if (VT.getSizeInBits().getKnownMinSize() != AArch64::SVEBitsPerBlock)
return SDValue(); return SDValue();
// The DUPQ operation is indepedent of element type so normalise to i64s. // The DUPQ operation is independent of element type so normalise to i64s.
SDValue Idx128 = Op.getOperand(2); SDValue Idx128 = Op.getOperand(2);
// DUPQ can be used when idx is in range. // DUPQ can be used when idx is in range.
auto *CIdx = dyn_cast<ConstantSDNode>(Idx128); auto *CIdx = dyn_cast<ConstantSDNode>(Idx128);
if (CIdx && (CIdx->getZExtValue() <= 3)) { if (CIdx && (CIdx->getZExtValue() <= 3)) {
SDValue CI = DAG.getTargetConstant(CIdx->getZExtValue(), DL, MVT::i64); SDValue CI = DAG.getTargetConstant(CIdx->getZExtValue(), DL, MVT::i64);
return DAG.getNode(AArch64ISD::DUPLANE128, DL, VT, Op.getOperand(1), CI); return DAG.getNode(AArch64ISD::DUPLANE128, DL, VT, Op.getOperand(1), CI);
} }
▲ Show 20 Lines • Show All 11,315 Lines • Show Last 20 Lines

llvm/lib/Target/AArch64/AArch64InstrInfo.h

Show First 20 Lines • Show All 305 Lines • ▼ Show 20 Linespublic:
/// condition codes as if it's results had been fed to a PTEST instruction /// condition codes as if it's results had been fed to a PTEST instruction
/// along with the same general predicate. /// along with the same general predicate.
bool isPTestLikeOpcode(unsigned Opc) const; bool isPTestLikeOpcode(unsigned Opc) const;
/// Returns true if the opcode is for an SVE WHILE## instruction. /// Returns true if the opcode is for an SVE WHILE## instruction.
bool isWhileOpcode(unsigned Opc) const; bool isWhileOpcode(unsigned Opc) const;
/// Returns true if the instruction has a shift by immediate that can be /// Returns true if the instruction has a shift by immediate that can be
/// executed in one cycle less. /// executed in one cycle less.
static bool isFalkorShiftExtFast(const MachineInstr &MI); static bool isFalkorShiftExtFast(const MachineInstr &MI);
/// Return true if the instructions is a SEH instruciton used for unwinding /// Return true if the instructions is a SEH instruction used for unwinding
/// on Windows. /// on Windows.
static bool isSEHInstruction(const MachineInstr &MI); static bool isSEHInstruction(const MachineInstr &MI);
Optional<RegImmPair> isAddImmediate(const MachineInstr &MI, Optional<RegImmPair> isAddImmediate(const MachineInstr &MI,
Register Reg) const override; Register Reg) const override;
Optional<ParamLoadedValue> describeLoadedValue(const MachineInstr &MI, Optional<ParamLoadedValue> describeLoadedValue(const MachineInstr &MI,
Register Reg) const override; Register Reg) const override;
▲ Show 20 Lines • Show All 237 Lines • Show Last 20 Lines

llvm/lib/Target/AArch64/AArch64InstrInfo.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 6,691 Lines • ▼ Show 20 Linesbool AArch64InstrInfo::optimizeCondBranch(MachineInstr &MI) const {
} }
// So we increment a zero register and test for bits other // So we increment a zero register and test for bits other
// than bit 0? Conservatively bail out in case the verifier // than bit 0? Conservatively bail out in case the verifier
// missed this case. // missed this case.
if (IsTestAndBranch && MI.getOperand(1).getImm()) if (IsTestAndBranch && MI.getOperand(1).getImm())
return false; return false;
// Find Definition. // Find Definition.
assert(MI.getParent() && "Incomplete machine instruciton\n"); assert(MI.getParent() && "Incomplete machine instruction\n");
MachineBasicBlock *MBB = MI.getParent(); MachineBasicBlock *MBB = MI.getParent();
MachineFunction *MF = MBB->getParent(); MachineFunction *MF = MBB->getParent();
MachineRegisterInfo *MRI = &MF->getRegInfo(); MachineRegisterInfo *MRI = &MF->getRegInfo();
Register VReg = MI.getOperand(0).getReg(); Register VReg = MI.getOperand(0).getReg();
if (!Register::isVirtualRegister(VReg)) if (!Register::isVirtualRegister(VReg))
return false; return false;
MachineInstr *DefMI = MRI->getVRegDef(VReg); MachineInstr *DefMI = MRI->getVRegDef(VReg);
▲ Show 20 Lines • Show All 1,445 Lines • Show Last 20 Lines

llvm/lib/Target/AArch64/AArch64LowerHomogeneousPrologEpilog.cpp

Show First 20 Lines • Show All 366 Lines • ▼ Show 20 Lines if (!llvm::is_contained(Regs, AArch64::LR))
return false; return false;
switch (Type) { switch (Type) {
case FrameHelperType::Prolog: case FrameHelperType::Prolog:
// Prolog helper cannot save FP/LR. // Prolog helper cannot save FP/LR.
InstCount--; InstCount--;
break; break;
case FrameHelperType::PrologFrame: { case FrameHelperType::PrologFrame: {
// Effecitvely no change in InstCount since FpAdjusment is included. // Effecitvely no change in InstCount since FpAdjustment is included.
break; break;
} }
case FrameHelperType::Epilog: case FrameHelperType::Epilog:
// Bail-out if X16 is live across the epilog helper because it is used in // Bail-out if X16 is live across the epilog helper because it is used in
// the helper to handle X30. // the helper to handle X30.
for (auto NextMI = NextMBBI; NextMI != MBB.end(); NextMI++) { for (auto NextMI = NextMBBI; NextMI != MBB.end(); NextMI++) {
if (NextMI->readsRegister(AArch64::W16, TRI)) if (NextMI->readsRegister(AArch64::W16, TRI))
return false; return false;
▲ Show 20 Lines • Show All 231 Lines • Show Last 20 Lines

llvm/lib/Target/AArch64/AArch64SLSHardening.cpp

//===- AArch64SLSHardening.cpp - Harden Straight Line Missspeculation -----===// //===- AArch64SLSHardening.cpp - Harden Straight Line Misspeculation -----===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file contains a pass to insert code to mitigate against side channel // This file contains a pass to insert code to mitigate against side channel
▲ Show 20 Lines • Show All 438 Lines • Show Last 20 Lines

llvm/lib/Target/AArch64/AArch64SpeculationHardening.cpp

//===- AArch64SpeculationHardening.cpp - Harden Against Missspeculation --===// //===- AArch64SpeculationHardening.cpp - Harden Against Misspeculation --===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file contains a pass to insert code to mitigate against side channel // This file contains a pass to insert code to mitigate against side channel
▲ Show 20 Lines • Show All 693 Lines • Show Last 20 Lines

llvm/lib/Target/AMDGPU/AMDGPUIGroupLP.cpp

Show First 20 Lines • Show All 190 Lines • ▼ Show 20 Linesprivate:
// Used to track instructions that are already to added to a different // Used to track instructions that are already to added to a different
// SchedGroup with the same SyncID. // SchedGroup with the same SyncID.
DenseMap<int, DenseSet<SUnit *>> SyncedInstrsMap; DenseMap<int, DenseSet<SUnit *>> SyncedInstrsMap;
// Add DAG edges that enforce SCHED_BARRIER ordering. // Add DAG edges that enforce SCHED_BARRIER ordering.
void addSchedBarrierEdges(SUnit &SU); void addSchedBarrierEdges(SUnit &SU);
// Use a SCHED_BARRIER's mask to identify instruction SchedGroups that should // Use a SCHED_BARRIER's mask to identify instruction SchedGroups that should
// not be reordered accross the SCHED_BARRIER. This is used for the base // not be reordered across the SCHED_BARRIER. This is used for the base
// SCHED_BARRIER, and not SCHED_GROUP_BARRIER. The difference is that // SCHED_BARRIER, and not SCHED_GROUP_BARRIER. The difference is that
// SCHED_BARRIER will always block all instructions that can be classified // SCHED_BARRIER will always block all instructions that can be classified
// into a particular SchedClass, whereas SCHED_GROUP_BARRIER has a fixed size // into a particular SchedClass, whereas SCHED_GROUP_BARRIER has a fixed size
// and may only synchronize with some SchedGroups. Returns the inverse of // and may only synchronize with some SchedGroups. Returns the inverse of
// Mask. SCHED_BARRIER's mask describes which instruction types should be // Mask. SCHED_BARRIER's mask describes which instruction types should be
// allowed to be scheduled across it. Invert the mask to get the // allowed to be scheduled across it. Invert the mask to get the
// SchedGroupMask of instructions that should be barred. // SchedGroupMask of instructions that should be barred.
SchedGroupMask invertSchedBarrierMask(SchedGroupMask Mask) const; SchedGroupMask invertSchedBarrierMask(SchedGroupMask Mask) const;
▲ Show 20 Lines • Show All 350 Lines • Show Last 20 Lines

llvm/lib/Target/ARM/ARMFrameLowering.cpp

Show First 20 Lines • Show All 2,767 Lines • ▼ Show 20 Linesbool ARMFrameLowering::assignCalleeSavedSpillSlots(
// For functions, which sign their return address, upon function entry, the // For functions, which sign their return address, upon function entry, the
// return address PAC is computed in R12. Treat R12 as a callee-saved register // return address PAC is computed in R12. Treat R12 as a callee-saved register
// in this case. // in this case.
const auto &AFI = *MF.getInfo<ARMFunctionInfo>(); const auto &AFI = *MF.getInfo<ARMFunctionInfo>();
if (AFI.shouldSignReturnAddress()) { if (AFI.shouldSignReturnAddress()) {
// The order of register must match the order we push them, because the // The order of register must match the order we push them, because the
// PEI assigns frame indices in that order. When compiling for return // PEI assigns frame indices in that order. When compiling for return
// address sign and authenication, we use split push, therefore the orders // address sign and authentication, we use split push, therefore the orders
// we want are: // we want are:
// LR, R7, R6, R5, R4, <R12>, R11, R10, R9, R8, D15-D8 // LR, R7, R6, R5, R4, <R12>, R11, R10, R9, R8, D15-D8
CSI.insert(find_if(CSI, CSI.insert(find_if(CSI,
[=](const auto &CS) { [=](const auto &CS) {
Register Reg = CS.getReg(); Register Reg = CS.getReg();
return Reg == ARM::R10 || Reg == ARM::R11 || return Reg == ARM::R10 || Reg == ARM::R11 ||
Reg == ARM::R8 || Reg == ARM::R9 || Reg == ARM::R8 || Reg == ARM::R9 ||
ARM::DPRRegClass.contains(Reg); ARM::DPRRegClass.contains(Reg);
▲ Show 20 Lines • Show All 577 Lines • Show Last 20 Lines

llvm/lib/Target/ARM/ARMSLSHardening.cpp

//===- ARMSLSHardening.cpp - Harden Straight Line Missspeculation ---------===// //===- ARMSLSHardening.cpp - Harden Straight Line Misspeculation ---------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file contains a pass to insert code to mitigate against side channel // This file contains a pass to insert code to mitigate against side channel
▲ Show 20 Lines • Show All 411 Lines • Show Last 20 Lines

llvm/lib/Target/ARM/ARMTargetTransformInfo.cpp

Show First 20 Lines • Show All 1,768 Lines • ▼ Show 20 LinesARMTTIImpl::getIntrinsicInstrCost(const IntrinsicCostAttributes &ICA,
} }
case Intrinsic::fptosi_sat: case Intrinsic::fptosi_sat:
case Intrinsic::fptoui_sat: { case Intrinsic::fptoui_sat: {
if (ICA.getArgTypes().empty()) if (ICA.getArgTypes().empty())
break; break;
bool IsSigned = ICA.getID() == Intrinsic::fptosi_sat; bool IsSigned = ICA.getID() == Intrinsic::fptosi_sat;
auto LT = TLI->getTypeLegalizationCost(DL, ICA.getArgTypes()[0]); auto LT = TLI->getTypeLegalizationCost(DL, ICA.getArgTypes()[0]);
EVT MTy = TLI->getValueType(DL, ICA.getReturnType()); EVT MTy = TLI->getValueType(DL, ICA.getReturnType());
// Check for the legal types, with the corect subtarget features. // Check for the legal types, with the correct subtarget features.
if ((ST->hasVFP2Base() && LT.second == MVT::f32 && MTy == MVT::i32) || if ((ST->hasVFP2Base() && LT.second == MVT::f32 && MTy == MVT::i32) ||
(ST->hasFP64() && LT.second == MVT::f64 && MTy == MVT::i32) || (ST->hasFP64() && LT.second == MVT::f64 && MTy == MVT::i32) ||
(ST->hasFullFP16() && LT.second == MVT::f16 && MTy == MVT::i32)) (ST->hasFullFP16() && LT.second == MVT::f16 && MTy == MVT::i32))
return LT.first; return LT.first;
// Equally for MVE vector types // Equally for MVE vector types
if (ST->hasMVEFloatOps() && if (ST->hasMVEFloatOps() &&
(LT.second == MVT::v4f32 || LT.second == MVT::v8f16) && (LT.second == MVT::v4f32 || LT.second == MVT::v8f16) &&
▲ Show 20 Lines • Show All 600 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 1,151 Lines • ▼ Show 20 Lines case MCCFIInstruction::OpOffset: // DW_CFA_offset
break; break;
case MCCFIInstruction::OpRelOffset: // DW_CFA_advance_loc case MCCFIInstruction::OpRelOffset: // DW_CFA_advance_loc
// Ignore // Ignore
break; break;
default: default:
// Directive not convertable to compact unwind, bail out. // Directive not convertable to compact unwind, bail out.
DEBUG_WITH_TYPE("compact-unwind", DEBUG_WITH_TYPE("compact-unwind",
llvm::dbgs() llvm::dbgs()
<< "CFI directive not compatiable with comact " << "CFI directive not compatible with compact "
"unwind encoding, opcode=" << Inst.getOperation() "unwind encoding, opcode="
<< "\n"); << Inst.getOperation() << "\n");
return CU::UNWIND_ARM_MODE_DWARF; return CU::UNWIND_ARM_MODE_DWARF;
break; break;
} }
} }
// If no frame set up, return no unwind info. // If no frame set up, return no unwind info.
if ((CFARegister == ARM::SP) && (CFARegisterOffset == 0)) if ((CFARegister == ARM::SP) && (CFARegisterOffset == 0))
return 0; return 0;
▲ Show 20 Lines • Show All 155 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 475 Lines • ▼ Show 20 Lines
/// NEONThumb2DataIPostEncoder - Post-process encoded NEON data-processing /// NEONThumb2DataIPostEncoder - Post-process encoded NEON data-processing
/// instructions, and rewrite them to their Thumb2 form if we are currently in /// instructions, and rewrite them to their Thumb2 form if we are currently in
/// Thumb2 mode. /// Thumb2 mode.
unsigned ARMMCCodeEmitter::NEONThumb2DataIPostEncoder(const MCInst &MI, unsigned ARMMCCodeEmitter::NEONThumb2DataIPostEncoder(const MCInst &MI,
unsigned EncodedValue, unsigned EncodedValue,
const MCSubtargetInfo &STI) const { const MCSubtargetInfo &STI) const {
if (isThumb2(STI)) { if (isThumb2(STI)) {
// NEON Thumb2 data-processsing encodings are very simple: bit 24 is moved // NEON Thumb2 data-processing encodings are very simple: bit 24 is moved
// to bit 12 of the high half-word (i.e. bit 28), and bits 27-24 are // to bit 12 of the high half-word (i.e. bit 28), and bits 27-24 are
// set to 1111. // set to 1111.
unsigned Bit24 = EncodedValue & 0x01000000; unsigned Bit24 = EncodedValue & 0x01000000;
unsigned Bit28 = Bit24 << 4; unsigned Bit28 = Bit24 << 4;
EncodedValue &= 0xEFFFFFFF; EncodedValue &= 0xEFFFFFFF;
EncodedValue |= Bit28; EncodedValue |= Bit28;
EncodedValue |= 0x0F000000; EncodedValue |= 0x0F000000;
} }
▲ Show 20 Lines • Show All 1,524 Lines • Show Last 20 Lines

llvm/lib/Target/ARM/MVETPAndVPTOptimisationsPass.cpp

Show First 20 Lines • Show All 851 Lines • ▼ Show 20 Linesbool MVETPAndVPTOptimisations::ReplaceVCMPsByVPNOTs(MachineBasicBlock &MBB) {
// operand here to remove the kill flag in case we need to use PrevVCMP's // operand here to remove the kill flag in case we need to use PrevVCMP's
// result. // result.
MachineOperand *PrevVCMPResultKiller = nullptr; MachineOperand *PrevVCMPResultKiller = nullptr;
for (MachineInstr &Instr : MBB.instrs()) { for (MachineInstr &Instr : MBB.instrs()) {
if (PrevVCMP) { if (PrevVCMP) {
if (MachineOperand *MO = Instr.findRegisterUseOperand( if (MachineOperand *MO = Instr.findRegisterUseOperand(
PrevVCMP->getOperand(0).getReg(), /*isKill*/ true)) { PrevVCMP->getOperand(0).getReg(), /*isKill*/ true)) {
// If we come accross the instr that kills PrevVCMP's result, record it // If we come across the instr that kills PrevVCMP's result, record it
// so we can remove the kill flag later if we need to. // so we can remove the kill flag later if we need to.
PrevVCMPResultKiller = MO; PrevVCMPResultKiller = MO;
} }
} }
// Ignore predicated instructions. // Ignore predicated instructions.
if (getVPTInstrPredicate(Instr) != ARMVCC::None) if (getVPTInstrPredicate(Instr) != ARMVCC::None)
continue; continue;
▲ Show 20 Lines • Show All 222 Lines • Show Last 20 Lines

llvm/lib/Target/AVR/AVRInstrInfo.cpp

Show First 20 Lines • Show All 314 Lines • ▼ Show 20 Lines if (I->getOpcode() == AVR::RJMPk) {
if (MBB.isLayoutSuccessor(I->getOperand(0).getMBB())) { if (MBB.isLayoutSuccessor(I->getOperand(0).getMBB())) {
TBB = nullptr; TBB = nullptr;
I->eraseFromParent(); I->eraseFromParent();
I = MBB.end(); I = MBB.end();
UnCondBrIter = MBB.end(); UnCondBrIter = MBB.end();
continue; continue;
} }
// TBB is used to indicate the unconditinal destination. // TBB is used to indicate the unconditional destination.
TBB = I->getOperand(0).getMBB(); TBB = I->getOperand(0).getMBB();
continue; continue;
} }
// Handle conditional branches. // Handle conditional branches.
AVRCC::CondCodes BranchCode = getCondFromBranchOpc(I->getOpcode()); AVRCC::CondCodes BranchCode = getCondFromBranchOpc(I->getOpcode());
if (BranchCode == AVRCC::COND_INVALID) { if (BranchCode == AVRCC::COND_INVALID) {
return true; // Can't handle indirect branch. return true; // Can't handle indirect branch.
▲ Show 20 Lines • Show All 250 Lines • Show Last 20 Lines

llvm/lib/Target/BPF/BPFAbstractMemberAccess.cpp

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
// This feature relies on the following three intrinsic calls: // This feature relies on the following three intrinsic calls:
// addr = preserve_array_access_index(base, dimension, index) // addr = preserve_array_access_index(base, dimension, index)
// addr = preserve_union_access_index(base, di_index) // addr = preserve_union_access_index(base, di_index)
// !llvm.preserve.access.index <union_ditype> // !llvm.preserve.access.index <union_ditype>
// addr = preserve_struct_access_index(base, gep_index, di_index) // addr = preserve_struct_access_index(base, gep_index, di_index)
// !llvm.preserve.access.index <struct_ditype> // !llvm.preserve.access.index <struct_ditype>
// //
// Bitfield member access needs special attention. User cannot take the // Bitfield member access needs special attention. User cannot take the
// address of a bitfield acceess. To facilitate kernel verifier // address of a bitfield access. To facilitate kernel verifier
// for easy bitfield code optimization, a new clang intrinsic is introduced: // for easy bitfield code optimization, a new clang intrinsic is introduced:
// uint32_t __builtin_preserve_field_info(member_access, info_kind) // uint32_t __builtin_preserve_field_info(member_access, info_kind)
// In IR, a chain with two (or more) intrinsic calls will be generated: // In IR, a chain with two (or more) intrinsic calls will be generated:
// ... // ...
// addr = preserve_struct_access_index(base, 1, 1) !struct s // addr = preserve_struct_access_index(base, 1, 1) !struct s
// uint32_t result = bpf_preserve_field_info(addr, info_kind) // uint32_t result = bpf_preserve_field_info(addr, info_kind)
// //
// Suppose the info_kind is FIELD_SIGNEDNESS, // Suppose the info_kind is FIELD_SIGNEDNESS,
▲ Show 20 Lines • Show All 1,158 Lines • Show Last 20 Lines

llvm/lib/Target/BPF/BPFInstrInfo.cpp

Show First 20 Lines • Show All 198 Lines • ▼ Show 20 Lines if (I->getOpcode() == BPF::JMP) {
// Delete the J if it's equivalent to a fall-through. // Delete the J if it's equivalent to a fall-through.
if (MBB.isLayoutSuccessor(I->getOperand(0).getMBB())) { if (MBB.isLayoutSuccessor(I->getOperand(0).getMBB())) {
TBB = nullptr; TBB = nullptr;
I->eraseFromParent(); I->eraseFromParent();
I = MBB.end(); I = MBB.end();
continue; continue;
} }
// TBB is used to indicate the unconditinal destination. // TBB is used to indicate the unconditional destination.
TBB = I->getOperand(0).getMBB(); TBB = I->getOperand(0).getMBB();
continue; continue;
} }
// Cannot handle conditional branches // Cannot handle conditional branches
return true; return true;
} }
return false; return false;
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

llvm/lib/Target/BPF/BPFMISimplifyPatchable.cpp

//===----- BPFMISimplifyPatchable.cpp - MI Simplify Patchable Insts -------===// //===----- BPFMISimplifyPatchable.cpp - MI Simplify Patchable Insts -------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This pass targets a subset of instructions like below // This pass targets a subset of instructions like below
// ld_imm64 r1, @global // ld_imm64 r1, @global
// ldd r2, r1, 0 // ldd r2, r1, 0
// add r3, struct_base_reg, r2 // add r3, struct_base_reg, r2
// //
// Here @global should represent an AMA (abstruct member access). // Here @global should represent an AMA (abstract member access).
// Such an access is subject to bpf load time patching. After this pass, the // Such an access is subject to bpf load time patching. After this pass, the
// code becomes // code becomes
// ld_imm64 r1, @global // ld_imm64 r1, @global
// add r3, struct_base_reg, r1 // add r3, struct_base_reg, r1
// //
// Eventually, at BTF output stage, a relocation record will be generated // Eventually, at BTF output stage, a relocation record will be generated
// for ld_imm64 which should be replaced later by bpf loader: // for ld_imm64 which should be replaced later by bpf loader:
// r1 = <calculated field_info> // r1 = <calculated field_info>
▲ Show 20 Lines • Show All 306 Lines • Show Last 20 Lines

llvm/lib/Target/CSKY/CSKYISelLowering.cpp

Show First 20 Lines • Show All 324 Lines • ▼ Show 20 Lines default:
report_fatal_error("Unsupported calling convention"); report_fatal_error("Unsupported calling convention");
case CallingConv::C: case CallingConv::C:
case CallingConv::Fast: case CallingConv::Fast:
break; break;
} }
MachineFunction &MF = DAG.getMachineFunction(); MachineFunction &MF = DAG.getMachineFunction();
// Used with vargs to acumulate store chains. // Used with vargs to accumulate store chains.
std::vector<SDValue> OutChains; std::vector<SDValue> OutChains;
// Assign locations to all of the incoming arguments. // Assign locations to all of the incoming arguments.
SmallVector<CCValAssign, 16> ArgLocs; SmallVector<CCValAssign, 16> ArgLocs;
CCState CCInfo(CallConv, IsVarArg, MF, ArgLocs, *DAG.getContext()); CCState CCInfo(CallConv, IsVarArg, MF, ArgLocs, *DAG.getContext());
CCInfo.AnalyzeFormalArguments(Ins, CCAssignFnForCall(CallConv, IsVarArg)); CCInfo.AnalyzeFormalArguments(Ins, CCAssignFnForCall(CallConv, IsVarArg));
▲ Show 20 Lines • Show All 1,001 Lines • Show Last 20 Lines

llvm/lib/Target/Hexagon/HexagonNewValueJump.cpp

//===- HexagonNewValueJump.cpp - Hexagon Backend New Value Jump -----------===// //===- HexagonNewValueJump.cpp - Hexagon Backend New Value Jump -----------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This implements NewValueJump pass in Hexagon. // This implements NewValueJump pass in Hexagon.
// Ideally, we should merge this as a Peephole pass prior to register // Ideally, we should merge this as a Peephole pass prior to register
// allocation, but because we have a spill in between the feeder and new value // allocation, but because we have a spill in between the feeder and new value
// jump instructions, we are forced to write after register allocation. // jump instructions, we are forced to write after register allocation.
// Having said that, we should re-attempt to pull this earlier at some point // Having said that, we should re-attempt to pull this earlier at some point
// in future. // in future.
// The basic approach looks for sequence of predicated jump, compare instruciton // The basic approach looks for sequence of predicated jump, compare instruction
// that genereates the predicate and, the feeder to the predicate. Once it finds // that genereates the predicate and, the feeder to the predicate. Once it finds
// all, it collapses compare and jump instruction into a new value jump // all, it collapses compare and jump instruction into a new value jump
// intstructions. // intstructions.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "llvm/InitializePasses.h" #include "llvm/InitializePasses.h"
#include "Hexagon.h" #include "Hexagon.h"
▲ Show 20 Lines • Show All 698 Lines • Show Last 20 Lines

llvm/lib/Target/Hexagon/HexagonVLIWPacketizer.h

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Linespublic:
// isSoloInstruction - return true if instruction MI can not be packetized // isSoloInstruction - return true if instruction MI can not be packetized
// with any other instruction, which means that MI itself is a packet. // with any other instruction, which means that MI itself is a packet.
bool isSoloInstruction(const MachineInstr &MI) override; bool isSoloInstruction(const MachineInstr &MI) override;
// isLegalToPacketizeTogether - Is it legal to packetize SUI and SUJ // isLegalToPacketizeTogether - Is it legal to packetize SUI and SUJ
// together. // together.
bool isLegalToPacketizeTogether(SUnit *SUI, SUnit *SUJ) override; bool isLegalToPacketizeTogether(SUnit *SUI, SUnit *SUJ) override;
// isLegalToPruneDependencies - Is it legal to prune dependece between SUI // isLegalToPruneDependencies - Is it legal to prune dependence between SUI
// and SUJ. // and SUJ.
bool isLegalToPruneDependencies(SUnit *SUI, SUnit *SUJ) override; bool isLegalToPruneDependencies(SUnit *SUI, SUnit *SUJ) override;
bool foundLSInPacket(); bool foundLSInPacket();
MachineBasicBlock::iterator addToPacket(MachineInstr &MI) override; MachineBasicBlock::iterator addToPacket(MachineInstr &MI) override;
void endPacket(MachineBasicBlock *MBB, void endPacket(MachineBasicBlock *MBB,
MachineBasicBlock::iterator MI) override; MachineBasicBlock::iterator MI) override;
bool shouldAddToPacket(const MachineInstr &MI) override; bool shouldAddToPacket(const MachineInstr &MI) override;
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

llvm/lib/Target/Hexagon/HexagonVLIWPacketizer.cpp

Show First 20 Lines • Show All 982 Lines • ▼ Show 20 Linesbool HexagonPacketizerList::arePredicatesComplements(MachineInstr &MI1,
// c) %p0 = C2_cmpeqi %r26, 1 // c) %p0 = C2_cmpeqi %r26, 1
// } // }
// //
// On general check a) and b) are complements, but presence of c) will // On general check a) and b) are complements, but presence of c) will
// convert a) to .new form, and then it is not a complement. // convert a) to .new form, and then it is not a complement.
// We attempt to detect it by analyzing existing dependencies in the packet. // We attempt to detect it by analyzing existing dependencies in the packet.
// Analyze relationships between all existing members of the packet. // Analyze relationships between all existing members of the packet.
// Look for Anti dependecy on the same predicate reg as used in the // Look for Anti dependency on the same predicate reg as used in the
// candidate. // candidate.
for (auto I : CurrentPacketMIs) { for (auto I : CurrentPacketMIs) {
// Scheduling Unit for current insn in the packet. // Scheduling Unit for current insn in the packet.
SUnit *PacketSU = MIToSUnit.find(I)->second; SUnit *PacketSU = MIToSUnit.find(I)->second;
// If this instruction in the packet is succeeded by the candidate... // If this instruction in the packet is succeeded by the candidate...
if (PacketSU->isSucc(SU)) { if (PacketSU->isSucc(SU)) {
for (unsigned i = 0; i < PacketSU->Succs.size(); ++i) { for (unsigned i = 0; i < PacketSU->Succs.size(); ++i) {
▲ Show 20 Lines • Show All 956 Lines • Show Last 20 Lines

llvm/lib/Target/Hexagon/HexagonVectorLoopCarriedReuse.cpp

Show First 20 Lines • Show All 320 Lines • ▼ Show 20 Lines
} }
bool HexagonVectorLoopCarriedReuse::isEquivalentOperation(Instruction *I1, bool HexagonVectorLoopCarriedReuse::isEquivalentOperation(Instruction *I1,
Instruction *I2) { Instruction *I2) {
if (!I1->isSameOperationAs(I2)) if (!I1->isSameOperationAs(I2))
return false; return false;
// This check is in place specifically for intrinsics. isSameOperationAs will // This check is in place specifically for intrinsics. isSameOperationAs will
// return two for any two hexagon intrinsics because they are essentially the // return two for any two hexagon intrinsics because they are essentially the
// same instruciton (CallInst). We need to scratch the surface to see if they // same instruction (CallInst). We need to scratch the surface to see if they
// are calls to the same function. // are calls to the same function.
if (CallInst *C1 = dyn_cast<CallInst>(I1)) { if (CallInst *C1 = dyn_cast<CallInst>(I1)) {
if (CallInst *C2 = dyn_cast<CallInst>(I2)) { if (CallInst *C2 = dyn_cast<CallInst>(I2)) {
if (C1->getCalledFunction() != C2->getCalledFunction()) if (C1->getCalledFunction() != C2->getCalledFunction())
return false; return false;
} }
} }
▲ Show 20 Lines • Show All 330 Lines • Show Last 20 Lines

llvm/lib/Target/M68k/M68kInstrInfo.td

Show First 20 Lines • Show All 458 Lines • ▼ Show 20 Lines
def MxCONDgt : PatLeaf<(i8 14)>; // Greater Than def MxCONDgt : PatLeaf<(i8 14)>; // Greater Than
def MxCONDle : PatLeaf<(i8 15)>; // Less or Equal def MxCONDle : PatLeaf<(i8 15)>; // Less or Equal
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Complex Patterns // Complex Patterns
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// NOTE Though this CP is not strictly necessarily it will simplify instruciton // NOTE Though this CP is not strictly necessarily it will simplify instruction
// definitions // definitions
def MxCP_ARI : ComplexPattern<iPTR, 1, "SelectARI", def MxCP_ARI : ComplexPattern<iPTR, 1, "SelectARI",
[], [SDNPWantParent]>; [], [SDNPWantParent]>;
def MxCP_ARIPI : ComplexPattern<iPTR, 1, "SelectARIPI", def MxCP_ARIPI : ComplexPattern<iPTR, 1, "SelectARIPI",
[], [SDNPWantParent]>; [], [SDNPWantParent]>;
def MxCP_ARIPD : ComplexPattern<iPTR, 1, "SelectARIPD", def MxCP_ARIPD : ComplexPattern<iPTR, 1, "SelectARIPD",
▲ Show 20 Lines • Show All 310 Lines • Show Last 20 Lines

llvm/lib/Target/M68k/MCTargetDesc/M68kMCCodeEmitter.cpp

//===-- M68kMCCodeEmitter.cpp - Convert M68k code emitter -------*- C++ -*-===// //===-- M68kMCCodeEmitter.cpp - Convert M68k code emitter -------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// ///
/// \file /// \file
/// This file contains defintions for M68k code emitter. /// This file contains definitions for M68k code emitter.
/// ///
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "MCTargetDesc/M68kMCCodeEmitter.h" #include "MCTargetDesc/M68kMCCodeEmitter.h"
#include "MCTargetDesc/M68kBaseInfo.h" #include "MCTargetDesc/M68kBaseInfo.h"
#include "MCTargetDesc/M68kFixupKinds.h" #include "MCTargetDesc/M68kFixupKinds.h"
#include "MCTargetDesc/M68kMCTargetDesc.h" #include "MCTargetDesc/M68kMCTargetDesc.h"
▲ Show 20 Lines • Show All 229 Lines • Show Last 20 Lines

llvm/lib/Target/MSP430/MSP430InstrInfo.cpp

Show First 20 Lines • Show All 203 Lines • ▼ Show 20 Lines if (I->getOpcode() == MSP430::JMP || I->getOpcode() == MSP430::Bi) {
// Delete the JMP if it's equivalent to a fall-through. // Delete the JMP if it's equivalent to a fall-through.
if (MBB.isLayoutSuccessor(I->getOperand(0).getMBB())) { if (MBB.isLayoutSuccessor(I->getOperand(0).getMBB())) {
TBB = nullptr; TBB = nullptr;
I->eraseFromParent(); I->eraseFromParent();
I = MBB.end(); I = MBB.end();
continue; continue;
} }
// TBB is used to indicate the unconditinal destination. // TBB is used to indicate the unconditional destination.
TBB = I->getOperand(0).getMBB(); TBB = I->getOperand(0).getMBB();
continue; continue;
} }
// Handle conditional branches. // Handle conditional branches.
assert(I->getOpcode() == MSP430::JCC && "Invalid conditional branch"); assert(I->getOpcode() == MSP430::JCC && "Invalid conditional branch");
MSP430CC::CondCodes BranchCode = MSP430CC::CondCodes BranchCode =
static_cast<MSP430CC::CondCodes>(I->getOperand(1).getImm()); static_cast<MSP430CC::CondCodes>(I->getOperand(1).getImm());
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

llvm/lib/Target/Mips/AsmParser/MipsAsmParser.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 6,470 Lines • ▼ Show 20 Lines if (Tok.isNot(AsmToken::LParen)) {
auto Base = MipsOperand::createGPRReg( auto Base = MipsOperand::createGPRReg(
0, "0", getContext().getRegisterInfo(), S, E, *this); 0, "0", getContext().getRegisterInfo(), S, E, *this);
Operands.push_back( Operands.push_back(
MipsOperand::CreateMem(std::move(Base), IdVal, S, E, *this)); MipsOperand::CreateMem(std::move(Base), IdVal, S, E, *this));
return MatchOperand_Success; return MatchOperand_Success;
} }
MCBinaryExpr::Opcode Opcode; MCBinaryExpr::Opcode Opcode;
// GAS and LLVM treat comparison operators different. GAS will generate -1 // GAS and LLVM treat comparison operators different. GAS will generate -1
// or 0, while LLVM will generate 0 or 1. Since a comparsion operator is // or 0, while LLVM will generate 0 or 1. Since a comparison operator is
// highly unlikely to be found in a memory offset expression, we don't // highly unlikely to be found in a memory offset expression, we don't
// handle them. // handle them.
switch (Tok.getKind()) { switch (Tok.getKind()) {
case AsmToken::Plus: case AsmToken::Plus:
Opcode = MCBinaryExpr::Add; Opcode = MCBinaryExpr::Add;
Parser.Lex(); Parser.Lex();
break; break;
case AsmToken::Minus: case AsmToken::Minus:
▲ Show 20 Lines • Show All 2,434 Lines • Show Last 20 Lines

llvm/lib/Target/Mips/MipsISelLowering.cpp

Show First 20 Lines • Show All 3,625 Lines • ▼ Show 20 LinesSDValue MipsTargetLowering::LowerFormalArguments(
const SmallVectorImpl<ISD::InputArg> &Ins, const SDLoc &DL, const SmallVectorImpl<ISD::InputArg> &Ins, const SDLoc &DL,
SelectionDAG &DAG, SmallVectorImpl<SDValue> &InVals) const { SelectionDAG &DAG, SmallVectorImpl<SDValue> &InVals) const {
MachineFunction &MF = DAG.getMachineFunction(); MachineFunction &MF = DAG.getMachineFunction();
MachineFrameInfo &MFI = MF.getFrameInfo(); MachineFrameInfo &MFI = MF.getFrameInfo();
MipsFunctionInfo *MipsFI = MF.getInfo<MipsFunctionInfo>(); MipsFunctionInfo *MipsFI = MF.getInfo<MipsFunctionInfo>();
MipsFI->setVarArgsFrameIndex(0); MipsFI->setVarArgsFrameIndex(0);
// Used with vargs to acumulate store chains. // Used with vargs to accumulate store chains.
std::vector<SDValue> OutChains; std::vector<SDValue> OutChains;
// Assign locations to all of the incoming arguments. // Assign locations to all of the incoming arguments.
SmallVector<CCValAssign, 16> ArgLocs; SmallVector<CCValAssign, 16> ArgLocs;
MipsCCState CCInfo(CallConv, IsVarArg, DAG.getMachineFunction(), ArgLocs, MipsCCState CCInfo(CallConv, IsVarArg, DAG.getMachineFunction(), ArgLocs,
*DAG.getContext()); *DAG.getContext());
CCInfo.AllocateStack(ABI.GetCalleeAllocdArgSizeInBytes(CallConv), Align(1)); CCInfo.AllocateStack(ABI.GetCalleeAllocdArgSizeInBytes(CallConv), Align(1));
const Function &Func = DAG.getMachineFunction().getFunction(); const Function &Func = DAG.getMachineFunction().getFunction();
▲ Show 20 Lines • Show All 1,392 Lines • Show Last 20 Lines

llvm/lib/Target/NVPTX/NVPTXISelDAGToDAG.cpp

Show First 20 Lines • Show All 1,002 Lines • ▼ Show 20 Linesbool NVPTXDAGToDAGISel::tryLoadVector(SDNode *N) {
if (canLowerToLDG(MemSD, *Subtarget, CodeAddrSpace, MF)) { if (canLowerToLDG(MemSD, *Subtarget, CodeAddrSpace, MF)) {
return tryLDGLDU(N); return tryLDGLDU(N);
} }
unsigned int PointerSize = unsigned int PointerSize =
CurDAG->getDataLayout().getPointerSizeInBits(MemSD->getAddressSpace()); CurDAG->getDataLayout().getPointerSizeInBits(MemSD->getAddressSpace());
// Volatile Setting // Volatile Setting
// - .volatile is only availalble for .global and .shared // - .volatile is only available for .global and .shared
bool IsVolatile = MemSD->isVolatile(); bool IsVolatile = MemSD->isVolatile();
if (CodeAddrSpace != NVPTX::PTXLdStInstCode::GLOBAL && if (CodeAddrSpace != NVPTX::PTXLdStInstCode::GLOBAL &&
CodeAddrSpace != NVPTX::PTXLdStInstCode::SHARED && CodeAddrSpace != NVPTX::PTXLdStInstCode::SHARED &&
CodeAddrSpace != NVPTX::PTXLdStInstCode::GENERIC) CodeAddrSpace != NVPTX::PTXLdStInstCode::GENERIC)
IsVolatile = false; IsVolatile = false;
// Vector Setting // Vector Setting
MVT SimpleVT = LoadedVT.getSimpleVT(); MVT SimpleVT = LoadedVT.getSimpleVT();
▲ Show 20 Lines • Show All 2,741 Lines • Show Last 20 Lines

llvm/lib/Target/PowerPC/MCTargetDesc/PPCELFStreamer.cpp

Show First 20 Lines • Show All 177 Lines • ▼ Show 20 Linesvoid PPCELFStreamer::emitGOTToPCRelLabel(const MCInst &Inst) {
const MCSymbolRefExpr *SymExpr = static_cast<const MCSymbolRefExpr *>(Expr); const MCSymbolRefExpr *SymExpr = static_cast<const MCSymbolRefExpr *>(Expr);
assert(SymExpr->getKind() == MCSymbolRefExpr::VK_PPC_PCREL_OPT && assert(SymExpr->getKind() == MCSymbolRefExpr::VK_PPC_PCREL_OPT &&
"Expecting a symbol of type VK_PPC_PCREL_OPT"); "Expecting a symbol of type VK_PPC_PCREL_OPT");
MCSymbol *LabelSym = MCSymbol *LabelSym =
getContext().getOrCreateSymbol(SymExpr->getSymbol().getName()); getContext().getOrCreateSymbol(SymExpr->getSymbol().getName());
emitLabel(LabelSym, Inst.getLoc()); emitLabel(LabelSym, Inst.getLoc());
} }
// This funciton checks if the parameter Inst is part of the setup for a link // This function checks if the parameter Inst is part of the setup for a link
// time GOT PC Relative optimization. For example in this situation: // time GOT PC Relative optimization. For example in this situation:
// <MCInst PLDpc <MCOperand Reg:282> <MCOperand Expr:(glob_double@got@pcrel)> // <MCInst PLDpc <MCOperand Reg:282> <MCOperand Expr:(glob_double@got@pcrel)>
// <MCOperand Imm:0> <MCOperand Expr:(.Lpcrel@<<invalid>>)>> // <MCOperand Imm:0> <MCOperand Expr:(.Lpcrel@<<invalid>>)>>
// <MCInst SOME_LOAD <MCOperand Reg:22> <MCOperand Imm:0> <MCOperand Reg:282> // <MCInst SOME_LOAD <MCOperand Reg:22> <MCOperand Imm:0> <MCOperand Reg:282>
// <MCOperand Expr:(.Lpcrel@<<invalid>>)>> // <MCOperand Expr:(.Lpcrel@<<invalid>>)>>
// The above is a pair of such instructions and this function will not return // The above is a pair of such instructions and this function will not return
// None for either one of them. In both cases we are looking for the last // None for either one of them. In both cases we are looking for the last
// operand <MCOperand Expr:(.Lpcrel@<<invalid>>)> which needs to be an MCExpr // operand <MCOperand Expr:(.Lpcrel@<<invalid>>)> which needs to be an MCExpr
// and has the flag MCSymbolRefExpr::VK_PPC_PCREL_OPT. After that we just look // and has the flag MCSymbolRefExpr::VK_PPC_PCREL_OPT. After that we just look
// at the opcode and in the case of PLDpc we will return true. For the load // at the opcode and in the case of PLDpc we will return true. For the load
// (or store) this function will return false indicating it has found the second // (or store) this function will return false indicating it has found the second
// instruciton in the pair. // instruction in the pair.
Optional<bool> llvm::isPartOfGOTToPCRelPair(const MCInst &Inst, Optional<bool> llvm::isPartOfGOTToPCRelPair(const MCInst &Inst,
const MCSubtargetInfo &STI) { const MCSubtargetInfo &STI) {
// Need at least two operands. // Need at least two operands.
if (Inst.getNumOperands() < 2) if (Inst.getNumOperands() < 2)
return None; return None;
unsigned LastOp = Inst.getNumOperands() - 1; unsigned LastOp = Inst.getNumOperands() - 1;
// The last operand needs to be an MCExpr and it needs to have a variant kind // The last operand needs to be an MCExpr and it needs to have a variant kind
Show All 22 Lines

llvm/lib/Target/PowerPC/PPCGenScalarMASSEntries.cpp

Show First 20 Lines • Show All 70 Lines • ▼ Show 20 Lines
// Returns true if 'nnan', 'ninf' and 'nsz' flags exist on the call instruction // Returns true if 'nnan', 'ninf' and 'nsz' flags exist on the call instruction
// with the math function // with the math function
bool PPCGenScalarMASSEntries::isFiniteCallSafe(const CallInst &CI) const { bool PPCGenScalarMASSEntries::isFiniteCallSafe(const CallInst &CI) const {
// skip functions with no scalar or vector FP type (like cosisin) // skip functions with no scalar or vector FP type (like cosisin)
if (!isa<FPMathOperator>(CI)) if (!isa<FPMathOperator>(CI))
return false; return false;
// FIXME: no-errno and trapping-math need to be set for MASS converstion // FIXME: no-errno and trapping-math need to be set for MASS conversion
// but they don't have IR representation. // but they don't have IR representation.
return CI.hasNoNaNs() && CI.hasNoInfs() && CI.hasNoSignedZeros(); return CI.hasNoNaNs() && CI.hasNoInfs() && CI.hasNoSignedZeros();
} }
/// Lowers scalar math functions to scalar MASS functions. /// Lowers scalar math functions to scalar MASS functions.
/// e.g.: tanh --> __xl_tanh_finite or __xl_tanh /// e.g.: tanh --> __xl_tanh_finite or __xl_tanh
/// Both function prototype and its callsite is updated during lowering. /// Both function prototype and its callsite is updated during lowering.
bool PPCGenScalarMASSEntries::createScalarMASSCall(StringRef MASSEntry, bool PPCGenScalarMASSEntries::createScalarMASSCall(StringRef MASSEntry,
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 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 290 Lines • ▼ Show 20 Lines bool SelectForceXForm(SDNode *Parent, SDValue N, SDValue &Disp,
SDValue &Base) { SDValue &Base) {
return PPCLowering->SelectForceXFormMode(N, Disp, Base, *CurDAG) == return PPCLowering->SelectForceXFormMode(N, Disp, Base, *CurDAG) ==
PPC::AM_XForm; PPC::AM_XForm;
} }
/// SelectAddrIdx - Given the specified address, check to see if it can be /// SelectAddrIdx - Given the specified address, check to see if it can be
/// represented as an indexed [r+r] operation. /// represented as an indexed [r+r] operation.
/// This is for xform instructions whose associated displacement form is D. /// This is for xform instructions whose associated displacement form is D.
/// The last parameter \p 0 means associated D form has no requirment for 16 /// The last parameter \p 0 means associated D form has no requirement for
/// bit signed displacement. /// 16 bit signed displacement.
/// Returns false if it can be represented by [r+imm], which are preferred. /// Returns false if it can be represented by [r+imm], which are preferred.
bool SelectAddrIdx(SDValue N, SDValue &Base, SDValue &Index) { bool SelectAddrIdx(SDValue N, SDValue &Base, SDValue &Index) {
return PPCLowering->SelectAddressRegReg(N, Base, Index, *CurDAG, None); return PPCLowering->SelectAddressRegReg(N, Base, Index, *CurDAG, None);
} }
/// SelectAddrIdx4 - Given the specified address, check to see if it can be /// SelectAddrIdx4 - Given the specified address, check to see if it can be
/// represented as an indexed [r+r] operation. /// represented as an indexed [r+r] operation.
/// This is for xform instructions whose associated displacement form is DS. /// This is for xform instructions whose associated displacement form is DS.
Show All 19 Lines public:
/// SelectAddrIdxOnly - Given the specified address, force it to be /// SelectAddrIdxOnly - Given the specified address, force it to be
/// represented as an indexed [r+r] operation. /// represented as an indexed [r+r] operation.
bool SelectAddrIdxOnly(SDValue N, SDValue &Base, SDValue &Index) { bool SelectAddrIdxOnly(SDValue N, SDValue &Base, SDValue &Index) {
return PPCLowering->SelectAddressRegRegOnly(N, Base, Index, *CurDAG); return PPCLowering->SelectAddressRegRegOnly(N, Base, Index, *CurDAG);
} }
/// SelectAddrImm - Returns true if the address N can be represented by /// SelectAddrImm - Returns true if the address N can be represented by
/// a base register plus a signed 16-bit displacement [r+imm]. /// a base register plus a signed 16-bit displacement [r+imm].
/// The last parameter \p 0 means D form has no requirment for 16 bit signed /// The last parameter \p 0 means D form has no requirement for 16 bit
/// displacement. /// signed displacement.
bool SelectAddrImm(SDValue N, SDValue &Disp, bool SelectAddrImm(SDValue N, SDValue &Disp,
SDValue &Base) { SDValue &Base) {
return PPCLowering->SelectAddressRegImm(N, Disp, Base, *CurDAG, None); return PPCLowering->SelectAddressRegImm(N, Disp, Base, *CurDAG, None);
} }
/// SelectAddrImmX4 - Returns true if the address N can be represented by /// SelectAddrImmX4 - Returns true if the address N can be represented by
/// a base register plus a signed 16-bit displacement that is a multiple of /// a base register plus a signed 16-bit displacement that is a multiple of
/// 4 (last parameter). Suitable for use by STD and friends. /// 4 (last parameter). Suitable for use by STD and friends.
▲ Show 20 Lines • Show All 7,162 Lines • Show Last 20 Lines

llvm/lib/Target/PowerPC/PPCISelLowering.h

Show First 20 Lines • Show All 314 Lines • ▼ Show 20 Lines enum NodeType : unsigned {
CR6SET, CR6SET,
CR6UNSET, CR6UNSET,
/// GPRC = address of _GLOBAL_OFFSET_TABLE_. Used by initial-exec TLS /// GPRC = address of _GLOBAL_OFFSET_TABLE_. Used by initial-exec TLS
/// for non-position independent code on PPC32. /// for non-position independent code on PPC32.
PPC32_GOT, PPC32_GOT,
/// GPRC = address of _GLOBAL_OFFSET_TABLE_. Used by general dynamic and /// GPRC = address of _GLOBAL_OFFSET_TABLE_. Used by general dynamic and
/// local dynamic TLS and position indendepent code on PPC32. /// local dynamic TLS and position independent code on PPC32.
PPC32_PICGOT, PPC32_PICGOT,
/// G8RC = ADDIS_GOT_TPREL_HA %x2, Symbol - Used by the initial-exec /// G8RC = ADDIS_GOT_TPREL_HA %x2, Symbol - Used by the initial-exec
/// TLS model, produces an ADDIS8 instruction that adds the GOT /// TLS model, produces an ADDIS8 instruction that adds the GOT
/// base to sym\@got\@tprel\@ha. /// base to sym\@got\@tprel\@ha.
ADDIS_GOT_TPREL_HA, ADDIS_GOT_TPREL_HA,
/// G8RC = LD_GOT_TPREL_L Symbol, G8RReg - Used by the initial-exec /// G8RC = LD_GOT_TPREL_L Symbol, G8RReg - Used by the initial-exec
▲ Show 20 Lines • Show All 1,160 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,224 Lines • ▼ Show 20 Linesstatic unsigned getCallOpcode(PPCTargetLowering::CallFlags CFlags,
const TargetMachine &TM, const TargetMachine &TM,
bool IsStrictFPCall = false) { bool IsStrictFPCall = false) {
if (CFlags.IsTailCall) if (CFlags.IsTailCall)
return PPCISD::TC_RETURN; return PPCISD::TC_RETURN;
unsigned RetOpc = 0; unsigned RetOpc = 0;
// This is a call through a function pointer. // This is a call through a function pointer.
if (CFlags.IsIndirect) { if (CFlags.IsIndirect) {
// AIX and the 64-bit ELF ABIs need to maintain the TOC pointer accross // AIX and the 64-bit ELF ABIs need to maintain the TOC pointer across
// indirect calls. The save of the caller's TOC pointer to the stack will be // indirect calls. The save of the caller's TOC pointer to the stack will be
// inserted into the DAG as part of call lowering. The restore of the TOC // inserted into the DAG as part of call lowering. The restore of the TOC
// pointer is modeled by using a pseudo instruction for the call opcode that // pointer is modeled by using a pseudo instruction for the call opcode that
// represents the 2 instruction sequence of an indirect branch and link, // represents the 2 instruction sequence of an indirect branch and link,
// immediately followed by a load of the TOC pointer from the the stack save // immediately followed by a load of the TOC pointer from the the stack save
// slot into gpr2. For 64-bit ELFv2 ABI with PCRel, do not restore the TOC // slot into gpr2. For 64-bit ELFv2 ABI with PCRel, do not restore the TOC
// as it is not saved or used. // as it is not saved or used.
RetOpc = isTOCSaveRestoreRequired(Subtarget) ? PPCISD::BCTRL_LOAD_TOC RetOpc = isTOCSaveRestoreRequired(Subtarget) ? PPCISD::BCTRL_LOAD_TOC
: PPCISD::BCTRL; : PPCISD::BCTRL;
} else if (Subtarget.isUsingPCRelativeCalls()) { } else if (Subtarget.isUsingPCRelativeCalls()) {
assert(Subtarget.is64BitELFABI() && "PC Relative is only on ELF ABI."); assert(Subtarget.is64BitELFABI() && "PC Relative is only on ELF ABI.");
RetOpc = PPCISD::CALL_NOTOC; RetOpc = PPCISD::CALL_NOTOC;
} else if (Subtarget.isAIXABI() || Subtarget.is64BitELFABI()) } else if (Subtarget.isAIXABI() || Subtarget.is64BitELFABI())
// The ABIs that maintain a TOC pointer accross calls need to have a nop // The ABIs that maintain a TOC pointer across calls need to have a nop
// immediately following the call instruction if the caller and callee may // immediately following the call instruction if the caller and callee may
// have different TOC bases. At link time if the linker determines the calls // have different TOC bases. At link time if the linker determines the calls
// may not share a TOC base, the call is redirected to a trampoline inserted // may not share a TOC base, the call is redirected to a trampoline inserted
// by the linker. The trampoline will (among other things) save the callers // by the linker. The trampoline will (among other things) save the callers
// TOC pointer at an ABI designated offset in the linkage area and the // TOC pointer at an ABI designated offset in the linkage area and the
// linker will rewrite the nop to be a load of the TOC pointer from the // linker will rewrite the nop to be a load of the TOC pointer from the
// linkage area into gpr2. // linkage area into gpr2.
RetOpc = callsShareTOCBase(&Caller, Callee, TM) ? PPCISD::CALL RetOpc = callsShareTOCBase(&Caller, Callee, TM) ? PPCISD::CALL
▲ Show 20 Lines • Show All 3,995 Lines • ▼ Show 20 Lines if (DAG.isSplatValue(Op, true) &&
unsigned NumUsesOfInputLD = 128 / ElementSize; unsigned NumUsesOfInputLD = 128 / ElementSize;
for (SDValue BVInOp : Op->ops()) for (SDValue BVInOp : Op->ops())
if (BVInOp.isUndef()) if (BVInOp.isUndef())
NumUsesOfInputLD--; NumUsesOfInputLD--;
// Exclude somes case where LD_SPLAT is worse than scalar_to_vector: // Exclude somes case where LD_SPLAT is worse than scalar_to_vector:
// Below cases should also happen for "lfiwzx/lfiwax + LE target + index // Below cases should also happen for "lfiwzx/lfiwax + LE target + index
// 1" and "lxvrhx + BE target + index 7" and "lxvrbx + BE target + index // 1" and "lxvrhx + BE target + index 7" and "lxvrbx + BE target + index
// 15", but funciton IsValidSplatLoad() now will only return true when // 15", but function IsValidSplatLoad() now will only return true when
// the data at index 0 is not nullptr. So we will not get into trouble for // the data at index 0 is not nullptr. So we will not get into trouble for
// these cases. // these cases.
// //
// case 1 - lfiwzx/lfiwax // case 1 - lfiwzx/lfiwax
// 1.1: load result is i32 and is sign/zero extend to i64; // 1.1: load result is i32 and is sign/zero extend to i64;
// 1.2: build a v2i64 vector type with above loaded value; // 1.2: build a v2i64 vector type with above loaded value;
// 1.3: the vector has only one value at index 0, others are all undef; // 1.3: the vector has only one value at index 0, others are all undef;
// 1.4: on BE target, so that lfiwzx/lfiwax does not need any permute. // 1.4: on BE target, so that lfiwzx/lfiwax does not need any permute.
▲ Show 20 Lines • Show All 8,930 Lines • Show Last 20 Lines

llvm/lib/Target/PowerPC/PPCLoopInstrFormPrep.cpp

Show First 20 Lines • Show All 634 Lines • ▼ Show 20 Lines
// Rewrite the new base according to BasePtrSCEV. // Rewrite the new base according to BasePtrSCEV.
// bb.loop.preheader: // bb.loop.preheader:
// %newstart = ... // %newstart = ...
// bb.loop.body: // bb.loop.body:
// %phinode = phi [ %newstart, %bb.loop.preheader ], [ %add, %bb.loop.body ] // %phinode = phi [ %newstart, %bb.loop.preheader ], [ %add, %bb.loop.body ]
// ... // ...
// %add = getelementptr %phinode, %inc // %add = getelementptr %phinode, %inc
// //
// First returned instruciton is %phinode (or a type cast to %phinode), caller // First returned instruction is %phinode (or a type cast to %phinode), caller
// needs this value to rewrite other load/stores in the same chain. // needs this value to rewrite other load/stores in the same chain.
// Second returned instruction is %add, caller needs this value to rewrite other // Second returned instruction is %add, caller needs this value to rewrite other
// load/stores in the same chain. // load/stores in the same chain.
std::pair<Instruction *, Instruction *> std::pair<Instruction *, Instruction *>
PPCLoopInstrFormPrep::rewriteForBase(Loop *L, const SCEVAddRecExpr *BasePtrSCEV, PPCLoopInstrFormPrep::rewriteForBase(Loop *L, const SCEVAddRecExpr *BasePtrSCEV,
Instruction *BaseMemI, bool CanPreInc, Instruction *BaseMemI, bool CanPreInc,
PrepForm Form, SCEVExpander &SCEVE, PrepForm Form, SCEVExpander &SCEVE,
SmallPtrSet<Value *, 16> &DeletedPtrs) { SmallPtrSet<Value *, 16> &DeletedPtrs) {
▲ Show 20 Lines • Show All 840 Lines • Show Last 20 Lines

llvm/lib/Target/PowerPC/PPCMIPeephole.cpp

Show First 20 Lines • Show All 1,373 Lines • ▼ Show 20 Lines for (MachineBasicBlock &MBB2 : *MF) {
MachineInstr *BI1 = &*MBB1->getFirstInstrTerminator(); MachineInstr *BI1 = &*MBB1->getFirstInstrTerminator();
MachineInstr *CMPI1 = MRI->getVRegDef(BI1->getOperand(1).getReg()); MachineInstr *CMPI1 = MRI->getVRegDef(BI1->getOperand(1).getReg());
MachineInstr *BI2 = &*MBB2.getFirstInstrTerminator(); MachineInstr *BI2 = &*MBB2.getFirstInstrTerminator();
MachineInstr *CMPI2 = MRI->getVRegDef(BI2->getOperand(1).getReg()); MachineInstr *CMPI2 = MRI->getVRegDef(BI2->getOperand(1).getReg());
bool IsPartiallyRedundant = (MBBtoMoveCmp != nullptr); bool IsPartiallyRedundant = (MBBtoMoveCmp != nullptr);
// We cannot optimize an unsupported compare opcode or // We cannot optimize an unsupported compare opcode or
// a mix of 32-bit and 64-bit comaprisons // a mix of 32-bit and 64-bit comparisons
if (!isSupportedCmpOp(CMPI1->getOpcode()) || if (!isSupportedCmpOp(CMPI1->getOpcode()) ||
!isSupportedCmpOp(CMPI2->getOpcode()) || !isSupportedCmpOp(CMPI2->getOpcode()) ||
is64bitCmpOp(CMPI1->getOpcode()) != is64bitCmpOp(CMPI2->getOpcode())) is64bitCmpOp(CMPI1->getOpcode()) != is64bitCmpOp(CMPI2->getOpcode()))
continue; continue;
unsigned NewOpCode = 0; unsigned NewOpCode = 0;
unsigned NewPredicate1 = 0, NewPredicate2 = 0; unsigned NewPredicate1 = 0, NewPredicate2 = 0;
int16_t Imm1 = 0, NewImm1 = 0, Imm2 = 0, NewImm2 = 0; int16_t Imm1 = 0, NewImm1 = 0, Imm2 = 0, NewImm2 = 0;
▲ Show 20 Lines • Show All 350 Lines • Show Last 20 Lines

llvm/lib/Target/PowerPC/PPCRegisterInfoMMA.td

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lineslet SubRegIndices = [sub_pair0, sub_pair1] in {
def ACC6 : ACC<6, "acc6", [VSRp12, VSRp13]>, DwarfRegNum<[-1, -1]>; def ACC6 : ACC<6, "acc6", [VSRp12, VSRp13]>, DwarfRegNum<[-1, -1]>;
def ACC7 : ACC<7, "acc7", [VSRp14, VSRp15]>, DwarfRegNum<[-1, -1]>; def ACC7 : ACC<7, "acc7", [VSRp14, VSRp15]>, DwarfRegNum<[-1, -1]>;
} }
def ACCRC : RegisterClass<"PPC", [v512i1], 128, (add ACC0, ACC1, ACC2, ACC3, def ACCRC : RegisterClass<"PPC", [v512i1], 128, (add ACC0, ACC1, ACC2, ACC3,
ACC4, ACC5, ACC6, ACC7)> { ACC4, ACC5, ACC6, ACC7)> {
// The AllocationPriority is in the range [0, 63]. Assigned the ACC registers // The AllocationPriority is in the range [0, 63]. Assigned the ACC registers
// the highest possible priority in this range to force the register allocator // the highest possible priority in this range to force the register allocator
// to assign these registers first. This is done because the ACC registers // to assign these registers first. This is done because the ACC registers
// must represent 4 advacent vector registers. For example ACC1 must be // must represent 4 adjacent vector registers. For example ACC1 must be
// VS4 - VS7. The value here must be at least 32 as we want to allocate // VS4 - VS7. The value here must be at least 32 as we want to allocate
// these registers even before we allocate global ranges. // these registers even before we allocate global ranges.
let AllocationPriority = 63; let AllocationPriority = 63;
let Size = 512; let Size = 512;
} }
let SubRegIndices = [sub_pair0, sub_pair1] in { let SubRegIndices = [sub_pair0, sub_pair1] in {
def UACC0 : UACC<0, "acc0", [VSRp0, VSRp1]>, DwarfRegNum<[-1, -1]>; def UACC0 : UACC<0, "acc0", [VSRp0, VSRp1]>, DwarfRegNum<[-1, -1]>;
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

llvm/lib/Target/PowerPC/README_ALTIVEC.txt

Show First 20 Lines • Show All 97 Lines • ▼ Show 20 Lines ...
vcmpeqfp. v2, v3, v2 vcmpeqfp. v2, v3, v2
bne cr6, LBB1_2 ; cond_next bne cr6, LBB1_2 ; cond_next
The vcmpeqfp/vcmpeqfp. instructions currently cannot be merged when the The vcmpeqfp/vcmpeqfp. instructions currently cannot be merged when the
vcmpeqfp. result is used by a branch. This can be improved. vcmpeqfp. result is used by a branch. This can be improved.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
The code generated for this is truly aweful: The code generated for this is truly awful:
vector float test(float a, float b) { vector float test(float a, float b) {
return (vector float){ 0.0, a, 0.0, 0.0}; return (vector float){ 0.0, a, 0.0, 0.0};
} }
LCPI1_0: ; float LCPI1_0: ; float
.space 4 .space 4
.text .text
▲ Show 20 Lines • Show All 224 Lines • Show Last 20 Lines

llvm/lib/Target/RISCV/RISCVISelLowering.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 10,967 Lines • ▼ Show 20 Lines if (Func.hasFnAttribute("interrupt")) {
if (!(Kind == "user" || Kind == "supervisor" || Kind == "machine")) if (!(Kind == "user" || Kind == "supervisor" || Kind == "machine"))
report_fatal_error( report_fatal_error(
"Function interrupt attribute argument not supported!"); "Function interrupt attribute argument not supported!");
} }
EVT PtrVT = getPointerTy(DAG.getDataLayout()); EVT PtrVT = getPointerTy(DAG.getDataLayout());
MVT XLenVT = Subtarget.getXLenVT(); MVT XLenVT = Subtarget.getXLenVT();
unsigned XLenInBytes = Subtarget.getXLen() / 8; unsigned XLenInBytes = Subtarget.getXLen() / 8;
// Used with vargs to acumulate store chains. // Used with vargs to accumulate store chains.
std::vector<SDValue> OutChains; std::vector<SDValue> OutChains;
// Assign locations to all of the incoming arguments. // Assign locations to all of the incoming arguments.
SmallVector<CCValAssign, 16> ArgLocs; SmallVector<CCValAssign, 16> ArgLocs;
CCState CCInfo(CallConv, IsVarArg, MF, ArgLocs, *DAG.getContext()); CCState CCInfo(CallConv, IsVarArg, MF, ArgLocs, *DAG.getContext());
if (CallConv == CallingConv::GHC) if (CallConv == CallingConv::GHC)
CCInfo.AnalyzeFormalArguments(Ins, CC_RISCV_GHC); CCInfo.AnalyzeFormalArguments(Ins, CC_RISCV_GHC);
▲ Show 20 Lines • Show All 1,612 Lines • Show Last 20 Lines

llvm/lib/Target/Sparc/SparcInstrInfo.td

Show First 20 Lines • Show All 1,581 Lines • ▼ Show 20 Lines def V9FCMPED : F3_3c<2, 0b110101, 0b001010110,
(outs FCCRegs:$rd), (ins DFPRegs:$rs1, DFPRegs:$rs2), (outs FCCRegs:$rd), (ins DFPRegs:$rs1, DFPRegs:$rs2),
"fcmped $rd, $rs1, $rs2", []>; "fcmped $rd, $rs1, $rs2", []>;
def V9FCMPEQ : F3_3c<2, 0b110101, 0b001010111, def V9FCMPEQ : F3_3c<2, 0b110101, 0b001010111,
(outs FCCRegs:$rd), (ins QFPRegs:$rs1, QFPRegs:$rs2), (outs FCCRegs:$rd), (ins QFPRegs:$rs1, QFPRegs:$rs2),
"fcmpeq $rd, $rs1, $rs2", []>, "fcmpeq $rd, $rs1, $rs2", []>,
Requires<[HasHardQuad]>; Requires<[HasHardQuad]>;
} }
// Floating point conditional move instrucitons with %fcc0-%fcc3. // Floating point conditional move instructions with %fcc0-%fcc3.
let Predicates = [HasV9] in { let Predicates = [HasV9] in {
let Constraints = "$f = $rd", intcc = 0 in { let Constraints = "$f = $rd", intcc = 0 in {
def V9MOVFCCrr def V9MOVFCCrr
: F4_1<0b101100, (outs IntRegs:$rd), : F4_1<0b101100, (outs IntRegs:$rd),
(ins FCCRegs:$cc, IntRegs:$rs2, IntRegs:$f, CCOp:$cond), (ins FCCRegs:$cc, IntRegs:$rs2, IntRegs:$f, CCOp:$cond),
"mov$cond $cc, $rs2, $rd", []>; "mov$cond $cc, $rs2, $rd", []>;
def V9MOVFCCri def V9MOVFCCri
: F4_2<0b101100, (outs IntRegs:$rd), : F4_2<0b101100, (outs IntRegs:$rd),
▲ Show 20 Lines • Show All 246 Lines • Show Last 20 Lines

llvm/lib/Target/SystemZ/SystemZInstrInfo.cpp

Show First 20 Lines • Show All 404 Lines • ▼ Show 20 Lines if (Branch.CCMask == SystemZ::CCMASK_ANY) {
// Delete the JMP if it's equivalent to a fall-through. // Delete the JMP if it's equivalent to a fall-through.
if (MBB.isLayoutSuccessor(Branch.getMBBTarget())) { if (MBB.isLayoutSuccessor(Branch.getMBBTarget())) {
TBB = nullptr; TBB = nullptr;
I->eraseFromParent(); I->eraseFromParent();
I = MBB.end(); I = MBB.end();
continue; continue;
} }
// TBB is used to indicate the unconditinal destination. // TBB is used to indicate the unconditional destination.
TBB = Branch.getMBBTarget(); TBB = Branch.getMBBTarget();
continue; continue;
} }
// Working from the bottom, handle the first conditional branch. // Working from the bottom, handle the first conditional branch.
if (Cond.empty()) { if (Cond.empty()) {
// FIXME: add X86-style branch swap // FIXME: add X86-style branch swap
FBB = TBB; FBB = TBB;
▲ Show 20 Lines • Show All 1,630 Lines • Show Last 20 Lines

llvm/lib/Target/WebAssembly/README.txt

Show All 11 LinesFor more information on WebAssembly itself, see the home page:
* https://webassembly.github.io/ * https://webassembly.github.io/
Emscripten provides a C/C++ compilation environment based on clang which Emscripten provides a C/C++ compilation environment based on clang which
includes standard libraries, tools, and packaging for producing WebAssembly includes standard libraries, tools, and packaging for producing WebAssembly
applications that can run in browsers and other environments. applications that can run in browsers and other environments.
wasi-sdk provides a more minimal C/C++ SDK based on clang, llvm and a libc based wasi-sdk provides a more minimal C/C++ SDK based on clang, llvm and a libc based
on musl, for producing WebAssemmbly applictions that use the WASI ABI. on musl, for producing WebAssemmbly applications that use the WASI ABI.
Rust provides WebAssembly support integrated into Cargo. There are two Rust provides WebAssembly support integrated into Cargo. There are two
main options: main options:
- wasm32-unknown-unknown, which provides a relatively minimal environment - wasm32-unknown-unknown, which provides a relatively minimal environment
that has an emphasis on being "native" that has an emphasis on being "native"
- wasm32-unknown-emscripten, which uses Emscripten internally and - wasm32-unknown-emscripten, which uses Emscripten internally and
provides standard C/C++ libraries, filesystem emulation, GL and SDL provides standard C/C++ libraries, filesystem emulation, GL and SDL
bindings bindings
▲ Show 20 Lines • Show All 145 Lines • Show Last 20 Lines

llvm/lib/Target/WebAssembly/WebAssemblyExceptionInfo.cpp

Show First 20 Lines • Show All 184 Lines • ▼ Show 20 Lines for (auto &P : UnwindWEVec) {
<< SrcWE->getEHPad()->getNumber() << "." << SrcWE->getEHPad()->getNumber() << "."
<< SrcWE->getEHPad()->getName() << "'s exception\n"); << SrcWE->getEHPad()->getName() << "'s exception\n");
WE->setParentException(SrcWE->getParentException()); WE->setParentException(SrcWE->getParentException());
} }
} }
} }
// Add BBs to exceptions' block set. This is a preparation to take out // Add BBs to exceptions' block set. This is a preparation to take out
// remaining incorect BBs from exceptions, because we need to iterate over BBs // remaining incorrect BBs from exceptions, because we need to iterate over
// for each exception. // BBs for each exception.
for (auto *DomNode : post_order(&MDT)) { for (auto *DomNode : post_order(&MDT)) {
MachineBasicBlock *MBB = DomNode->getBlock(); MachineBasicBlock *MBB = DomNode->getBlock();
WebAssemblyException *WE = getExceptionFor(MBB); WebAssemblyException *WE = getExceptionFor(MBB);
for (; WE; WE = WE->getParentException()) for (; WE; WE = WE->getParentException())
WE->addToBlocksSet(MBB); WE->addToBlocksSet(MBB);
} }
// 2. We take out remaining individual BBs out. Now we have added BBs to each // 2. We take out remaining individual BBs out. Now we have added BBs to each
▲ Show 20 Lines • Show All 168 Lines • Show Last 20 Lines

llvm/lib/Target/WebAssembly/WebAssemblyFixBrTableDefaults.cpp

Show All 35 Lines
public: public:
static char ID; // Pass identification, replacement for typeid static char ID; // Pass identification, replacement for typeid
WebAssemblyFixBrTableDefaults() : MachineFunctionPass(ID) {} WebAssemblyFixBrTableDefaults() : MachineFunctionPass(ID) {}
}; };
char WebAssemblyFixBrTableDefaults::ID = 0; char WebAssemblyFixBrTableDefaults::ID = 0;
// Target indepedent selection dag assumes that it is ok to use PointerTy // Target independent selection dag assumes that it is ok to use PointerTy
// as the index for a "switch", whereas Wasm so far only has a 32-bit br_table. // as the index for a "switch", whereas Wasm so far only has a 32-bit br_table.
// See e.g. SelectionDAGBuilder::visitJumpTableHeader // See e.g. SelectionDAGBuilder::visitJumpTableHeader
// We have a 64-bit br_table in the tablegen defs as a result, which does get // We have a 64-bit br_table in the tablegen defs as a result, which does get
// selected, and thus we get incorrect truncates/extensions happening on // selected, and thus we get incorrect truncates/extensions happening on
// wasm64. Here we fix that. // wasm64. Here we fix that.
void fixBrTableIndex(MachineInstr &MI, MachineBasicBlock *MBB, void fixBrTableIndex(MachineInstr &MI, MachineBasicBlock *MBB,
MachineFunction &MF) { MachineFunction &MF) {
// Only happens on wasm64. // Only happens on wasm64.
▲ Show 20 Lines • Show All 146 Lines • Show Last 20 Lines

llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

Show First 20 Lines • Show All 244 Lines • ▼ Show 20 Lines for (auto CC : {ISD::SETUGT, ISD::SETUGE, ISD::SETULT, ISD::SETULE})
setCondCodeAction(CC, MVT::v2i64, Custom); setCondCodeAction(CC, MVT::v2i64, Custom);
// 64x2 conversions are not in the spec // 64x2 conversions are not in the spec
for (auto Op : for (auto Op :
{ISD::SINT_TO_FP, ISD::UINT_TO_FP, ISD::FP_TO_SINT, ISD::FP_TO_UINT}) {ISD::SINT_TO_FP, ISD::UINT_TO_FP, ISD::FP_TO_SINT, ISD::FP_TO_UINT})
for (auto T : {MVT::v2i64, MVT::v2f64}) for (auto T : {MVT::v2i64, MVT::v2f64})
setOperationAction(Op, T, Expand); setOperationAction(Op, T, Expand);
// But saturating fp_to_int converstions are // But saturating fp_to_int conversions are
for (auto Op : {ISD::FP_TO_SINT_SAT, ISD::FP_TO_UINT_SAT}) for (auto Op : {ISD::FP_TO_SINT_SAT, ISD::FP_TO_UINT_SAT})
setOperationAction(Op, MVT::v4i32, Custom); setOperationAction(Op, MVT::v4i32, Custom);
} }
// As a special case, these operators use the type to mean the type to // As a special case, these operators use the type to mean the type to
// sign-extend from. // sign-extend from.
setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i1, Expand); setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i1, Expand);
if (!Subtarget->hasSignExt()) { if (!Subtarget->hasSignExt()) {
▲ Show 20 Lines • Show All 2,491 Lines • Show Last 20 Lines

llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.cpp

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
bool WebAssemblyInstrInfo::isReallyTriviallyReMaterializable( bool WebAssemblyInstrInfo::isReallyTriviallyReMaterializable(
const MachineInstr &MI) const { const MachineInstr &MI) const {
switch (MI.getOpcode()) { switch (MI.getOpcode()) {
case WebAssembly::CONST_I32: case WebAssembly::CONST_I32:
case WebAssembly::CONST_I64: case WebAssembly::CONST_I64:
case WebAssembly::CONST_F32: case WebAssembly::CONST_F32:
case WebAssembly::CONST_F64: case WebAssembly::CONST_F64:
// isReallyTriviallyReMaterializableGeneric misses these because of the // isReallyTriviallyReMaterializableGeneric misses these because of the
// ARGUMENTS implicit def, so we manualy override it here. // ARGUMENTS implicit def, so we manually override it here.
return true; return true;
default: default:
return false; return false;
} }
} }
void WebAssemblyInstrInfo::copyPhysReg(MachineBasicBlock &MBB, void WebAssemblyInstrInfo::copyPhysReg(MachineBasicBlock &MBB,
MachineBasicBlock::iterator I, MachineBasicBlock::iterator I,
▲ Show 20 Lines • Show All 148 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 525 Lines • ▼ Show 20 Linesvoid X86AsmBackend::emitInstructionBegin(MCObjectStreamer &OS,
if (!CanPadInst) if (!CanPadInst)
return; return;
if (PendingBA && OS.getCurrentFragment()->getPrevNode() == PendingBA) { if (PendingBA && OS.getCurrentFragment()->getPrevNode() == PendingBA) {
// Macro fusion actually happens and there is no other fragment inserted // Macro fusion actually happens and there is no other fragment inserted
// after the previous instruction. // after the previous instruction.
// //
// Do nothing here since we already inserted a BoudaryAlign fragment when // Do nothing here since we already inserted a BoundaryAlign fragment when
// we met the first instruction in the fused pair and we'll tie them // we met the first instruction in the fused pair and we'll tie them
// together in emitInstructionEnd. // together in emitInstructionEnd.
// //
// Note: When there is at least one fragment, such as MCAlignFragment, // Note: When there is at least one fragment, such as MCAlignFragment,
// inserted after the previous instruction, e.g. // inserted after the previous instruction, e.g.
// //
// \code // \code
// cmp %rax %rcx // cmp %rax %rcx
▲ Show 20 Lines • Show All 1,008 Lines • Show Last 20 Lines

llvm/lib/Target/X86/X86ISelDAGToDAG.cpp

Show First 20 Lines • Show All 5,232 Lines • ▼ Show 20 Lines case MVT::i64:
IsSigned ? X86::IMUL64m : X86::MUL64m; IsSigned ? X86::IMUL64m : X86::MUL64m;
LoReg = UseMULX ? X86::RDX : X86::RAX; LoReg = UseMULX ? X86::RDX : X86::RAX;
HiReg = X86::RDX; HiReg = X86::RDX;
break; break;
} }
SDValue Tmp0, Tmp1, Tmp2, Tmp3, Tmp4; SDValue Tmp0, Tmp1, Tmp2, Tmp3, Tmp4;
bool foldedLoad = tryFoldLoad(Node, N1, Tmp0, Tmp1, Tmp2, Tmp3, Tmp4); bool foldedLoad = tryFoldLoad(Node, N1, Tmp0, Tmp1, Tmp2, Tmp3, Tmp4);
// Multiply is commmutative. // Multiply is commutative.
if (!foldedLoad) { if (!foldedLoad) {
foldedLoad = tryFoldLoad(Node, N0, Tmp0, Tmp1, Tmp2, Tmp3, Tmp4); foldedLoad = tryFoldLoad(Node, N0, Tmp0, Tmp1, Tmp2, Tmp3, Tmp4);
if (foldedLoad) if (foldedLoad)
std::swap(N0, N1); std::swap(N0, N1);
} }
SDValue InFlag = CurDAG->getCopyToReg(CurDAG->getEntryNode(), dl, LoReg, SDValue InFlag = CurDAG->getCopyToReg(CurDAG->getEntryNode(), dl, LoReg,
N0, SDValue()).getValue(1); N0, SDValue()).getValue(1);
▲ Show 20 Lines • Show All 946 Lines • Show Last 20 Lines

llvm/lib/Target/X86/X86InstrFMA3Info.h

Show All 37 Linesstruct X86InstrFMA3Group {
enum : uint16_t { enum : uint16_t {
/// This bit must be set in the 'Attributes' field of FMA group if such /// This bit must be set in the 'Attributes' field of FMA group if such
/// group of FMA opcodes consists of FMA intrinsic opcodes. /// group of FMA opcodes consists of FMA intrinsic opcodes.
Intrinsic = 0x1, Intrinsic = 0x1,
/// This bit must be set in the 'Attributes' field of FMA group if such /// This bit must be set in the 'Attributes' field of FMA group if such
/// group of FMA opcodes consists of AVX512 opcodes accepting a k-mask and /// group of FMA opcodes consists of AVX512 opcodes accepting a k-mask and
/// passing the elements from the 1st operand to the result of the operation /// passing the elements from the 1st operand to the result of the operation
/// when the correpondings bits in the k-mask are unset. /// when the corresponding bits in the k-mask are unset.
KMergeMasked = 0x2, KMergeMasked = 0x2,
/// This bit must be set in the 'Attributes' field of FMA group if such /// This bit must be set in the 'Attributes' field of FMA group if such
/// group of FMA opcodes consists of AVX512 opcodes accepting a k-zeromask. /// group of FMA opcodes consists of AVX512 opcodes accepting a k-zeromask.
KZeroMasked = 0x4, KZeroMasked = 0x4,
}; };
/// Returns the 132 form of FMA opcode. /// Returns the 132 form of FMA opcode.
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

llvm/lib/Target/X86/X86InstrFragmentsSIMD.td

Show First 20 Lines • Show All 1,004 Lines • ▼ Show 20 Lines
def X86SubVBroadcastld256 : PatFrag<(ops node:$src), def X86SubVBroadcastld256 : PatFrag<(ops node:$src),
(X86SubVBroadcastld node:$src), [{ (X86SubVBroadcastld node:$src), [{
return cast<MemIntrinsicSDNode>(N)->getMemoryVT().getStoreSize() == 32; return cast<MemIntrinsicSDNode>(N)->getMemoryVT().getStoreSize() == 32;
}]>; }]>;
// Scalar SSE intrinsic fragments to match several different types of loads. // Scalar SSE intrinsic fragments to match several different types of loads.
// Used by scalar SSE intrinsic instructions which have 128 bit types, but // Used by scalar SSE intrinsic instructions which have 128 bit types, but
// only load a single element. // only load a single element.
// FIXME: We should add more canolicalizing in DAGCombine. Particulary removing // FIXME: We should add more canonicalizing in DAGCombine. Particulary removing
// the simple_load case. // the simple_load case.
def sse_load_f16 : PatFrags<(ops node:$ptr), def sse_load_f16 : PatFrags<(ops node:$ptr),
[(v8f16 (simple_load node:$ptr)), [(v8f16 (simple_load node:$ptr)),
(v8f16 (X86vzload16 node:$ptr)), (v8f16 (X86vzload16 node:$ptr)),
(v8f16 (scalar_to_vector (loadf16 node:$ptr)))]>; (v8f16 (scalar_to_vector (loadf16 node:$ptr)))]>;
def sse_load_f32 : PatFrags<(ops node:$ptr), def sse_load_f32 : PatFrags<(ops node:$ptr),
[(v4f32 (simple_load node:$ptr)), [(v4f32 (simple_load node:$ptr)),
(v4f32 (X86vzload32 node:$ptr)), (v4f32 (X86vzload32 node:$ptr)),
▲ Show 20 Lines • Show All 224 Lines • Show Last 20 Lines

llvm/lib/Target/X86/X86MCInstLower.cpp

Show First 20 Lines • Show All 1,387 Lines • ▼ Show 20 Linesvoid X86AsmPrinter::LowerPATCHABLE_OP(const MachineInstr &MI,
SmallVector<MCFixup, 4> Fixups; SmallVector<MCFixup, 4> Fixups;
raw_svector_ostream VecOS(Code); raw_svector_ostream VecOS(Code);
CodeEmitter->encodeInstruction(MCI, VecOS, Fixups, getSubtargetInfo()); CodeEmitter->encodeInstruction(MCI, VecOS, Fixups, getSubtargetInfo());
if (Code.size() < MinSize) { if (Code.size() < MinSize) {
if (MinSize == 2 && Subtarget->is32Bit() && if (MinSize == 2 && Subtarget->is32Bit() &&
Subtarget->isTargetWindowsMSVC() && Subtarget->isTargetWindowsMSVC() &&
(Subtarget->getCPU().empty() || Subtarget->getCPU() == "pentium3")) { (Subtarget->getCPU().empty() || Subtarget->getCPU() == "pentium3")) {
// For compatibilty reasons, when targetting MSVC, is is important to // For compatibility reasons, when targetting MSVC, is is important to
// generate a 'legacy' NOP in the form of a 8B FF MOV EDI, EDI. Some tools // generate a 'legacy' NOP in the form of a 8B FF MOV EDI, EDI. Some tools
// rely specifically on this pattern to be able to patch a function. // rely specifically on this pattern to be able to patch a function.
// This is only for 32-bit targets, when using /arch:IA32 or /arch:SSE. // This is only for 32-bit targets, when using /arch:IA32 or /arch:SSE.
OutStreamer->emitInstruction( OutStreamer->emitInstruction(
MCInstBuilder(X86::MOV32rr_REV).addReg(X86::EDI).addReg(X86::EDI), MCInstBuilder(X86::MOV32rr_REV).addReg(X86::EDI).addReg(X86::EDI),
*Subtarget); *Subtarget);
} else if (MinSize == 2 && Opcode == X86::PUSH64r) { } else if (MinSize == 2 && Opcode == X86::PUSH64r) {
// This is an optimization that lets us get away without emitting a nop in // This is an optimization that lets us get away without emitting a nop in
▲ Show 20 Lines • Show All 1,289 Lines • Show Last 20 Lines

llvm/lib/Target/X86/X86PreAMXConfig.cpp

Show First 20 Lines • Show All 227 Lines • ▼ Show 20 Lines
bool X86PreAMXConfig::getKeyAMXShapes(IntrinsicInst *KeyAMX, bool X86PreAMXConfig::getKeyAMXShapes(IntrinsicInst *KeyAMX,
SmallVector<Value *, 8> &Shapes) { SmallVector<Value *, 8> &Shapes) {
for (unsigned I = 0; I < KeyAMX->getNumOperands(); I++) { for (unsigned I = 0; I < KeyAMX->getNumOperands(); I++) {
Value *Op = KeyAMX->getOperand(I); Value *Op = KeyAMX->getOperand(I);
if (!Op->getType()->isX86_AMXTy()) if (!Op->getType()->isX86_AMXTy())
continue; continue;
IntrinsicInst *TileDef = dyn_cast<IntrinsicInst>(Op); IntrinsicInst *TileDef = dyn_cast<IntrinsicInst>(Op);
assert((TileDef && isTileLoad(TileDef)) && assert((TileDef && isTileLoad(TileDef)) &&
"All KeyAMX's tile definiation should comes from TileLoad!"); "All KeyAMX's tile definition should comes from TileLoad!");
Shapes.push_back(TileDef->getOperand(0)); Shapes.push_back(TileDef->getOperand(0));
Shapes.push_back(TileDef->getOperand(1)); Shapes.push_back(TileDef->getOperand(1));
} }
if (!isTileStore(KeyAMX)) { if (!isTileStore(KeyAMX)) {
Shapes.push_back(KeyAMX->getOperand(0)); Shapes.push_back(KeyAMX->getOperand(0));
Shapes.push_back(KeyAMX->getOperand(1)); Shapes.push_back(KeyAMX->getOperand(1));
} }
return Shapes.size() != 0; return Shapes.size() != 0;
▲ Show 20 Lines • Show All 169 Lines • Show Last 20 Lines

llvm/lib/Target/X86/X86SpeculativeLoadHardening.cpp

Show First 20 Lines • Show All 574 Lines • ▼ Show 20 Lines if (MBB.succ_size() <= 1)
continue; continue;
// Skip blocks unless their terminators start with a branch. Other // Skip blocks unless their terminators start with a branch. Other
// terminators don't seem interesting for guarding against misspeculation. // terminators don't seem interesting for guarding against misspeculation.
auto TermIt = MBB.getFirstTerminator(); auto TermIt = MBB.getFirstTerminator();
if (TermIt == MBB.end() || !TermIt->isBranch()) if (TermIt == MBB.end() || !TermIt->isBranch())
continue; continue;
// Add all the non-EH-pad succossors to the blocks we want to harden. We // Add all the non-EH-pad successors to the blocks we want to harden. We
// skip EH pads because there isn't really a condition of interest on // skip EH pads because there isn't really a condition of interest on
// entering. // entering.
for (MachineBasicBlock *SuccMBB : MBB.successors()) for (MachineBasicBlock *SuccMBB : MBB.successors())
if (!SuccMBB->isEHPad()) if (!SuccMBB->isEHPad())
Blocks.insert(SuccMBB); Blocks.insert(SuccMBB);
} }
for (MachineBasicBlock *MBB : Blocks) { for (MachineBasicBlock *MBB : Blocks) {
▲ Show 20 Lines • Show All 1,687 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,127 Lines • ▼ Show 20 Lines auto *CoalescedVecTy =
CurrNumEltPerOp == 1 CurrNumEltPerOp == 1
? CurrVecTy ? CurrVecTy
: FixedVectorType::get( : FixedVectorType::get(
IntegerType::get(Src->getContext(), IntegerType::get(Src->getContext(),
EltTyBits * CurrNumEltPerOp), EltTyBits * CurrNumEltPerOp),
CurrVecTy->getNumElements() / CurrNumEltPerOp); CurrVecTy->getNumElements() / CurrNumEltPerOp);
assert(DL.getTypeSizeInBits(CoalescedVecTy) == assert(DL.getTypeSizeInBits(CoalescedVecTy) ==
DL.getTypeSizeInBits(CurrVecTy) && DL.getTypeSizeInBits(CurrVecTy) &&
"coalesciing elements doesn't change vector width."); "coalescing elements doesn't change vector width.");
while (NumEltRemaining > 0) { while (NumEltRemaining > 0) {
assert(SubVecEltsLeft >= 0 && "Subreg element count overconsumtion?"); assert(SubVecEltsLeft >= 0 && "Subreg element count overconsumtion?");
// Can we use this vector size, as per the remaining element count? // Can we use this vector size, as per the remaining element count?
// Iff the vector is naturally aligned, we can do a wide load regardless. // Iff the vector is naturally aligned, we can do a wide load regardless.
if (NumEltRemaining < CurrNumEltPerOp && if (NumEltRemaining < CurrNumEltPerOp &&
(!IsLoad || Alignment.valueOrOne() < CurrOpSizeBytes) && (!IsLoad || Alignment.valueOrOne() < CurrOpSizeBytes) &&
▲ Show 20 Lines • Show All 1,847 Lines • Show Last 20 Lines

llvm/lib/Transforms/Coroutines/CoroFrame.cpp

Show First 20 Lines • Show All 1,224 Lines • ▼ Show 20 Lines Shape.AsyncLowering.FrameOffset =
alignTo(Shape.AsyncLowering.ContextHeaderSize, Shape.FrameAlign); alignTo(Shape.AsyncLowering.ContextHeaderSize, Shape.FrameAlign);
// Also make the final context size a multiple of the context alignment to // Also make the final context size a multiple of the context alignment to
// make allocation easier for allocators. // make allocation easier for allocators.
Shape.AsyncLowering.ContextSize = Shape.AsyncLowering.ContextSize =
alignTo(Shape.AsyncLowering.FrameOffset + Shape.FrameSize, alignTo(Shape.AsyncLowering.FrameOffset + Shape.FrameSize,
Shape.AsyncLowering.getContextAlignment()); Shape.AsyncLowering.getContextAlignment());
if (Shape.AsyncLowering.getContextAlignment() < Shape.FrameAlign) { if (Shape.AsyncLowering.getContextAlignment() < Shape.FrameAlign) {
report_fatal_error( report_fatal_error(
"The alignment requirment of frame variables cannot be higher than " "The alignment requirement of frame variables cannot be higher than "
"the alignment of the async function context"); "the alignment of the async function context");
} }
break; break;
} }
} }
return FrameTy; return FrameTy;
} }
▲ Show 20 Lines • Show All 1,440 Lines • ▼ Show 20 Lines if (auto *AsyncEnd = dyn_cast<CoroAsyncEndInst>(CE)) {
auto Arguments = ArrayRef<Value *>(Args).drop_front(3); auto Arguments = ArrayRef<Value *>(Args).drop_front(3);
auto *Call = createMustTailCall(AsyncEnd->getDebugLoc(), MustTailCallFn, auto *Call = createMustTailCall(AsyncEnd->getDebugLoc(), MustTailCallFn,
Arguments, Builder); Arguments, Builder);
splitAround(Call, "MustTailCall.Before.CoroEnd"); splitAround(Call, "MustTailCall.Before.CoroEnd");
} }
} }
// Later code makes structural assumptions about single predecessors phis e.g // Later code makes structural assumptions about single predecessors phis e.g
// that they are not live accross a suspend point. // that they are not live across a suspend point.
cleanupSinglePredPHIs(F); cleanupSinglePredPHIs(F);
// Transforms multi-edge PHI Nodes, so that any value feeding into a PHI will // Transforms multi-edge PHI Nodes, so that any value feeding into a PHI will
// never has its definition separated from the PHI by the suspend point. // never has its definition separated from the PHI by the suspend point.
rewritePHIs(F); rewritePHIs(F);
// Build suspend crossing info. // Build suspend crossing info.
SuspendCrossingInfo Checker(F, Shape); SuspendCrossingInfo Checker(F, Shape);
▲ Show 20 Lines • Show All 120 Lines • Show Last 20 Lines

llvm/lib/Transforms/Coroutines/CoroSplit.cpp

Show First 20 Lines • Show All 1,282 Lines • ▼ Show 20 Lines while (I->isTerminator() || isa<CmpInst>(I)) {
} else if (auto *CondCmp = dyn_cast<CmpInst>(I)) { } else if (auto *CondCmp = dyn_cast<CmpInst>(I)) {
// If the case number of suspended switch instruction is reduced to // If the case number of suspended switch instruction is reduced to
// 1, then it is simplified to CmpInst in llvm::ConstantFoldTerminator. // 1, then it is simplified to CmpInst in llvm::ConstantFoldTerminator.
auto *BR = dyn_cast<BranchInst>( auto *BR = dyn_cast<BranchInst>(
GetFirstValidInstruction(CondCmp->getNextNode())); GetFirstValidInstruction(CondCmp->getNextNode()));
if (!BR || !BR->isConditional() || CondCmp != BR->getCondition()) if (!BR || !BR->isConditional() || CondCmp != BR->getCondition())
return false; return false;
// And the comparsion looks like : %cond = icmp eq i8 %V, constant. // And the comparison looks like : %cond = icmp eq i8 %V, constant.
// So we try to resolve constant for the first operand only since the // So we try to resolve constant for the first operand only since the
// second operand should be literal constant by design. // second operand should be literal constant by design.
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
▲ Show 20 Lines • Show All 833 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 701 Lines • ▼ Show 20 Lines
namespace AA { namespace AA {
namespace PointerInfo { namespace PointerInfo {
struct State; struct State;
} // namespace PointerInfo } // namespace PointerInfo
} // namespace AA } // namespace AA
/// Helper for AA::PointerInfo::Acccess DenseMap/Set usage. /// Helper for AA::PointerInfo::Access DenseMap/Set usage.
template <> template <>
struct DenseMapInfo<AAPointerInfo::Access> : DenseMapInfo<Instruction *> { struct DenseMapInfo<AAPointerInfo::Access> : DenseMapInfo<Instruction *> {
using Access = AAPointerInfo::Access; using Access = AAPointerInfo::Access;
static inline Access getEmptyKey(); static inline Access getEmptyKey();
static inline Access getTombstoneKey(); static inline Access getTombstoneKey();
static unsigned getHashValue(const Access &A); static unsigned getHashValue(const Access &A);
static bool isEqual(const Access &LHS, const Access &RHS); static bool isEqual(const Access &LHS, const Access &RHS);
}; };
/// Helper that allows OffsetAndSize as a key in a DenseMap. /// Helper that allows OffsetAndSize as a key in a DenseMap.
template <> template <>
struct DenseMapInfo<AAPointerInfo ::OffsetAndSize> struct DenseMapInfo<AAPointerInfo ::OffsetAndSize>
: DenseMapInfo<std::pair<int64_t, int64_t>> {}; : DenseMapInfo<std::pair<int64_t, int64_t>> {};
/// Helper for AA::PointerInfo::Acccess DenseMap/Set usage ignoring everythign /// Helper for AA::PointerInfo::Access DenseMap/Set usage ignoring everythign
/// but the instruction /// but the instruction
struct AccessAsInstructionInfo : DenseMapInfo<Instruction *> { struct AccessAsInstructionInfo : DenseMapInfo<Instruction *> {
using Base = DenseMapInfo<Instruction *>; using Base = DenseMapInfo<Instruction *>;
using Access = AAPointerInfo::Access; using Access = AAPointerInfo::Access;
static inline Access getEmptyKey(); static inline Access getEmptyKey();
static inline Access getTombstoneKey(); static inline Access getTombstoneKey();
static unsigned getHashValue(const Access &A); static unsigned getHashValue(const Access &A);
static bool isEqual(const Access &LHS, const Access &RHS); static bool isEqual(const Access &LHS, const Access &RHS);
▲ Show 20 Lines • Show All 10,157 Lines • Show Last 20 Lines

llvm/lib/Transforms/IPO/OpenMPOpt.cpp

Show First 20 Lines • Show All 113 Lines • ▼ Show 20 Lines
static cl::opt<bool> PrintModuleBeforeOptimizations( static cl::opt<bool> PrintModuleBeforeOptimizations(
"openmp-opt-print-module-before", "openmp-opt-print-module-before",
cl::desc("Print the current module before OpenMP optimizations."), cl::desc("Print the current module before OpenMP optimizations."),
cl::Hidden, cl::init(false)); cl::Hidden, cl::init(false));
static cl::opt<bool> AlwaysInlineDeviceFunctions( static cl::opt<bool> AlwaysInlineDeviceFunctions(
"openmp-opt-inline-device", "openmp-opt-inline-device",
cl::desc("Inline all applicible functions on the device."), cl::Hidden, cl::desc("Inline all applicable functions on the device."), cl::Hidden,
cl::init(false)); cl::init(false));
static cl::opt<bool> static cl::opt<bool>
EnableVerboseRemarks("openmp-opt-verbose-remarks", EnableVerboseRemarks("openmp-opt-verbose-remarks",
cl::desc("Enables more verbose remarks."), cl::Hidden, cl::desc("Enables more verbose remarks."), cl::Hidden,
cl::init(false)); cl::init(false));
static cl::opt<unsigned> static cl::opt<unsigned>
▲ Show 20 Lines • Show All 5,109 Lines • Show Last 20 Lines

llvm/lib/Transforms/IPO/PartialInlining.cpp

Show First 20 Lines • Show All 743 Lines • ▼ Show 20 LinesBranchProbability PartialInlinerImpl::getOutliningCallBBRelativeFreq(
// When profile data is not available, we need to be conservative in // When profile data is not available, we need to be conservative in
// estimating the overall savings. Static branch prediction can usually // estimating the overall savings. Static branch prediction can usually
// guess the branch direction right (taken/non-taken), but the guessed // guess the branch direction right (taken/non-taken), but the guessed
// branch probability is usually not biased enough. In case when the // branch probability is usually not biased enough. In case when the
// outlined region is predicted to be likely, its probability needs // outlined region is predicted to be likely, its probability needs
// to be made higher (more biased) to not under-estimate the cost of // to be made higher (more biased) to not under-estimate the cost of
// function outlining. On the other hand, if the outlined region // function outlining. On the other hand, if the outlined region
// is predicted to be less likely, the predicted probablity is usually // is predicted to be less likely, the predicted probability is usually
// higher than the actual. For instance, the actual probability of the // higher than the actual. For instance, the actual probability of the
// less likely target is only 5%, but the guessed probablity can be // less likely target is only 5%, but the guessed probability can be
// 40%. In the latter case, there is no need for further adjustement. // 40%. In the latter case, there is no need for further adjustement.
// FIXME: add an option for this. // FIXME: add an option for this.
if (OutlineRegionRelFreq < BranchProbability(45, 100)) if (OutlineRegionRelFreq < BranchProbability(45, 100))
return OutlineRegionRelFreq; return OutlineRegionRelFreq;
OutlineRegionRelFreq = std::max( OutlineRegionRelFreq = std::max(
OutlineRegionRelFreq, BranchProbability(OutlineRegionFreqPercent, 100)); OutlineRegionRelFreq, BranchProbability(OutlineRegionFreqPercent, 100));
▲ Show 20 Lines • Show All 798 Lines • Show Last 20 Lines

llvm/lib/Transforms/IPO/SampleProfile.cpp

Show First 20 Lines • Show All 1,327 Lines • ▼ Show 20 LinesSampleProfileLoader::shouldInlineCandidate(InlineCandidate &Candidate) {
InlineParams Params = getInlineParams(); InlineParams Params = getInlineParams();
// We will ignore the threshold from inline cost, so always get full cost. // We will ignore the threshold from inline cost, so always get full cost.
Params.ComputeFullInlineCost = true; Params.ComputeFullInlineCost = true;
Params.AllowRecursiveCall = AllowRecursiveInline; Params.AllowRecursiveCall = AllowRecursiveInline;
// Checks if there is anything in the reachable portion of the callee at // Checks if there is anything in the reachable portion of the callee at
// this callsite that makes this inlining potentially illegal. Need to // this callsite that makes this inlining potentially illegal. Need to
// set ComputeFullInlineCost, otherwise getInlineCost may return early // set ComputeFullInlineCost, otherwise getInlineCost may return early
// when cost exceeds threshold without checking all IRs in the callee. // when cost exceeds threshold without checking all IRs in the callee.
// The acutal cost does not matter because we only checks isNever() to // The actual cost does not matter because we only checks isNever() to
// see if it is legal to inline the callsite. // see if it is legal to inline the callsite.
InlineCost Cost = getInlineCost(*Candidate.CallInstr, Callee, Params, InlineCost Cost = getInlineCost(*Candidate.CallInstr, Callee, Params,
GetTTI(*Callee), GetAC, GetTLI); GetTTI(*Callee), GetAC, GetTLI);
// Honor always inline and never inline from call analyzer // Honor always inline and never inline from call analyzer
if (Cost.isNever() || Cost.isAlways()) if (Cost.isNever() || Cost.isAlways())
return Cost; return Cost;
▲ Show 20 Lines • Show All 834 Lines • Show Last 20 Lines

llvm/lib/Transforms/IPO/SampleProfileProbe.cpp

Show First 20 Lines • Show All 69 Lines • ▼ Show 20 Linesstatic uint64_t computeCallStackHash(const Instruction &Inst) {
return getCallStackHash(Inst.getDebugLoc()); return getCallStackHash(Inst.getDebugLoc());
} }
bool PseudoProbeVerifier::shouldVerifyFunction(const Function *F) { bool PseudoProbeVerifier::shouldVerifyFunction(const Function *F) {
// Skip function declaration. // Skip function declaration.
if (F->isDeclaration()) if (F->isDeclaration())
return false; return false;
// Skip function that will not be emitted into object file. The prevailing // Skip function that will not be emitted into object file. The prevailing
// defintion will be verified instead. // definition will be verified instead.
if (F->hasAvailableExternallyLinkage()) if (F->hasAvailableExternallyLinkage())
return false; return false;
// Do a name matching. // Do a name matching.
static std::unordered_set<std::string> VerifyFuncNames( static std::unordered_set<std::string> VerifyFuncNames(
VerifyPseudoProbeFuncList.begin(), VerifyPseudoProbeFuncList.end()); VerifyPseudoProbeFuncList.begin(), VerifyPseudoProbeFuncList.end());
return VerifyFuncNames.empty() || VerifyFuncNames.count(F->getName().str()); return VerifyFuncNames.empty() || VerifyFuncNames.count(F->getName().str());
} }
▲ Show 20 Lines • Show All 370 Lines • Show Last 20 Lines

llvm/lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp

Show First 20 Lines • Show All 181 Lines • ▼ Show 20 Lines if (!F.isDeclaration() || F.getFunctionType() == EmptyFT ||
// Changing the type of an intrinsic may invalidate the IR. // Changing the type of an intrinsic may invalidate the IR.
F.getName().startswith("llvm.")) F.getName().startswith("llvm."))
continue; continue;
Function *NewF = Function *NewF =
Function::Create(EmptyFT, GlobalValue::ExternalLinkage, Function::Create(EmptyFT, GlobalValue::ExternalLinkage,
F.getAddressSpace(), "", &M); F.getAddressSpace(), "", &M);
NewF->copyAttributesFrom(&F); NewF->copyAttributesFrom(&F);
// Only copy function attribtues. // Only copy function attributes.
NewF->setAttributes(AttributeList::get(M.getContext(), NewF->setAttributes(AttributeList::get(M.getContext(),
AttributeList::FunctionIndex, AttributeList::FunctionIndex,
F.getAttributes().getFnAttrs())); F.getAttributes().getFnAttrs()));
NewF->takeName(&F); NewF->takeName(&F);
F.replaceAllUsesWith(ConstantExpr::getBitCast(NewF, F.getType())); F.replaceAllUsesWith(ConstantExpr::getBitCast(NewF, F.getType()));
F.eraseFromParent(); F.eraseFromParent();
} }
▲ Show 20 Lines • Show All 409 Lines • Show Last 20 Lines

llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp

Show First 20 Lines • Show All 83 Lines • ▼ Show 20 Lines private:
APFloat *getFpValPtr() { return reinterpret_cast<APFloat *>(&FpValBuf); } APFloat *getFpValPtr() { return reinterpret_cast<APFloat *>(&FpValBuf); }
const APFloat *getFpValPtr() const { const APFloat *getFpValPtr() const {
return reinterpret_cast<const APFloat *>(&FpValBuf); return reinterpret_cast<const APFloat *>(&FpValBuf);
} }
const APFloat &getFpVal() const { const APFloat &getFpVal() const {
assert(IsFp && BufHasFpVal && "Incorret state"); assert(IsFp && BufHasFpVal && "Incorrect state");
return *getFpValPtr(); return *getFpValPtr();
} }
APFloat &getFpVal() { APFloat &getFpVal() {
assert(IsFp && BufHasFpVal && "Incorret state"); assert(IsFp && BufHasFpVal && "Incorrect state");
return *getFpValPtr(); return *getFpValPtr();
} }
bool isInt() const { return !IsFp; } bool isInt() const { return !IsFp; }
// If the coefficient is represented by an integer, promote it to a // If the coefficient is represented by an integer, promote it to a
// floating point. // floating point.
void convertToFpType(const fltSemantics &Sem); void convertToFpType(const fltSemantics &Sem);
▲ Show 20 Lines • Show All 2,413 Lines • Show Last 20 Lines

llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp

Show First 20 Lines • Show All 1,543 Lines • ▼ Show 20 LinesInstruction *AddressSanitizer::instrumentAMDGPUAddress(
uint32_t TypeSize, bool IsWrite, Value *SizeArgument) { uint32_t TypeSize, bool IsWrite, Value *SizeArgument) {
// Do not instrument unsupported addrspaces. // Do not instrument unsupported addrspaces.
if (isUnsupportedAMDGPUAddrspace(Addr)) if (isUnsupportedAMDGPUAddrspace(Addr))
return nullptr; return nullptr;
Type *PtrTy = cast<PointerType>(Addr->getType()->getScalarType()); Type *PtrTy = cast<PointerType>(Addr->getType()->getScalarType());
// Follow host instrumentation for global and constant addresses. // Follow host instrumentation for global and constant addresses.
if (PtrTy->getPointerAddressSpace() != 0) if (PtrTy->getPointerAddressSpace() != 0)
return InsertBefore; return InsertBefore;
// Instrument generic addresses in supported addressspaces. // Instrument generic addresses in supported address spaces.
IRBuilder<> IRB(InsertBefore); IRBuilder<> IRB(InsertBefore);
Value *AddrLong = IRB.CreatePointerCast(Addr, IRB.getInt8PtrTy()); Value *AddrLong = IRB.CreatePointerCast(Addr, IRB.getInt8PtrTy());
Value *IsShared = IRB.CreateCall(AMDGPUAddressShared, {AddrLong}); Value *IsShared = IRB.CreateCall(AMDGPUAddressShared, {AddrLong});
Value *IsPrivate = IRB.CreateCall(AMDGPUAddressPrivate, {AddrLong}); Value *IsPrivate = IRB.CreateCall(AMDGPUAddressPrivate, {AddrLong});
Value *IsSharedOrPrivate = IRB.CreateOr(IsShared, IsPrivate); Value *IsSharedOrPrivate = IRB.CreateOr(IsShared, IsPrivate);
Value *Cmp = IRB.CreateICmpNE(IRB.getTrue(), IsSharedOrPrivate); Value *Cmp = IRB.CreateICmpNE(IRB.getTrue(), IsSharedOrPrivate);
Value *AddrSpaceZeroLanding = Value *AddrSpaceZeroLanding =
SplitBlockAndInsertIfThen(Cmp, InsertBefore, false); SplitBlockAndInsertIfThen(Cmp, InsertBefore, false);
▲ Show 20 Lines • Show All 1,885 Lines • Show Last 20 Lines

llvm/lib/Transforms/Scalar/IndVarSimplify.cpp

Show First 20 Lines • Show All 1,723 Lines • ▼ Show 20 Linesbool IndVarSimplify::predicateLoopExits(Loop *L, SCEVExpander &Rewriter) {
// Finally, see if we can rewrite our exit conditions into a loop invariant // Finally, see if we can rewrite our exit conditions into a loop invariant
// form. If we have a read-only loop, and we can tell that we must exit down // form. If we have a read-only loop, and we can tell that we must exit down
// a path which does not need any of the values computed within the loop, we // a path which does not need any of the values computed within the loop, we
// can rewrite the loop to exit on the first iteration. Note that this // can rewrite the loop to exit on the first iteration. Note that this
// doesn't either a) tell us the loop exits on the first iteration (unless // doesn't either a) tell us the loop exits on the first iteration (unless
// *all* exits are predicateable) or b) tell us *which* exit might be taken. // *all* exits are predicateable) or b) tell us *which* exit might be taken.
// This transformation looks a lot like a restricted form of dead loop // This transformation looks a lot like a restricted form of dead loop
// elimination, but restricted to read-only loops and without neccesssarily // elimination, but restricted to read-only loops and without neccessarily
// needing to kill the loop entirely. // needing to kill the loop entirely.
if (!LoopPredication) if (!LoopPredication)
return false; return false;
// Note: ExactBTC is the exact backedge taken count *iff* the loop exits // Note: ExactBTC is the exact backedge taken count *iff* the loop exits
// through *explicit* control flow. We have to eliminate the possibility of // through *explicit* control flow. We have to eliminate the possibility of
// implicit exits (see below) before we know it's truly exact. // implicit exits (see below) before we know it's truly exact.
const SCEV *ExactBTC = SE->getBackedgeTakenCount(L); const SCEV *ExactBTC = SE->getBackedgeTakenCount(L);
▲ Show 20 Lines • Show All 415 Lines • Show Last 20 Lines

llvm/lib/Transforms/Scalar/LoopFuse.cpp

Show First 20 Lines • Show All 422 Lines • ▼ Show 20 Lines
}; };
using LoopVector = SmallVector<Loop *, 4>; using LoopVector = SmallVector<Loop *, 4>;
// Set of Control Flow Equivalent (CFE) Fusion Candidates, sorted in dominance // Set of Control Flow Equivalent (CFE) Fusion Candidates, sorted in dominance
// order. Thus, if FC0 comes *before* FC1 in a FusionCandidateSet, then FC0 // order. Thus, if FC0 comes *before* FC1 in a FusionCandidateSet, then FC0
// dominates FC1 and FC1 post-dominates FC0. // dominates FC1 and FC1 post-dominates FC0.
// std::set was chosen because we want a sorted data structure with stable // std::set was chosen because we want a sorted data structure with stable
// iterators. A subsequent patch to loop fusion will enable fusing non-ajdacent // iterators. A subsequent patch to loop fusion will enable fusing non-adjacent
// loops by moving intervening code around. When this intervening code contains // loops by moving intervening code around. When this intervening code contains
// loops, those loops will be moved also. The corresponding FusionCandidates // loops, those loops will be moved also. The corresponding FusionCandidates
// will also need to be moved accordingly. As this is done, having stable // will also need to be moved accordingly. As this is done, having stable
// iterators will simplify the logic. Similarly, having an efficient insert that // iterators will simplify the logic. Similarly, having an efficient insert that
// keeps the FusionCandidateSet sorted will also simplify the implementation. // keeps the FusionCandidateSet sorted will also simplify the implementation.
using FusionCandidateSet = std::set<FusionCandidate, FusionCandidateCompare>; using FusionCandidateSet = std::set<FusionCandidate, FusionCandidateCompare>;
using FusionCandidateCollection = SmallVector<FusionCandidateSet, 4>; using FusionCandidateCollection = SmallVector<FusionCandidateSet, 4>;
▲ Show 20 Lines • Show All 294 Lines • ▼ Show 20 Lines haveIdenticalTripCounts(const FusionCandidate &FC0,
const unsigned TC0 = SE.getSmallConstantTripCount(FC0.L); const unsigned TC0 = SE.getSmallConstantTripCount(FC0.L);
const unsigned TC1 = SE.getSmallConstantTripCount(FC1.L); const unsigned TC1 = SE.getSmallConstantTripCount(FC1.L);
// If any of the tripcounts are zero that means that loop(s) do not have // If any of the tripcounts are zero that means that loop(s) do not have
// a single exit or a constant tripcount. // a single exit or a constant tripcount.
if (TC0 == 0 || TC1 == 0) { if (TC0 == 0 || TC1 == 0) {
LLVM_DEBUG(dbgs() << "Loop(s) do not have a single exit point or do not " LLVM_DEBUG(dbgs() << "Loop(s) do not have a single exit point or do not "
"have a constant number of iterations. Peeling " "have a constant number of iterations. Peeling "
"is not benefical\n"); "is not beneficial\n");
return {false, None}; return {false, None};
} }
Optional<unsigned> Difference = None; Optional<unsigned> Difference = None;
int Diff = TC0 - TC1; int Diff = TC0 - TC1;
if (Diff > 0) if (Diff > 0)
Difference = Diff; Difference = Diff;
▲ Show 20 Lines • Show All 1,274 Lines • Show Last 20 Lines

llvm/lib/Transforms/Scalar/LoopLoadElimination.cpp

Show First 20 Lines • Show All 176 Lines • ▼ Show 20 Lines findStoreToLoadDependences(const LoopAccessInfo &LAI) {
const auto *Deps = LAI.getDepChecker().getDependences(); const auto *Deps = LAI.getDepChecker().getDependences();
if (!Deps) if (!Deps)
return Candidates; return Candidates;
// Find store->load dependences (consequently true dep). Both lexically // Find store->load dependences (consequently true dep). Both lexically
// forward and backward dependences qualify. Disqualify loads that have // forward and backward dependences qualify. Disqualify loads that have
// other unknown dependences. // other unknown dependences.
SmallPtrSet<Instruction *, 4> LoadsWithUnknownDepedence; SmallPtrSet<Instruction *, 4> LoadsWithUnknownDependence;
for (const auto &Dep : *Deps) { for (const auto &Dep : *Deps) {
Instruction *Source = Dep.getSource(LAI); Instruction *Source = Dep.getSource(LAI);
Instruction *Destination = Dep.getDestination(LAI); Instruction *Destination = Dep.getDestination(LAI);
if (Dep.Type == MemoryDepChecker::Dependence::Unknown) { if (Dep.Type == MemoryDepChecker::Dependence::Unknown) {
if (isa<LoadInst>(Source)) if (isa<LoadInst>(Source))
LoadsWithUnknownDepedence.insert(Source); LoadsWithUnknownDependence.insert(Source);
if (isa<LoadInst>(Destination)) if (isa<LoadInst>(Destination))
LoadsWithUnknownDepedence.insert(Destination); LoadsWithUnknownDependence.insert(Destination);
continue; continue;
} }
if (Dep.isBackward()) if (Dep.isBackward())
// Note that the designations source and destination follow the program // Note that the designations source and destination follow the program
// order, i.e. source is always first. (The direction is given by the // order, i.e. source is always first. (The direction is given by the
// DepType.) // DepType.)
std::swap(Source, Destination); std::swap(Source, Destination);
Show All 10 Lines for (const auto &Dep : *Deps) {
// Only progagate the value if they are of the same type. // Only progagate the value if they are of the same type.
if (Store->getPointerOperandType() != Load->getPointerOperandType() || if (Store->getPointerOperandType() != Load->getPointerOperandType() ||
getLoadStoreType(Store) != getLoadStoreType(Load)) getLoadStoreType(Store) != getLoadStoreType(Load))
continue; continue;
Candidates.emplace_front(Load, Store); Candidates.emplace_front(Load, Store);
} }
if (!LoadsWithUnknownDepedence.empty()) if (!LoadsWithUnknownDependence.empty())
Candidates.remove_if([&](const StoreToLoadForwardingCandidate &C) { Candidates.remove_if([&](const StoreToLoadForwardingCandidate &C) {
return LoadsWithUnknownDepedence.count(C.Load); return LoadsWithUnknownDependence.count(C.Load);
}); });
return Candidates; return Candidates;
} }
/// Return the index of the instruction according to program order. /// Return the index of the instruction according to program order.
unsigned getInstrIndex(Instruction *Inst) { unsigned getInstrIndex(Instruction *Inst) {
auto I = InstOrder.find(Inst); auto I = InstOrder.find(Inst);
assert(I != InstOrder.end() && "No index for instruction"); assert(I != InstOrder.end() && "No index for instruction");
return I->second; return I->second;
} }
/// If a load has multiple candidates associated (i.e. different /// If a load has multiple candidates associated (i.e. different
/// stores), it means that it could be forwarding from multiple stores /// stores), it means that it could be forwarding from multiple stores
/// depending on control flow. Remove these candidates. /// depending on control flow. Remove these candidates.
/// ///
/// Here, we rely on LAA to include the relevant loop-independent dependences. /// Here, we rely on LAA to include the relevant loop-independent dependences.
/// LAA is known to omit these in the very simple case when the read and the /// LAA is known to omit these in the very simple case when the read and the
/// write within an alias set always takes place using the *same* pointer. /// write within an alias set always takes place using the *same* pointer.
/// ///
/// However, we know that this is not the case here, i.e. we can rely on LAA /// However, we know that this is not the case here, i.e. we can rely on LAA
/// to provide us with loop-independent dependences for the cases we're /// to provide us with loop-independent dependences for the cases we're
/// interested. Consider the case for example where a loop-independent /// interested. Consider the case for example where a loop-independent
/// dependece S1->S2 invalidates the forwarding S3->S2. /// dependence S1->S2 invalidates the forwarding S3->S2.
/// ///
/// A[i] = ... (S1) /// A[i] = ... (S1)
/// ... = A[i] (S2) /// ... = A[i] (S2)
/// A[i+1] = ... (S3) /// A[i+1] = ... (S3)
/// ///
/// LAA will perform dependence analysis here because there are two /// LAA will perform dependence analysis here because there are two
/// *different* pointers involved in the same alias set (&A[i] and &A[i+1]). /// *different* pointers involved in the same alias set (&A[i] and &A[i+1]).
void removeDependencesFromMultipleStores( void removeDependencesFromMultipleStores(
▲ Show 20 Lines • Show All 482 Lines • Show Last 20 Lines

llvm/lib/Transforms/Scalar/LoopSimplifyCFG.cpp

Show First 20 Lines • Show All 468 Lines • ▼ Show 20 Lines void deleteDeadLoopBlocks() {
DTU.applyUpdates(DTUpdates); DTU.applyUpdates(DTUpdates);
DTUpdates.clear(); DTUpdates.clear();
for (auto *BB : DeadLoopBlocks) for (auto *BB : DeadLoopBlocks)
DTU.deleteBB(BB); DTU.deleteBB(BB);
NumLoopBlocksDeleted += DeadLoopBlocks.size(); NumLoopBlocksDeleted += DeadLoopBlocks.size();
} }
/// Constant-fold terminators of blocks acculumated in FoldCandidates into the /// Constant-fold terminators of blocks accumulated in FoldCandidates into the
/// unconditional branches. /// unconditional branches.
void foldTerminators() { void foldTerminators() {
for (BasicBlock *BB : FoldCandidates) { for (BasicBlock *BB : FoldCandidates) {
assert(LI.getLoopFor(BB) == &L && "Should be a loop block!"); assert(LI.getLoopFor(BB) == &L && "Should be a loop block!");
BasicBlock *TheOnlySucc = getOnlyLiveSuccessor(BB); BasicBlock *TheOnlySucc = getOnlyLiveSuccessor(BB);
assert(TheOnlySucc && "Should have one live successor!"); assert(TheOnlySucc && "Should have one live successor!");
LLVM_DEBUG(dbgs() << "Replacing terminator of " << BB->getName() LLVM_DEBUG(dbgs() << "Replacing terminator of " << BB->getName()
▲ Show 20 Lines • Show All 291 Lines • Show Last 20 Lines

llvm/lib/Transforms/Scalar/LoopStrengthReduce.cpp

Show First 20 Lines • Show All 4,850 Lines • ▼ Show 20 Lines
/// reg({-1,+,1}) (2/3) * (2/3) * 1 /// reg({-1,+,1}) (2/3) * (2/3) * 1
/// reg({a,+,1}) (2/3) * 1 * 1 /// reg({a,+,1}) (2/3) * 1 * 1
/// reg({b,+,1}) 1 * (2/3) * (2/3) /// reg({b,+,1}) 1 * (2/3) * (2/3)
/// reg(c) 1 * 1 * 0 /// reg(c) 1 * 1 * 0
/// ///
/// Now count registers number mathematical expectation for each formula: /// Now count registers number mathematical expectation for each formula:
/// Note that for each use we exclude probability if not selecting for the use. /// Note that for each use we exclude probability if not selecting for the use.
/// For example for Use1 probability for reg(a) would be just 1 * 1 (excluding /// For example for Use1 probability for reg(a) would be just 1 * 1 (excluding
/// probabilty 1/3 of not selecting for Use1). /// probability 1/3 of not selecting for Use1).
/// Use1: /// Use1:
/// reg(a) + reg({0,+,1}) 1 + 1/3 -- to be deleted /// reg(a) + reg({0,+,1}) 1 + 1/3 -- to be deleted
/// reg(a) + reg({-1,+,1}) + 1 1 + 4/9 -- to be deleted /// reg(a) + reg({-1,+,1}) + 1 1 + 4/9 -- to be deleted
/// reg({a,+,1}) 1 /// reg({a,+,1}) 1
/// Use2: /// Use2:
/// reg(b) + reg({0,+,1}) 1/2 + 1/3 -- to be deleted /// reg(b) + reg({0,+,1}) 1/2 + 1/3 -- to be deleted
/// reg(b) + reg({-1,+,1}) + 1 1/2 + 2/3 -- to be deleted /// reg(b) + reg({-1,+,1}) + 1 1/2 + 2/3 -- to be deleted
/// reg({b,+,1}) 2/3 /// reg({b,+,1}) 2/3
▲ Show 20 Lines • Show All 1,836 Lines • Show Last 20 Lines

llvm/lib/Transforms/Scalar/PlaceSafepoints.cpp

Show First 20 Lines • Show All 481 Lines • ▼ Show 20 Linesbool PlaceSafepoints::runOnFunction(Function &F) {
const TargetLibraryInfo &TLI = const TargetLibraryInfo &TLI =
getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F); getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F);
bool Modified = false; bool Modified = false;
// In various bits below, we rely on the fact that uses are reachable from // In various bits below, we rely on the fact that uses are reachable from
// defs. When there are basic blocks unreachable from the entry, dominance // defs. When there are basic blocks unreachable from the entry, dominance
// and reachablity queries return non-sensical results. Thus, we preprocess // and reachability queries return non-sensical results. Thus, we preprocess
// the function to ensure these properties hold. // the function to ensure these properties hold.
Modified |= removeUnreachableBlocks(F); Modified |= removeUnreachableBlocks(F);
// STEP 1 - Insert the safepoint polling locations. We do not need to // STEP 1 - Insert the safepoint polling locations. We do not need to
// actually insert parse points yet. That will be done for all polls and // actually insert parse points yet. That will be done for all polls and
// calls in a single pass. // calls in a single pass.
DominatorTree DT; DominatorTree DT;
▲ Show 20 Lines • Show All 193 Lines • Show Last 20 Lines

llvm/lib/Transforms/Utils/AssumeBundleBuilder.cpp

Show All 23 Lines
#include "llvm/Support/DebugCounter.h" #include "llvm/Support/DebugCounter.h"
#include "llvm/Transforms/Utils/Local.h" #include "llvm/Transforms/Utils/Local.h"
using namespace llvm; using namespace llvm;
namespace llvm { namespace llvm {
cl::opt<bool> ShouldPreserveAllAttributes( cl::opt<bool> ShouldPreserveAllAttributes(
"assume-preserve-all", cl::init(false), cl::Hidden, "assume-preserve-all", cl::init(false), cl::Hidden,
cl::desc("enable preservation of all attrbitues. even those that are " cl::desc("enable preservation of all attributes. even those that are "
"unlikely to be usefull")); "unlikely to be usefull"));
cl::opt<bool> EnableKnowledgeRetention( cl::opt<bool> EnableKnowledgeRetention(
"enable-knowledge-retention", cl::init(false), cl::Hidden, "enable-knowledge-retention", cl::init(false), cl::Hidden,
cl::desc( cl::desc(
"enable preservation of attributes throughout code transformation")); "enable preservation of attributes throughout code transformation"));
} // namespace llvm } // namespace llvm
▲ Show 20 Lines • Show All 611 Lines • Show Last 20 Lines

llvm/lib/Transforms/Utils/CodeExtractor.cpp

Show First 20 Lines • Show All 1,839 Lines • ▼ Show 20 Lines if (doesNotReturn)
newFunction->setDoesNotReturn(); newFunction->setDoesNotReturn();
LLVM_DEBUG(if (verifyFunction(*newFunction, &errs())) { LLVM_DEBUG(if (verifyFunction(*newFunction, &errs())) {
newFunction->dump(); newFunction->dump();
report_fatal_error("verification of newFunction failed!"); report_fatal_error("verification of newFunction failed!");
}); });
LLVM_DEBUG(if (verifyFunction(*oldFunction)) LLVM_DEBUG(if (verifyFunction(*oldFunction))
report_fatal_error("verification of oldFunction failed!")); report_fatal_error("verification of oldFunction failed!"));
LLVM_DEBUG(if (AC && verifyAssumptionCache(*oldFunction, *newFunction, AC)) LLVM_DEBUG(
report_fatal_error("Stale Asumption cache for old Function!")); if (AC && verifyAssumptionCache(*oldFunction, *newFunction, AC))
report_fatal_error("Stale Assumption 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_or_null<CallInst>(AssumeVH);
Show All 27 Lines

llvm/lib/Transforms/Utils/LoopPeel.cpp

Show First 20 Lines • Show All 304 Lines • ▼ Show 20 Lines for (auto *BB : L.blocks()) {
// With *that* peel count, does the predicate !Pred become known in the // With *that* peel count, does the predicate !Pred become known in the
// first iteration of the loop body after peeling? // first iteration of the loop body after peeling?
if (!SE.isKnownPredicate(ICmpInst::getInversePredicate(Pred), IterVal, if (!SE.isKnownPredicate(ICmpInst::getInversePredicate(Pred), IterVal,
RightSCEV)) RightSCEV))
continue; // If not, give up. continue; // If not, give up.
// However, for equality comparisons, that isn't always sufficient to // However, for equality comparisons, that isn't always sufficient to
// eliminate the comparsion in loop body, we may need to peel one more // eliminate the comparison in loop body, we may need to peel one more
// iteration. See if that makes !Pred become unknown again. // iteration. See if that makes !Pred become unknown again.
if (ICmpInst::isEquality(Pred) && if (ICmpInst::isEquality(Pred) &&
!SE.isKnownPredicate(ICmpInst::getInversePredicate(Pred), NextIterVal, !SE.isKnownPredicate(ICmpInst::getInversePredicate(Pred), NextIterVal,
RightSCEV) && RightSCEV) &&
!SE.isKnownPredicate(Pred, IterVal, RightSCEV) && !SE.isKnownPredicate(Pred, IterVal, RightSCEV) &&
SE.isKnownPredicate(Pred, NextIterVal, RightSCEV)) { SE.isKnownPredicate(Pred, NextIterVal, RightSCEV)) {
if (!CanPeelOneMoreIteration()) if (!CanPeelOneMoreIteration())
continue; // Need to peel one more iteration, but can't. Give up. continue; // Need to peel one more iteration, but can't. Give up.
PeelOneMoreIteration(); // Great! PeelOneMoreIteration(); // Great!
} }
DesiredPeelCount = std::max(DesiredPeelCount, NewPeelCount); DesiredPeelCount = std::max(DesiredPeelCount, NewPeelCount);
} }
return DesiredPeelCount; return DesiredPeelCount;
} }
/// This "heuristic" exactly matches implicit behavior which used to exist /// This "heuristic" exactly matches implicit behavior which used to exist
/// inside getLoopEstimatedTripCount. It was added here to keep an /// inside getLoopEstimatedTripCount. It was added here to keep an
/// improvement inside that API from causing peeling to become more agressive. /// improvement inside that API from causing peeling to become more aggressive.
/// This should probably be removed. /// This should probably be removed.
static bool violatesLegacyMultiExitLoopCheck(Loop *L) { static bool violatesLegacyMultiExitLoopCheck(Loop *L) {
BasicBlock *Latch = L->getLoopLatch(); BasicBlock *Latch = L->getLoopLatch();
if (!Latch) if (!Latch)
return true; return true;
BranchInst *LatchBR = dyn_cast<BranchInst>(Latch->getTerminator()); BranchInst *LatchBR = dyn_cast<BranchInst>(Latch->getTerminator());
if (!LatchBR || LatchBR->getNumSuccessors() != 2 || !L->isLoopExiting(Latch)) if (!LatchBR || LatchBR->getNumSuccessors() != 2 || !L->isLoopExiting(Latch))
▲ Show 20 Lines • Show All 580 Lines • Show Last 20 Lines

llvm/lib/Transforms/Utils/SymbolRewriter.cpp

Show All 34 Lines
// + Transform (pattern transformation) // + Transform (pattern transformation)
// - global alias: (global alias rewriting) // - global alias: (global alias rewriting)
// + Source (original name of the aliased name) // + Source (original name of the aliased name)
// + Target (explicit transformation) // + Target (explicit transformation)
// + Transform (pattern transformation) // + Transform (pattern transformation)
// //
// Note that source and exactly one of [Target, Transform] must be provided // Note that source and exactly one of [Target, Transform] must be provided
// //
// New rewrite descriptors can be created. Addding a new rewrite descriptor // New rewrite descriptors can be created. Adding a new rewrite descriptor
// involves: // involves:
// //
// a) extended the rewrite descriptor kind enumeration // a) extended the rewrite descriptor kind enumeration
// (<anonymous>::RewriteDescriptor::RewriteDescriptorType) // (<anonymous>::RewriteDescriptor::RewriteDescriptorType)
// b) implementing the new descriptor // b) implementing the new descriptor
// (c.f. <anonymous>::ExplicitRewriteFunctionDescriptor) // (c.f. <anonymous>::ExplicitRewriteFunctionDescriptor)
// c) extending the rewrite map parser // c) extending the rewrite map parser
// (<anonymous>::RewriteMapParser::parseEntry) // (<anonymous>::RewriteMapParser::parseEntry)
▲ Show 20 Lines • Show All 535 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 698 Lines • ▼ Show 20 Linesprotected:
Value *TripCount = nullptr; Value *TripCount = nullptr;
/// Trip count of the widened loop (TripCount - TripCount % (VF*UF)) /// Trip count of the widened loop (TripCount - TripCount % (VF*UF))
Value *VectorTripCount = nullptr; Value *VectorTripCount = nullptr;
/// The legality analysis. /// The legality analysis.
LoopVectorizationLegality *Legal; LoopVectorizationLegality *Legal;
/// The profitablity analysis. /// The profitability analysis.
LoopVectorizationCostModel *Cost; LoopVectorizationCostModel *Cost;
// Record whether runtime checks are added. // Record whether runtime checks are added.
bool AddedSafetyChecks = false; bool AddedSafetyChecks = false;
// Holds the end values for each induction variable. We save the end values // Holds the end values for each induction variable. We save the end values
// so we can later fix-up the external users of the induction variables. // so we can later fix-up the external users of the induction variables.
DenseMap<PHINode *, Value *> IVEndValues; DenseMap<PHINode *, Value *> IVEndValues;
▲ Show 20 Lines • Show All 9,848 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 9,392 Lines • ▼ Show 20 Lines for (ScheduleData *BundleMember = SD; BundleMember;
ScheduleData *DestBundle = DepDest->FirstInBundle; ScheduleData *DestBundle = DepDest->FirstInBundle;
if (!DestBundle->IsScheduled) if (!DestBundle->IsScheduled)
BundleMember->incrementUnscheduledDeps(1); BundleMember->incrementUnscheduledDeps(1);
if (!DestBundle->hasValidDependencies()) if (!DestBundle->hasValidDependencies())
WorkList.push_back(DestBundle); WorkList.push_back(DestBundle);
}; };
// Any instruction which isn't safe to speculate at the begining of the // Any instruction which isn't safe to speculate at the begining of the
// block is control dependend on any early exit or non-willreturn call // block is control dependent on any early exit or non-willreturn call
// which proceeds it. // which proceeds it.
if (!isGuaranteedToTransferExecutionToSuccessor(BundleMember->Inst)) { if (!isGuaranteedToTransferExecutionToSuccessor(BundleMember->Inst)) {
for (Instruction *I = BundleMember->Inst->getNextNode(); for (Instruction *I = BundleMember->Inst->getNextNode();
I != ScheduleEnd; I = I->getNextNode()) { I != ScheduleEnd; I = I->getNextNode()) {
if (isSafeToSpeculativelyExecute(I, &*BB->begin())) if (isSafeToSpeculativelyExecute(I, &*BB->begin()))
continue; continue;
// Add the dependency // Add the dependency
Show All 11 Lines for (ScheduleData *BundleMember = SD; BundleMember;
// from reordering above a preceeding stackrestore. // from reordering above a preceeding stackrestore.
if (match(BundleMember->Inst, m_Intrinsic<Intrinsic::stacksave>()) || if (match(BundleMember->Inst, m_Intrinsic<Intrinsic::stacksave>()) ||
match(BundleMember->Inst, m_Intrinsic<Intrinsic::stackrestore>())) { match(BundleMember->Inst, m_Intrinsic<Intrinsic::stackrestore>())) {
for (Instruction *I = BundleMember->Inst->getNextNode(); for (Instruction *I = BundleMember->Inst->getNextNode();
I != ScheduleEnd; I = I->getNextNode()) { I != ScheduleEnd; I = I->getNextNode()) {
if (match(I, m_Intrinsic<Intrinsic::stacksave>()) || if (match(I, m_Intrinsic<Intrinsic::stacksave>()) ||
match(I, m_Intrinsic<Intrinsic::stackrestore>())) match(I, m_Intrinsic<Intrinsic::stackrestore>()))
// Any allocas past here must be control dependent on I, and I // Any allocas past here must be control dependent on I, and I
// must be memory dependend on BundleMember->Inst. // must be memory dependent on BundleMember->Inst.
break; break;
if (!isa<AllocaInst>(I)) if (!isa<AllocaInst>(I))
continue; continue;
// Add the dependency // Add the dependency
makeControlDependent(I); makeControlDependent(I);
} }
▲ Show 20 Lines • Show All 3,038 Lines • Show Last 20 Lines

llvm/lib/Transforms/Vectorize/VPRecipeBuilder.h

Show All 28 Linesclass VPRecipeBuilder {
Loop *OrigLoop; Loop *OrigLoop;
/// Target Library Info. /// Target Library Info.
const TargetLibraryInfo *TLI; const TargetLibraryInfo *TLI;
/// The legality analysis. /// The legality analysis.
LoopVectorizationLegality *Legal; LoopVectorizationLegality *Legal;
/// The profitablity analysis. /// The profitability analysis.
LoopVectorizationCostModel &CM; LoopVectorizationCostModel &CM;
PredicatedScalarEvolution &PSE; PredicatedScalarEvolution &PSE;
VPBuilder &Builder; VPBuilder &Builder;
/// When we if-convert we need to create edge masks. We have to cache values /// When we if-convert we need to create edge masks. We have to cache values
/// so that we don't end up with exponential recursion/IR. Note that /// so that we don't end up with exponential recursion/IR. Note that
▲ Show 20 Lines • Show All 135 Lines • Show Last 20 Lines

llvm/lib/Transforms/Vectorize/VPlan.h

Show First 20 Lines • Show All 1,493 Lines • ▼ Show 20 Lines return Op == getAddr() && all_of(getStoredValues(), [Op](VPValue *StoredV) {
}); });
} }
}; };
/// A recipe to represent inloop reduction operations, performing a reduction on /// A recipe to represent inloop reduction operations, performing a reduction on
/// a vector operand into a scalar value, and adding the result to a chain. /// a vector operand into a scalar value, and adding the result to a chain.
/// The Operands are {ChainOp, VecOp, [Condition]}. /// The Operands are {ChainOp, VecOp, [Condition]}.
class VPReductionRecipe : public VPRecipeBase, public VPValue { class VPReductionRecipe : public VPRecipeBase, public VPValue {
/// The recurrence decriptor for the reduction in question. /// The recurrence descriptor for the reduction in question.
const RecurrenceDescriptor *RdxDesc; const RecurrenceDescriptor *RdxDesc;
/// Pointer to the TTI, needed to create the target reduction /// Pointer to the TTI, needed to create the target reduction
const TargetTransformInfo *TTI; const TargetTransformInfo *TTI;
public: public:
VPReductionRecipe(const RecurrenceDescriptor *R, Instruction *I, VPReductionRecipe(const RecurrenceDescriptor *R, Instruction *I,
VPValue *ChainOp, VPValue *VecOp, VPValue *CondOp, VPValue *ChainOp, VPValue *VecOp, VPValue *CondOp,
const TargetTransformInfo *TTI) const TargetTransformInfo *TTI)
▲ Show 20 Lines • Show All 1,558 Lines • Show Last 20 Lines

llvm/test/Analysis/BasicAA/modref.ll

Show First 20 Lines • Show All 188 Lines • ▼ Show 20 Lines
; ;
%V1 = load i32, i32* %P %V1 = load i32, i32* %P
call i32 @func_argmemonly(i32* %P2) call i32 @func_argmemonly(i32* %P2)
%V2 = load i32, i32* %P %V2 = load i32, i32* %P
%Diff = sub i32 %V1, %V2 %Diff = sub i32 %V1, %V2
ret i32 %Diff ret i32 %Diff
} }
;; In this case load can *not* be removed. Function clobers only %P2 but it may ;; In this case load can *not* be removed. Function clobbers only %P2 but it may
;; alias with %P. ;; alias with %P.
define i32 @test10(i32* %P, i32* %P2) { define i32 @test10(i32* %P, i32* %P2) {
; CHECK-LABEL: @test10( ; CHECK-LABEL: @test10(
; CHECK-NEXT: [[V1:%.*]] = load i32, i32* [[P:%.*]], align 4 ; CHECK-NEXT: [[V1:%.*]] = load i32, i32* [[P:%.*]], align 4
; CHECK-NEXT: [[TMP1:%.*]] = call i32 @func_argmemonly(i32* [[P2:%.*]]) ; CHECK-NEXT: [[TMP1:%.*]] = call i32 @func_argmemonly(i32* [[P2:%.*]])
; CHECK-NEXT: [[V2:%.*]] = load i32, i32* [[P]], align 4 ; CHECK-NEXT: [[V2:%.*]] = load i32, i32* [[P]], align 4
; CHECK-NEXT: [[DIFF:%.*]] = sub i32 [[V1]], [[V2]] ; CHECK-NEXT: [[DIFF:%.*]] = sub i32 [[V1]], [[V2]]
; CHECK-NEXT: ret i32 [[DIFF]] ; CHECK-NEXT: ret i32 [[DIFF]]
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

llvm/test/Analysis/DependenceAnalysis/SimpleSIVNoValidityCheckFixedSize.ll

; RUN: opt < %s -disable-output -passes="print<da>" 2>&1 | FileCheck %s ; RUN: opt < %s -disable-output -passes="print<da>" 2>&1 | FileCheck %s
; Note: exact results can be achived even if ; Note: exact results can be achieved even if
; "-da-disable-delinearization-checks" is not used ; "-da-disable-delinearization-checks" is not used
; CHECK-LABEL: t1 ; CHECK-LABEL: t1
; CHECK: da analyze - none! ; CHECK: da analyze - none!
; CHECK: da analyze - consistent anti [1 -2]! ; CHECK: da analyze - consistent anti [1 -2]!
; CHECK: da analyze - none! ; CHECK: da analyze - none!
;; #define N 1024 ;; #define N 1024
▲ Show 20 Lines • Show All 149 Lines • Show Last 20 Lines

llvm/test/Analysis/LoopAccessAnalysis/forward-loop-independent.ll

; RUN: opt -passes='print-access-info' -disable-output < %s 2>&1 | FileCheck %s ; RUN: opt -passes='print-access-info' -disable-output < %s 2>&1 | FileCheck %s
; Check that loop-indepedent forward dependences are discovered properly. ; Check that loop-independent forward dependences are discovered properly.
; ;
; FIXME: This does not actually always work which is pretty confusing. Right ; FIXME: This does not actually always work which is pretty confusing. Right
; now there is hack in LAA that tries to figure out loop-indepedent forward ; now there is hack in LAA that tries to figure out loop-independent forward
; dependeces *outside* of the MemoryDepChecker logic (i.e. proper dependence ; dependencies *outside* of the MemoryDepChecker logic (i.e. proper dependence
; analysis). ; analysis).
; ;
; Therefore if there is only loop-independent dependences for an array ; Therefore if there is only loop-independent dependences for an array
; (i.e. the same index is used), we don't discover the forward dependence. ; (i.e. the same index is used), we don't discover the forward dependence.
; So, at ***, we add another non-I-based access of A to trigger ; So, at ***, we add another non-I-based access of A to trigger
; MemoryDepChecker analysis for accesses of A. ; MemoryDepChecker analysis for accesses of A.
; ;
; for (unsigned i = 0; i < 100; i++) { ; for (unsigned i = 0; i < 100; i++) {
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

llvm/test/Analysis/LoopAccessAnalysis/stride-access-dependence.ll

Show First 20 Lines • Show All 102 Lines • ▼ Show 20 Linesfor.body: ; preds = %entry, %for.body
%arrayidx3 = getelementptr inbounds i32, i32* %A, i64 %1 %arrayidx3 = getelementptr inbounds i32, i32* %A, i64 %1
%2 = trunc i64 %1 to i32 %2 = trunc i64 %1 to i32
store i32 %2, i32* %arrayidx3, align 4 store i32 %2, i32* %arrayidx3, align 4
%indvars.iv.next = add nuw nsw i64 %indvars.iv, 2 %indvars.iv.next = add nuw nsw i64 %indvars.iv, 2
%cmp = icmp ult i64 %indvars.iv.next, 1024 %cmp = icmp ult i64 %indvars.iv.next, 1024
br i1 %cmp, label %for.body, label %for.cond.cleanup br i1 %cmp, label %for.body, label %for.cond.cleanup
} }
; Following cases are unsafe depdences and are not vectorizable. ; Following cases are unsafe dependencies and are not vectorizable.
; void unsafe_Read_Write(int *A) { ; void unsafe_Read_Write(int *A) {
; for (unsigned i = 0; i < 1024; i+=3) ; for (unsigned i = 0; i < 1024; i+=3)
; A[i+3] = A[i] + 1; ; A[i+3] = A[i] + 1;
; } ; }
; CHECK: function 'unsafe_Read_Write': ; CHECK: function 'unsafe_Read_Write':
; CHECK-NEXT: for.body: ; CHECK-NEXT: for.body:
▲ Show 20 Lines • Show All 428 Lines • Show Last 20 Lines

llvm/test/BugPoint/metadata.ll

; REQUIRES: plugins ; REQUIRES: plugins
; RUN: bugpoint -load %llvmshlibdir/BugpointPasses%pluginext %s -output-prefix %t -bugpoint-crashcalls -silence-passes -disable-namedmd-remove -disable-strip-debuginfo -disable-strip-debug-types > /dev/null ; RUN: bugpoint -load %llvmshlibdir/BugpointPasses%pluginext %s -output-prefix %t -bugpoint-crashcalls -silence-passes -disable-namedmd-remove -disable-strip-debuginfo -disable-strip-debug-types > /dev/null
; RUN: llvm-dis %t-reduced-simplified.bc -o - | FileCheck %s ; RUN: llvm-dis %t-reduced-simplified.bc -o - | FileCheck %s
; ;
; RUN: bugpoint -load %llvmshlibdir/BugpointPasses%pluginext %s -output-prefix %t-nodebug -bugpoint-crashcalls -silence-passes -disable-namedmd-remove > /dev/null ; RUN: bugpoint -load %llvmshlibdir/BugpointPasses%pluginext %s -output-prefix %t-nodebug -bugpoint-crashcalls -silence-passes -disable-namedmd-remove > /dev/null
; RUN: llvm-dis %t-nodebug-reduced-simplified.bc -o - | FileCheck %s --check-prefix=NODEBUG ; RUN: llvm-dis %t-nodebug-reduced-simplified.bc -o - | FileCheck %s --check-prefix=NODEBUG
; ;
; RUN: bugpoint -load %llvmshlibdir/BugpointPasses%pluginext %s -output-prefix %t-notype -bugpoint-crashcalls -silence-passes -disable-namedmd-remove -disable-strip-debuginfo > /dev/null ; RUN: bugpoint -load %llvmshlibdir/BugpointPasses%pluginext %s -output-prefix %t-notype -bugpoint-crashcalls -silence-passes -disable-namedmd-remove -disable-strip-debuginfo > /dev/null
; RUN: llvm-dis %t-notype-reduced-simplified.bc -o - | FileCheck %s --check-prefix=NOTYPE ; RUN: llvm-dis %t-notype-reduced-simplified.bc -o - | FileCheck %s --check-prefix=NOTYPE
; ;
; Bugpoint can drop the metadata on the call, as it does not contrinute to the crash. ; Bugpoint can drop the metadata on the call, as it does not contribute to the crash.
; CHECK: call void @foo() ; CHECK: call void @foo()
; NODEBUG: call void @foo() ; NODEBUG: call void @foo()
; NOTYPE: call void @foo() ; NOTYPE: call void @foo()
; NODEBUG-NOT: call void @foo() ; NODEBUG-NOT: call void @foo()
; NOTYPE-NOT: !DIBasicType ; NOTYPE-NOT: !DIBasicType
; NOTYPE: !DICompileUnit ; NOTYPE: !DICompileUnit
; NOTYPE-NOT: !DIBasicType ; NOTYPE-NOT: !DIBasicType
Show All 35 Lines

llvm/test/CodeGen/AArch64/argument-blocks-array-of-struct.ll

Show First 20 Lines • Show All 266 Lines • ▼ Show 20 Lines
; CHECK-NEXT: movi d1, #0000000000000000 ; CHECK-NEXT: movi d1, #0000000000000000
; CHECK-NEXT: movi d2, #0000000000000000 ; CHECK-NEXT: movi d2, #0000000000000000
; CHECK-NEXT: movi d3, #0000000000000000 ; CHECK-NEXT: movi d3, #0000000000000000
; CHECK-NEXT: ret ; CHECK-NEXT: ret
ret [ 2 x %T_STRUCT_ARRAYM ] zeroinitializer ret [ 2 x %T_STRUCT_ARRAYM ] zeroinitializer
} }
;; All non-aggregate fields must have the same type, all through the ;; All non-aggregate fields must have the same type, all through the
;; overall aggreagate. This is false here because of the i32. ;; overall aggregate. This is false here because of the i32.
%T_NESTED_STRUCT_DIFFM = type { %T_NESTED_STRUCT_DIFFM = type {
[ 1 x { { double, double } } ], [ 1 x { { double, double } } ],
[ 1 x { { double, i32 } } ] [ 1 x { { double, i32 } } ]
}; };
define %T_NESTED_STRUCT_DIFFM @struct_nested_different_field_types() { define %T_NESTED_STRUCT_DIFFM @struct_nested_different_field_types() {
; CHECK-LABEL: struct_nested_different_field_types: ; CHECK-LABEL: struct_nested_different_field_types:
; CHECK: // %bb.0: ; CHECK: // %bb.0:
▲ Show 20 Lines • Show All 303 Lines • Show Last 20 Lines

llvm/test/CodeGen/AArch64/arm64-misched-basic-A57.ll

; REQUIRES: asserts ; REQUIRES: asserts
; ;
; The Cortext-A57 machine model will avoid scheduling load instructions in ; The Cortex-A57 machine model will avoid scheduling load instructions in
; succession because loads on the A57 have a latency of 4 cycles and they all ; succession because loads on the A57 have a latency of 4 cycles and they all
; issue to the same pipeline. Instead, it will move other instructions between ; issue to the same pipeline. Instead, it will move other instructions between
; the loads to avoid unnecessary stalls. The generic machine model schedules 4 ; the loads to avoid unnecessary stalls. The generic machine model schedules 4
; loads consecutively for this case and will cause stalls. ; loads consecutively for this case and will cause stalls.
; ;
; RUN: llc < %s -mtriple=arm64-linux-gnu -mcpu=cortex-a57 -enable-misched -verify-misched -debug-only=machine-scheduler -o - 2>&1 > /dev/null | FileCheck %s ; RUN: llc < %s -mtriple=arm64-linux-gnu -mcpu=cortex-a57 -enable-misched -verify-misched -debug-only=machine-scheduler -o - 2>&1 > /dev/null | FileCheck %s
; CHECK: ********** MI Scheduling ********** ; CHECK: ********** MI Scheduling **********
; CHECK: main:%bb.2 ; CHECK: main:%bb.2
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

llvm/test/CodeGen/AArch64/ccmp-successor-probs.mir

# RUN: llc -o - %s -mtriple=aarch64--linux-gnu -mcpu=falkor -run-pass=aarch64-ccmp | FileCheck %s # RUN: llc -o - %s -mtriple=aarch64--linux-gnu -mcpu=falkor -run-pass=aarch64-ccmp | FileCheck %s
--- ---
# This test checks that successor probabilties are properly updated after a # This test checks that successor probabilities are properly updated after a
# ccmp-conversion. # ccmp-conversion.
# #
# CHECK-LABEL: name: aarch64-ccmp-successor-probs # CHECK-LABEL: name: aarch64-ccmp-successor-probs
# CHECK: bb.0: # CHECK: bb.0:
# CHECK-NEXT: successors: %bb.2(0x04000000), %bb.3(0x7c000000) # CHECK-NEXT: successors: %bb.2(0x04000000), %bb.3(0x7c000000)
# CHECK: CCMPXr %5, %4, 0, 10, implicit-def $nzcv, implicit $nzcv # CHECK: CCMPXr %5, %4, 0, 10, implicit-def $nzcv, implicit $nzcv
# #
name: aarch64-ccmp-successor-probs name: aarch64-ccmp-successor-probs
Show All 35 Lines

llvm/test/CodeGen/AArch64/ifcvt-select.ll

; RUN: llc -mtriple=arm64-apple-ios -mcpu=cyclone < %s | FileCheck %s ; RUN: llc -mtriple=arm64-apple-ios -mcpu=cyclone < %s | FileCheck %s
; Do not generate redundant select in early if-converstion pass. ; Do not generate redundant select in early if-conversion pass.
define i32 @foo(i32 %a, i32 %b) { define i32 @foo(i32 %a, i32 %b) {
entry: entry:
;CHECK-LABEL: foo: ;CHECK-LABEL: foo:
;CHECK: csinc ;CHECK: csinc
;CHECK-NOT: csel ;CHECK-NOT: csel
%sub = sub nsw i32 %b, %a %sub = sub nsw i32 %b, %a
%cmp10 = icmp sgt i32 %a, 0 %cmp10 = icmp sgt i32 %a, 0
Show All 31 Lines

llvm/test/CodeGen/AArch64/swift-async-win.ll

Show All 31 Linesentryresume.0:
%7 = bitcast i8* %6 to void (%swift.context*)** %7 = bitcast i8* %6 to void (%swift.context*)**
%8 = load void (%swift.context*)*, void (%swift.context*)** %7, align 8 %8 = load void (%swift.context*)*, void (%swift.context*)** %7, align 8
%9 = bitcast i8* %5 to %swift.context* %9 = bitcast i8* %5 to %swift.context*
musttail call swifttailcc void %8(%swift.context* %9) #4 musttail call swifttailcc void %8(%swift.context* %9) #4
ret void ret void
} }
; NOTE: we do not see the canonical windows frame setup due to the `nounwind` ; NOTE: we do not see the canonical windows frame setup due to the `nounwind`
; attribtue on the function. ; attribute on the function.
; CHECK: sub sp, sp, #64 ; CHECK: sub sp, sp, #64
; CHECK: stp x30, x29, [sp, #16] ; CHECK: stp x30, x29, [sp, #16]
; CHECK: add x29, sp, #16 ; CHECK: add x29, sp, #16
; CHECK: stp x22, x21, [sp, #32] ; CHECK: stp x22, x21, [sp, #32]
; CHECK: sub x8, x29, #8 ; CHECK: sub x8, x29, #8
; CHECK: stp x20, x19, [sp, #48] ; CHECK: stp x20, x19, [sp, #48]
; CHECK: ldr x9, [x0] ; CHECK: ldr x9, [x0]
Show All 14 Lines

llvm/test/CodeGen/AArch64/tailcall_misched_graph.ll

Show All 31 Lines
; COMMON: [[VRA:%.*]]:gpr64 = LDRXui %fixed-stack.3 ; COMMON: [[VRA:%.*]]:gpr64 = LDRXui %fixed-stack.3
; COMMON: [[VRB:%.*]]:gpr64 = LDRXui %fixed-stack.2 ; COMMON: [[VRB:%.*]]:gpr64 = LDRXui %fixed-stack.2
; SDAG: STRXui %{{.*}}, %fixed-stack.0 ; SDAG: STRXui %{{.*}}, %fixed-stack.0
; SDAG: STRXui [[VRB]]{{[^,]*}}, %fixed-stack.1 ; SDAG: STRXui [[VRB]]{{[^,]*}}, %fixed-stack.1
; GISEL: STRXui [[VRB]]{{[^,]*}}, %fixed-stack.1 ; GISEL: STRXui [[VRB]]{{[^,]*}}, %fixed-stack.1
; GISEL: STRXui %{{.*}}, %fixed-stack.0 ; GISEL: STRXui %{{.*}}, %fixed-stack.0
; Make sure that there is an dependence edge between fi#-2 and fi#-4. ; Make sure that there is an dependence edge between fi#-2 and fi#-4.
; Without this edge the scheduler would be free to move the store accross the load. ; Without this edge the scheduler would be free to move the store across the load.
; COMMON: {{^SU(.*)}}: [[VRB]]:gpr64 = LDRXui %fixed-stack.2 ; COMMON: {{^SU(.*)}}: [[VRB]]:gpr64 = LDRXui %fixed-stack.2
; COMMON-NOT: {{^SU(.*)}}: ; COMMON-NOT: {{^SU(.*)}}:
; COMMON: Successors: ; COMMON: Successors:
; COMMON: SU([[DEPSTOREB:.*]]): Ord Latency=0 ; COMMON: SU([[DEPSTOREB:.*]]): Ord Latency=0
; COMMON: SU([[DEPSTOREA:.*]]): Ord Latency=0 ; COMMON: SU([[DEPSTOREA:.*]]): Ord Latency=0
; GlobalISel outputs DEPSTOREB before DEPSTOREA, but the dependency relationship ; GlobalISel outputs DEPSTOREB before DEPSTOREA, but the dependency relationship
; still holds. ; still holds.
; SDAG: SU([[DEPSTOREA]]): STRXui %{{.*}}, %fixed-stack.0 ; SDAG: SU([[DEPSTOREA]]): STRXui %{{.*}}, %fixed-stack.0
; SDAG: SU([[DEPSTOREB]]): STRXui %{{.*}}, %fixed-stack.1 ; SDAG: SU([[DEPSTOREB]]): STRXui %{{.*}}, %fixed-stack.1
; GISEL: SU([[DEPSTOREB]]): STRXui %{{.*}}, %fixed-stack.0 ; GISEL: SU([[DEPSTOREB]]): STRXui %{{.*}}, %fixed-stack.0
; GISEL: SU([[DEPSTOREA]]): STRXui %{{.*}}, %fixed-stack.1 ; GISEL: SU([[DEPSTOREA]]): STRXui %{{.*}}, %fixed-stack.1

llvm/test/CodeGen/AMDGPU/GlobalISel/irtranslator-fast-math-flags.ll

Show All 12 Lines
; CHECK-LABEL: name: fma_fast ; CHECK-LABEL: name: fma_fast
; CHECK: nnan ninf nsz arcp contract afn reassoc G_FMA ; CHECK: nnan ninf nsz arcp contract afn reassoc G_FMA
define amdgpu_kernel void @fma_fast(float %arg0, float %arg1, float %arg2) { define amdgpu_kernel void @fma_fast(float %arg0, float %arg1, float %arg2) {
%res = call fast float @llvm.fma.f32(float %arg0, float %arg1, float %arg2) %res = call fast float @llvm.fma.f32(float %arg0, float %arg1, float %arg2)
store float %res, float addrspace(1)* undef store float %res, float addrspace(1)* undef
ret void ret void
} }
; Check flags are preserved for an arbitrarry target intrinsic ; Check flags are preserved for an arbitrary target intrinsic
; CHECK-LABEL: name: rcp_nsz ; CHECK-LABEL: name: rcp_nsz
; CHECK: = nsz G_INTRINSIC intrinsic(@llvm.amdgcn.rcp), %{{[0-9]+}}(s32) ; CHECK: = nsz G_INTRINSIC intrinsic(@llvm.amdgcn.rcp), %{{[0-9]+}}(s32)
define amdgpu_kernel void @rcp_nsz(float %arg0) { define amdgpu_kernel void @rcp_nsz(float %arg0) {
%res = call nsz float @llvm.amdgcn.rcp.f32 (float %arg0) %res = call nsz float @llvm.amdgcn.rcp.f32 (float %arg0)
store float %res, float addrspace(1)* undef store float %res, float addrspace(1)* undef
ret void ret void
} }
declare float @llvm.fma.f32(float, float, float) declare float @llvm.fma.f32(float, float, float)
declare float @llvm.amdgcn.rcp.f32(float) declare float @llvm.amdgcn.rcp.f32(float)

llvm/test/CodeGen/AMDGPU/collapse-endcf.mir

# NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py # NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py
# RUN: llc -march=amdgcn -verify-machineinstrs -run-pass=si-lower-control-flow -amdgpu-remove-redundant-endcf %s -o - | FileCheck -check-prefix=GCN %s # RUN: llc -march=amdgcn -verify-machineinstrs -run-pass=si-lower-control-flow -amdgpu-remove-redundant-endcf %s -o - | FileCheck -check-prefix=GCN %s
# Make sure dbg_value doesn't change codeegn when collapsing end_cf # Make sure dbg_value doesn't change codegen when collapsing end_cf
--- ---
name: simple_nested_if_dbg_value name: simple_nested_if_dbg_value
tracksRegLiveness: true tracksRegLiveness: true
machineFunctionInfo: machineFunctionInfo:
isEntryFunction: true isEntryFunction: true
body: | body: |
; GCN-LABEL: name: simple_nested_if_dbg_value ; GCN-LABEL: name: simple_nested_if_dbg_value
; GCN: bb.0: ; GCN: bb.0:
▲ Show 20 Lines • Show All 1,014 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/idot4u.ll

Show First 20 Lines • Show All 880 Lines • ▼ Show 20 Linesentry:
%mad2 = add i8 %mul2, %mad1 %mad2 = add i8 %mul2, %mad1
%mad3 = add i8 %mul3, %mad2 %mad3 = add i8 %mul3, %mad2
%mad4 = add i8 %mul4, %mad3 %mad4 = add i8 %mul4, %mad3
store i8 %mad4, i8 addrspace(1)* %dst, align 2 store i8 %mad4, i8 addrspace(1)* %dst, align 2
ret void ret void
} }
; TODO: Support commutation accross the adds. ; TODO: Support commutation across the adds.
define amdgpu_kernel void @udot4_CommutationAccrossMADs(<4 x i8> addrspace(1)* %src1, define amdgpu_kernel void @udot4_CommutationAccrossMADs(<4 x i8> addrspace(1)* %src1,
; GFX7-LABEL: udot4_CommutationAccrossMADs: ; GFX7-LABEL: udot4_CommutationAccrossMADs:
; GFX7: ; %bb.0: ; %entry ; GFX7: ; %bb.0: ; %entry
; GFX7-NEXT: s_load_dwordx4 s[4:7], s[0:1], 0x9 ; GFX7-NEXT: s_load_dwordx4 s[4:7], s[0:1], 0x9
; GFX7-NEXT: s_load_dwordx2 s[0:1], s[0:1], 0xd ; GFX7-NEXT: s_load_dwordx2 s[0:1], s[0:1], 0xd
; GFX7-NEXT: s_mov_b32 s3, 0xf000 ; GFX7-NEXT: s_mov_b32 s3, 0xf000
; GFX7-NEXT: s_mov_b32 s10, 0 ; GFX7-NEXT: s_mov_b32 s10, 0
; GFX7-NEXT: s_mov_b32 s11, s3 ; GFX7-NEXT: s_mov_b32 s11, s3
▲ Show 20 Lines • Show All 1,346 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/idot8u.ll

Show First 20 Lines • Show All 2,805 Lines • ▼ Show 20 Linesentry:
%add6 = add i8 %add5, %mul5 %add6 = add i8 %add5, %mul5
%add7 = add i8 %add6, %mul6 %add7 = add i8 %add6, %mul6
%add8 = add i8 %add7, %mul7 %add8 = add i8 %add7, %mul7
store i8 %add8, i8 addrspace(1)* %dst, align 4 store i8 %add8, i8 addrspace(1)* %dst, align 4
ret void ret void
} }
; TODO: Once the adictional "and+add" are removed, the pattern will be recognized. ; TODO: Once the additional "and+add" are removed, the pattern will be recognized.
define amdgpu_kernel void @udot8_acc4_vecMul(<8 x i4> addrspace(1)* %src1, define amdgpu_kernel void @udot8_acc4_vecMul(<8 x i4> addrspace(1)* %src1,
; GFX7-LABEL: udot8_acc4_vecMul: ; GFX7-LABEL: udot8_acc4_vecMul:
; GFX7: ; %bb.0: ; %entry ; GFX7: ; %bb.0: ; %entry
; GFX7-NEXT: s_mov_b32 s12, SCRATCH_RSRC_DWORD0 ; GFX7-NEXT: s_mov_b32 s12, SCRATCH_RSRC_DWORD0
; GFX7-NEXT: s_mov_b32 s13, SCRATCH_RSRC_DWORD1 ; GFX7-NEXT: s_mov_b32 s13, SCRATCH_RSRC_DWORD1
; GFX7-NEXT: s_load_dwordx4 s[4:7], s[0:1], 0x9 ; GFX7-NEXT: s_load_dwordx4 s[4:7], s[0:1], 0x9
; GFX7-NEXT: s_load_dwordx2 s[0:1], s[0:1], 0xd ; GFX7-NEXT: s_load_dwordx2 s[0:1], s[0:1], 0xd
; GFX7-NEXT: s_mov_b32 s14, -1 ; GFX7-NEXT: s_mov_b32 s14, -1
▲ Show 20 Lines • Show All 572 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/indirect-addressing-si.ll

Show First 20 Lines • Show All 416 Lines • ▼ Show 20 Linesbb:
%tmp6 = extractelement <9 x i32> %tmp5, i32 1 %tmp6 = extractelement <9 x i32> %tmp5, i32 1
%tmp7 = bitcast <9 x float> %tmp4 to <9 x i32> %tmp7 = bitcast <9 x float> %tmp4 to <9 x i32>
%tmp8 = extractelement <9 x i32> %tmp7, i32 5 %tmp8 = extractelement <9 x i32> %tmp7, i32 5
store volatile i32 %tmp6, i32 addrspace(3)* undef, align 4 store volatile i32 %tmp6, i32 addrspace(3)* undef, align 4
store volatile i32 %tmp8, i32 addrspace(3)* undef, align 4 store volatile i32 %tmp8, i32 addrspace(3)* undef, align 4
ret void ret void
} }
; offset puts outside of superegister bounaries, so clamp to 1st element. ; offset puts outside of superegister boundaries, so clamp to 1st element.
; GCN-LABEL: {{^}}extract_largest_inbounds_offset: ; GCN-LABEL: {{^}}extract_largest_inbounds_offset:
; GCN-DAG: buffer_load_dwordx4 v[[[LO_ELT:[0-9]+]]:[[HI_ELT:[0-9]+]] ; GCN-DAG: buffer_load_dwordx4 v[[[LO_ELT:[0-9]+]]:[[HI_ELT:[0-9]+]]
; GCN-DAG: s_load_dword [[IDX0:s[0-9]+]] ; GCN-DAG: s_load_dword [[IDX0:s[0-9]+]]
; GCN-DAG: s_add_i32 [[IDX:s[0-9]+]], [[IDX0]], 15 ; GCN-DAG: s_add_i32 [[IDX:s[0-9]+]], [[IDX0]], 15
; MOVREL: s_mov_b32 m0, [[IDX]] ; MOVREL: s_mov_b32 m0, [[IDX]]
; MOVREL: v_movrels_b32_e32 [[EXTRACT:v[0-9]+]], v[[LO_ELT]] ; MOVREL: v_movrels_b32_e32 [[EXTRACT:v[0-9]+]], v[[LO_ELT]]
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/insert-delay-alu.mir

Show First 20 Lines • Show All 189 Lines • ▼ Show 20 Lines bb.0:
; CHECK-NEXT: v_add_nc_u32_e32 v1, v1, v1 ; CHECK-NEXT: v_add_nc_u32_e32 v1, v1, v1
; CHECK-NEXT: s_delay_alu instid0(TRANS32_DEP_1) | instid1(VALU_DEP_1) ; CHECK-NEXT: s_delay_alu instid0(TRANS32_DEP_1) | instid1(VALU_DEP_1)
; CHECK-NEXT: v_add_nc_u32_e32 v0, v0, v1 ; CHECK-NEXT: v_add_nc_u32_e32 v0, v0, v1
$vgpr0 = V_EXP_F32_e32 $vgpr0, implicit $exec, implicit $mode $vgpr0 = V_EXP_F32_e32 $vgpr0, implicit $exec, implicit $mode
$vgpr1 = V_ADD_U32_e32 $vgpr1, $vgpr1, implicit $exec $vgpr1 = V_ADD_U32_e32 $vgpr1, $vgpr1, implicit $exec
$vgpr0 = V_ADD_U32_e32 $vgpr0, $vgpr1, implicit $exec $vgpr0 = V_ADD_U32_e32 $vgpr0, $vgpr1, implicit $exec
... ...
# There's no need to encode the VALU depdendency because it will complete before # There's no need to encode the VALU dependency because it will complete before
# the TRANS. # the TRANS.
--- ---
name: trans32_dep_1_only name: trans32_dep_1_only
body: | body: |
bb.0: bb.0:
; CHECK-LABEL: {{^}}trans32_dep_1_only: ; CHECK-LABEL: {{^}}trans32_dep_1_only:
; CHECK: %bb.0: ; CHECK: %bb.0:
; CHECK-NEXT: v_add_nc_u32_e32 v0, v0, v0 ; CHECK-NEXT: v_add_nc_u32_e32 v0, v0, v0
▲ Show 20 Lines • Show All 355 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/remaining-virtual-register-operands.ll

; RUN: not --crash llc -mtriple=amdgcn-amd-amdhsa -mcpu=gfx908 -verify-machineinstrs < %s 2>&1 | FileCheck %s ; RUN: not --crash llc -mtriple=amdgcn-amd-amdhsa -mcpu=gfx908 -verify-machineinstrs < %s 2>&1 | FileCheck %s
; This testcase fails register allocation at the same time it performs ; This testcase fails register allocation at the same time it performs
; virtual register splitting (by introducing VGPR to AGPR copies). We ; virtual register splitting (by introducing VGPR to AGPR copies). We
; still need to enqueue and allocate the newly split vregs after the ; still need to enqueue and allocate the newly split vregs after the
; failure. ; failure.
; The machine verifier complains about usage of register ; The machine verifier complains about usage of register
; which is marked as killed in previous instruction. ; which is marked as killed in previous instruction.
; This happens due to when register allocator is out of registers ; This happens due to when register allocator is out of registers
; it takes the first avialable register. ; it takes the first available register.
; CHECK: error: ran out of registers during register allocation ; CHECK: error: ran out of registers during register allocation
; CHECK: Bad machine code: Using an undefined physical register ; CHECK: Bad machine code: Using an undefined physical register
define amdgpu_kernel void @alloc_failure_with_split_vregs(float %v0, float %v1) #0 { define amdgpu_kernel void @alloc_failure_with_split_vregs(float %v0, float %v1) #0 {
%agpr0 = call float asm sideeffect "; def $0", "=${a0}"() %agpr0 = call float asm sideeffect "; def $0", "=${a0}"()
%agpr.vec = insertelement <16 x float> undef, float %agpr0, i32 0 %agpr.vec = insertelement <16 x float> undef, float %agpr0, i32 0
%mfma0 = call <16 x float> @llvm.amdgcn.mfma.f32.16x16x1f32(float %v0, float %v1, <16 x float> %agpr.vec, i32 0, i32 0, i32 0) %mfma0 = call <16 x float> @llvm.amdgcn.mfma.f32.16x16x1f32(float %v0, float %v1, <16 x float> %agpr.vec, i32 0, i32 0, i32 0)
%mfma0.3 = extractelement <16 x float> %mfma0, i32 3 %mfma0.3 = extractelement <16 x float> %mfma0, i32 3
Show All 13 Lines

llvm/test/CodeGen/AMDGPU/schedule-global-loads.ll

Show All 13 Linesdefine amdgpu_kernel void @cluster_global_arg_loads(i32 addrspace(1)* %out0, i32 addrspace(1)* %out1, i32 addrspace(1)* %ptr) #0 {
%load0 = load i32, i32 addrspace(1)* %ptr, align 4 %load0 = load i32, i32 addrspace(1)* %ptr, align 4
%gep = getelementptr i32, i32 addrspace(1)* %ptr, i32 2 %gep = getelementptr i32, i32 addrspace(1)* %ptr, i32 2
%load1 = load i32, i32 addrspace(1)* %gep, align 4 %load1 = load i32, i32 addrspace(1)* %gep, align 4
store i32 %load0, i32 addrspace(1)* %out0, align 4 store i32 %load0, i32 addrspace(1)* %out0, align 4
store i32 %load1, i32 addrspace(1)* %out1, align 4 store i32 %load1, i32 addrspace(1)* %out1, align 4
ret void ret void
} }
; Test for a crach in SIInstrInfo::areLoadsFromSameBasePtr() when checking ; Test for a crash in SIInstrInfo::areLoadsFromSameBasePtr() when checking
; an MUBUF load which does not have a vaddr operand. ; an MUBUF load which does not have a vaddr operand.
; FUNC-LABEL: {{^}}same_base_ptr_crash: ; FUNC-LABEL: {{^}}same_base_ptr_crash:
; SI: buffer_load_dword ; SI: buffer_load_dword
; SI: buffer_load_dword ; SI: buffer_load_dword
define amdgpu_kernel void @same_base_ptr_crash(i32 addrspace(1)* %out, i32 addrspace(1)* %in, i32 %offset) { define amdgpu_kernel void @same_base_ptr_crash(i32 addrspace(1)* %out, i32 addrspace(1)* %in, i32 %offset) {
entry: entry:
%out1 = getelementptr i32, i32 addrspace(1)* %out, i32 %offset %out1 = getelementptr i32, i32 addrspace(1)* %out, i32 %offset
%tmp0 = load i32, i32 addrspace(1)* %out %tmp0 = load i32, i32 addrspace(1)* %out
%tmp1 = load i32, i32 addrspace(1)* %out1 %tmp1 = load i32, i32 addrspace(1)* %out1
%tmp2 = add i32 %tmp0, %tmp1 %tmp2 = add i32 %tmp0, %tmp1
store i32 %tmp2, i32 addrspace(1)* %out store i32 %tmp2, i32 addrspace(1)* %out
ret void ret void
} }
attributes #0 = { nounwind } attributes #0 = { nounwind }
attributes #1 = { nounwind readnone } attributes #1 = { nounwind readnone }

llvm/test/CodeGen/AMDGPU/scratch-buffer.ll

; RUN: llc -amdgpu-scalarize-global-loads=false -verify-machineinstrs -march=amdgcn < %s | FileCheck -enable-var-scope -check-prefix=GCN %s ; RUN: llc -amdgpu-scalarize-global-loads=false -verify-machineinstrs -march=amdgcn < %s | FileCheck -enable-var-scope -check-prefix=GCN %s
; RUN: llc -amdgpu-scalarize-global-loads=false -verify-machineinstrs -march=amdgcn -mcpu=tonga < %s | FileCheck -enable-var-scope -check-prefix=GCN %s ; RUN: llc -amdgpu-scalarize-global-loads=false -verify-machineinstrs -march=amdgcn -mcpu=tonga < %s | FileCheck -enable-var-scope -check-prefix=GCN %s
; When a frame index offset is more than 12-bits, make sure we don't store ; When a frame index offset is more than 12-bits, make sure we don't store
; it in mubuf's offset field. ; it in mubuf's offset field.
; Also, make sure we use the same register for storing the scratch buffer addresss ; Also, make sure we use the same register for storing the scratch buffer address
; for both stores. This register is allocated by the register scavenger, so we ; for both stores. This register is allocated by the register scavenger, so we
; should be able to reuse the same regiser for each scratch buffer access. ; should be able to reuse the same regiser for each scratch buffer access.
; GCN-LABEL: {{^}}legal_offset_fi: ; GCN-LABEL: {{^}}legal_offset_fi:
; GCN: buffer_store_dword v{{[0-9]+}}, off, s[{{[0-9]+}}:{{[0-9]+}}], 0 offset:4{{$}} ; GCN: buffer_store_dword v{{[0-9]+}}, off, s[{{[0-9]+}}:{{[0-9]+}}], 0 offset:4{{$}}
; GCN: v_mov_b32_e32 [[OFFSET:v[0-9]+]], 0x8004 ; GCN: v_mov_b32_e32 [[OFFSET:v[0-9]+]], 0x8004
; GCN: buffer_store_dword v{{[0-9]+}}, [[OFFSET]], s[{{[0-9]+}}:{{[0-9]+}}], 0 offen{{$}} ; GCN: buffer_store_dword v{{[0-9]+}}, [[OFFSET]], s[{{[0-9]+}}:{{[0-9]+}}], 0 offen{{$}}
▲ Show 20 Lines • Show All 108 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/structurize1.ll

; RUN: llc -march=r600 -mcpu=redwood -r600-if-convert=0 < %s | FileCheck %s ; RUN: llc -march=r600 -mcpu=redwood -r600-if-convert=0 < %s | FileCheck %s
; This tests for abug where the AMDILCFGStructurizer was crashing on loops ; This tests for a bug where the AMDILCFGStructurizer was crashing on loops
; like this: ; like this:
; ;
; for (i = 0; i < x; i++) { ; for (i = 0; i < x; i++) {
; if (cond0) { ; if (cond0) {
; if (cond1) { ; if (cond1) {
; ;
; } else { ; } else {
; ;
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/vgpr-tuple-allocation.ll

Show First 20 Lines • Show All 210 Lines • ▼ Show 20 Linesmain_body:
call void asm sideeffect "", "~{v24},~{v25},~{v26},~{v27},~{v28},~{v29},~{v30},~{v31}"() #0 call void asm sideeffect "", "~{v24},~{v25},~{v26},~{v27},~{v28},~{v29},~{v30},~{v31}"() #0
%v = call <4 x float> @llvm.amdgcn.image.gather4.c.b.cl.2d.v4f32.f32.f32(i32 1, float %bias, float %zcompare, float %s, float %t, float %clamp, <8 x i32> undef, <4 x i32> undef, i1 false, i32 0, i32 0) %v = call <4 x float> @llvm.amdgcn.image.gather4.c.b.cl.2d.v4f32.f32.f32(i32 1, float %bias, float %zcompare, float %s, float %t, float %clamp, <8 x i32> undef, <4 x i32> undef, i1 false, i32 0, i32 0)
call void @extern_func() call void @extern_func()
ret <4 x float> %v ret <4 x float> %v
} }
define <4 x float> @call_preserved_vgpr_tuple8(<8 x i32> %rsrc, <4 x i32> %samp, float %bias, float %zcompare, float %s, float %t, float %clamp) { define <4 x float> @call_preserved_vgpr_tuple8(<8 x i32> %rsrc, <4 x i32> %samp, float %bias, float %zcompare, float %s, float %t, float %clamp) {
; The vgpr tuple8 operand in image_gather4_c_b_cl instruction needs to be preserved ; The vgpr tuple8 operand in image_gather4_c_b_cl instruction needs to be preserved
; across the call and should get allcoated to 8 CSRs. ; across the call and should get allocated to 8 CSRs.
; Only the lower 5 sub-registers of the tuple are preserved. ; Only the lower 5 sub-registers of the tuple are preserved.
; The upper 3 sub-registers are unused. ; The upper 3 sub-registers are unused.
; GFX9-LABEL: call_preserved_vgpr_tuple8: ; GFX9-LABEL: call_preserved_vgpr_tuple8:
; GFX9: ; %bb.0: ; %main_body ; GFX9: ; %bb.0: ; %main_body
; GFX9-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX9-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0)
; GFX9-NEXT: s_or_saveexec_b64 s[4:5], -1 ; GFX9-NEXT: s_or_saveexec_b64 s[4:5], -1
; GFX9-NEXT: buffer_store_dword v40, off, s[0:3], s32 offset:20 ; 4-byte Folded Spill ; GFX9-NEXT: buffer_store_dword v40, off, s[0:3], s32 offset:20 ; 4-byte Folded Spill
; GFX9-NEXT: s_mov_b64 exec, s[4:5] ; GFX9-NEXT: s_mov_b64 exec, s[4:5]
▲ Show 20 Lines • Show All 230 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/vtx-schedule.ll

; RUN: llc < %s -march=r600 -mcpu=redwood | FileCheck %s ; RUN: llc < %s -march=r600 -mcpu=redwood | FileCheck %s
; This test is for a scheduler bug where VTX_READ instructions that used ; This test is for a scheduler bug where VTX_READ instructions that used
; the result of another VTX_READ instruction were being grouped in the ; the result of another VTX_READ instruction were being grouped in the
; same fetch clasue. ; same fetch clause.
; CHECK: {{^}}test: ; CHECK: {{^}}test:
; CHECK: Fetch clause ; CHECK: Fetch clause
; CHECK: VTX_READ_32 [[IN0:T[0-9]+\.X]], [[IN0]], 0 ; CHECK: VTX_READ_32 [[IN0:T[0-9]+\.X]], [[IN0]], 0
; CHECK: Fetch clause ; CHECK: Fetch clause
; CHECK: VTX_READ_32 [[IN1:T[0-9]+\.X]], [[IN1]], 0 ; CHECK: VTX_READ_32 [[IN1:T[0-9]+\.X]], [[IN1]], 0
define amdgpu_kernel void @test(i32 addrspace(1)* nocapture %out, i32 addrspace(1)* addrspace(1)* nocapture %in0) { define amdgpu_kernel void @test(i32 addrspace(1)* nocapture %out, i32 addrspace(1)* addrspace(1)* nocapture %in0) {
entry: entry:
%0 = load i32 addrspace(1)*, i32 addrspace(1)* addrspace(1)* %in0 %0 = load i32 addrspace(1)*, i32 addrspace(1)* addrspace(1)* %in0
%1 = load i32, i32 addrspace(1)* %0 %1 = load i32, i32 addrspace(1)* %0
store i32 %1, i32 addrspace(1)* %out store i32 %1, i32 addrspace(1)* %out
ret void ret void
} }

llvm/test/CodeGen/AVR/pseudo/FRMIDX.mir

# RUN: llc -O0 -run-pass=avr-expand-pseudo %s -o - | FileCheck %s # RUN: llc -O0 -run-pass=avr-expand-pseudo %s -o - | FileCheck %s
# TODO: Write this test. # TODO: Write this test.
# This instruction isn't expanded by the pseudo expansion passs, but # This instruction isn't expanded by the pseudo expansion pass, but
# rather AVRRegisterInfo::eliminateFrameIndex. # rather AVRRegisterInfo::eliminateFrameIndex.
--- | --- |
target triple = "avr--" target triple = "avr--"
define void @test() { define void @test() {
entry: entry:
ret void ret void
} }
Show All 14 Lines

llvm/test/CodeGen/Hexagon/fp16.ll

; RUN: llc -march=hexagon < %s | FileCheck %s ; RUN: llc -march=hexagon < %s | FileCheck %s
; This test validates the following facts for half-precision floating point ; This test validates the following facts for half-precision floating point
; conversions. ; conversions.
; Generate correct libcall names for conversion from fp16 to fp32. ; Generate correct libcall names for conversion from fp16 to fp32.
; (__extendhfsf2). ; (__extendhfsf2).
; The extension from fp16 to fp64 is implicitly handled by __extendhfsf2 and convert_sf2d. ; The extension from fp16 to fp64 is implicitly handled by __extendhfsf2 and convert_sf2d.
; (fp16->fp32->fp64). ; (fp16->fp32->fp64).
; Generate correcct libcall names for conversion from fp32/fp64 to fp16 ; Generate correct libcall names for conversion from fp32/fp64 to fp16
; (__truncsfhf2 and __truncdfhf2) ; (__truncsfhf2 and __truncdfhf2)
; Verify that we generate loads and stores of halfword. ; Verify that we generate loads and stores of halfword.
; Validate that we generate correct lib calls to convert fp16 ; Validate that we generate correct lib calls to convert fp16
;CHECK-LABEL: @test1 ;CHECK-LABEL: @test1
;CHECK: call __extendhfsf2 ;CHECK: call __extendhfsf2
;CHECK: r0 = memuh ;CHECK: r0 = memuh
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

llvm/test/CodeGen/Hexagon/swp-epilog-phi7.ll

; RUN: llc -march=hexagon -O2 -enable-pipeliner -disable-block-placement=0 < %s | FileCheck %s ; RUN: llc -march=hexagon -O2 -enable-pipeliner -disable-block-placement=0 < %s | FileCheck %s
; For the Phis generated in the epilog, test that we generate the correct ; For the Phis generated in the epilog, test that we generate the correct
; names for the values coming from the prolog stages. The test belows ; names for the values coming from the prolog stages. The test below
; checks that the value loaded in the first prolog block gets propagated ; checks that the value loaded in the first prolog block gets propagated
; through the first epilog to the use after the loop. ; through the first epilog to the use after the loop.
; CHECK: if ({{.*}}) jump ; CHECK: if ({{.*}}) jump
; CHECK: [[VREG:v([0-9]+)]]{{.*}} = {{.*}}vmem(r{{[0-9]+}}++#1) ; CHECK: [[VREG:v([0-9]+)]]{{.*}} = {{.*}}vmem(r{{[0-9]+}}++#1)
; CHECK: if ({{.*}}) {{jump|jump:nt|jump:t}} [[EPLOG1:(.*)]] ; CHECK: if ({{.*}}) {{jump|jump:nt|jump:t}} [[EPLOG1:(.*)]]
; CHECK: if ({{.*}}) {{jump|jump:nt|jump:t}} [[EPLOG:(.*)]] ; CHECK: if ({{.*}}) {{jump|jump:nt|jump:t}} [[EPLOG:(.*)]]
; CHECK: [[EPLOG]]: ; CHECK: [[EPLOG]]:
▲ Show 20 Lines • Show All 263 Lines • Show Last 20 Lines

llvm/test/CodeGen/Hexagon/swp-listen-loop3.ll

; RUN: llc -march=hexagon -pipeliner-ignore-recmii -pipeliner-max-stages=2 -enable-pipeliner < %s -pipeliner-experimental-cg=true | FileCheck %s ; RUN: llc -march=hexagon -pipeliner-ignore-recmii -pipeliner-max-stages=2 -enable-pipeliner < %s -pipeliner-experimental-cg=true | FileCheck %s
; This is a loop we pipeline to three packets, though we could do bettter. ; This is a loop we pipeline to three packets, though we could do better.
; CHECK: loop0(.LBB0_[[LOOP:.]], ; CHECK: loop0(.LBB0_[[LOOP:.]],
; CHECK: .LBB0_[[LOOP]]: ; CHECK: .LBB0_[[LOOP]]:
; CHECK: { ; CHECK: {
; CHECK: } ; CHECK: }
; CHECK: { ; CHECK: {
; CHECK: } ; CHECK: }
; CHECK: { ; CHECK: {
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

llvm/test/CodeGen/M68k/Arith/mul64.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc < %s -mtriple=m68k-linux -verify-machineinstrs | FileCheck %s ; RUN: llc < %s -mtriple=m68k-linux -verify-machineinstrs | FileCheck %s
; Currenlty making the libcall is ok, x20 supports i32 mul/div which ; Currently making the libcall is ok, x20 supports i32 mul/div which
; yields saner expansion for i64 mul ; yields saner expansion for i64 mul
define i64 @foo(i64 %t, i64 %u) nounwind { define i64 @foo(i64 %t, i64 %u) nounwind {
; CHECK-LABEL: foo: ; CHECK-LABEL: foo:
; CHECK: ; %bb.0: ; CHECK: ; %bb.0:
; CHECK-NEXT: suba.l #20, %sp ; CHECK-NEXT: suba.l #20, %sp
; CHECK-NEXT: move.l (36,%sp), (12,%sp) ; CHECK-NEXT: move.l (36,%sp), (12,%sp)
; CHECK-NEXT: move.l (32,%sp), (8,%sp) ; CHECK-NEXT: move.l (32,%sp), (8,%sp)
; CHECK-NEXT: move.l (28,%sp), (4,%sp) ; CHECK-NEXT: move.l (28,%sp), (4,%sp)
; CHECK-NEXT: move.l (24,%sp), (%sp) ; CHECK-NEXT: move.l (24,%sp), (%sp)
; CHECK-NEXT: jsr __muldi3@PLT ; CHECK-NEXT: jsr __muldi3@PLT
; CHECK-NEXT: adda.l #20, %sp ; CHECK-NEXT: adda.l #20, %sp
; CHECK-NEXT: rts ; CHECK-NEXT: rts
%k = mul i64 %t, %u %k = mul i64 %t, %u
ret i64 %k ret i64 %k
} }

llvm/test/CodeGen/M68k/CollapseMOVEM.mir

# NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py # NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
# RUN: llc %s -mtriple=m68k -start-after=prologepilog -O0 -filetype=asm -o - \ # RUN: llc %s -mtriple=m68k -start-after=prologepilog -O0 -filetype=asm -o - \
# RUN: | FileCheck %s # RUN: | FileCheck %s
#------------------------------------------------------------------------------ #------------------------------------------------------------------------------
# CollapseMOVEM pass finds sequences of MOVEM instructions and collapse them # CollapseMOVEM pass finds sequences of MOVEM instructions and collapse them
# into a single instruciton with merged masks. This only works with stack data # into a single instruction with merged masks. This only works with stack data
#------------------------------------------------------------------------------ #------------------------------------------------------------------------------
--- # CollapseMOVEM_RM --- # CollapseMOVEM_RM
# #
# CHECK-LABEL: CollapseMOVEM_RM # CHECK-LABEL: CollapseMOVEM_RM
# CHECK: movem.l (0,%sp), %d0-%d2/%d7/%a1-%a3/%a5 # CHECK: movem.l (0,%sp), %d0-%d2/%d7/%a1-%a3/%a5
name: CollapseMOVEM_RM name: CollapseMOVEM_RM
body: | body: |
▲ Show 20 Lines • Show All 148 Lines • Show Last 20 Lines

llvm/test/CodeGen/PowerPC/ppc-vaarg-agg.ll

Show All 34 Lines
sw.bb326: ; preds = %repeat sw.bb326: ; preds = %repeat
unreachable unreachable
maxlen_reached: ; preds = %entry maxlen_reached: ; preds = %entry
ret void ret void
} }
; If the SD nodes are not cleaup up correctly, then this can fail to compile ; If the SD nodes are not cleaned up correctly, then this can fail to compile
; with an error like: Cannot select: ch = setlt [ID=6] ; with an error like: Cannot select: ch = setlt [ID=6]
; CHECK: @test1 ; CHECK: @test1

llvm/test/CodeGen/PowerPC/ppc64-sibcall.ll

Show All 39 Lines
; CHECK-SCO-LABEL: caller_64_64_copy: ; CHECK-SCO-LABEL: caller_64_64_copy:
; CHECK-SCO: b callee_64_64_copy ; CHECK-SCO: b callee_64_64_copy
} }
define internal fastcc void @callee_64_64_copy_fastcc([8 x i64] %a, [8 x i64] %b) #0 { ret void } define internal fastcc void @callee_64_64_copy_fastcc([8 x i64] %a, [8 x i64] %b) #0 { ret void }
define dso_local void @caller_64_64_copy_ccc([8 x i64] %a, [8 x i64] %b) #1 { define dso_local void @caller_64_64_copy_ccc([8 x i64] %a, [8 x i64] %b) #1 {
tail call fastcc void @callee_64_64_copy_fastcc([8 x i64] %a, [8 x i64] %b) tail call fastcc void @callee_64_64_copy_fastcc([8 x i64] %a, [8 x i64] %b)
ret void ret void
; If caller and callee use different calling convensions, we cannot apply TCO. ; If caller and callee use different calling conventions, we cannot apply TCO.
; CHECK-SCO-LABEL: caller_64_64_copy_ccc: ; CHECK-SCO-LABEL: caller_64_64_copy_ccc:
; CHECK-SCO: bl callee_64_64_copy_fastcc ; CHECK-SCO: bl callee_64_64_copy_fastcc
} }
define dso_local void @caller_64_64_reorder_copy([8 x i64] %a, [8 x i64] %b) #1 { define dso_local void @caller_64_64_reorder_copy([8 x i64] %a, [8 x i64] %b) #1 {
tail call void @callee_64_64_copy([8 x i64] %b, [8 x i64] %a) tail call void @callee_64_64_copy([8 x i64] %b, [8 x i64] %a)
ret void ret void
▲ Show 20 Lines • Show All 158 Lines • Show Last 20 Lines

llvm/test/CodeGen/PowerPC/store_fptoi.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc -mcpu=pwr9 -mtriple=powerpc64le-unknown-unknown -ppc-vsr-nums-as-vr \ ; RUN: llc -mcpu=pwr9 -mtriple=powerpc64le-unknown-unknown -ppc-vsr-nums-as-vr \
; RUN: -verify-machineinstrs < %s | FileCheck %s ; RUN: -verify-machineinstrs < %s | FileCheck %s
; RUN: llc -mcpu=pwr8 -mtriple=powerpc64le-unknown-unknown -ppc-vsr-nums-as-vr \ ; RUN: llc -mcpu=pwr8 -mtriple=powerpc64le-unknown-unknown -ppc-vsr-nums-as-vr \
; RUN: -verify-machineinstrs < %s | FileCheck -check-prefix=CHECK-PWR8 %s ; RUN: -verify-machineinstrs < %s | FileCheck -check-prefix=CHECK-PWR8 %s
; ========================================== ; ==========================================
; Tests for store of fp_to_sint converstions ; Tests for store of fp_to_sint conversions
; ========================================== ; ==========================================
; Function Attrs: norecurse nounwind ; Function Attrs: norecurse nounwind
define void @qpConv2sdw(fp128* nocapture readonly %a, i64* nocapture %b) { define void @qpConv2sdw(fp128* nocapture readonly %a, i64* nocapture %b) {
; CHECK-LABEL: qpConv2sdw: ; CHECK-LABEL: qpConv2sdw:
; CHECK: # %bb.0: # %entry ; CHECK: # %bb.0: # %entry
; CHECK-NEXT: lxv 2, 0(3) ; CHECK-NEXT: lxv 2, 0(3)
; CHECK-NEXT: xscvqpsdz 2, 2 ; CHECK-NEXT: xscvqpsdz 2, 2
▲ Show 20 Lines • Show All 567 Lines • ▼ Show 20 Linesentry:
%arrayidx = getelementptr inbounds i8, i8* %b, i64 %idxprom %arrayidx = getelementptr inbounds i8, i8* %b, i64 %idxprom
store i8 %conv, i8* %arrayidx, align 1 store i8 %conv, i8* %arrayidx, align 1
ret void ret void
} }
; ========================================== ; ==========================================
; Tests for store of fp_to_uint converstions ; Tests for store of fp_to_uint conversions
; ========================================== ; ==========================================
; Function Attrs: norecurse nounwind ; Function Attrs: norecurse nounwind
define void @dpConv2udw(double* nocapture readonly %a, i64* nocapture %b) { define void @dpConv2udw(double* nocapture readonly %a, i64* nocapture %b) {
; CHECK-LABEL: dpConv2udw: ; CHECK-LABEL: dpConv2udw:
; CHECK: # %bb.0: # %entry ; CHECK: # %bb.0: # %entry
; CHECK-NEXT: lfd 0, 0(3) ; CHECK-NEXT: lfd 0, 0(3)
; CHECK-NEXT: xscvdpuxds 2, 0 ; CHECK-NEXT: xscvdpuxds 2, 0
▲ Show 20 Lines • Show All 421 Lines • Show Last 20 Lines

llvm/test/CodeGen/PowerPC/test-vector-insert.ll

Show All 12 Lines
; RUN: -mcpu=pwr7 < %s | FileCheck %s --check-prefix=CHECK-BE-P7 ; RUN: -mcpu=pwr7 < %s | FileCheck %s --check-prefix=CHECK-BE-P7
; RUN: llc -verify-machineinstrs -mtriple=powerpc64-unknown-linux-gnu \ ; RUN: llc -verify-machineinstrs -mtriple=powerpc64-unknown-linux-gnu \
; RUN: -ppc-asm-full-reg-names -ppc-vsr-nums-as-vr \ ; RUN: -ppc-asm-full-reg-names -ppc-vsr-nums-as-vr \
; RUN: -mcpu=pwr8 < %s | FileCheck %s --check-prefix=CHECK-BE-P8 ; RUN: -mcpu=pwr8 < %s | FileCheck %s --check-prefix=CHECK-BE-P8
; RUN: llc -verify-machineinstrs -mtriple=powerpc64-unknown-linux-gnu \ ; RUN: llc -verify-machineinstrs -mtriple=powerpc64-unknown-linux-gnu \
; RUN: -ppc-asm-full-reg-names -ppc-vsr-nums-as-vr \ ; RUN: -ppc-asm-full-reg-names -ppc-vsr-nums-as-vr \
; RUN: -mcpu=pwr9 < %s | FileCheck %s --check-prefix=CHECK-BE-P9 ; RUN: -mcpu=pwr9 < %s | FileCheck %s --check-prefix=CHECK-BE-P9
; xscvdpsxws and xscvdpsxws is only available on Power7 and above ; xscvdpsxws and xscvdpsxws is only available on Power7 and above
; Codgen is different for Power7, Power8, and Power9. ; Codegen is different for Power7, Power8, and Power9.
define dso_local <4 x i32> @test(<4 x i32> %a, double %b) { define dso_local <4 x i32> @test(<4 x i32> %a, double %b) {
; CHECK-LE-P7-LABEL: test: ; CHECK-LE-P7-LABEL: test:
; CHECK-LE-P7: # %bb.0: # %entry ; CHECK-LE-P7: # %bb.0: # %entry
; CHECK-LE-P7-NEXT: xscvdpsxws f0, f1 ; CHECK-LE-P7-NEXT: xscvdpsxws f0, f1
; CHECK-LE-P7-NEXT: addi r3, r1, -4 ; CHECK-LE-P7-NEXT: addi r3, r1, -4
; CHECK-LE-P7-NEXT: addis r4, r2, .LCPI0_0@toc@ha ; CHECK-LE-P7-NEXT: addis r4, r2, .LCPI0_0@toc@ha
; CHECK-LE-P7-NEXT: addi r4, r4, .LCPI0_0@toc@l ; CHECK-LE-P7-NEXT: addi r4, r4, .LCPI0_0@toc@l
▲ Show 20 Lines • Show All 268 Lines • Show Last 20 Lines

llvm/test/CodeGen/RISCV/frm-dependency.ll

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Linesdefine float @fmadd_s(float %a, float %b, float %c) nounwind {
; RV64IF-NEXT: [[COPY2:%[0-9]+]]:fpr32 = COPY $f10_f ; RV64IF-NEXT: [[COPY2:%[0-9]+]]:fpr32 = COPY $f10_f
; RV64IF-NEXT: %3:fpr32 = nofpexcept FMADD_S [[COPY2]], [[COPY1]], [[COPY]], 7, implicit $frm ; RV64IF-NEXT: %3:fpr32 = nofpexcept FMADD_S [[COPY2]], [[COPY1]], [[COPY]], 7, implicit $frm
; RV64IF-NEXT: $f10_f = COPY %3 ; RV64IF-NEXT: $f10_f = COPY %3
; RV64IF-NEXT: PseudoRET implicit $f10_f ; RV64IF-NEXT: PseudoRET implicit $f10_f
%1 = call float @llvm.fma.f32(float %a, float %b, float %c) %1 = call float @llvm.fma.f32(float %a, float %b, float %c)
ret float %1 ret float %1
} }
; This uses rtz instead of dyn rounding mode so shouldn't have an FRM dependncy. ; This uses rtz instead of dyn rounding mode so shouldn't have an FRM dependency.
define i32 @fcvt_w_s(float %a) nounwind { define i32 @fcvt_w_s(float %a) nounwind {
; RV32IF-LABEL: name: fcvt_w_s ; RV32IF-LABEL: name: fcvt_w_s
; RV32IF: bb.0 (%ir-block.0): ; RV32IF: bb.0 (%ir-block.0):
; RV32IF-NEXT: liveins: $f10_f ; RV32IF-NEXT: liveins: $f10_f
; RV32IF-NEXT: {{ $}} ; RV32IF-NEXT: {{ $}}
; RV32IF-NEXT: [[COPY:%[0-9]+]]:fpr32 = COPY $f10_f ; RV32IF-NEXT: [[COPY:%[0-9]+]]:fpr32 = COPY $f10_f
; RV32IF-NEXT: %1:gpr = nofpexcept FCVT_W_S [[COPY]], 1 ; RV32IF-NEXT: %1:gpr = nofpexcept FCVT_W_S [[COPY]], 1
; RV32IF-NEXT: $x10 = COPY %1 ; RV32IF-NEXT: $x10 = COPY %1
Show All 35 Lines

llvm/test/CodeGen/SystemZ/fp-const-10.ll

; Test loads of SNaN. ; Test loads of SNaN.
; ;
; RUN: llc < %s -mtriple=s390x-linux-gnu | FileCheck %s ; RUN: llc < %s -mtriple=s390x-linux-gnu | FileCheck %s
; Test that we don't do an FP extending load, as this would result in a ; Test that we don't do an FP extending load, as this would result in a
; converstion to QNaN. ; conversion to QNaN.
define double @f1() { define double @f1() {
; CHECK-LABEL: .LCPI0_0 ; CHECK-LABEL: .LCPI0_0
; CHECK: .quad 0x7ff4000000000000 ; CHECK: .quad 0x7ff4000000000000
; CHECK-LABEL: f1: ; CHECK-LABEL: f1:
; CHECK: larl %r1, .LCPI0_0 ; CHECK: larl %r1, .LCPI0_0
; CHECK-NOT: ldeb %f0, 0(%r1) ; CHECK-NOT: ldeb %f0, 0(%r1)
; CHECK: ld %f0, 0(%r1) ; CHECK: ld %f0, 0(%r1)
ret double 0x7FF4000000000000 ret double 0x7FF4000000000000
} }

llvm/test/CodeGen/Thumb2/2010-02-24-BigStack.ll

; RUN: llc < %s -O0 -relocation-model=pic -frame-pointer=all -mcpu=cortex-a8 -mattr=+vfp2 ; RUN: llc < %s -O0 -relocation-model=pic -frame-pointer=all -mcpu=cortex-a8 -mattr=+vfp2
; This test creates a big stack frame without spilling any callee-saved registers. ; This test creates a big stack frame without spilling any callee-saved registers.
; Make sure the whole stack frame is addrerssable wiothout scavenger crashes. ; Make sure the whole stack frame is addressable wiothout scavenger crashes.
target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:64:64-v128:128:128-a0:0:32-n32" target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:64:64-v128:128:128-a0:0:32-n32"
target triple = "thumbv7-apple-darwin3.0.0-iphoneos" target triple = "thumbv7-apple-darwin3.0.0-iphoneos"
define void @FindMin(double* %panelTDEL, i8* %dclOfRow, i32 %numRows, i32 %numCols, double* %retMin_RES_TDEL) { define void @FindMin(double* %panelTDEL, i8* %dclOfRow, i32 %numRows, i32 %numCols, double* %retMin_RES_TDEL) {
entry: entry:
%panelTDEL.addr = alloca double*, align 4 ; <double**> [#uses=1] %panelTDEL.addr = alloca double*, align 4 ; <double**> [#uses=1]
%panelResTDEL = alloca [2560 x double], align 4 ; <[2560 x double]*> [#uses=0] %panelResTDEL = alloca [2560 x double], align 4 ; <[2560 x double]*> [#uses=0]
store double* %panelTDEL, double** %panelTDEL.addr store double* %panelTDEL, double** %panelTDEL.addr
store double* %retMin_RES_TDEL, double** undef store double* %retMin_RES_TDEL, double** undef
store i32 0, i32* undef store i32 0, i32* undef
unreachable unreachable
} }

llvm/test/CodeGen/Thumb2/thumb2-sub5.ll

; RUN: llc -mtriple=thumb-eabi -mcpu=arm1156t2-s -mattr=+thumb2,+32bit %s -o - \ ; RUN: llc -mtriple=thumb-eabi -mcpu=arm1156t2-s -mattr=+thumb2,+32bit %s -o - \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
define i64 @f1(i64 %a, i64 %b) { define i64 @f1(i64 %a, i64 %b) {
; CHECK-LABEL: f1: ; CHECK-LABEL: f1:
; CHECK: subs.w r0, r0, r2 ; CHECK: subs.w r0, r0, r2
; To test dead_carry, +32bit prevents sbc conveting to 16-bit sbcs ; To test dead_carry, +32bit prevents sbc converting to 16-bit sbcs
; CHECK: sbc.w r1, r1, r3 ; CHECK: sbc.w r1, r1, r3
%tmp = sub i64 %a, %b %tmp = sub i64 %a, %b
ret i64 %tmp ret i64 %tmp
} }

llvm/test/CodeGen/WebAssembly/exception.ll

Show First 20 Lines • Show All 313 Lines • ▼ Show 20 Linescatch.start: ; preds = %catch.dispatch
%2 = call i8* @llvm.wasm.get.exception(token %1) %2 = call i8* @llvm.wasm.get.exception(token %1)
%3 = call i32 @llvm.wasm.get.ehselector(token %1) %3 = call i32 @llvm.wasm.get.ehselector(token %1)
catchret from %1 to label %try.cont catchret from %1 to label %try.cont
try.cont: ; preds = %catch.start, %entry try.cont: ; preds = %catch.start, %entry
ret void ret void
} }
; Tests a case when a cleanup region (cleanuppad ~ clanupret) contains another ; Tests a case when a cleanup region (cleanuppad ~ cleanupret) contains another
; catchpad ; catchpad
define void @test_complex_cleanup_region() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) { define void @test_complex_cleanup_region() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
entry: entry:
invoke void @foo() invoke void @foo()
to label %invoke.cont unwind label %ehcleanup to label %invoke.cont unwind label %ehcleanup
invoke.cont: ; preds = %entry invoke.cont: ; preds = %entry
ret void ret void
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/2006-05-02-InstrSched1.ll

; REQUIRES: asserts ; REQUIRES: asserts
; RUN: llc < %s -mtriple=i686-unknown-linux -relocation-model=static -stats 2>&1 | \ ; RUN: llc < %s -mtriple=i686-unknown-linux -relocation-model=static -stats 2>&1 | \
; RUN: grep asm-printer | grep 14 ; RUN: grep asm-printer | grep 14
; ;
; It's possible to schedule this in 14 instructions by avoiding ; It's possible to schedule this in 14 instructions by avoiding
; callee-save registers, but the scheduler isn't currently that ; callee-save registers, but the scheduler isn't currently that
; conervative with registers. ; conservative with registers.
@size20 = external dso_local global i32 ; <ptr> [#uses=1] @size20 = external dso_local global i32 ; <ptr> [#uses=1]
@in5 = external dso_local global ptr ; <ptr> [#uses=1] @in5 = external dso_local global ptr ; <ptr> [#uses=1]
define i32 @compare(ptr %a, ptr %b) nounwind { define i32 @compare(ptr %a, ptr %b) nounwind {
%tmp.upgrd.1 = load i32, ptr @size20 ; <i32> [#uses=1] %tmp.upgrd.1 = load i32, ptr @size20 ; <i32> [#uses=1]
%tmp.upgrd.2 = load ptr, ptr @in5 ; <ptr> [#uses=2] %tmp.upgrd.2 = load ptr, ptr @in5 ; <ptr> [#uses=2]
%tmp3 = load i32, ptr %b ; <i32> [#uses=1] %tmp3 = load i32, ptr %b ; <i32> [#uses=1]
%gep.upgrd.3 = zext i32 %tmp3 to i64 ; <i64> [#uses=1] %gep.upgrd.3 = zext i32 %tmp3 to i64 ; <i64> [#uses=1]
Show All 9 Lines

llvm/test/CodeGen/X86/2010-02-19-TailCallRetAddrBug.ll

; RUN: llc -mcpu=generic -mtriple=i386-apple-darwin -tailcallopt -enable-misched=false < %s | FileCheck %s ; RUN: llc -mcpu=generic -mtriple=i386-apple-darwin -tailcallopt -enable-misched=false < %s | FileCheck %s
; Check that lowered arguments do not overwrite the return address before it is moved. ; Check that lowered arguments do not overwrite the return address before it is moved.
; Bug 6225 ; Bug 6225
; ;
; If a call is a fastcc tail call and tail call optimization is enabled, the ; If a call is a fastcc tail call and tail call optimization is enabled, the
; caller frame is replaced by the callee frame. This can require that arguments are ; caller frame is replaced by the callee frame. This can require that arguments are
; placed on the former return address stack slot. Special care needs to be taken ; placed on the former return address stack slot. Special care needs to be taken
; taken that the return address is moved / or stored in a register before ; taken that the return address is moved / or stored in a register before
; lowering of arguments potentially overwrites the value. ; lowering of arguments potentially overwrites the value.
; ;
; Move return address (76(%esp)) to a temporary register (%ebp) ; Move return address (76(%esp)) to a temporary register (%ebp)
; CHECK: movl 76(%esp), [[REGISTER:%[a-z]+]] ; CHECK: movl 76(%esp), [[REGISTER:%[a-z]+]]
; Overwrite return addresss ; Overwrite return address
; CHECK: movl [[EBX:%[a-z]+]], 76(%esp) ; CHECK: movl [[EBX:%[a-z]+]], 76(%esp)
; Move return address from temporary register (%ebp) to new stack location (60(%esp)) ; Move return address from temporary register (%ebp) to new stack location (60(%esp))
; CHECK: movl [[REGISTER]], 60(%esp) ; CHECK: movl [[REGISTER]], 60(%esp)
%tupl = type [9 x i32] %tupl = type [9 x i32]
declare fastcc void @l297(i32 %r10, i32 %r9, i32 %r8, i32 %r7, i32 %r6, i32 %r5, i32 %r3, i32 %r2) nounwind declare fastcc void @l297(i32 %r10, i32 %r9, i32 %r8, i32 %r7, i32 %r6, i32 %r5, i32 %r3, i32 %r2) nounwind
declare fastcc void @l298(i32 %r10, i32 %r9, i32 %r4) nounwind declare fastcc void @l298(i32 %r10, i32 %r9, i32 %r4) nounwind
Show All 31 Lines

llvm/test/CodeGen/X86/avx2-vbroadcast.ll

Show First 20 Lines • Show All 1,074 Lines • ▼ Show 20 Lines; X64-AVX512VL-NEXT: retq
%2 = insertelement <8 x i32> undef, i32 %1, i32 0 %2 = insertelement <8 x i32> undef, i32 %1, i32 0
%3 = shufflevector <8 x i32> %2, <8 x i32> undef, <8 x i32> zeroinitializer %3 = shufflevector <8 x i32> %2, <8 x i32> undef, <8 x i32> zeroinitializer
%4 = shufflevector <8 x i32> undef, <8 x i32> %3, <16 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11, i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15> %4 = shufflevector <8 x i32> undef, <8 x i32> %3, <16 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11, i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
store <16 x i32> %4, ptr %b, align 4 store <16 x i32> %4, ptr %b, align 4
ret void ret void
} }
; Test cases for <rdar://problem/16074331>. ; Test cases for <rdar://problem/16074331>.
; Instruction selection for broacast instruction fails if ; Instruction selection for broadcast instruction fails if
; the load cannot be folded into the broadcast. ; the load cannot be folded into the broadcast.
; This happens if the load has initial one use but other uses are ; This happens if the load has initial one use but other uses are
; created later, or if selection DAG cannot prove that folding the ; created later, or if selection DAG cannot prove that folding the
; load will not create a cycle in the DAG. ; load will not create a cycle in the DAG.
; Those test cases exerce the latter. ; Those test cases exerce the latter.
define void @isel_crash_16b(ptr %cV_R.addr) { define void @isel_crash_16b(ptr %cV_R.addr) {
; X32-LABEL: isel_crash_16b: ; X32-LABEL: isel_crash_16b:
▲ Show 20 Lines • Show All 390 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/bitcnt-false-dep.ll

Show First 20 Lines • Show All 80 Lines • ▼ Show 20 Linesloop:
br i1 %exitcond, label %ret, label %loop br i1 %exitcond, label %ret, label %loop
ret: ret:
ret i32 %s2 ret i32 %s2
;HSW-LABEL:@loopdep_tzct32 ;HSW-LABEL:@loopdep_tzct32
;HSW: xorl [[GPR0:%e[a-d]x]], [[GPR0]] ;HSW: xorl [[GPR0:%e[a-d]x]], [[GPR0]]
;HSW-NEXT: tzcntl {{.*}}, [[GPR0]] ;HSW-NEXT: tzcntl {{.*}}, [[GPR0]]
; This false dependecy issue was fixed in Skylake ; This false dependency issue was fixed in Skylake
;SKL-LABEL:@loopdep_tzct32 ;SKL-LABEL:@loopdep_tzct32
;SKL-NOT: xor ;SKL-NOT: xor
;SKL: tzcntl ;SKL: tzcntl
} }
define i64 @loopdep_tzct64(ptr nocapture %x, ptr nocapture %y) nounwind { define i64 @loopdep_tzct64(ptr nocapture %x, ptr nocapture %y) nounwind {
entry: entry:
%vx = load i64, ptr %x %vx = load i64, ptr %x
Show All 10 Linesloop:
br i1 %exitcond, label %ret, label %loop br i1 %exitcond, label %ret, label %loop
ret: ret:
ret i64 %s2 ret i64 %s2
;HSW-LABEL:@loopdep_tzct64 ;HSW-LABEL:@loopdep_tzct64
;HSW: xorl %e[[GPR0:[a-d]x]], %e[[GPR0]] ;HSW: xorl %e[[GPR0:[a-d]x]], %e[[GPR0]]
;HSW-NEXT: tzcntq {{.*}}, %r[[GPR0]] ;HSW-NEXT: tzcntq {{.*}}, %r[[GPR0]]
; This false dependecy issue was fixed in Skylake ; This false dependency issue was fixed in Skylake
;SKL-LABEL:@loopdep_tzct64 ;SKL-LABEL:@loopdep_tzct64
;SKL-NOT: xor ;SKL-NOT: xor
;SKL: tzcntq ;SKL: tzcntq
} }
define i32 @loopdep_lzct32(ptr nocapture %x, ptr nocapture %y) nounwind { define i32 @loopdep_lzct32(ptr nocapture %x, ptr nocapture %y) nounwind {
entry: entry:
%vx = load i32, ptr %x %vx = load i32, ptr %x
Show All 10 Linesloop:
br i1 %exitcond, label %ret, label %loop br i1 %exitcond, label %ret, label %loop
ret: ret:
ret i32 %s2 ret i32 %s2
;HSW-LABEL:@loopdep_lzct32 ;HSW-LABEL:@loopdep_lzct32
;HSW: xorl [[GPR0:%e[a-d]x]], [[GPR0]] ;HSW: xorl [[GPR0:%e[a-d]x]], [[GPR0]]
;HSW-NEXT: lzcntl {{.*}}, [[GPR0]] ;HSW-NEXT: lzcntl {{.*}}, [[GPR0]]
; This false dependecy issue was fixed in Skylake ; This false dependency issue was fixed in Skylake
;SKL-LABEL:@loopdep_lzct32 ;SKL-LABEL:@loopdep_lzct32
;SKL-NOT: xor ;SKL-NOT: xor
;SKL: lzcntl ;SKL: lzcntl
} }
define i64 @loopdep_lzct64(ptr nocapture %x, ptr nocapture %y) nounwind { define i64 @loopdep_lzct64(ptr nocapture %x, ptr nocapture %y) nounwind {
entry: entry:
%vx = load i64, ptr %x %vx = load i64, ptr %x
Show All 10 Linesloop:
br i1 %exitcond, label %ret, label %loop br i1 %exitcond, label %ret, label %loop
ret: ret:
ret i64 %s2 ret i64 %s2
;HSW-LABEL:@loopdep_lzct64 ;HSW-LABEL:@loopdep_lzct64
;HSW: xorl %e[[GPR0:[a-d]x]], %e[[GPR0]] ;HSW: xorl %e[[GPR0:[a-d]x]], %e[[GPR0]]
;HSW-NEXT: lzcntq {{.*}}, %r[[GPR0]] ;HSW-NEXT: lzcntq {{.*}}, %r[[GPR0]]
; This false dependecy issue was fixed in Skylake ; This false dependency issue was fixed in Skylake
;SKL-LABEL:@loopdep_lzct64 ;SKL-LABEL:@loopdep_lzct64
;SKL-NOT: xor ;SKL-NOT: xor
;SKL: lzcntq ;SKL: lzcntq
} }

llvm/test/CodeGen/X86/block-placement.ll

Show First 20 Lines • Show All 1,490 Lines • ▼ Show 20 Linesret: ; preds = %endif, %then
ret void ret void
} }
define i32 @not_rotate_if_extra_branch(i32 %count) { define i32 @not_rotate_if_extra_branch(i32 %count) {
; Test checks that there is no loop rotation ; Test checks that there is no loop rotation
; if it introduces extra branch. ; if it introduces extra branch.
; Specifically in this case because best exit is .header ; Specifically in this case because best exit is .header
; but it has fallthrough to .middle block and last block in ; but it has fallthrough to .middle block and last block in
; loop chain .slow does not have afallthrough to .header. ; loop chain .slow does not have a fallthrough to .header.
; CHECK-LABEL: not_rotate_if_extra_branch ; CHECK-LABEL: not_rotate_if_extra_branch
; CHECK: %.entry ; CHECK: %.entry
; CHECK: %.header ; CHECK: %.header
; CHECK: %.middle ; CHECK: %.middle
; CHECK: %.backedge ; CHECK: %.backedge
; CHECK: %.slow ; CHECK: %.slow
; CHECK: %.bailout ; CHECK: %.bailout
; CHECK: %.stop ; CHECK: %.stop
Show All 28 Lines
.stop: .stop:
%sum.phi = phi i32 [ %sum.1, %.backedge ], [ %sum.2, %.bailout ] %sum.phi = phi i32 [ %sum.1, %.backedge ], [ %sum.2, %.bailout ]
ret i32 %sum.phi ret i32 %sum.phi
} }
define i32 @not_rotate_if_extra_branch_regression(i32 %count, i32 %init) { define i32 @not_rotate_if_extra_branch_regression(i32 %count, i32 %init) {
; This is a regression test against patch avoid loop rotation if ; This is a regression test against patch avoid loop rotation if
; it introduce an extra btanch. ; it introduce an extra branch.
; CHECK-LABEL: not_rotate_if_extra_branch_regression ; CHECK-LABEL: not_rotate_if_extra_branch_regression
; CHECK: %.entry ; CHECK: %.entry
; CHECK: %.first_backedge ; CHECK: %.first_backedge
; CHECK: %.second_header ; CHECK: %.second_header
; CHECK: %.slow ; CHECK: %.slow
.entry: .entry:
%sum.0 = shl nsw i32 %count, 1 %sum.0 = shl nsw i32 %count, 1
br label %.first_header br label %.first_header
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/crash-lre-eliminate-dead-def.ll

Show All 19 Lines
; ... ; ...
; v2 = loadimm cst ; v2 = loadimm cst
; ... ; ...
; = use v2 ; = use v2
; ;
; v1 is now dead so we remove its live-range. ; v1 is now dead so we remove its live-range.
; Actually, we shrink it to empty to keep the ; Actually, we shrink it to empty to keep the
; instruction around for futher remat opportunities ; instruction around for futher remat opportunities
; (accessbile via the origin pointer.) ; (accessible via the origin pointer.)
; ;
; Later v2 gets remove as well (e.g., because we ; Later v2 gets remove as well (e.g., because we
; remat it closer to its use) and the live-range ; remat it closer to its use) and the live-range
; gets eliminated. We used to crash at this point ; gets eliminated. We used to crash at this point
; because we were looking for a VNI of origin (v1) ; because we were looking for a VNI of origin (v1)
; at the slot index of the definition of v2. However, ; at the slot index of the definition of v2. However,
; we do not have a VNI for v1 at this point, since the ; we do not have a VNI for v1 at this point, since the
; live-range is now empty... crash! ; live-range is now empty... crash!
▲ Show 20 Lines • Show All 232 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/dagcombine-shifts.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc < %s -mtriple=x86_64-linux-gnu | FileCheck %s ; RUN: llc < %s -mtriple=x86_64-linux-gnu | FileCheck %s
; fold (shl (zext (lshr (A, X))), X) -> (zext (shl (lshr (A, X)), X)) ; fold (shl (zext (lshr (A, X))), X) -> (zext (shl (lshr (A, X)), X))
; Canolicalize the sequence shl/zext/lshr performing the zeroextend ; Canonicalize the sequence shl/zext/lshr performing the zeroextend
; as the last instruction of the sequence. ; as the last instruction of the sequence.
; This will help DAGCombiner to identify and then fold the sequence ; This will help DAGCombiner to identify and then fold the sequence
; of shifts into a single AND. ; of shifts into a single AND.
; This transformation is profitable if the shift amounts are the same ; This transformation is profitable if the shift amounts are the same
; and if there is only one use of the zext. ; and if there is only one use of the zext.
define i16 @fun1(i8 zeroext %v) { define i16 @fun1(i8 zeroext %v) {
; CHECK-LABEL: fun1: ; CHECK-LABEL: fun1:
▲ Show 20 Lines • Show All 203 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/fptoui-may-overflow.ll

Show All 13 Lines
; CHECK-NEXT: vpmovzxbd {{.*#+}} xmm0 = xmm0[0],zero,zero,zero,xmm0[1],zero,zero,zero,xmm0[2],zero,zero,zero,xmm0[3],zero,zero,zero ; CHECK-NEXT: vpmovzxbd {{.*#+}} xmm0 = xmm0[0],zero,zero,zero,xmm0[1],zero,zero,zero,xmm0[2],zero,zero,zero,xmm0[3],zero,zero,zero
; CHECK-NEXT: retq ; CHECK-NEXT: retq
%f = fptoui <4 x float> %arg to <4 x i8> %f = fptoui <4 x float> %arg to <4 x i8>
%z = zext <4 x i8> %f to <4 x i32> %z = zext <4 x i8> %f to <4 x i32>
%b = bitcast <4 x i32> %z to <16 x i8> %b = bitcast <4 x i32> %z to <16 x i8>
ret <16 x i8> %b ret <16 x i8> %b
} }
; In @fptoui_shuffle, we must preserve the vpand for correctnesss. Only the ; In @fptoui_shuffle, we must preserve the vpand for correctness. Only the
; i8 values extracted from %s are poison. The values from the zeroinitializer ; i8 values extracted from %s are poison. The values from the zeroinitializer
; are not. ; are not.
define <16 x i8> @fptoui_shuffle(<4 x float> %arg) { define <16 x i8> @fptoui_shuffle(<4 x float> %arg) {
; CHECK-LABEL: fptoui_shuffle: ; CHECK-LABEL: fptoui_shuffle:
; CHECK: # %bb.0: ; CHECK: # %bb.0:
; CHECK-NEXT: vcvttps2dq %xmm0, %xmm0 ; CHECK-NEXT: vcvttps2dq %xmm0, %xmm0
; CHECK-NEXT: vandps {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0, %xmm0 ; CHECK-NEXT: vandps {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0, %xmm0
; CHECK-NEXT: retq ; CHECK-NEXT: retq
%f = fptoui <4 x float> %arg to <4 x i8> %f = fptoui <4 x float> %arg to <4 x i8>
%s = shufflevector <4 x i8> %f, <4 x i8> undef, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef> %s = shufflevector <4 x i8> %f, <4 x i8> undef, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%ss = shufflevector <16 x i8> %s, <16 x i8> zeroinitializer, <16 x i32> <i32 0, i32 17, i32 18, i32 19, i32 1, i32 21, i32 22, i32 23, i32 2, i32 25, i32 26, i32 27, i32 3, i32 29, i32 30, i32 31> %ss = shufflevector <16 x i8> %s, <16 x i8> zeroinitializer, <16 x i32> <i32 0, i32 17, i32 18, i32 19, i32 1, i32 21, i32 22, i32 23, i32 2, i32 25, i32 26, i32 27, i32 3, i32 29, i32 30, i32 31>
ret <16 x i8> %ss ret <16 x i8> %ss
} }

llvm/test/CodeGen/X86/i386-tlscall-fastregalloc.ll

Show All 12 Lines
; Get c. ; Get c.
; C is spilled because of the scheduling of the instructions, ; C is spilled because of the scheduling of the instructions,
; but a smarter regalloc wouldn't have spilled it. ; but a smarter regalloc wouldn't have spilled it.
; CHECK: movl L_c{{[^,]*}}, [[C_ADDR:%[a-z]+]] ; CHECK: movl L_c{{[^,]*}}, [[C_ADDR:%[a-z]+]]
; CHECK-NEXT: movl [[C_ADDR]], [[C_SPILLED:[0-8]+\(%esp\)]] ; CHECK-NEXT: movl [[C_ADDR]], [[C_SPILLED:[0-8]+\(%esp\)]]
; Get p. ; Get p.
; CHECK-NEXT: movl _p@{{[0-9a-zA-Z]+}}, [[P_ADDR:%[a-z]+]] ; CHECK-NEXT: movl _p@{{[0-9a-zA-Z]+}}, [[P_ADDR:%[a-z]+]]
; CHECK-NEXT: calll *([[P_ADDR]]) ; CHECK-NEXT: calll *([[P_ADDR]])
; At this point eax contiains the address of p. ; At this point eax contains the address of p.
; Load c address. ; Load c address.
; Make sure we do not clobber eax. ; Make sure we do not clobber eax.
; CHECK-NEXT: movl [[C_SPILLED]], [[C_ADDR_RELOADED:%e[b-z]x+]] ; CHECK-NEXT: movl [[C_SPILLED]], [[C_ADDR_RELOADED:%e[b-z]x+]]
; Store c address into p. ; Store c address into p.
; CHECK-NEXT: movl [[C_ADDR_RELOADED]], (%eax) ; CHECK-NEXT: movl [[C_ADDR_RELOADED]], (%eax)
define void @f() #0 { define void @f() #0 {
entry: entry:
store ptr @c, ptr @p, align 4 store ptr @c, ptr @p, align 4
ret void ret void
} }

llvm/test/CodeGen/X86/win64-funclet-preisel-intrinsics.ll

; RUN: llc -mtriple=x86_64-windows-msvc < %s | FileCheck %s ; RUN: llc -mtriple=x86_64-windows-msvc < %s | FileCheck %s
; WinEH requires funclet tokens on nounwind intrinsics if they can lower to ; WinEH requires funclet tokens on nounwind intrinsics if they can lower to
; regular function calls in the course of IR transformations. ; regular function calls in the course of IR transformations.
; ;
; Test that the code generator will emit the function call and not consider it ; Test that the code generator will emit the function call and not consider it
; an "implausible instruciton". In the past this silently truncated code on ; an "implausible instruction". In the past this silently truncated code on
; exception paths and caused crashes at runtime. ; exception paths and caused crashes at runtime.
; ;
; Reduced IR generated from ObjC++ source: ; Reduced IR generated from ObjC++ source:
; ;
; @class Ety; ; @class Ety;
; void opaque(void); ; void opaque(void);
; void test_catch_with_objc_intrinsic(void) { ; void test_catch_with_objc_intrinsic(void) {
; @try { ; @try {
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/x86-no_caller_saved_registers-preserve.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc -mtriple=x86_64-unknown-unknown < %s | FileCheck %s ; RUN: llc -mtriple=x86_64-unknown-unknown < %s | FileCheck %s
;; In functions with 'no_caller_saved_registers' attribute, all registers should ;; In functions with 'no_caller_saved_registers' attribute, all registers should
;; be preserved except for registers used for passing/returning arguments. ;; be preserved except for registers used for passing/returning arguments.
;; In the following function registers %rdi, %rsi and %xmm0 are used to store ;; In the following function registers %rdi, %rsi and %xmm0 are used to store
;; arguments %a0, %a1 and %b0 accordingally. The value is returned in %rax. ;; arguments %a0, %a1 and %b0 accordingly. The value is returned in %rax.
;; The above registers should not be preserved, however other registers ;; The above registers should not be preserved, however other registers
;; (that are modified by the function) should be preserved (%rdx and %xmm1). ;; (that are modified by the function) should be preserved (%rdx and %xmm1).
define x86_64_sysvcc i32 @bar(i32 %a0, i32 %a1, float %b0) #0 { define x86_64_sysvcc i32 @bar(i32 %a0, i32 %a1, float %b0) #0 {
; CHECK-LABEL: bar: ; CHECK-LABEL: bar:
; CHECK: # %bb.0: ; CHECK: # %bb.0:
; CHECK-NEXT: pushq %rdx ; CHECK-NEXT: pushq %rdx
; CHECK-NEXT: .cfi_def_cfa_offset 16 ; CHECK-NEXT: .cfi_def_cfa_offset 16
; CHECK-NEXT: movaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill ; CHECK-NEXT: movaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/x86-shrink-wrap-unwind.ll

Show First 20 Lines • Show All 270 Lines • ▼ Show 20 Lineslanding:
ret void ret void
return: return:
ret void ret void
} }
; Check landing pad again. ; Check landing pad again.
; This time checks that we can shrink-wrap when the epilogue does not ; This time checks that we can shrink-wrap when the epilogue does not
; span accross several blocks. ; span across several blocks.
; ;
; CHECK-LABEL: with_nounwind_same_succ: ; CHECK-LABEL: with_nounwind_same_succ:
; ;
; Jump to throw_exception: ; Jump to throw_exception:
; CHECK: testb $1, %dil ; CHECK: testb $1, %dil
; CHECK-NEXT: je [[RET_LABEL:LBB[0-9_]+]] ; CHECK-NEXT: je [[RET_LABEL:LBB[0-9_]+]]
; ;
; Prologue ; Prologue
Show All 38 Lines

llvm/test/CodeGen/X86/x86-shrink-wrapping.ll

Show First 20 Lines • Show All 1,162 Lines • ▼ Show 20 Linesend:
ret i32 %tmp.0 ret i32 %tmp.0
} }
@b = internal unnamed_addr global i1 false @b = internal unnamed_addr global i1 false
@c = internal unnamed_addr global i8 0, align 1 @c = internal unnamed_addr global i8 0, align 1
@a = common global i32 0, align 4 @a = common global i32 0, align 4
; Make sure the prologue does not clobber the EFLAGS when ; Make sure the prologue does not clobber the EFLAGS when
; it is live accross. ; it is live across.
; PR25629. ; PR25629.
; Note: The registers may change in the following patterns, but ; Note: The registers may change in the following patterns, but
; because they imply register hierarchy (e.g., eax, al) this is ; because they imply register hierarchy (e.g., eax, al) this is
; tricky to write robust patterns. ; tricky to write robust patterns.
define i32 @useLEAForPrologue(i32 %d, i32 %a, i8 %c) #3 { define i32 @useLEAForPrologue(i32 %d, i32 %a, i8 %c) #3 {
; ENABLE-LABEL: useLEAForPrologue: ; ENABLE-LABEL: useLEAForPrologue:
; ENABLE: ## %bb.0: ## %entry ; ENABLE: ## %bb.0: ## %entry
; ENABLE-NEXT: pushq %rbx ; ENABLE-NEXT: pushq %rbx
▲ Show 20 Lines • Show All 399 Lines • Show Last 20 Lines

llvm/test/DebugInfo/Generic/debug-info-enum.ll

Show First 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
; CHECK: DW_TAG_enumeration_type ; CHECK: DW_TAG_enumeration_type
; CHECK-DW2-NOT: DW_AT_type ; CHECK-DW2-NOT: DW_AT_type
; CHECK-DW4: DW_AT_type{{.*}}"int" ; CHECK-DW4: DW_AT_type{{.*}}"int"
; CHECK-NOT: DW_AT_enum_class ; CHECK-NOT: DW_AT_enum_class
; CHECK: DW_AT_name ("E8") ; CHECK: DW_AT_name ("E8")
; Test enumeration without a fixed underlying type, but with the DIFlagEnumClass ; Test enumeration without a fixed underlying type, but with the DIFlagEnumClass
; set. The DW_AT_enum_class attribute should be absent. This behaviour is ; set. The DW_AT_enum_class attribute should be absent. This behaviour is
; intented to keep compatibilty with existing DWARF consumers, which may imply ; intented to keep compatibility with existing DWARF consumers, which may imply
; the type is present whenever DW_AT_enum_class is set. ; the type is present whenever DW_AT_enum_class is set.
!63 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "E9", file: !3, line: 63, size: 32, flags: DIFlagEnumClass, elements: !64, identifier: "_ZTS2E9") !63 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "E9", file: !3, line: 63, size: 32, flags: DIFlagEnumClass, elements: !64, identifier: "_ZTS2E9")
!64 = !{!65, !66} !64 = !{!65, !66}
!65 = !DIEnumerator(name: "A9", value: -128) !65 = !DIEnumerator(name: "A9", value: -128)
!66 = !DIEnumerator(name: "B9", value: 127) !66 = !DIEnumerator(name: "B9", value: 127)
; CHECK: DW_TAG_enumeration_type ; CHECK: DW_TAG_enumeration_type
; CHECK-NOT: DW_AT_type ; CHECK-NOT: DW_AT_type
; CHECK-NOT: DW_AT_enum_class ; CHECK-NOT: DW_AT_enum_class
Show All 22 Lines

llvm/test/DebugInfo/MIR/X86/mlicm-hoist-pre-regalloc.mir

--- | --- |
; RUN: llc -run-pass=machinelicm -o - %s | FileCheck %s ; RUN: llc -run-pass=machinelicm -o - %s | FileCheck %s
; Line numbers should not be retained when loop invariant instructions are hoisted. ; Line numbers should not be retained when loop invariant instructions are hoisted.
; Doing so causes poor stepping bevavior. ; Doing so causes poor stepping behavior.
; ;
; Created from: ; Created from:
; int x; ; int x;
; void Process(const unsigned int *p) ; void Process(const unsigned int *p)
; { ; {
; while (1) ; while (1)
; x = *p++; ; x = *p++;
; } ; }
▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines

llvm/test/DebugInfo/X86/dbg-value-funcarg3.ll

Show All 20 Lines
; CHECK-LABEL: name: fn1 ; CHECK-LABEL: name: fn1
; CHECK: DBG_VALUE $rdi, $noreg, ![[T1]], !DIExpression(), ; CHECK: DBG_VALUE $rdi, $noreg, ![[T1]], !DIExpression(),
; CHECK-NEXT: %0:gr64 = COPY $rdi ; CHECK-NEXT: %0:gr64 = COPY $rdi
; CHECK-NEXT: DBG_VALUE %0, $noreg, ![[T1]], !DIExpression(), ; CHECK-NEXT: DBG_VALUE %0, $noreg, ![[T1]], !DIExpression(),
; CHECK-NEXT: %1:gr32 = COPY %0.sub_32bit ; CHECK-NEXT: %1:gr32 = COPY %0.sub_32bit
; CHECK-NEXT: COPY ; CHECK-NEXT: COPY
; CHECK-NEXT: RET ; CHECK-NEXT: RET
; ;
;; For instr-ref, no copies should be considered. Because argumenst are ;; For instr-ref, no copies should be considered. Because arguments are
;; Special, we don't label them in the same way, and currently emit a ;; Special, we don't label them in the same way, and currently emit a
;; DBG_VALUE for the physreg. ;; DBG_VALUE for the physreg.
; INSTRREF-LABEL: name: fn1 ; INSTRREF-LABEL: name: fn1
; INSTRREF: DBG_VALUE $rdi, $noreg, ![[T1]], !DIExpression(), ; INSTRREF: DBG_VALUE $rdi, $noreg, ![[T1]], !DIExpression(),
; INSTRREF-NEXT: %0:gr64 = COPY $rdi ; INSTRREF-NEXT: %0:gr64 = COPY $rdi
; INSTRREF-NEXT: %1:gr32 = COPY %0.sub_32bit ; INSTRREF-NEXT: %1:gr32 = COPY %0.sub_32bit
; INSTRREF-NEXT: COPY ; INSTRREF-NEXT: COPY
; INSTRREF-NEXT: RET ; INSTRREF-NEXT: RET
Show All 34 Lines

llvm/test/DebugInfo/X86/dimodule-external-fortran.ll

; This test verifies that the debug info for an external Fortran module ; This test verifies that the debug info for an external Fortran module
; is correctly generated. ; is correctly generated.
; ;
; To generate the test source, compile the following two files in order in ; To generate the test source, compile the following two files in order in
; the same directory (as the second compilation uses the .mod from the first): ; the same directory (as the second compilation uses the .mod from the first):
; external_module.f90 (to compile: <fortran compiler> -g -c external_module.f90) ; external_module.f90 (to compile: <fortran compiler> -g -c external_module.f90)
; module external_module ; module external_module
; real :: dummy ; real :: dummy
; end module external_module ; end module external_module
; ;
; em.f90 (to compile: <fortran compierl> -g -llvm-emit -c -S em.f90) ; em.f90 (to compile: <fortran compiler> -g -llvm-emit -c -S em.f90)
; program use_external_module ; program use_external_module
; use external_module ; use external_module
; implicit none ; implicit none
; ;
; real :: x ; real :: x
; x = 2.0 + dummy ; x = 2.0 + dummy
; ;
; end program use_external_module ; end program use_external_module
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

llvm/test/DebugInfo/macro_link.ll

; RUN: llvm-link %s %s -S -o -| FileCheck %s ; RUN: llvm-link %s %s -S -o -| FileCheck %s
; This test checks that DIMacro and DIMacroFile comaprison works correctly. ; This test checks that DIMacro and DIMacroFile comparison works correctly.
; CHECK: !llvm.dbg.cu = !{[[CU1:![0-9]*]], [[CU2:![0-9]*]]} ; CHECK: !llvm.dbg.cu = !{[[CU1:![0-9]*]], [[CU2:![0-9]*]]}
; CHECK: [[CU1]] = distinct !DICompileUnit ; CHECK: [[CU1]] = distinct !DICompileUnit
; CHECK-SAME: macros: [[MS1:![0-9]*]] ; CHECK-SAME: macros: [[MS1:![0-9]*]]
; CHECK: [[F1:![0-9]*]] = !DIFile(filename: "t.c" ; CHECK: [[F1:![0-9]*]] = !DIFile(filename: "t.c"
; CHECK: [[MS1]] = !{[[MF1:![0-9]*]]} ; CHECK: [[MS1]] = !{[[MF1:![0-9]*]]}
; CHECK: [[MF1]] = !DIMacroFile( ; CHECK: [[MF1]] = !DIMacroFile(
Show All 19 Lines

llvm/test/Instrumentation/SanitizerCoverage/gep-tracing.ll

Show All 25 Linesentry:
ret void ret void
} }
; CHECK-LABEL: define void @gep_2([1000 x i32]* nocapture %a, i32 %i, i32 %j) ; CHECK-LABEL: define void @gep_2([1000 x i32]* nocapture %a, i32 %i, i32 %j)
; CHECK: call void @__sanitizer_cov_trace_gep(i64 %idxprom1) ; CHECK: call void @__sanitizer_cov_trace_gep(i64 %idxprom1)
; CHECK: call void @__sanitizer_cov_trace_gep(i64 %idxprom) ; CHECK: call void @__sanitizer_cov_trace_gep(i64 %idxprom)
; CHECK: ret void ; CHECK: ret void
; Just make sure we don't insturment this one and don't crash ; Just make sure we don't instrument this one and don't crash
define void @gep_3(<2 x i8*> %a, i32 %i, i32 %j) { define void @gep_3(<2 x i8*> %a, i32 %i, i32 %j) {
entry: entry:
%0 = getelementptr i8, <2 x i8*> %a, <2 x i64> <i64 8, i64 8> %0 = getelementptr i8, <2 x i8*> %a, <2 x i64> <i64 8, i64 8>
ret void ret void
} }

llvm/test/MC/AArch64/arm64-branch-encoding.s

Show All 17 Lines
; CHECK: encoding: [0xa0,0x00,0x1f,0xd6] ; CHECK: encoding: [0xa0,0x00,0x1f,0xd6]
blr x9 blr x9
; CHECK: encoding: [0x20,0x01,0x3f,0xd6] ; CHECK: encoding: [0x20,0x01,0x3f,0xd6]
bl L1 bl L1
; CHECK: bl L1 ; encoding: [A,A,A,0b100101AA] ; CHECK: bl L1 ; encoding: [A,A,A,0b100101AA]
; CHECK: fixup A - offset: 0, value: L1, kind: fixup_aarch64_pcrel_call26 ; CHECK: fixup A - offset: 0, value: L1, kind: fixup_aarch64_pcrel_call26
;----------------------------------------------------------------------------- ;-----------------------------------------------------------------------------
; Contitional branch instructions. ; Conditional branch instructions.
;----------------------------------------------------------------------------- ;-----------------------------------------------------------------------------
b L1 b L1
; CHECK: b L1 ; encoding: [A,A,A,0b000101AA] ; CHECK: b L1 ; encoding: [A,A,A,0b000101AA]
; CHECK: fixup A - offset: 0, value: L1, kind: fixup_aarch64_pcrel_branch26 ; CHECK: fixup A - offset: 0, value: L1, kind: fixup_aarch64_pcrel_branch26
b.eq L1 b.eq L1
; CHECK: b.eq L1 ; encoding: [0bAAA00000,A,A,0x54] ; CHECK: b.eq L1 ; encoding: [0bAAA00000,A,A,0x54]
; CHECK: fixup A - offset: 0, value: L1, kind: fixup_aarch64_pcrel_branch19 ; CHECK: fixup A - offset: 0, value: L1, kind: fixup_aarch64_pcrel_branch19
▲ Show 20 Lines • Show All 125 Lines • Show Last 20 Lines

llvm/test/MC/ARM/mul-v4.s

@ PR17647: MUL/MLA/SMLAL/UMLAL should be avalaibe to IAS for ARMv4 and higher @ PR17647: MUL/MLA/SMLAL/UMLAL should be available to IAS for ARMv4 and higher
@ RUN: llvm-mc < %s -triple armv4-unknown-unknown -show-encoding | FileCheck %s --check-prefix=ARMV4 @ RUN: llvm-mc < %s -triple armv4-unknown-unknown -show-encoding | FileCheck %s --check-prefix=ARMV4
@ ARMV4: mul r0, r1, r2 @ encoding: [0x91,0x02,0x00,0xe0] @ ARMV4: mul r0, r1, r2 @ encoding: [0x91,0x02,0x00,0xe0]
@ ARMV4: muls r0, r1, r2 @ encoding: [0x91,0x02,0x10,0xe0] @ ARMV4: muls r0, r1, r2 @ encoding: [0x91,0x02,0x10,0xe0]
@ ARMV4: mulne r0, r1, r2 @ encoding: [0x91,0x02,0x00,0x10] @ ARMV4: mulne r0, r1, r2 @ encoding: [0x91,0x02,0x00,0x10]
@ ARMV4: mulseq r0, r1, r2 @ encoding: [0x91,0x02,0x10,0x00] @ ARMV4: mulseq r0, r1, r2 @ encoding: [0x91,0x02,0x10,0x00]
mul r0, r1, r2 mul r0, r1, r2
Show All 30 Lines

llvm/test/MC/AsmParser/directive_abort.s

# RUN: not llvm-mc -triple i386-unknown-unknown %s 2> %t # RUN: not llvm-mc -triple i386-unknown-unknown %s 2> %t
# RUN: FileCheck -input-file %t %s # RUN: FileCheck -input-file %t %s
# CHECK: error: .abort 'please stop assembing' # CHECK: error: .abort 'please stop assembling'
TEST0: TEST0:
.abort please stop assembing .abort please stop assembling

llvm/test/MC/ELF/section-sym.s

// RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux-gnu %s -o - | llvm-readobj -S --symbols -r --expand-relocs - | FileCheck %s // RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux-gnu %s -o - | llvm-readobj -S --symbols -r --expand-relocs - | FileCheck %s
.section foo, "aG", @progbits, f1, comdat .section foo, "aG", @progbits, f1, comdat
.section foo, "G", @progbits, f2, comdat .section foo, "G", @progbits, f2, comdat
.section bar .section bar
.long foo .long foo
// Test that the relocation points to the first section foo. // Test that the relocation points to the first section foo.
// The first seciton foo has index 6 // The first section foo has index 6
// CHECK: Section { // CHECK: Section {
// CHECK: Index: 4 // CHECK: Index: 4
// CHECK-NEXT: Name: foo // CHECK-NEXT: Name: foo
// CHECK-NEXT: Type: SHT_PROGBITS (0x1) // CHECK-NEXT: Type: SHT_PROGBITS (0x1)
// CHECK-NEXT: Flags [ (0x202) // CHECK-NEXT: Flags [ (0x202)
// CHECK-NEXT: SHF_ALLOC (0x2) // CHECK-NEXT: SHF_ALLOC (0x2)
// CHECK-NEXT: SHF_GROUP (0x200) // CHECK-NEXT: SHF_GROUP (0x200)
// CHECK-NEXT: ] // CHECK-NEXT: ]
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

llvm/test/MC/ELF/section-unique-err4.s

// RUN: not llvm-mc -triple x86_64-pc-linux-gnu %s -o - 2>&1 | FileCheck %s // RUN: not llvm-mc -triple x86_64-pc-linux-gnu %s -o - 2>&1 | FileCheck %s
// CHECK: error: expected commma // CHECK: error: expected comma
.section .text,"ax",@progbits,unique 1 .section .text,"ax",@progbits,unique 1

llvm/test/MC/Hexagon/capitalizedEndloop.s

# RUN: llvm-mc -triple=hexagon -filetype=obj %s | llvm-objdump -d -r - | FileCheck %s # RUN: llvm-mc -triple=hexagon -filetype=obj %s | llvm-objdump -d -r - | FileCheck %s
# #
# Verify that capitaizled endloops work # Verify that capitalized endloops work
{ R0 = mpyi(R0,R0) } : endloop0 { R0 = mpyi(R0,R0) } : endloop0
{ R0 = mpyi(R0,R0) } : ENDLOOP0 { R0 = mpyi(R0,R0) } : ENDLOOP0
{ R0 = mpyi(R0,R0) }:endloop0 { R0 = mpyi(R0,R0) }:endloop0
{ R0 = mpyi(R0,R0) } : endloop1 { R0 = mpyi(R0,R0) } : endloop1
{ R0 = mpyi(R0,R0) } : ENDLOOP1 { R0 = mpyi(R0,R0) } : ENDLOOP1
{ R0 = mpyi(R0,R0) }:endloop1 { R0 = mpyi(R0,R0) }:endloop1
Show All 24 Lines

llvm/test/MC/Mips/mt/module-directive.s

# RUN: llvm-mc < %s -arch=mips -mcpu=mips32r2 -filetype=obj -o - | \ # RUN: llvm-mc < %s -arch=mips -mcpu=mips32r2 -filetype=obj -o - | \
# RUN: llvm-readobj -A - | FileCheck --check-prefix=CHECK-OBJ %s # RUN: llvm-readobj -A - | FileCheck --check-prefix=CHECK-OBJ %s
# RUN: llvm-mc < %s -arch=mips -mcpu=mips32r2 -filetype=asm -o - | \ # RUN: llvm-mc < %s -arch=mips -mcpu=mips32r2 -filetype=asm -o - | \
# RUN: FileCheck --check-prefix=CHECK-ASM %s # RUN: FileCheck --check-prefix=CHECK-ASM %s
# Test that the .module directive sets the MT flag in .MIPS.abiflags when # Test that the .module directive sets the MT flag in .MIPS.abiflags when
# assembling to boject files. # assembling to object files.
# Test that the .moodule directive is re-emitted when expanding assembly. # Test that the .moodule directive is re-emitted when expanding assembly.
# CHECK-OBJ: ASEs # CHECK-OBJ: ASEs
# CHECK-OBJ-NEXT: MT (0x40) # CHECK-OBJ-NEXT: MT (0x40)
# CHECK-ASM: .module mt # CHECK-ASM: .module mt
.module mt .module mt
nop nop

llvm/test/MC/X86/align-via-relaxation.s

Show All 38 Lines# NOPAD-NEXT: 20: cc int3
jmp foo jmp foo
jmp foo jmp foo
jmp foo jmp foo
.p2align 5 .p2align 5
int3 int3
foo: foo:
ret ret
# Check that we're not shifting aroudn the offsets of labels - doing # Check that we're not shifting around the offsets of labels - doing
# that would require a further round of relaxation # that would require a further round of relaxation
# CHECK: <bar>: # CHECK: <bar>:
# CHECK: 22: eb fe jmp 0x22 <bar> # CHECK: 22: eb fe jmp 0x22 <bar>
# CHECK: 24: 66 66 66 2e 0f 1f 84 00 00 00 00 00 nopw %cs:(%rax,%rax) # CHECK: 24: 66 66 66 2e 0f 1f 84 00 00 00 00 00 nopw %cs:(%rax,%rax)
# CHECK: 30: 0f 0b ud2 # CHECK: 30: 0f 0b ud2
bar: bar:
jmp bar jmp bar
Show All 34 Lines

llvm/test/Object/archive-update.test

Show All 11 Lines
Either the shell supports the 'touch' command with a flag to manually set the Either the shell supports the 'touch' command with a flag to manually set the
mtime or we sleep for over two seconds so that the mtime is definitely mtime or we sleep for over two seconds so that the mtime is definitely
observable. observable.
RUN: touch -m -t 200001010000 %t/tmp.older/evenlen || sleep 2.1 RUN: touch -m -t 200001010000 %t/tmp.older/evenlen || sleep 2.1
RUN: echo newer > %t/tmp.newer/evenlen RUN: echo newer > %t/tmp.newer/evenlen
RUN: touch %t/tmp.newer/evenlen RUN: touch %t/tmp.newer/evenlen
Create an achive with the newest file Create an archive with the newest file
RUN: llvm-ar rU %t/tmp.a %t/tmp.newer/evenlen RUN: llvm-ar rU %t/tmp.a %t/tmp.newer/evenlen
RUN: llvm-ar p %t/tmp.a | FileCheck --check-prefix=NEWER %s RUN: llvm-ar p %t/tmp.a | FileCheck --check-prefix=NEWER %s
Check that without the 'u' option the member is replaced with an older file. Check that without the 'u' option the member is replaced with an older file.
RUN: llvm-ar rU %t/tmp.a %t/tmp.older/evenlen RUN: llvm-ar rU %t/tmp.a %t/tmp.older/evenlen
RUN: llvm-ar p %t/tmp.a | FileCheck --check-prefix=OLDER %s RUN: llvm-ar p %t/tmp.a | FileCheck --check-prefix=OLDER %s
Check that with the 'u' option the member is replaced with a newer file. Check that with the 'u' option the member is replaced with a newer file.
Show All 23 Lines

llvm/test/ThinLTO/X86/guid_collision.ll

; Make sure LTO succeeds even if %t.bc contains a GlobalVariable F and ; Make sure LTO succeeds even if %t.bc contains a GlobalVariable F and
; %t2.bc cointains a Function F with the same GUID. ; %t2.bc contains a Function F with the same GUID.
; ;
; RUN: opt -module-summary %s -o %t.bc ; RUN: opt -module-summary %s -o %t.bc
; RUN: opt -module-summary %p/Inputs/guid_collision.ll -o %t2.bc ; RUN: opt -module-summary %p/Inputs/guid_collision.ll -o %t2.bc
; RUN: llvm-lto2 run %t.bc %t2.bc -o %t.out -save-temps \ ; RUN: llvm-lto2 run %t.bc %t2.bc -o %t.out -save-temps \
; RUN: -r=%t.bc,H,px -r=%t.bc,G, -r=%t2.bc,G,px ; RUN: -r=%t.bc,H,px -r=%t.bc,G, -r=%t2.bc,G,px
; RUN: llvm-dis -o - %t.out.1.3.import.bc | FileCheck %s ; RUN: llvm-dis -o - %t.out.1.3.import.bc | FileCheck %s
; RUN: llvm-lto2 run %t.bc %t2.bc -o %t.out -thinlto-distributed-indexes \ ; RUN: llvm-lto2 run %t.bc %t2.bc -o %t.out -thinlto-distributed-indexes \
Show All 27 Lines

llvm/test/Transforms/ArgumentPromotion/profile.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
; RUN: opt -passes=argpromotion,mem2reg -S < %s | FileCheck %s ; RUN: opt -passes=argpromotion,mem2reg -S < %s | FileCheck %s
target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128" target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
; Checks if !prof metadata is corret in deadargelim. ; Checks if !prof metadata is correct in deadargelim.
define void @caller() #0 { define void @caller() #0 {
; CHECK-LABEL: define {{[^@]+}}@caller() { ; CHECK-LABEL: define {{[^@]+}}@caller() {
; CHECK-NEXT: call void @promote_i32_ptr(i32 42), !prof [[PROF0:![0-9]+]] ; CHECK-NEXT: call void @promote_i32_ptr(i32 42), !prof [[PROF0:![0-9]+]]
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%x = alloca i32 %x = alloca i32
store i32 42, i32* %x store i32 42, i32* %x
Show All 19 Lines

llvm/test/Transforms/Attributor/ArgumentPromotion/profile.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -attributor -enable-new-pm=0 -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_NPM,NOT_CGSCC_OPM,NOT_TUNIT_NPM,IS__TUNIT____,IS________OPM,IS__TUNIT_OPM ; RUN: opt -attributor -enable-new-pm=0 -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_NPM,NOT_CGSCC_OPM,NOT_TUNIT_NPM,IS__TUNIT____,IS________OPM,IS__TUNIT_OPM
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_OPM,NOT_CGSCC_NPM,NOT_TUNIT_OPM,IS__TUNIT____,IS________NPM,IS__TUNIT_NPM ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_OPM,NOT_CGSCC_NPM,NOT_TUNIT_OPM,IS__TUNIT____,IS________NPM,IS__TUNIT_NPM
; RUN: opt -attributor-cgscc -enable-new-pm=0 -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_TUNIT_NPM,NOT_TUNIT_OPM,NOT_CGSCC_NPM,IS__CGSCC____,IS________OPM,IS__CGSCC_OPM ; RUN: opt -attributor-cgscc -enable-new-pm=0 -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_TUNIT_NPM,NOT_TUNIT_OPM,NOT_CGSCC_NPM,IS__CGSCC____,IS________OPM,IS__CGSCC_OPM
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_TUNIT_NPM,NOT_TUNIT_OPM,NOT_CGSCC_OPM,IS__CGSCC____,IS________NPM,IS__CGSCC_NPM ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_TUNIT_NPM,NOT_TUNIT_OPM,NOT_CGSCC_OPM,IS__CGSCC____,IS________NPM,IS__CGSCC_NPM
target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128" target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
; Checks if !prof metadata is corret in deadargelim. ; Checks if !prof metadata is correct in deadargelim.
define void @caller() #0 { define void @caller() #0 {
; IS________OPM-LABEL: define {{[^@]+}}@caller() { ; IS________OPM-LABEL: define {{[^@]+}}@caller() {
; IS________OPM-NEXT: [[X:%.*]] = alloca i32, align 4 ; IS________OPM-NEXT: [[X:%.*]] = alloca i32, align 4
; IS________OPM-NEXT: store i32 42, i32* [[X]], align 4 ; IS________OPM-NEXT: store i32 42, i32* [[X]], align 4
; IS________OPM-NEXT: call void @promote_i32_ptr(i32* noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[X]]), !prof [[PROF0:![0-9]+]] ; IS________OPM-NEXT: call void @promote_i32_ptr(i32* noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[X]]), !prof [[PROF0:![0-9]+]]
; IS________OPM-NEXT: ret void ; IS________OPM-NEXT: ret void
; ;
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

llvm/test/Transforms/Attributor/dereferenceable-1.ll

Show First 20 Lines • Show All 304 Lines • ▼ Show 20 Lines
; CHECK-NEXT: store i32 1, i32* [[TMP0]], align 4 ; CHECK-NEXT: store i32 1, i32* [[TMP0]], align 4
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
store i32 1, i32* %0 store i32 1, i32* %0
ret void ret void
} }
; TEST 8 ; TEST 8
; Use Constant range in deereferenceable ; Use Constant range in dereferenceable
; void g(int *p, long long int *range){ ; void g(int *p, long long int *range){
; int r = *range ; // [10, 99] ; int r = *range ; // [10, 99]
; fill_range(p, *range); ; fill_range(p, *range);
; } ; }
; FIXME: %ptr should be dereferenceable(31) ; FIXME: %ptr should be dereferenceable(31)
define void @test8(i8* %ptr) #0 { define void @test8(i8* %ptr) #0 {
; IS________OPM: Function Attrs: argmemonly nofree norecurse nosync nounwind writeonly ; IS________OPM: Function Attrs: argmemonly nofree norecurse nosync nounwind writeonly
▲ Show 20 Lines • Show All 695 Lines • Show Last 20 Lines

llvm/test/Transforms/Attributor/liveness.ll

Show First 20 Lines • Show All 491 Lines • ▼ Show 20 Linescontinue:
%p = phi i32 [ %call, %cond.true ], [ %call1, %cond.false ] %p = phi i32 [ %call, %cond.true ], [ %call1, %cond.false ]
ret i32 %p ret i32 %p
cleanup: cleanup:
%res = landingpad { i8*, i32 } catch i8* null %res = landingpad { i8*, i32 } catch i8* null
ret i32 0 ret i32 0
} }
; TEST 6: Undefined behvior, taken from LangRef. ; TEST 6: Undefined behavior, taken from LangRef.
; FIXME: Should be able to detect undefined behavior. ; FIXME: Should be able to detect undefined behavior.
define void @ub(i32* %0) { define void @ub(i32* %0) {
; NOT_CGSCC_NPM: Function Attrs: argmemonly nofree norecurse nosync nounwind willreturn writeonly ; NOT_CGSCC_NPM: Function Attrs: argmemonly nofree norecurse nosync nounwind willreturn writeonly
; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@ub ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@ub
; NOT_CGSCC_NPM-SAME: (i32* nocapture nofree writeonly [[TMP0:%.*]]) #[[ATTR7:[0-9]+]] { ; NOT_CGSCC_NPM-SAME: (i32* nocapture nofree writeonly [[TMP0:%.*]]) #[[ATTR7:[0-9]+]] {
; NOT_CGSCC_NPM-NEXT: [[POISON:%.*]] = sub nuw i32 0, 1 ; NOT_CGSCC_NPM-NEXT: [[POISON:%.*]] = sub nuw i32 0, 1
; NOT_CGSCC_NPM-NEXT: [[STILL_POISON:%.*]] = and i32 [[POISON]], 0 ; NOT_CGSCC_NPM-NEXT: [[STILL_POISON:%.*]] = and i32 [[POISON]], 0
▲ Show 20 Lines • Show All 2,180 Lines • Show Last 20 Lines

llvm/test/Transforms/CodeGenPrepare/AArch64/widen_switch.ll

;; AArch64 is arbitralily chosen as a 32/64-bit RISC representative to show the transform in all tests. ;; AArch64 is arbitrarily chosen as a 32/64-bit RISC representative to show the transform in all tests.
; RUN: opt < %s -codegenprepare -S -mtriple=aarch64-unknown-unknown | FileCheck %s --check-prefix=ARM64 ; RUN: opt < %s -codegenprepare -S -mtriple=aarch64-unknown-unknown | FileCheck %s --check-prefix=ARM64
; AArch64 widens to 32-bit. ; AArch64 widens to 32-bit.
define i32 @widen_switch_i16(i32 %a) { define i32 @widen_switch_i16(i32 %a) {
entry: entry:
%trunc = trunc i32 %a to i16 %trunc = trunc i32 %a to i16
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadArgElim/aggregates.ll

Show First 20 Lines • Show All 125 Lines • ▼ Show 20 Lines
} }
define i32 @test_ret_applies_to_all() { define i32 @test_ret_applies_to_all() {
%val = call {i32, i32} @ret_applies_to_all({i32, i32} {i32 42, i32 43}) %val = call {i32, i32} @ret_applies_to_all({i32, i32} {i32 42, i32 43})
%ret = extractvalue {i32, i32} %val, 1 %ret = extractvalue {i32, i32} %val, 1
ret i32 %ret ret i32 %ret
} }
; Case 6: When considering @mid, the return instruciton has sub-value 0 ; Case 6: When considering @mid, the return instruction has sub-value 0
; unconditionally live, but 1 only conditionally live. Since at that level we're ; unconditionally live, but 1 only conditionally live. Since at that level we're
; applying the results to the whole of %res, this means %res is live and cannot ; applying the results to the whole of %res, this means %res is live and cannot
; be reduced. There is scope for further optimisation here (though not visible ; be reduced. There is scope for further optimisation here (though not visible
; in this test-case). ; in this test-case).
; CHECK-LABEL: define internal { i8*, i32 } @inner() ; CHECK-LABEL: define internal { i8*, i32 } @inner()
define internal {i8*, i32} @mid() { define internal {i8*, i32} @mid() {
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadArgElim/call_profile.ll

; RUN: opt -passes=deadargelim -S < %s | FileCheck %s ; RUN: opt -passes=deadargelim -S < %s | FileCheck %s
; Checks if !prof metadata is corret in deadargelim. ; Checks if !prof metadata is correct in deadargelim.
define void @caller() #0 { define void @caller() #0 {
; CHECK: call void @test_vararg(), !prof ![[PROF:[0-9]]] ; CHECK: call void @test_vararg(), !prof ![[PROF:[0-9]]]
; CHECK: call void @test(), !prof ![[PROF]] ; CHECK: call void @test(), !prof ![[PROF]]
call void (i32, ...) @test_vararg(i32 1), !prof !0 call void (i32, ...) @test_vararg(i32 1), !prof !0
call void @test(i32 1), !prof !0 call void @test(i32 1), !prof !0
ret void ret void
} }
Show All 11 Lines

llvm/test/Transforms/EarlyCSE/fence.ll

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Lines
; CHECK: ret ; CHECK: ret
%a = load i32, ptr %addr.i, align 4 %a = load i32, ptr %addr.i, align 4
fence acquire fence acquire
%a2 = load i32, ptr %addr.i, align 4 %a2 = load i32, ptr %addr.i, align 4
%res = sub i32 %a, %a2 %res = sub i32 %a, %a2
ret i32 %res ret i32 %res
} }
; We can not dead store eliminate accross the fence. We could in ; We can not dead store eliminate across the fence. We could in
; principal reorder the second store above the fence and then DSE either ; principal reorder the second store above the fence and then DSE either
; store, but this is beyond the simple last-store DSE which EarlyCSE ; store, but this is beyond the simple last-store DSE which EarlyCSE
; implements. ; implements.
define void @test4(ptr %addr.i) { define void @test4(ptr %addr.i) {
; CHECK-LABEL: @test4 ; CHECK-LABEL: @test4
; CHECK: store ; CHECK: store
; CHECK: fence ; CHECK: fence
; CHECK: store ; CHECK: store
Show All 20 Lines

llvm/test/Transforms/EarlyCSE/invariant.start.ll

Show First 20 Lines • Show All 569 Lines • ▼ Show 20 Lines;
%v1 = load i32, ptr %p %v1 = load i32, ptr %p
call void @clobber() call void @clobber()
%v2 = load i32, ptr %p %v2 = load i32, ptr %p
call void @llvm.invariant.end.p0(ptr %scope, i64 4, ptr %p) call void @llvm.invariant.end.p0(ptr %scope, i64 4, ptr %p)
%sub = sub i32 %v1, %v2 %sub = sub i32 %v1, %v2
ret i32 %sub ret i32 %sub
} }
; Invariant load defact starts an invariant.start scope of the appropriate size ; Invariant load defacto starts an invariant.start scope of the appropriate size
define i32 @test_invariant_load_scope(ptr %p) { define i32 @test_invariant_load_scope(ptr %p) {
; NO_ASSUME-LABEL: define {{[^@]+}}@test_invariant_load_scope ; NO_ASSUME-LABEL: define {{[^@]+}}@test_invariant_load_scope
; NO_ASSUME-SAME: (ptr [[P:%.*]]) ; NO_ASSUME-SAME: (ptr [[P:%.*]])
; NO_ASSUME-NEXT: [[V1:%.*]] = load i32, ptr [[P]], align 4, !invariant.load !4 ; NO_ASSUME-NEXT: [[V1:%.*]] = load i32, ptr [[P]], align 4, !invariant.load !4
; NO_ASSUME-NEXT: call void @clobber() ; NO_ASSUME-NEXT: call void @clobber()
; NO_ASSUME-NEXT: ret i32 0 ; NO_ASSUME-NEXT: ret i32 0
; ;
; USE_ASSUME-LABEL: define {{[^@]+}}@test_invariant_load_scope ; USE_ASSUME-LABEL: define {{[^@]+}}@test_invariant_load_scope
Show All 19 Lines

llvm/test/Transforms/GlobalOpt/invariant.group.ll

Show All 39 Linesenter:
ret void ret void
} }
; We can't step through launder.invariant.group here, because that would change ; We can't step through launder.invariant.group here, because that would change
; this load in @usage_of_globals() ; this load in @usage_of_globals()
; %val = load i32, i32* %ptrVal, !invariant.group !0 ; %val = load i32, i32* %ptrVal, !invariant.group !0
; into ; into
; %val = load i32, i32* @tmp3, !invariant.group !0 ; %val = load i32, i32* @tmp3, !invariant.group !0
; and then we could assume that %val and %val2 to be the same, which coud be ; and then we could assume that %val and %val2 to be the same, which could be
; false, because @changeTmp3ValAndCallBarrierInside() may change the value ; false, because @changeTmp3ValAndCallBarrierInside() may change the value
; of @tmp3. ; of @tmp3.
define void @_not_optimizable() { define void @_not_optimizable() {
enter: enter:
store i32 13, i32* @tmp3, !invariant.group !0 store i32 13, i32* @tmp3, !invariant.group !0
%0 = bitcast i32* @tmp3 to i8* %0 = bitcast i32* @tmp3 to i8*
%barr = call i8* @llvm.launder.invariant.group(i8* %0) %barr = call i8* @llvm.launder.invariant.group(i8* %0)
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

llvm/test/Transforms/GuardWidening/posion.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -guard-widening -dce < %s | FileCheck %s ; RUN: opt -S -guard-widening -dce < %s | FileCheck %s
; FIXME: All the tests below must be fixed. ; FIXME: All the tests below must be fixed.
declare void @llvm.experimental.guard(i1,...) declare void @llvm.experimental.guard(i1,...)
; This tests shows the incorrect behavior of guard widening in terms of ; This tests shows the incorrect behavior of guard widening in terms of
; interaction with poison values. ; interaction with poison values.
; Let x incoming parameter is used for rane checks. ; Let x incoming parameter is used for rane checks.
; Test generates 5 checks. One of them (c2) is used to get the corretness ; Test generates 5 checks. One of them (c2) is used to get the correctness
; of nuw/nsw flags for x3 and x5. Others are used in guards and represent ; of nuw/nsw flags for x3 and x5. Others are used in guards and represent
; the checks x + 10 u< L, x + 15 u< L, x + 20 u< L and x + 3 u< L. ; the checks x + 10 u< L, x + 15 u< L, x + 20 u< L and x + 3 u< L.
; The first two checks are in the first basic block and guard widening ; The first two checks are in the first basic block and guard widening
; considers them as profitable to combine. ; considers them as profitable to combine.
; When c4 and c3 are considered, number of check becomes more than two ; When c4 and c3 are considered, number of check becomes more than two
; and combineRangeCheck consider them as profitable even if they are in ; and combineRangeCheck consider them as profitable even if they are in
; different basic blocks. ; different basic blocks.
; Accoding to algorithm of combineRangeCheck it detects that c3 and c4 ; According to algorithm of combineRangeCheck it detects that c3 and c4
; are enough to cover c1 and c5, so it ends up with guard of c3 && c4 ; are enough to cover c1 and c5, so it ends up with guard of c3 && c4
; while both of them are poison at entry. This is a bug. ; while both of them are poison at entry. This is a bug.
define void @combine_range_checks(i32 %x) { define void @combine_range_checks(i32 %x) {
; CHECK-LABEL: @combine_range_checks( ; CHECK-LABEL: @combine_range_checks(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[X2:%.*]] = add i32 [[X:%.*]], 0 ; CHECK-NEXT: [[X2:%.*]] = add i32 [[X:%.*]], 0
; CHECK-NEXT: [[C2:%.*]] = icmp ult i32 [[X2]], 200 ; CHECK-NEXT: [[C2:%.*]] = icmp ult i32 [[X2]], 200
▲ Show 20 Lines • Show All 124 Lines • Show Last 20 Lines

llvm/test/Transforms/IndVarSimplify/lftr-dead-ivs.ll

Show All 11 Lines
; Provide legal integer types. ; Provide legal integer types.
target datalayout = "n8:16:32:64" target datalayout = "n8:16:32:64"
@data = common global [240 x i8] zeroinitializer, align 16 @data = common global [240 x i8] zeroinitializer, align 16
;; In this example, the pointer IV is dynamicaly dead. As such, the fact that ;; In this example, the pointer IV is dynamicaly dead. As such, the fact that
;; inbounds produces poison *does not* trigger UB in the original loop. As ;; inbounds produces poison *does not* trigger UB in the original loop. As
;; such, the pointer IV can be poison and adding a new use of the pointer ;; such, the pointer IV can be poison and adding a new use of the pointer
;; IV which dependends on that poison computation in a manner which might ;; IV which depends on that poison computation in a manner which might
;; trigger UB would be incorrect. ;; trigger UB would be incorrect.
;; FIXME: This currently shows a miscompile! ;; FIXME: This currently shows a miscompile!
define void @neg_dynamically_dead_inbounds(i1 %always_false) #0 { define void @neg_dynamically_dead_inbounds(i1 %always_false) #0 {
; CHECK-LABEL: @neg_dynamically_dead_inbounds( ; CHECK-LABEL: @neg_dynamically_dead_inbounds(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[LOOP:%.*]] ; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop: ; CHECK: loop:
; CHECK-NEXT: [[I_0:%.*]] = phi i8 [ 0, [[ENTRY:%.*]] ], [ [[TMP4:%.*]], [[CONT:%.*]] ] ; CHECK-NEXT: [[I_0:%.*]] = phi i8 [ 0, [[ENTRY:%.*]] ], [ [[TMP4:%.*]], [[CONT:%.*]] ]
▲ Show 20 Lines • Show All 227 Lines • Show Last 20 Lines

llvm/test/Transforms/Inline/inline_call.ll

Show All 15 Linesentry:
; CHECK: {{.*}} = {{.*}} call {{.*}} @ext ; CHECK: {{.*}} = {{.*}} call {{.*}} @ext
; CHECK-NOT: {{.*}} = {{.*}} call {{.*}} @third ; CHECK-NOT: {{.*}} = {{.*}} call {{.*}} @third
; CHECK-NOT: {{.*}} = {{.*}} call {{.*}} @second ; CHECK-NOT: {{.*}} = {{.*}} call {{.*}} @second
; CHECK-NOT: {{.*}} = {{.*}} call {{.*}} @wrapper ; CHECK-NOT: {{.*}} = {{.*}} call {{.*}} @wrapper
%q = alloca i8*, align 8 %q = alloca i8*, align 8
store i8* bitcast (void ()* @third to i8*), i8** %q, align 8 store i8* bitcast (void ()* @third to i8*), i8** %q, align 8
%tmp = call void (...)* @second(i8** %q) %tmp = call void (...)* @second(i8** %q)
; The call to 'wrapper' here is to ensure that its function attributes ; The call to 'wrapper' here is to ensure that its function attributes
; i.e., returning its parameter and having no side effect, will be decuded ; i.e., returning its parameter and having no side effect, will be deduced
; before the next round of inlining happens to 'top' to expose the bug. ; before the next round of inlining happens to 'top' to expose the bug.
%call = call void (...)* @wrapper(void (...)* %tmp) %call = call void (...)* @wrapper(void (...)* %tmp)
; The indirect call here is to confuse the alias analyzer so that ; The indirect call here is to confuse the alias analyzer so that
; an incomplete graph will be built during the first round of inlining. ; an incomplete graph will be built during the first round of inlining.
; This allows the current function to be processed before the actual ; This allows the current function to be processed before the actual
; callee, i.e., the function 'run', is processed. Once it's simplified to ; callee, i.e., the function 'run', is processed. Once it's simplified to
; a direct call, it also enables an additional round of inlining with all ; a direct call, it also enables an additional round of inlining with all
; function attributes deduced. ; function attributes deduced.
Show All 31 Lines
entry: entry:
%f = alloca void (...)*, align 8 %f = alloca void (...)*, align 8
%call = call void (...)* @gen() %call = call void (...)* @gen()
store void (...)* %call, void (...)** %f, align 8 store void (...)* %call, void (...)** %f, align 8
%tmp = load void (...)*, void (...)** %f, align 8 %tmp = load void (...)*, void (...)** %f, align 8
call void @run(void (...)* %tmp) call void @run(void (...)* %tmp)
ret void ret void
} }
No newline at end of file No newline at end of file

llvm/test/Transforms/InstCombine/memchr-10.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -passes=instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; ;
; Verify that the result of memchr calls with past-the-end pointers used ; Verify that the result of memchr calls with past-the-end pointers used
; in equality expressions don't cause trouble and either are folded when ; in equality expressions don't cause trouble and either are folded when
; they might be valid or not when they're provably undefined. ; they might be valid or not when they're provably undefined.
declare i8* @memchr(i8*, i32, i64) declare i8* @memchr(i8*, i32, i64)
@a5 = constant [5 x i8] c"12345" @a5 = constant [5 x i8] c"12345"
; Fold memchr(a5 + 5, c, 1) == a5 + 5 to an arbitrary constrant. ; Fold memchr(a5 + 5, c, 1) == a5 + 5 to an arbitrary constraint.
; The call is transformed to a5[5] == c by the memchr simplifier, with ; The call is transformed to a5[5] == c by the memchr simplifier, with
; a5[5] being indeterminate. The equality then is the folded with ; a5[5] being indeterminate. The equality then is the folded with
; an undefined/arbitrary result. ; an undefined/arbitrary result.
define i1 @call_memchr_ap5_c_1_eq_a(i32 %c, i64 %n) { define i1 @call_memchr_ap5_c_1_eq_a(i32 %c, i64 %n) {
; CHECK-LABEL: @call_memchr_ap5_c_1_eq_a( ; CHECK-LABEL: @call_memchr_ap5_c_1_eq_a(
; CHECK-NEXT: ret i1 ; CHECK-NEXT: ret i1
; ;
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/zext.ll

Show First 20 Lines • Show All 118 Lines • ▼ Show 20 Lines;
%1 = icmp sgt i64 %a, %b %1 = icmp sgt i64 %a, %b
%2 = zext i1 %1 to i8 %2 = zext i1 %1 to i8
%3 = icmp slt i64 %a, %c %3 = icmp slt i64 %a, %c
%4 = zext i1 %3 to i8 %4 = zext i1 %3 to i8
%5 = xor i8 %2, %4 %5 = xor i8 %2, %4
ret i8 %5 ret i8 %5
} }
; Assert that zexts in logic(zext(icmp), zext(icmp)) are also folded accross ; Assert that zexts in logic(zext(icmp), zext(icmp)) are also folded across
; nested logical operators. ; nested logical operators.
define i8 @fold_nested_logic_zext_icmp(i64 %a, i64 %b, i64 %c, i64 %d) { define i8 @fold_nested_logic_zext_icmp(i64 %a, i64 %b, i64 %c, i64 %d) {
; CHECK-LABEL: @fold_nested_logic_zext_icmp( ; CHECK-LABEL: @fold_nested_logic_zext_icmp(
; CHECK-NEXT: [[TMP1:%.*]] = icmp sgt i64 [[A:%.*]], [[B:%.*]] ; CHECK-NEXT: [[TMP1:%.*]] = icmp sgt i64 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[TMP2:%.*]] = icmp slt i64 [[A]], [[C:%.*]] ; CHECK-NEXT: [[TMP2:%.*]] = icmp slt i64 [[A]], [[C:%.*]]
; CHECK-NEXT: [[TMP3:%.*]] = and i1 [[TMP1]], [[TMP2]] ; CHECK-NEXT: [[TMP3:%.*]] = and i1 [[TMP1]], [[TMP2]]
; CHECK-NEXT: [[TMP4:%.*]] = icmp eq i64 [[A]], [[D:%.*]] ; CHECK-NEXT: [[TMP4:%.*]] = icmp eq i64 [[A]], [[D:%.*]]
▲ Show 20 Lines • Show All 377 Lines • Show Last 20 Lines

llvm/test/Transforms/LICM/hoist-phi.ll

Show First 20 Lines • Show All 968 Lines • ▼ Show 20 Lines
cond2.end: cond2.end:
br label %end br label %end
end: end:
%phi2 = phi i32 [ 1, %cond1 ], [ 2, %cond1.else ], [ 3, %cond1.end ], [ 4, %cond2 ], [ 5, %cond2.else ], [ 6, %cond2.end ] %phi2 = phi i32 [ 1, %cond1 ], [ 2, %cond1.else ], [ 3, %cond1.end ], [ 4, %cond2 ], [ 5, %cond2.else ], [ 6, %cond2.end ]
br label %loop br label %loop
} }
; Check that we correctly handle the hoisting of %gep when theres a critical ; Check that we correctly handle the hoisting of %gep when there's a critical
; edge that branches to the preheader. ; edge that branches to the preheader.
; CHECK-LABEL: @crit_edge ; CHECK-LABEL: @crit_edge
define void @crit_edge(i32* %ptr, i32 %idx, i1 %cond1, i1 %cond2) { define void @crit_edge(i32* %ptr, i32 %idx, i1 %cond1, i1 %cond2) {
; CHECK-LABEL: entry: ; CHECK-LABEL: entry:
; CHECK: %gep = getelementptr inbounds i32, i32* %ptr, i32 %idx ; CHECK: %gep = getelementptr inbounds i32, i32* %ptr, i32 %idx
; CHECK: br label %preheader ; CHECK: br label %preheader
entry: entry:
br label %preheader br label %preheader
▲ Show 20 Lines • Show All 533 Lines • Show Last 20 Lines

llvm/test/Transforms/LoadStoreVectorizer/AMDGPU/multiple_tails.ll

Show All 20 Linesdefine amdgpu_kernel void @no_crash(i32 %arg) {
store i32 0, i32 addrspace(3)* %tmp3, align 4 store i32 0, i32 addrspace(3)* %tmp3, align 4
store i32 0, i32 addrspace(3)* %tmp5, align 4 store i32 0, i32 addrspace(3)* %tmp5, align 4
store i32 0, i32 addrspace(3)* %tmp5, align 4 store i32 0, i32 addrspace(3)* %tmp5, align 4
store i32 0, i32 addrspace(3)* %tmp5, align 4 store i32 0, i32 addrspace(3)* %tmp5, align 4
ret void ret void
} }
; Check adjiacent memory locations are properly matched and the ; Check adjacent memory locations are properly matched and the
; longest chain vectorized ; longest chain vectorized
; GCN-LABEL: @interleave_get_longest ; GCN-LABEL: @interleave_get_longest
; GFX7: load <2 x i32> ; GFX7: load <2 x i32>
; GFX7: load i32 ; GFX7: load i32
; GFX7: store <2 x i32> zeroinitializer ; GFX7: store <2 x i32> zeroinitializer
; GFX7: load i32 ; GFX7: load i32
Show All 36 Lines

llvm/test/Transforms/LoopFusion/cannot_fuse.ll

Show First 20 Lines • Show All 70 Lines • ▼ Show 20 Lines
bb33.loopexit: ; preds = %bb30 bb33.loopexit: ; preds = %bb30
br label %bb33 br label %bb33
bb33: ; preds = %bb33.loopexit, %bb16, %bb34 bb33: ; preds = %bb33.loopexit, %bb16, %bb34
ret void ret void
} }
; Check that fusion detects the two canddates are not adjacent (the exit block ; Check that fusion detects the two candidates are not adjacent (the exit block
; of the first candidate is not the preheader of the second candidate). ; of the first candidate is not the preheader of the second candidate).
; CHECK: Performing Loop Fusion on function non_adjacent ; CHECK: Performing Loop Fusion on function non_adjacent
; CHECK: Fusion Candidates: ; CHECK: Fusion Candidates:
; CHECK: *** Fusion Candidate Set *** ; CHECK: *** Fusion Candidate Set ***
; CHECK-NEXT: [[LOOP1PREHEADER:bb[0-9]*]] ; CHECK-NEXT: [[LOOP1PREHEADER:bb[0-9]*]]
; CHECK-NEXT: [[LOOP2PREHEADER:bb[0-9]*]] ; CHECK-NEXT: [[LOOP2PREHEADER:bb[0-9]*]]
; CHECK-NEXT: **************************** ; CHECK-NEXT: ****************************
▲ Show 20 Lines • Show All 329 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopStrengthReduce/X86/lsr-insns-2.ll

Show All 12 Lines
; REGS: %lsr.iv4 = phi ; REGS: %lsr.iv4 = phi
; REGS: %lsr.iv2 = phi ; REGS: %lsr.iv2 = phi
; REGS: %lsr.iv1 = phi ; REGS: %lsr.iv1 = phi
; REGS: getelementptr i32, i32* %lsr.iv1, i64 1 ; REGS: getelementptr i32, i32* %lsr.iv1, i64 1
; REGS: getelementptr i32, i32* %lsr.iv2, i64 1 ; REGS: getelementptr i32, i32* %lsr.iv2, i64 1
; REGS: getelementptr i32, i32* %lsr.iv4, i64 1 ; REGS: getelementptr i32, i32* %lsr.iv4, i64 1
; LLC checks that LSR prefers less instructions to less registers. ; LLC checks that LSR prefers less instructions to less registers.
; LSR should prefer complicated address to additonal add instructions. ; LSR should prefer complicated address to additional add instructions.
; CHECK: LBB0_2: ; CHECK: LBB0_2:
; CHECK-NEXT: movl (%r{{.+}}, ; CHECK-NEXT: movl (%r{{.+}},
; CHECK-NEXT: addl (%r{{.+}}, ; CHECK-NEXT: addl (%r{{.+}},
; CHECK-NEXT: movl %e{{.+}}, (%r{{.+}}, ; CHECK-NEXT: movl %e{{.+}}, (%r{{.+}},
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
Show All 29 Lines

llvm/test/Transforms/LoopStrengthReduce/pr50765.ll

; RUN: opt -S -loop-reduce < %s | FileCheck %s ; RUN: opt -S -loop-reduce < %s | FileCheck %s
; ;
;This test produces zero factor that becomes a denumerator and fails an assetion. ;This test produces zero factor that becomes a denumerator and fails an assertion.
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128-ni:1-p2:32:8:8:32-ni:2" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128-ni:1-p2:32:8:8:32-ni:2"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @test() { define void @test() {
; CHECK-LABEL: test ; CHECK-LABEL: test
bb: bb:
%tmp = load i32, i32 addrspace(3)* undef, align 4 %tmp = load i32, i32 addrspace(3)* undef, align 4
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopUnroll/full-unroll-heuristics.ll

; In this test we check how heuristics for complete unrolling work. We have ; In this test we check how heuristics for complete unrolling work. We have
; three knobs: ; three knobs:
; 1) -unroll-threshold ; 1) -unroll-threshold
; 3) -unroll-percent-dynamic-cost-saved-threshold and ; 3) -unroll-percent-dynamic-cost-saved-threshold and
; 2) -unroll-dynamic-cost-savings-discount ; 2) -unroll-dynamic-cost-savings-discount
; ;
; They control loop-unrolling according to the following rules: ; They control loop-unrolling according to the following rules:
; * If size of unrolled loop exceeds the absoulte threshold, we don't unroll ; * If size of unrolled loop exceeds the absolute threshold, we don't unroll
; this loop under any circumstances. ; this loop under any circumstances.
; * If size of unrolled loop is below the '-unroll-threshold', then we'll ; * If size of unrolled loop is below the '-unroll-threshold', then we'll
; consider this loop as a very small one, and completely unroll it. ; consider this loop as a very small one, and completely unroll it.
; * If a loop size is between these two tresholds, we only do complete unroll ; * If a loop size is between these two tresholds, we only do complete unroll
; it if estimated number of potentially optimized instructions is high (we ; it if estimated number of potentially optimized instructions is high (we
; specify the minimal percent of such instructions). ; specify the minimal percent of such instructions).
; In this particular test-case, complete unrolling will allow later ; In this particular test-case, complete unrolling will allow later
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopUnroll/peel-loop-noalias-scope-decl.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -S -loop-unroll -unroll-force-peel-count=1 | FileCheck %s ; RUN: opt < %s -S -loop-unroll -unroll-force-peel-count=1 | FileCheck %s
; RUN: opt < %s -S -passes='loop-unroll<peeling;no-runtime>' -unroll-force-peel-count=1 | FileCheck %s ; RUN: opt < %s -S -passes='loop-unroll<peeling;no-runtime>' -unroll-force-peel-count=1 | FileCheck %s
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; Loop peeling must result in valid scope declartions ; Loop peeling must result in valid scope declarations
define internal fastcc void @test01(i8* %p0, i8* %p1, i8* %p2) unnamed_addr align 2 { define internal fastcc void @test01(i8* %p0, i8* %p1, i8* %p2) unnamed_addr align 2 {
; CHECK-LABEL: @test01( ; CHECK-LABEL: @test01(
; CHECK-NEXT: for.body47.lr.ph: ; CHECK-NEXT: for.body47.lr.ph:
; CHECK-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata !0) ; CHECK-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata !0)
; CHECK-NEXT: br label [[FOR_BODY47_PEEL_BEGIN:%.*]] ; CHECK-NEXT: br label [[FOR_BODY47_PEEL_BEGIN:%.*]]
; CHECK: for.body47.peel.begin: ; CHECK: for.body47.peel.begin:
; CHECK-NEXT: br label [[FOR_BODY47_PEEL:%.*]] ; CHECK-NEXT: br label [[FOR_BODY47_PEEL:%.*]]
▲ Show 20 Lines • Show All 133 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopUnrollAndJam/unroll-and-jam.ll

Show First 20 Lines • Show All 697 Lines • ▼ Show 20 Lines
for.end: for.end:
%.lcssa.lcssa = phi i32 [ %.lcssa, %for.latch ] %.lcssa.lcssa = phi i32 [ %.lcssa, %for.latch ]
%inc.lcssa.lcssa = phi i32 [ 7, %for.latch ] %inc.lcssa.lcssa = phi i32 [ 7, %for.latch ]
ret i32 0 ret i32 0
} }
; Has a positive dependency between two stores. Still valid. ; Has a positive dependency between two stores. Still valid.
; The negative dependecy is in unroll-and-jam-disabled.ll ; The negative dependency is in unroll-and-jam-disabled.ll
define void @test7(i32 %I, i32 %E, i32* noalias nocapture %A, i32* noalias nocapture readonly %B) #0 { define void @test7(i32 %I, i32 %E, i32* noalias nocapture %A, i32* noalias nocapture readonly %B) #0 {
; CHECK-LABEL: @test7( ; CHECK-LABEL: @test7(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[CMP:%.*]] = icmp ne i32 [[E:%.*]], 0 ; CHECK-NEXT: [[CMP:%.*]] = icmp ne i32 [[E:%.*]], 0
; CHECK-NEXT: [[CMP128:%.*]] = icmp ne i32 [[I:%.*]], 0 ; CHECK-NEXT: [[CMP128:%.*]] = icmp ne i32 [[I:%.*]], 0
; CHECK-NEXT: [[OR_COND:%.*]] = and i1 [[CMP128]], [[CMP]] ; CHECK-NEXT: [[OR_COND:%.*]] = and i1 [[CMP128]], [[CMP]]
; CHECK-NEXT: br i1 [[OR_COND]], label [[FOR_PREHEADER:%.*]], label [[FOR_END:%.*]] ; CHECK-NEXT: br i1 [[OR_COND]], label [[FOR_PREHEADER:%.*]], label [[FOR_END:%.*]]
; CHECK: for.preheader: ; CHECK: for.preheader:
▲ Show 20 Lines • Show All 766 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/X86/masked_load_store.ll

Show First 20 Lines • Show All 1,315 Lines • ▼ Show 20 Lines
} }
; The source code: ; The source code:
; ;
;void foo4(double *A, double *B, int *trigger) { ;void foo4(double *A, double *B, int *trigger) {
; ;
; for (int i=0; i<10000; i += 16) { ; for (int i=0; i<10000; i += 16) {
; if (trigger[i] < 100) { ; if (trigger[i] < 100) {
; A[i] = B[i*2] + trigger[i]; << non-cosecutive access ; A[i] = B[i*2] + trigger[i]; << non-consecutive access
; } ; }
; } ; }
;} ;}
define void @foo4(double* nocapture %A, double* nocapture readonly %B, i32* nocapture readonly %trigger) local_unnamed_addr #0 { define void @foo4(double* nocapture %A, double* nocapture readonly %B, i32* nocapture readonly %trigger) local_unnamed_addr #0 {
; AVX-LABEL: @foo4( ; AVX-LABEL: @foo4(
; AVX-NEXT: entry: ; AVX-NEXT: entry:
; AVX-NEXT: br label [[FOR_BODY:%.*]] ; AVX-NEXT: br label [[FOR_BODY:%.*]]
▲ Show 20 Lines • Show All 1,304 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/X86/x86-interleaved-accesses-masked-group.ll

Show First 20 Lines • Show All 880 Lines • ▼ Show 20 Linesfor.body:
br i1 %exitcond, label %for.end, label %for.body br i1 %exitcond, label %for.end, label %for.body
for.end: for.end:
ret void ret void
} }
; Unconditioal accesses with gaps under Optsize scenario again, with unknown ; Unconditional accesses with gaps under Optsize scenario again, with unknown
; trip-count this time, in order to check the behavior of folding-the-tail ; trip-count this time, in order to check the behavior of folding-the-tail
; (folding the remainder loop into the main loop using masking) together with ; (folding the remainder loop into the main loop using masking) together with
; interleaved-groups. Folding-the-tail turns the accesses to conditional which ; interleaved-groups. Folding-the-tail turns the accesses to conditional which
; requires proper masking. In addition we need to mask out the gaps (all ; requires proper masking. In addition we need to mask out the gaps (all
; because we are not allowed to use an epilog due to optsize). ; because we are not allowed to use an epilog due to optsize).
; When enable-masked-interleaved-access is disabled, the interleave-groups will ; When enable-masked-interleaved-access is disabled, the interleave-groups will
; be invalidated during cost-model checks. So there we check for no epilogue ; be invalidated during cost-model checks. So there we check for no epilogue
; and for scalarized conditional accesses. ; and for scalarized conditional accesses.
▲ Show 20 Lines • Show All 2,226 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/skip-iterations.ll

; RUN: opt < %s -loop-vectorize -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; tests skipping iterations within a VF through break/continue/gotos. ; tests skipping iterations within a VF through break/continue/gotos.
; The main difficulty in vectorizing these loops in test1,test2 and test3 is ; The main difficulty in vectorizing these loops in test1,test2 and test3 is
; safely speculating that the widened load of A[i] should not fault if the ; safely speculating that the widened load of A[i] should not fault if the
; scalarized loop does not fault. For example, the ; scalarized loop does not fault. For example, the
; original load in the scalar loop may not fault, but the last iteration of the ; original load in the scalar loop may not fault, but the last iteration of the
; vectorized load can fault (if it crosses a page boudary for example). ; vectorized load can fault (if it crosses a page boundary for example).
; This last vector iteration is where *one* of the ; This last vector iteration is where *one* of the
; scalar iterations lead to the early exit. ; scalar iterations lead to the early exit.
; int test(int *A, int Length) { ; int test(int *A, int Length) {
; for (int i = 0; i < Length; i++) { ; for (int i = 0; i < Length; i++) {
; if (A[i] > 10.0) goto end; ; if (A[i] > 10.0) goto end;
; A[i] = 0; ; A[i] = 0;
; } ; }
▲ Show 20 Lines • Show All 162 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/vplan-widen-select-instruction.ll

; RUN: opt -loop-vectorize -force-vector-width=4 -enable-vplan-native-path -S %s | FileCheck %s ; RUN: opt -loop-vectorize -force-vector-width=4 -enable-vplan-native-path -S %s | FileCheck %s
; Test that VPlan native path is able to widen select instruction in the ; Test that VPlan native path is able to widen select instruction in the
; innermost loop under different conditions when outer loop is marked to be ; innermost loop under different conditions when outer loop is marked to be
; vectorized. These conditions include following: ; vectorized. These conditions include following:
; * Inner and outer loop invariant select condition ; * Inner and outer loop invariant select condition
; * Select condition depending on outer loop iteration variable. ; * Select condition depending on outer loop iteration variable.
; * Select condidition depending on inner loop iteration variable. ; * Select condition depending on inner loop iteration variable.
; * Select conditition depending on both outer and inner loop iteration ; * Select condition depending on both outer and inner loop iteration
; variables. ; variables.
define void @loop_invariant_select(double* noalias nocapture %out, i1 %select, double %a, double %b) { define void @loop_invariant_select(double* noalias nocapture %out, i1 %select, double %a, double %b) {
; CHECK-LABEL: @loop_invariant_select( ; CHECK-LABEL: @loop_invariant_select(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 false, label [[SCALAR_PH:%.*]], label [[VECTOR_PH:%.*]] ; CHECK-NEXT: br i1 false, label [[SCALAR_PH:%.*]], label [[VECTOR_PH:%.*]]
; CHECK: vector.ph: ; CHECK: vector.ph:
; CHECK-NEXT: [[BROADCAST_SPLATINSERT:%.*]] = insertelement <4 x double> poison, double [[A:%.*]], i32 0 ; CHECK-NEXT: [[BROADCAST_SPLATINSERT:%.*]] = insertelement <4 x double> poison, double [[A:%.*]], i32 0
▲ Show 20 Lines • Show All 183 Lines • Show Last 20 Lines

llvm/test/Transforms/LowerTypeTests/cfi-direct-call.ll

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
; as it may be overriden at run time. ; as it may be overriden at run time.
; CHECK-NEXT: call void @internal_default_def() ; CHECK-NEXT: call void @internal_default_def()
; Internal function with hidden visibility defined outside the module ; Internal function with hidden visibility defined outside the module
; generates a jump table entry and is renamed to *.cfi: route direct call ; generates a jump table entry and is renamed to *.cfi: route direct call
; to the actual function, not jump table ; to the actual function, not jump table
; CHECK-NEXT: call void @internal_hidden_def.cfi() ; CHECK-NEXT: call void @internal_hidden_def.cfi()
; dso_local function with defailt visibility can be short-circuited ; dso_local function with default visibility can be short-circuited
; CHECK-NEXT: call void @dsolocal_default_def.cfi() ; CHECK-NEXT: call void @dsolocal_default_def.cfi()
; Local call - no action ; Local call - no action
; CHECK-NEXT: call void @local_b ; CHECK-NEXT: call void @local_b
; CHECK-NEXT: ret i8 1 ; CHECK-NEXT: ret i8 1
; CHECK: declare hidden void @internal_hidden_def.cfi() ; CHECK: declare hidden void @internal_hidden_def.cfi()
; CHECK: declare hidden void @external_decl.cfi_jt() ; CHECK: declare hidden void @external_decl.cfi_jt()

llvm/test/Transforms/MergeFunc/vector-GEP-crash.ll

; RUN: opt -mergefunc -disable-output < %s ; RUN: opt -mergefunc -disable-output < %s
; This used to cause a crash when compairing the GEPs ; This used to cause a crash when comparing the GEPs
define void @foo(<2 x i64*>) { define void @foo(<2 x i64*>) {
%tmp = getelementptr i64, <2 x i64*> %0, <2 x i64> <i64 0, i64 0> %tmp = getelementptr i64, <2 x i64*> %0, <2 x i64> <i64 0, i64 0>
ret void ret void
} }
define void @bar(<2 x i64*>) { define void @bar(<2 x i64*>) {
%tmp = getelementptr i64, <2 x i64*> %0, <2 x i64> <i64 0, i64 0> %tmp = getelementptr i64, <2 x i64*> %0, <2 x i64> <i64 0, i64 0>
ret void ret void
} }

llvm/test/Transforms/Reassociate/xor_reassoc.ll

Show First 20 Lines • Show All 295 Lines • ▼ Show 20 Lines
; ;
%1 = ptrtoint i32* undef to i64 %1 = ptrtoint i32* undef to i64
%2 = xor i64 %1, ptrtoint (<{}>* @xor_bug1_data to i64) %2 = xor i64 %1, ptrtoint (<{}>* @xor_bug1_data to i64)
%3 = and i64 undef, %2 %3 = and i64 undef, %2
ret void ret void
} }
; The bug was that when the compiler optimize "(x | c1)" ^ "(x & c2)", it may ; The bug was that when the compiler optimize "(x | c1)" ^ "(x & c2)", it may
; swap the two xor-subexpressions if they are not in canoninical order; however, ; swap the two xor-subexpressions if they are not in canonical order; however,
; when optimizer swaps two sub-expressions, if forgot to swap the cached value ; when optimizer swaps two sub-expressions, if forgot to swap the cached value
; of c1 and c2 accordingly, hence cause the problem. ; of c1 and c2 accordingly, hence cause the problem.
; ;
define i32 @xor_bug2(i32, i32, i32, i32) { define i32 @xor_bug2(i32, i32, i32, i32) {
; CHECK-LABEL: @xor_bug2( ; CHECK-LABEL: @xor_bug2(
; CHECK-NEXT: [[TMP5:%.*]] = mul i32 [[TMP0:%.*]], 123 ; CHECK-NEXT: [[TMP5:%.*]] = mul i32 [[TMP0:%.*]], 123
; CHECK-NEXT: [[TMP6:%.*]] = and i32 [[TMP1:%.*]], 3456789 ; CHECK-NEXT: [[TMP6:%.*]] = and i32 [[TMP1:%.*]], 3456789
; CHECK-NEXT: [[TMP7:%.*]] = or i32 [[TMP6]], 4567890 ; CHECK-NEXT: [[TMP7:%.*]] = or i32 [[TMP6]], 4567890
Show All 30 Lines

llvm/test/Transforms/SROA/preserve-nonnull.ll

Show All 32 Linesentry:
%buf = alloca ptr %buf = alloca ptr
call void @llvm.memcpy.p0.p0.i64(ptr align 8 %buf, ptr align 8 %arg, i64 8, i1 false) call void @llvm.memcpy.p0.p0.i64(ptr align 8 %buf, ptr align 8 %arg, i64 8, i1 false)
%ret = load ptr, ptr %buf, align 8, !nonnull !0 %ret = load ptr, ptr %buf, align 8, !nonnull !0
ret ptr %ret ret ptr %ret
} }
; Make sure we properly handle the !nonnull attribute when we convert ; Make sure we properly handle the !nonnull attribute when we convert
; a pointer load to an integer load. ; a pointer load to an integer load.
; FIXME: While this doesn't do anythnig actively harmful today, it really ; FIXME: While this doesn't do anything actively harmful today, it really
; should propagate the !nonnull metadata to range metadata. The irony is, it ; should propagate the !nonnull metadata to range metadata. The irony is, it
; *does* initially, but then we lose that !range metadata before we finish ; *does* initially, but then we lose that !range metadata before we finish
; SROA. ; SROA.
define ptr @propagate_nonnull_to_int() { define ptr @propagate_nonnull_to_int() {
; CHECK-LABEL: define ptr @propagate_nonnull_to_int( ; CHECK-LABEL: define ptr @propagate_nonnull_to_int(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: %[[A:.*]] = alloca ptr ; CHECK-NEXT: %[[A:.*]] = alloca ptr
; CHECK-NEXT: store ptr inttoptr (i64 42 to ptr), ptr %[[A]] ; CHECK-NEXT: store ptr inttoptr (i64 42 to ptr), ptr %[[A]]
Show All 29 Lines

llvm/test/Transforms/SampleProfile/inline-mergeprof-dup.ll

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Lines
!10 = distinct !DILexicalBlock(scope: !6, file: !1, line: 10) !10 = distinct !DILexicalBlock(scope: !6, file: !1, line: 10)
!11 = !DILocation(line: 12, scope: !6) !11 = !DILocation(line: 12, scope: !6)
!12 = distinct !DISubprogram(name: "sum", scope: !1, file: !1, line: 3, type: !7, scopeLine: 3, virtualIndex: 6, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2) !12 = distinct !DISubprogram(name: "sum", scope: !1, file: !1, line: 3, type: !7, scopeLine: 3, virtualIndex: 6, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
!13 = !DILocation(line: 4, scope: !12) !13 = !DILocation(line: 4, scope: !12)
!14 = !DILocation(line: 5, scope: !12) !14 = !DILocation(line: 5, scope: !12)
!15 = !DILocation(line: 6, scope: !12) !15 = !DILocation(line: 6, scope: !12)
;; Check the profile of funciton sum is only merged once though the original callsite is replicted. ;; Check the profile of function sum is only merged once though the original callsite is replicted.
; CHECK: name: "sum" ; CHECK: name: "sum"
; CHECK-NEXT: {!"function_entry_count", i64 46} ; CHECK-NEXT: {!"function_entry_count", i64 46}
; CHECK: !{!"branch_weights", i32 11, i32 37} ; CHECK: !{!"branch_weights", i32 11, i32 37}
; CHECK: !{!"branch_weights", i32 11, i32 1} ; CHECK: !{!"branch_weights", i32 11, i32 1}

llvm/test/Transforms/SimplifyCFG/X86/remove-debug.ll

; RUN: opt < %s -simplifycfg -simplifycfg-require-and-preserve-domtree=1 -S -hoist-common-insts=true | FileCheck %s ; RUN: opt < %s -simplifycfg -simplifycfg-require-and-preserve-domtree=1 -S -hoist-common-insts=true | FileCheck %s
; TODO: Track the acutal DebugLoc of the hoisted instruction when no-line ; TODO: Track the actual DebugLoc of the hoisted instruction when no-line
; DebugLoc is supported (https://reviews.llvm.org/D24180) ; DebugLoc is supported (https://reviews.llvm.org/D24180)
; Checks if the debug info for hoisted "x = i" is removed and ; Checks if the debug info for hoisted "x = i" is removed and
; the debug info for hoisted "bar()" is set as line 0 ; the debug info for hoisted "bar()" is set as line 0
; int x; ; int x;
; void bar(); ; void bar();
; void baz(); ; void baz();
; ;
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

llvm/test/Transforms/SimplifyCFG/preserve-branchweights.ll

Show First 20 Lines • Show All 356 Lines • ▼ Show 20 Lines
b: b:
call void @helper(i32 1) nounwind call void @helper(i32 1) nounwind
ret void ret void
bees: bees:
call void @helper(i32 2) nounwind call void @helper(i32 2) nounwind
ret void ret void
} }
; Test edge splitting when the default target has icmp and unconditinal ; Test edge splitting when the default target has icmp and unconditional
; branch ; branch
define i1 @test9(i32 %x, i32 %y) nounwind { define i1 @test9(i32 %x, i32 %y) nounwind {
; CHECK-LABEL: @test9( ; CHECK-LABEL: @test9(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: switch i32 [[X:%.*]], label [[BEES:%.*]] [ ; CHECK-NEXT: switch i32 [[X:%.*]], label [[BEES:%.*]] [
; CHECK-NEXT: i32 0, label [[A:%.*]] ; CHECK-NEXT: i32 0, label [[A:%.*]]
; CHECK-NEXT: i32 1, label [[END:%.*]] ; CHECK-NEXT: i32 1, label [[END:%.*]]
; CHECK-NEXT: i32 2, label [[END]] ; CHECK-NEXT: i32 2, label [[END]]
▲ Show 20 Lines • Show All 793 Lines • Show Last 20 Lines

llvm/test/Transforms/SimplifyCFG/switch_thread.ll

Show First 20 Lines • Show All 92 Lines • ▼ Show 20 Lines
A: ; preds = %0 A: ; preds = %0
call void @foo1( ) call void @foo1( )
;; This switch is always statically determined. ;; This switch is always statically determined.
switch i32 %V, label %E [ switch i32 %V, label %E [
i32 4, label %C i32 4, label %C
i32 17, label %C i32 17, label %C
i32 42, label %D i32 42, label %D
] ]
;; unreacahble. ;; unreachable.
C: ; preds = %A, %A C: ; preds = %A, %A
call void @DEAD( ) call void @DEAD( )
ret void ret void
T: ; preds = %0 T: ; preds = %0
call void @foo1( ) call void @foo1( )
call void @foo1( ) call void @foo1( )
ret void ret void
D: ; preds = %A, %0 D: ; preds = %A, %0
call void @foo1( ) call void @foo1( )
ret void ret void
E: ; preds = %A, %0 E: ; preds = %A, %0
ret void ret void
} }

llvm/test/tools/llvm-objcopy/COFF/basic-copy.test

Test plain passthrough copying with llvm-objcopy, by checking that obj2yaml Test plain passthrough copying with llvm-objcopy, by checking that obj2yaml
produces identical output for both input and output object files/executables. produces identical output for both input and output object files/executables.
(Intentionally not comparing to the original input yaml, in case there are (Intentionally not comparing to the original input yaml, in case there are
superficial differences like line endings.) In order to have a check of the superficial differences like line endings.) In order to have a check of the
whole file and not just individual fields with FileCheck, checking with whole file and not just individual fields with FileCheck, checking with
obj2yaml+cmp instead of llvm-readobj+cmp, as llvm-readobj also prints file obj2yaml+cmp instead of llvm-readobj+cmp, as llvm-readobj also prints file
details that can differ between otherwise equal files (such as file offsets). details that can differ between otherwise equal files (such as file offsets).
Actual copied object files/executables can differ in, among others, the Actual copied object files/executables can differ in, among others, the
following aspects: following aspects:
- The padding of executable sections (lld uses 0xcc, which is int3 on x86) - The padding of executable sections (lld uses 0xcc, which is int3 on x86)
- The actual layout of the string table (it can be filled linearly, - The actual layout of the string table (it can be filled linearly,
strings can be dedupliated, the table can be optimized by sharing tails strings can be deduplicated, the table can be optimized by sharing tails
of longer strings; different parts in llvm do each of these three options) of longer strings; different parts in llvm do each of these three options)
- The size indication for an empty/missing string table can either be 4 - The size indication for an empty/missing string table can either be 4
or left out altogether or left out altogether
- Alignment of section data - Alignment of section data
- Checksums - Checksums
RUN: yaml2obj %p/Inputs/i386-obj.yaml -o %t.i386.o RUN: yaml2obj %p/Inputs/i386-obj.yaml -o %t.i386.o
RUN: llvm-objcopy %t.i386.o %t.i386-copy.o RUN: llvm-objcopy %t.i386.o %t.i386-copy.o
Show All 27 Lines

llvm/test/tools/llvm-objcopy/COFF/remove-section.test

Show All 40 Lines
# SYMBOLS-PRE-NEXT: AUX scnlen {{.*}} assoc 3 comdat 2 # SYMBOLS-PRE-NEXT: AUX scnlen {{.*}} assoc 3 comdat 2
# SYMBOLS-PRE-NEXT: {{.*}}(sec 3){{.*}} foo # SYMBOLS-PRE-NEXT: {{.*}}(sec 3){{.*}} foo
# SYMBOLS-PRE-NEXT: {{.*}}(sec 1){{.*}} main # SYMBOLS-PRE-NEXT: {{.*}}(sec 1){{.*}} main
# SYMBOLS-PRE-EMPTY: # SYMBOLS-PRE-EMPTY:
# #
# #
# Removing the .bss section removes one symbol and its aux symbol, # Removing the .bss section removes one symbol and its aux symbol,
# and updates the section indices in symbols pointing to later # and updates the section indices in symbols pointing to later
# symbols, including the aux section defintitions. # symbols, including the aux section definitions.
# #
# Testing that the absolute symbol @feat.00 survives the section number # Testing that the absolute symbol @feat.00 survives the section number
# mangling. # mangling.
# #
# SECTIONS-REMOVE-BSS: Sections: # SECTIONS-REMOVE-BSS: Sections:
# SECTIONS-REMOVE-BSS-NEXT: Idx Name # SECTIONS-REMOVE-BSS-NEXT: Idx Name
# SECTIONS-REMOVE-BSS-NEXT: 0 .text # SECTIONS-REMOVE-BSS-NEXT: 0 .text
# SECTIONS-REMOVE-BSS-NEXT: 1 .comdat # SECTIONS-REMOVE-BSS-NEXT: 1 .comdat
▲ Show 20 Lines • Show All 153 Lines • Show Last 20 Lines

llvm/test/tools/llvm-readobj/ELF/call-graph-profile.test

Show First 20 Lines • Show All 118 Lines • ▼ Show 20 Lines Relocations:
- Offset: 0x10 - Offset: 0x10
Symbol: 0x4 ## This index goes past the end of the symbol table. Symbol: 0x4 ## This index goes past the end of the symbol table.
Type: R_X86_64_NONE Type: R_X86_64_NONE
- Name: .strtab - Name: .strtab
Type: SHT_STRTAB Type: SHT_STRTAB
Content: "0041004200" ## '\0', 'A', '\0', 'B', '\0' Content: "0041004200" ## '\0', 'A', '\0', 'B', '\0'
Symbols: Symbols:
- StName: 1 ## 'A' - StName: 1 ## 'A'
- StName: 0xFF ## An arbitrary currupted index in the string table. - StName: 0xFF ## An arbitrary corrupted index in the string table.
- StName: 3 ## 'B' - StName: 3 ## 'B'
## Check we report a warning when a relocation section is not present. ## Check we report a warning when a relocation section is not present.
# RUN: yaml2obj %s --docnum=3 -o %t4.o # RUN: yaml2obj %s --docnum=3 -o %t4.o
# RUN: llvm-readobj %t4.o --cg-profile 2>&1 | FileCheck %s -DFILE=%t4.o --check-prefix=LLVM-NO-RELOC # RUN: llvm-readobj %t4.o --cg-profile 2>&1 | FileCheck %s -DFILE=%t4.o --check-prefix=LLVM-NO-RELOC
# RUN: llvm-readobj %t4.o --elf-cg-profile 2>&1 | FileCheck %s -DFILE=%t4.o --check-prefix=LLVM-NO-RELOC # RUN: llvm-readobj %t4.o --elf-cg-profile 2>&1 | FileCheck %s -DFILE=%t4.o --check-prefix=LLVM-NO-RELOC
# LLVM-NO-RELOC: warning: '[[FILE]]': relocation section for a call graph section doesn't exist # LLVM-NO-RELOC: warning: '[[FILE]]': relocation section for a call graph section doesn't exist
▲ Show 20 Lines • Show All 217 Lines • Show Last 20 Lines

llvm/test/tools/llvm-readobj/ELF/dynamic-reloc.test

Show All 9 Lines
# LLVM-NONE-NOT: {{.}} # LLVM-NONE-NOT: {{.}}
--- !ELF --- !ELF
FileHeader: FileHeader:
Class: ELFCLASS64 Class: ELFCLASS64
Data: ELFDATA2LSB Data: ELFDATA2LSB
Type: ET_DYN Type: ET_DYN
## Check that we dump all possbile dynamic relocation sections. ## Check that we dump all possible dynamic relocation sections.
# RUN: yaml2obj --docnum=2 %s -o %t2.1 # RUN: yaml2obj --docnum=2 %s -o %t2.1
# RUN: llvm-readobj --dyn-relocations %t2.1 2>&1 | \ # RUN: llvm-readobj --dyn-relocations %t2.1 2>&1 | \
# RUN: FileCheck %s --implicit-check-not=warning: --check-prefix=LLVM-RELOCS # RUN: FileCheck %s --implicit-check-not=warning: --check-prefix=LLVM-RELOCS
# RUN: llvm-readelf --dyn-relocations %t2.1 2>&1 | \ # RUN: llvm-readelf --dyn-relocations %t2.1 2>&1 | \
# RUN: FileCheck %s --implicit-check-not=warning: --strict-whitespace \ # RUN: FileCheck %s --implicit-check-not=warning: --strict-whitespace \
# RUN: --match-full-lines --check-prefixes=GNU-RELOCS,GNU-PLTREL # RUN: --match-full-lines --check-prefixes=GNU-RELOCS,GNU-PLTREL
## 7 == DT_RELA. ## 7 == DT_RELA.
▲ Show 20 Lines • Show All 139 Lines • Show Last 20 Lines

llvm/test/tools/llvm-readobj/ELF/mips-options-sec.test

Show First 20 Lines • Show All 70 Lines • ▼ Show 20 Lines ContentArray: [ [[KIND=0x1]], ## Kind. ODK_REGINFO == 1.
0x0, 0x0, 0x0, 0x0, ## Kind-specific information. 0x0, 0x0, 0x0, 0x0, ## Kind-specific information.
0xA, 0xB, 0xC, 0xD, ## ODK_REGINFO: bit-mask of used general registers. 0xA, 0xB, 0xC, 0xD, ## ODK_REGINFO: bit-mask of used general registers.
0x11, 0x22, 0x33, 0x44, ## ODK_REGINFO: unused padding field. 0x11, 0x22, 0x33, 0x44, ## ODK_REGINFO: unused padding field.
0x55, 0x66, 0x77, 0x88, ## ODK_REGINFO: bit-mask of used co-processor registers (0). 0x55, 0x66, 0x77, 0x88, ## ODK_REGINFO: bit-mask of used co-processor registers (0).
0x99, 0xAA, 0xBB, 0xCC, ## ODK_REGINFO: bit-mask of used co-processor registers (1). 0x99, 0xAA, 0xBB, 0xCC, ## ODK_REGINFO: bit-mask of used co-processor registers (1).
0xDD, 0xEE, 0xFF, 0x1E, ## ODK_REGINFO: bit-mask of used co-processor registers (2). 0xDD, 0xEE, 0xFF, 0x1E, ## ODK_REGINFO: bit-mask of used co-processor registers (2).
0x2E, 0x3E, 0x4E, 0x5E, ## ODK_REGINFO: bit-mask of used co-processor registers (3). 0x2E, 0x3E, 0x4E, 0x5E, ## ODK_REGINFO: bit-mask of used co-processor registers (3).
0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, ## ODK_REGINFO: gp register value. 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, ## ODK_REGINFO: gp register value.
## A descriptor for one more arbirtary supported option. ## A descriptor for one more arbitrary supported option.
0x1, 0x28, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x28, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 ] 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 ]
- Type: SHT_PROGBITS - Type: SHT_PROGBITS
ShName: [[NAME=<none>]] ShName: [[NAME=<none>]]
## Check we report a warning when we are unable to find the .MIPS.options section due to an error. ## Check we report a warning when we are unable to find the .MIPS.options section due to an error.
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

llvm/test/tools/obj2yaml/ELF/offset.yaml

## Check how the "Offset" field is dumped by obj2yaml. ## Check how the "Offset" field is dumped by obj2yaml.
## For each section we calulate the expected offset. ## For each section we calculate the expected offset.
## When it does not match the actual offset, we emit the "Offset" key. ## When it does not match the actual offset, we emit the "Offset" key.
# RUN: yaml2obj %s -o %t1.o # RUN: yaml2obj %s -o %t1.o
# RUN: obj2yaml %t1.o | FileCheck %s --check-prefix=BASIC # RUN: obj2yaml %t1.o | FileCheck %s --check-prefix=BASIC
# BASIC: --- !ELF # BASIC: --- !ELF
# BASIC-NEXT: FileHeader: # BASIC-NEXT: FileHeader:
# BASIC-NEXT: Class: ELFCLASS64 # BASIC-NEXT: Class: ELFCLASS64
▲ Show 20 Lines • Show All 291 Lines • Show Last 20 Lines

llvm/tools/llvm-ar/llvm-ar.cpp

Show First 20 Lines • Show All 1,319 Lines • ▼ Show 20 Lines
} }
static int ar_main(int argc, char **argv) { static int ar_main(int argc, char **argv) {
SmallVector<const char *, 0> Argv(argv + 1, argv + argc); SmallVector<const char *, 0> Argv(argv + 1, argv + argc);
StringSaver Saver(Alloc); StringSaver Saver(Alloc);
cl::ExpandResponseFiles(Saver, getRspQuoting(makeArrayRef(argv, argc)), Argv); cl::ExpandResponseFiles(Saver, getRspQuoting(makeArrayRef(argv, argc)), Argv);
// Get BitMode from enviorment variable "OBJECT_MODE" for AIX OS, if // Get BitMode from environment variable "OBJECT_MODE" for AIX OS, if
// specified. // specified.
if (object::Archive::getDefaultKindForHost() == object::Archive::K_AIXBIG) { if (object::Archive::getDefaultKindForHost() == object::Archive::K_AIXBIG) {
BitMode = getBitMode(getenv("OBJECT_MODE")); BitMode = getBitMode(getenv("OBJECT_MODE"));
if (BitMode == BitModeTy::Unknown) if (BitMode == BitModeTy::Unknown)
BitMode = BitModeTy::Bit32; BitMode = BitModeTy::Bit32;
} }
for (ArrayRef<const char *>::iterator ArgIt = Argv.begin(); for (ArrayRef<const char *>::iterator ArgIt = Argv.begin();
▲ Show 20 Lines • Show All 142 Lines • Show Last 20 Lines

llvm/tools/llvm-cov/CoverageReport.cpp

Show First 20 Lines • Show All 102 Lines • ▼ Show 20 Lines
/// Prints a horizontal divider long enough to cover the given column /// Prints a horizontal divider long enough to cover the given column
/// widths. /// widths.
void renderDivider(ArrayRef<size_t> ColumnWidths, raw_ostream &OS) { void renderDivider(ArrayRef<size_t> ColumnWidths, raw_ostream &OS) {
size_t Length = std::accumulate(ColumnWidths.begin(), ColumnWidths.end(), 0); size_t Length = std::accumulate(ColumnWidths.begin(), ColumnWidths.end(), 0);
for (size_t I = 0; I < Length; ++I) for (size_t I = 0; I < Length; ++I)
OS << '-'; OS << '-';
} }
/// Return the color which correponds to the coverage percentage of a /// Return the color which corresponds to the coverage percentage of a
/// certain metric. /// certain metric.
template <typename T> template <typename T>
raw_ostream::Colors determineCoveragePercentageColor(const T &Info) { raw_ostream::Colors determineCoveragePercentageColor(const T &Info) {
if (Info.isFullyCovered()) if (Info.isFullyCovered())
return raw_ostream::GREEN; return raw_ostream::GREEN;
return Info.getPercentCovered() >= 80.0 ? raw_ostream::YELLOW return Info.getPercentCovered() >= 80.0 ? raw_ostream::YELLOW
: raw_ostream::RED; : raw_ostream::RED;
} }
▲ Show 20 Lines • Show All 371 Lines • Show Last 20 Lines

llvm/tools/llvm-dwarfutil/DebugInfoLinker.cpp

Show First 20 Lines • Show All 270 Lines • ▼ Show 20 LinesError linkDebugInfo(object::ObjectFile &File, const Options &Options,
DebugInfoLinker.setErrorHandler(ReportErr); DebugInfoLinker.setErrorHandler(ReportErr);
DebugInfoLinker.setWarningHandler(ReportWarn); DebugInfoLinker.setWarningHandler(ReportWarn);
DebugInfoLinker.setNumThreads(Options.NumThreads); DebugInfoLinker.setNumThreads(Options.NumThreads);
DebugInfoLinker.setNoODR(!Options.DoODRDeduplication); DebugInfoLinker.setNoODR(!Options.DoODRDeduplication);
DebugInfoLinker.setVerbosity(Options.Verbose); DebugInfoLinker.setVerbosity(Options.Verbose);
DebugInfoLinker.setUpdate(!Options.DoGarbageCollection); DebugInfoLinker.setUpdate(!Options.DoGarbageCollection);
std::vector<std::unique_ptr<DWARFFile>> ObjectsForLinking(1); std::vector<std::unique_ptr<DWARFFile>> ObjectsForLinking(1);
std::vector<std::unique_ptr<AddressesMap>> AddresssMapForLinking(1); std::vector<std::unique_ptr<AddressesMap>> AddressMapForLinking(1);
std::vector<std::string> EmptyWarnings; std::vector<std::string> EmptyWarnings;
std::unique_ptr<DWARFContext> Context = DWARFContext::create(File); std::unique_ptr<DWARFContext> Context = DWARFContext::create(File);
// Unknown debug sections would be removed. Display warning // Unknown debug sections would be removed. Display warning
// for such sections. // for such sections.
for (SectionName Sec : Context->getDWARFObj().getSectionNames()) { for (SectionName Sec : Context->getDWARFObj().getSectionNames()) {
if (isDebugSection(Sec.Name) && !knownByDWARFUtil(Sec.Name)) if (isDebugSection(Sec.Name) && !knownByDWARFUtil(Sec.Name))
warning( warning(
formatv("'{0}' is not currently supported: section will be skipped", formatv("'{0}' is not currently supported: section will be skipped",
Sec.Name), Sec.Name),
Options.InputFileName); Options.InputFileName);
} }
// Add object files to the DWARFLinker. // Add object files to the DWARFLinker.
AddresssMapForLinking[0] = AddressMapForLinking[0] =
std::make_unique<ObjFileAddressMap>(*Context, Options, File); std::make_unique<ObjFileAddressMap>(*Context, Options, File);
ObjectsForLinking[0] = std::make_unique<DWARFFile>( ObjectsForLinking[0] =
File.getFileName(), &*Context, AddresssMapForLinking[0].get(), std::make_unique<DWARFFile>(File.getFileName(), &*Context,
EmptyWarnings); AddressMapForLinking[0].get(), EmptyWarnings);
for (size_t I = 0; I < ObjectsForLinking.size(); I++) for (size_t I = 0; I < ObjectsForLinking.size(); I++)
DebugInfoLinker.addObjectFile(*ObjectsForLinking[I]); DebugInfoLinker.addObjectFile(*ObjectsForLinking[I]);
// Link debug info. // Link debug info.
if (Error Err = DebugInfoLinker.link()) if (Error Err = DebugInfoLinker.link())
return Err; return Err;
OutStreamer.finish(); OutStreamer.finish();
return Error::success(); return Error::success();
} }
} // end of namespace dwarfutil } // end of namespace dwarfutil
} // end of namespace llvm } // end of namespace llvm

llvm/tools/llvm-exegesis/lib/Analysis.cpp

Show First 20 Lines • Show All 388 Lines • ▼ Show 20 Lines if (RSC.SCDesc->isValid()) {
OS << "<td>" << RSC.SCDesc->NumMicroOps << "</td>"; OS << "<td>" << RSC.SCDesc->NumMicroOps << "</td>";
// Latencies. // Latencies.
OS << "<td><ul>"; OS << "<td><ul>";
for (int I = 0, E = RSC.SCDesc->NumWriteLatencyEntries; I < E; ++I) { for (int I = 0, E = RSC.SCDesc->NumWriteLatencyEntries; I < E; ++I) {
const auto *const Entry = const auto *const Entry =
SubtargetInfo_->getWriteLatencyEntry(RSC.SCDesc, I); SubtargetInfo_->getWriteLatencyEntry(RSC.SCDesc, I);
OS << "<li>" << Entry->Cycles; OS << "<li>" << Entry->Cycles;
if (RSC.SCDesc->NumWriteLatencyEntries > 1) { if (RSC.SCDesc->NumWriteLatencyEntries > 1) {
// Dismabiguate if more than 1 latency. // Disambiguate if more than 1 latency.
OS << " (WriteResourceID " << Entry->WriteResourceID << ")"; OS << " (WriteResourceID " << Entry->WriteResourceID << ")";
} }
OS << "</li>"; OS << "</li>";
} }
OS << "</ul></td>"; OS << "</ul></td>";
// inverse throughput. // inverse throughput.
OS << "<td>"; OS << "<td>";
writeMeasurementValue<kEscapeHtml>( writeMeasurementValue<kEscapeHtml>(
▲ Show 20 Lines • Show All 203 Lines • Show Last 20 Lines

llvm/tools/llvm-objdump/MachODump.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 3,398 Lines • ▼ Show 20 Linesstatic const char *get_symbol_32(uint32_t sect_offset, SectionRef S,
uint64_t n_value64; uint64_t n_value64;
return get_symbol_64(sect_offset, S, info, n_value64, ReferenceValue); return get_symbol_64(sect_offset, S, info, n_value64, ReferenceValue);
} }
namespace { namespace {
// These are structs in the Objective-C meta data and read to produce the // These are structs in the Objective-C meta data and read to produce the
// comments for disassembly. While these are part of the ABI they are no // comments for disassembly. While these are part of the ABI they are no
// public defintions. So the are here not in include/llvm/BinaryFormat/MachO.h // public definitions. So the are here not in include/llvm/BinaryFormat/MachO.h
// . // .
// The cfstring object in a 64-bit Mach-O file. // The cfstring object in a 64-bit Mach-O file.
struct cfstring64_t { struct cfstring64_t {
uint64_t isa; // class64_t * (64-bit pointer) uint64_t isa; // class64_t * (64-bit pointer)
uint64_t flags; // flag bits uint64_t flags; // flag bits
uint64_t characters; // char * (64-bit pointer) uint64_t characters; // char * (64-bit pointer)
uint64_t length; // number of non-NULL characters in above uint64_t length; // number of non-NULL characters in above
▲ Show 20 Lines • Show All 7,139 Lines • Show Last 20 Lines

llvm/tools/llvm-objdump/OtoolOpts.td

include "llvm/Option/OptParser.td" include "llvm/Option/OptParser.td"
def help : Flag<["--"], "help">, HelpText<"print help">; def help : Flag<["--"], "help">, HelpText<"print help">;
def help_hidden : Flag<["--"], "help-hidden">, def help_hidden : Flag<["--"], "help-hidden">,
HelpText<"print help for hidden flags">; HelpText<"print help for hidden flags">;
def arch : Separate<["-"], "arch">, def arch : Separate<["-"], "arch">,
HelpText<"select slice of universal Mach-O file">; HelpText<"select slice of universal Mach-O file">;
def C : Flag<["-"], "C">, HelpText<"print linker optimization hints">; def C : Flag<["-"], "C">, HelpText<"print linker optimization hints">;
def d : Flag<["-"], "d">, HelpText<"print data section">; def d : Flag<["-"], "d">, HelpText<"print data section">;
def D : Flag<["-"], "D">, HelpText<"print shared library id">; def D : Flag<["-"], "D">, HelpText<"print shared library id">;
def f : Flag<["-"], "f">, HelpText<"print universal headers">; def f : Flag<["-"], "f">, HelpText<"print universal headers">;
def G : Flag<["-"], "G">, HelpText<"print data-in-code table">; def G : Flag<["-"], "G">, HelpText<"print data-in-code table">;
def h : Flag<["-"], "h">, HelpText<"print mach header">; def h : Flag<["-"], "h">, HelpText<"print mach header">;
def I : Flag<["-"], "I">, HelpText<"print indirect symbol table">; def I : Flag<["-"], "I">, HelpText<"print indirect symbol table">;
def j : Flag<["-"], "j">, HelpText<"print opcode bytes">; def j : Flag<["-"], "j">, HelpText<"print opcode bytes">;
def l : Flag<["-"], "l">, HelpText<"print load commnads">; def l : Flag<["-"], "l">, HelpText<"print load commands">;
def L : Flag<["-"], "L">, HelpText<"print used shared libraries">; def L : Flag<["-"], "L">, HelpText<"print used shared libraries">;
def mcpu_EQ : Joined<["-"], "mcpu=">, HelpText<"select cpu for disassembly">; def mcpu_EQ : Joined<["-"], "mcpu=">, HelpText<"select cpu for disassembly">;
def o : Flag<["-"], "o">, HelpText<"print Objective-C segment">; def o : Flag<["-"], "o">, HelpText<"print Objective-C segment">;
def p : Separate<["-"], "p">, def p : Separate<["-"], "p">,
MetaVarName<"<function name>">, MetaVarName<"<function name>">,
HelpText<"start disassembly at <function name>">; HelpText<"start disassembly at <function name>">;
def P : Flag<["-"], "P">, HelpText<"print __TEXT,__info_plist section as strings">; def P : Flag<["-"], "P">, HelpText<"print __TEXT,__info_plist section as strings">;
def : Flag<["-"], "q">, Flags<[HelpHidden]>, def : Flag<["-"], "q">, Flags<[HelpHidden]>,
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

llvm/tools/llvm-pdbutil/llvm-pdbutil.cpp

Show First 20 Lines • Show All 521 Lines • ▼ Show 20 Linescl::opt<bool> DumpIdExtras("id-extras",
cl::cat(TypeOptions), cl::sub(DumpSubcommand)); cl::cat(TypeOptions), cl::sub(DumpSubcommand));
cl::list<uint32_t> DumpIdIndex( cl::list<uint32_t> DumpIdIndex(
"id-index", cl::CommaSeparated, "id-index", cl::CommaSeparated,
cl::desc("only dump ids with the specified hexadecimal type index"), cl::desc("only dump ids with the specified hexadecimal type index"),
cl::cat(TypeOptions), cl::sub(DumpSubcommand)); cl::cat(TypeOptions), cl::sub(DumpSubcommand));
cl::opt<bool> DumpTypeDependents( cl::opt<bool> DumpTypeDependents(
"dependents", "dependents",
cl::desc("In conjunection with -type-index and -id-index, dumps the entire " cl::desc("In conjunction with -type-index and -id-index, dumps the entire "
"dependency graph for the specified index instead of " "dependency graph for the specified index instead of "
"just the single record with the specified index"), "just the single record with the specified index"),
cl::cat(TypeOptions), cl::sub(DumpSubcommand)); cl::cat(TypeOptions), cl::sub(DumpSubcommand));
// SYMBOL OPTIONS // SYMBOL OPTIONS
cl::opt<bool> DumpGlobals("globals", cl::desc("dump Globals symbol records"), cl::opt<bool> DumpGlobals("globals", cl::desc("dump Globals symbol records"),
cl::cat(SymbolOptions), cl::sub(DumpSubcommand)); cl::cat(SymbolOptions), cl::sub(DumpSubcommand));
cl::opt<bool> DumpGlobalExtras("global-extras", cl::desc("dump Globals hashes"), cl::opt<bool> DumpGlobalExtras("global-extras", cl::desc("dump Globals hashes"),
▲ Show 20 Lines • Show All 1,102 Lines • Show Last 20 Lines

llvm/tools/llvm-profgen/PerfReader.cpp

Show First 20 Lines • Show All 1,164 Lines • ▼ Show 20 Lines emitWarningSummary(
UnmatchedRange, TotalRangeNum, UnmatchedRange, TotalRangeNum,
"of samples are from ranges that do not belong to any functions."); "of samples are from ranges that do not belong to any functions.");
emitWarningSummary( emitWarningSummary(
RangeCrossFunc, TotalRangeNum, RangeCrossFunc, TotalRangeNum,
"of samples are from ranges that do cross function boundaries."); "of samples are from ranges that do cross function boundaries.");
emitWarningSummary( emitWarningSummary(
BogusRange, TotalRangeNum, BogusRange, TotalRangeNum,
"of samples are from ranges that have range start after or too far from " "of samples are from ranges that have range start after or too far from "
"range end acrossing the unconditinal jmp."); "range end across the unconditional jmp.");
} }
void PerfScriptReader::parsePerfTraces() { void PerfScriptReader::parsePerfTraces() {
// Parse perf traces and do aggregation. // Parse perf traces and do aggregation.
parseAndAggregateTrace(); parseAndAggregateTrace();
emitWarningSummary(NumLeafExternalFrame, NumTotalSample, emitWarningSummary(NumLeafExternalFrame, NumTotalSample,
"of samples have leaf external frame in call stack."); "of samples have leaf external frame in call stack.");
Show All 15 Lines

llvm/tools/llvm-profgen/ProfiledBinary.h

Show First 20 Lines • Show All 143 Lines • ▼ Show 20 Linesstruct PrologEpilogTracker {
} }
}; };
// Track function byte size under different context (outlined version as well as // Track function byte size under different context (outlined version as well as
// various inlined versions). It also provides query support to get function // various inlined versions). It also provides query support to get function
// size with the best matching context, which is used to help pre-inliner use // size with the best matching context, which is used to help pre-inliner use
// accurate post-optimization size to make decisions. // accurate post-optimization size to make decisions.
// TODO: If an inlinee is completely optimized away, ideally we should have zero // TODO: If an inlinee is completely optimized away, ideally we should have zero
// for its context size, currently we would misss such context since it doesn't // for its context size, currently we would miss such context since it doesn't
// have instructions. To fix this, we need to mark all inlinee with entry probe // have instructions. To fix this, we need to mark all inlinee with entry probe
// but without instructions as having zero size. // but without instructions as having zero size.
class BinarySizeContextTracker { class BinarySizeContextTracker {
public: public:
// Add instruction with given size to a context // Add instruction with given size to a context
void addInstructionForContext(const SampleContextFrameVector &Context, void addInstructionForContext(const SampleContextFrameVector &Context,
uint32_t InstrSize); uint32_t InstrSize);
▲ Show 20 Lines • Show All 417 Lines • Show Last 20 Lines

llvm/tools/llvm-symbolizer/llvm-symbolizer.cpp

Show First 20 Lines • Show All 283 Lines • ▼ Show 20 Linesstatic void printHelp(StringRef ToolName, const SymbolizerOptTable &Tbl,
OS << "\nPass @FILE as argument to read options from FILE.\n"; OS << "\nPass @FILE as argument to read options from FILE.\n";
} }
static opt::InputArgList parseOptions(int Argc, char *Argv[], bool IsAddr2Line, static opt::InputArgList parseOptions(int Argc, char *Argv[], bool IsAddr2Line,
StringSaver &Saver, StringSaver &Saver,
SymbolizerOptTable &Tbl) { SymbolizerOptTable &Tbl) {
StringRef ToolName = IsAddr2Line ? "llvm-addr2line" : "llvm-symbolizer"; StringRef ToolName = IsAddr2Line ? "llvm-addr2line" : "llvm-symbolizer";
// The environment variable specifies initial options which can be overridden // The environment variable specifies initial options which can be overridden
// by commnad line options. // by command line options.
Tbl.setInitialOptionsFromEnvironment(IsAddr2Line ? "LLVM_ADDR2LINE_OPTS" Tbl.setInitialOptionsFromEnvironment(IsAddr2Line ? "LLVM_ADDR2LINE_OPTS"
: "LLVM_SYMBOLIZER_OPTS"); : "LLVM_SYMBOLIZER_OPTS");
bool HasError = false; bool HasError = false;
opt::InputArgList Args = opt::InputArgList Args =
Tbl.parseArgs(Argc, Argv, OPT_UNKNOWN, Saver, [&](StringRef Msg) { Tbl.parseArgs(Argc, Argv, OPT_UNKNOWN, Saver, [&](StringRef Msg) {
errs() << ("error: " + Msg + "\n"); errs() << ("error: " + Msg + "\n");
HasError = true; HasError = true;
}); });
▲ Show 20 Lines • Show All 203 Lines • Show Last 20 Lines

llvm/tools/llvm-xray/xray-account.cpp

Show First 20 Lines • Show All 72 Lines • ▼ Show 20 Linesenum class SortField {
SUM, SUM,
FUNC, FUNC,
}; };
static cl::opt<SortField> AccountSortOutput( static cl::opt<SortField> AccountSortOutput(
"sort", cl::desc("sort output by this field"), cl::value_desc("field"), "sort", cl::desc("sort output by this field"), cl::value_desc("field"),
cl::sub(Account), cl::init(SortField::FUNCID), cl::sub(Account), cl::init(SortField::FUNCID),
cl::values(clEnumValN(SortField::FUNCID, "funcid", "function id"), cl::values(clEnumValN(SortField::FUNCID, "funcid", "function id"),
clEnumValN(SortField::COUNT, "count", "funciton call counts"), clEnumValN(SortField::COUNT, "count", "function call counts"),
clEnumValN(SortField::MIN, "min", "minimum function durations"), clEnumValN(SortField::MIN, "min", "minimum function durations"),
clEnumValN(SortField::MED, "med", "median function durations"), clEnumValN(SortField::MED, "med", "median function durations"),
clEnumValN(SortField::PCT90, "90p", "90th percentile durations"), clEnumValN(SortField::PCT90, "90p", "90th percentile durations"),
clEnumValN(SortField::PCT99, "99p", "99th percentile durations"), clEnumValN(SortField::PCT99, "99p", "99th percentile durations"),
clEnumValN(SortField::MAX, "max", "maximum function durations"), clEnumValN(SortField::MAX, "max", "maximum function durations"),
clEnumValN(SortField::SUM, "sum", "sum of call durations"), clEnumValN(SortField::SUM, "sum", "sum of call durations"),
clEnumValN(SortField::FUNC, "func", "function names"))); clEnumValN(SortField::FUNC, "func", "function names")));
static cl::alias AccountSortOutput2("s", cl::aliasopt(AccountSortOutput), static cl::alias AccountSortOutput2("s", cl::aliasopt(AccountSortOutput),
▲ Show 20 Lines • Show All 430 Lines • Show Last 20 Lines

llvm/tools/llvm-xray/xray-graph.cpp

Show First 20 Lines • Show All 192 Lines • ▼ Show 20 Lines
// structure representing the call stack for that function. // structure representing the call stack for that function.
// If the record is an EXIT record it checks computes computes the ammount of // If the record is an EXIT record it checks computes computes the ammount of
// time the function took to complete and then stores that information in an // time the function took to complete and then stores that information in an
// edge of the graph. If there is no matching ENTER record the function tries // edge of the graph. If there is no matching ENTER record the function tries
// to recover by assuming that there were EXIT records which were missed, for // to recover by assuming that there were EXIT records which were missed, for
// example caused by tail call elimination and if the option is enabled then // example caused by tail call elimination and if the option is enabled then
// then tries to recover from this. // then tries to recover from this.
// //
// This funciton will also error if the records are out of order, as the trace // This function will also error if the records are out of order, as the trace
// is expected to be sorted. // is expected to be sorted.
// //
// The graph generated has an immaginary root for functions called by no-one at // The graph generated has an immaginary root for functions called by no-one at
// FuncId 0. // FuncId 0.
// //
// FIXME: Refactor this and account subcommand to reduce code duplication. // FIXME: Refactor this and account subcommand to reduce code duplication.
Error GraphRenderer::accountRecord(const XRayRecord &Record) { Error GraphRenderer::accountRecord(const XRayRecord &Record) {
using std::make_error_code; using std::make_error_code;
▲ Show 20 Lines • Show All 326 Lines • Show Last 20 Lines

llvm/unittests/ADT/FallibleIteratorTest.cpp

Show First 20 Lines • Show All 62 Lines • ▼ Show 20 Lines Error dec() {
if (C[Idx].second == ValidLink) if (C[Idx].second == ValidLink)
return Error::success(); return Error::success();
return make_error<StringError>("cant get prev object in (mock) collection", return make_error<StringError>("cant get prev object in (mock) collection",
inconvertibleErrorCode()); inconvertibleErrorCode());
} }
friend bool operator==(const FallibleCollectionWalker &LHS, friend bool operator==(const FallibleCollectionWalker &LHS,
const FallibleCollectionWalker &RHS) { const FallibleCollectionWalker &RHS) {
assert(&LHS.C == &RHS.C && "Comparing iterators across collectionss."); assert(&LHS.C == &RHS.C && "Comparing iterators across collections.");
return LHS.Idx == RHS.Idx; return LHS.Idx == RHS.Idx;
} }
private: private:
FallibleCollection &C; FallibleCollection &C;
unsigned Idx; unsigned Idx;
}; };
▲ Show 20 Lines • Show All 212 Lines • Show Last 20 Lines

llvm/unittests/ADT/SequenceTest.cpp

//===- SequenceTest.cpp - Unit tests for a sequence abstraciton -----------===// //===- SequenceTest.cpp - Unit tests for a sequence abstraction -----------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "llvm/ADT/Sequence.h" #include "llvm/ADT/Sequence.h"
▲ Show 20 Lines • Show All 290 Lines • Show Last 20 Lines

llvm/unittests/Analysis/MemorySSATest.cpp

Show First 20 Lines • Show All 96 Lines • ▼ Show 20 LinesTEST_F(MemorySSATest, CreateALoad) {
// Add the load // Add the load
B.SetInsertPoint(Merge); B.SetInsertPoint(Merge);
LoadInst *LoadInst = B.CreateLoad(B.getInt8Ty(), PointerArg); LoadInst *LoadInst = B.CreateLoad(B.getInt8Ty(), PointerArg);
// MemoryPHI should already exist. // MemoryPHI should already exist.
MemoryPhi *MP = MSSA.getMemoryAccess(Merge); MemoryPhi *MP = MSSA.getMemoryAccess(Merge);
EXPECT_NE(MP, nullptr); EXPECT_NE(MP, nullptr);
// Create the load memory acccess // Create the load memory access
MemoryUse *LoadAccess = cast<MemoryUse>(Updater.createMemoryAccessInBB( MemoryUse *LoadAccess = cast<MemoryUse>(Updater.createMemoryAccessInBB(
LoadInst, MP, Merge, MemorySSA::Beginning)); LoadInst, MP, Merge, MemorySSA::Beginning));
MemoryAccess *DefiningAccess = LoadAccess->getDefiningAccess(); MemoryAccess *DefiningAccess = LoadAccess->getDefiningAccess();
EXPECT_TRUE(isa<MemoryPhi>(DefiningAccess)); EXPECT_TRUE(isa<MemoryPhi>(DefiningAccess));
MSSA.verifyMemorySSA(); MSSA.verifyMemorySSA();
} }
TEST_F(MemorySSATest, CreateLoadsAndStoreUpdater) { TEST_F(MemorySSATest, CreateLoadsAndStoreUpdater) {
// We create a diamond, then build memoryssa with no memory accesses, and // We create a diamond, then build memoryssa with no memory accesses, and
▲ Show 20 Lines • Show All 119 Lines • ▼ Show 20 LinesTEST_F(MemorySSATest, CreateALoadUpdater) {
// MemoryPHI should be created when inserting the def // MemoryPHI should be created when inserting the def
MemoryPhi *MP = MSSA.getMemoryAccess(Merge); MemoryPhi *MP = MSSA.getMemoryAccess(Merge);
EXPECT_NE(MP, nullptr); EXPECT_NE(MP, nullptr);
// Add the load // Add the load
B.SetInsertPoint(Merge, Merge->begin()); B.SetInsertPoint(Merge, Merge->begin());
LoadInst *LoadInst = B.CreateLoad(B.getInt8Ty(), PointerArg); LoadInst *LoadInst = B.CreateLoad(B.getInt8Ty(), PointerArg);
// Create the load memory acccess // Create the load memory access
MemoryUse *LoadAccess = cast<MemoryUse>(Updater.createMemoryAccessInBB( MemoryUse *LoadAccess = cast<MemoryUse>(Updater.createMemoryAccessInBB(
LoadInst, nullptr, Merge, MemorySSA::Beginning)); LoadInst, nullptr, Merge, MemorySSA::Beginning));
Updater.insertUse(LoadAccess); Updater.insertUse(LoadAccess);
MemoryAccess *DefiningAccess = LoadAccess->getDefiningAccess(); MemoryAccess *DefiningAccess = LoadAccess->getDefiningAccess();
EXPECT_TRUE(isa<MemoryPhi>(DefiningAccess)); EXPECT_TRUE(isa<MemoryPhi>(DefiningAccess));
MSSA.verifyMemorySSA(); MSSA.verifyMemorySSA();
} }
▲ Show 20 Lines • Show All 650 Lines • ▼ Show 20 LinesTEST_F(MemorySSATest, Irreducible) {
B.CreateBr(LoopMainBB); B.CreateBr(LoopMainBB);
B.SetInsertPoint(LoopMainBB); B.SetInsertPoint(LoopMainBB);
B.CreateCondBr(B.getTrue(), LoopStartBB, AfterLoopBB); B.CreateCondBr(B.getTrue(), LoopStartBB, AfterLoopBB);
B.SetInsertPoint(AfterLoopBB); B.SetInsertPoint(AfterLoopBB);
Argument *FirstArg = &*F->arg_begin(); Argument *FirstArg = &*F->arg_begin();
setupAnalyses(); setupAnalyses();
MemorySSA &MSSA = *Analyses->MSSA; MemorySSA &MSSA = *Analyses->MSSA;
MemorySSAUpdater Updater(&MSSA); MemorySSAUpdater Updater(&MSSA);
// Create the load memory acccess // Create the load memory access
LoadInst *LoadInst = B.CreateLoad(B.getInt8Ty(), FirstArg); LoadInst *LoadInst = B.CreateLoad(B.getInt8Ty(), FirstArg);
MemoryUse *LoadAccess = cast<MemoryUse>(Updater.createMemoryAccessInBB( MemoryUse *LoadAccess = cast<MemoryUse>(Updater.createMemoryAccessInBB(
LoadInst, nullptr, AfterLoopBB, MemorySSA::Beginning)); LoadInst, nullptr, AfterLoopBB, MemorySSA::Beginning));
Updater.insertUse(LoadAccess); Updater.insertUse(LoadAccess);
MSSA.verifyMemorySSA(); MSSA.verifyMemorySSA();
} }
TEST_F(MemorySSATest, MoveToBeforeLiveOnEntryInvalidatesCache) { TEST_F(MemorySSATest, MoveToBeforeLiveOnEntryInvalidatesCache) {
▲ Show 20 Lines • Show All 947 Lines • Show Last 20 Lines

llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp

Show First 20 Lines • Show All 68 Lines • ▼ Show 20 LinesTEST_F(CoreAPIsStandardTest, EmptyLookup) {
ES.lookup(LookupKind::Static, makeJITDylibSearchOrder(&JD), SymbolLookupSet(), ES.lookup(LookupKind::Static, makeJITDylibSearchOrder(&JD), SymbolLookupSet(),
SymbolState::Ready, OnCompletion, NoDependenciesToRegister); SymbolState::Ready, OnCompletion, NoDependenciesToRegister);
EXPECT_TRUE(OnCompletionRun) << "OnCompletion was not run for empty query"; EXPECT_TRUE(OnCompletionRun) << "OnCompletion was not run for empty query";
} }
TEST_F(CoreAPIsStandardTest, ResolveUnrequestedSymbol) { TEST_F(CoreAPIsStandardTest, ResolveUnrequestedSymbol) {
// Test that all symbols in a MaterializationUnit materialize corretly when // Test that all symbols in a MaterializationUnit materialize correctly when
// only a subset of symbols is looked up. // only a subset of symbols is looked up.
// The aim here is to ensure that we're not relying on the query to set up // The aim here is to ensure that we're not relying on the query to set up
// state needed to materialize the unrequested symbols. // state needed to materialize the unrequested symbols.
cantFail(JD.define(std::make_unique<SimpleMaterializationUnit>( cantFail(JD.define(std::make_unique<SimpleMaterializationUnit>(
SymbolFlagsMap({{Foo, FooSym.getFlags()}, {Bar, BarSym.getFlags()}}), SymbolFlagsMap({{Foo, FooSym.getFlags()}, {Bar, BarSym.getFlags()}}),
[this](std::unique_ptr<MaterializationResponsibility> R) { [this](std::unique_ptr<MaterializationResponsibility> R) {
cantFail(R->notifyResolved({{Foo, FooSym}, {Bar, BarSym}})); cantFail(R->notifyResolved({{Foo, FooSym}, {Bar, BarSym}}));
▲ Show 20 Lines • Show All 778 Lines • ▼ Show 20 LinesTEST_F(CoreAPIsStandardTest, FailAfterMaterialization) {
BarR->failMaterialization(); BarR->failMaterialization();
// Verify that both queries failed. // Verify that both queries failed.
EXPECT_TRUE(OnFooReadyRun) << "Query for Foo did not run"; EXPECT_TRUE(OnFooReadyRun) << "Query for Foo did not run";
EXPECT_TRUE(OnBarReadyRun) << "Query for Bar did not run"; EXPECT_TRUE(OnBarReadyRun) << "Query for Bar did not run";
} }
TEST_F(CoreAPIsStandardTest, FailMaterializerWithUnqueriedSymbols) { TEST_F(CoreAPIsStandardTest, FailMaterializerWithUnqueriedSymbols) {
// Make sure that symbols with no queries aganist them still // Make sure that symbols with no queries against them still
// fail correctly. // fail correctly.
bool MaterializerRun = false; bool MaterializerRun = false;
auto MU = std::make_unique<SimpleMaterializationUnit>( auto MU = std::make_unique<SimpleMaterializationUnit>(
SymbolFlagsMap( SymbolFlagsMap(
{{Foo, JITSymbolFlags::Exported}, {Bar, JITSymbolFlags::Exported}}), {{Foo, JITSymbolFlags::Exported}, {Bar, JITSymbolFlags::Exported}}),
[&](std::unique_ptr<MaterializationResponsibility> R) { [&](std::unique_ptr<MaterializationResponsibility> R) {
MaterializerRun = true; MaterializerRun = true;
▲ Show 20 Lines • Show All 711 Lines • Show Last 20 Lines

llvm/unittests/Frontend/OpenMPIRBuilderTest.cpp

Show First 20 Lines • Show All 4,043 Lines • ▼ Show 20 LinesTEST_F(OpenMPIRBuilderTest, CreateReductions) {
EXPECT_NE(Outlined, nullptr); EXPECT_NE(Outlined, nullptr);
// Check that the lock variable was created with the expected name. // Check that the lock variable was created with the expected name.
GlobalVariable *LockVar = GlobalVariable *LockVar =
M->getGlobalVariable(".gomp_critical_user_.reduction.var"); M->getGlobalVariable(".gomp_critical_user_.reduction.var");
EXPECT_NE(LockVar, nullptr); EXPECT_NE(LockVar, nullptr);
// Find the allocation of a local array that will be used to call the runtime // Find the allocation of a local array that will be used to call the runtime
// reduciton function. // reduction function.
BasicBlock &AllocBlock = Outlined->getEntryBlock(); BasicBlock &AllocBlock = Outlined->getEntryBlock();
Value *LocalArray = nullptr; Value *LocalArray = nullptr;
for (Instruction &I : AllocBlock) { for (Instruction &I : AllocBlock) {
if (AllocaInst *Alloc = dyn_cast<AllocaInst>(&I)) { if (AllocaInst *Alloc = dyn_cast<AllocaInst>(&I)) {
if (!Alloc->getAllocatedType()->isArrayTy() || if (!Alloc->getAllocatedType()->isArrayTy() ||
!Alloc->getAllocatedType()->getArrayElementType()->isPointerTy()) !Alloc->getAllocatedType()->getArrayElementType()->isPointerTy())
continue; continue;
LocalArray = Alloc; LocalArray = Alloc;
▲ Show 20 Lines • Show All 1,032 Lines • Show Last 20 Lines

llvm/utils/TableGen/CodeGenSchedule.h

Show First 20 Lines • Show All 423 Lines • ▼ Show 20 Linesclass CodeGenSchedModels {
// Per-operand SchedReadWrite types. // Per-operand SchedReadWrite types.
std::vector<CodeGenSchedRW> SchedWrites; std::vector<CodeGenSchedRW> SchedWrites;
std::vector<CodeGenSchedRW> SchedReads; std::vector<CodeGenSchedRW> SchedReads;
// List of unique SchedClasses. // List of unique SchedClasses.
std::vector<CodeGenSchedClass> SchedClasses; std::vector<CodeGenSchedClass> SchedClasses;
// Any inferred SchedClass has an index greater than NumInstrSchedClassses. // Any inferred SchedClass has an index greater than NumInstrSchedClasses.
unsigned NumInstrSchedClasses; unsigned NumInstrSchedClasses;
RecVec ProcResourceDefs; RecVec ProcResourceDefs;
RecVec ProcResGroups; RecVec ProcResGroups;
// Map each instruction to its unique SchedClass index considering the // Map each instruction to its unique SchedClass index considering the
// combination of it's itinerary class, SchedRW list, and InstRW records. // combination of it's itinerary class, SchedRW list, and InstRW records.
using InstClassMapTy = DenseMap<Record*, unsigned>; using InstClassMapTy = DenseMap<Record*, unsigned>;
▲ Show 20 Lines • Show All 207 Lines • Show Last 20 Lines

llvm/utils/TableGen/DAGISelMatcher.h

Show All 40 Linesclass Matcher {
// The next matcher node that is executed after this one. Null if this is the // The next matcher node that is executed after this one. Null if this is the
// last stage of a match. // last stage of a match.
std::unique_ptr<Matcher> Next; std::unique_ptr<Matcher> Next;
size_t Size; // Size in bytes of matcher and all its children (if any). size_t Size; // Size in bytes of matcher and all its children (if any).
virtual void anchor(); virtual void anchor();
public: public:
enum KindTy { enum KindTy {
// Matcher state manipulation. // Matcher state manipulation.
Scope, // Push a checking scope. Scope, // Push a checking scope.
RecordNode, // Record the current node. RecordNode, // Record the current node.
RecordChild, // Record a child of the current node. RecordChild, // Record a child of the current node.
RecordMemRef, // Record the memref in the current node. RecordMemRef, // Record the memref in the current node.
CaptureGlueInput, // If the current node has an input glue, save it. CaptureGlueInput, // If the current node has an input glue, save it.
MoveChild, // Move current node to specified child. MoveChild, // Move current node to specified child.
MoveParent, // Move current node to parent. MoveParent, // Move current node to parent.
// Predicate checking. // Predicate checking.
CheckSame, // Fail if not same as prev match. CheckSame, // Fail if not same as prev match.
CheckChildSame, // Fail if child not same as prev match. CheckChildSame, // Fail if child not same as prev match.
CheckPatternPredicate, CheckPatternPredicate,
CheckPredicate, // Fail if node predicate fails. CheckPredicate, // Fail if node predicate fails.
CheckOpcode, // Fail if not opcode. CheckOpcode, // Fail if not opcode.
SwitchOpcode, // Dispatch based on opcode. SwitchOpcode, // Dispatch based on opcode.
CheckType, // Fail if not correct type. CheckType, // Fail if not correct type.
SwitchType, // Dispatch based on type. SwitchType, // Dispatch based on type.
CheckChildType, // Fail if child has wrong type. CheckChildType, // Fail if child has wrong type.
CheckInteger, // Fail if wrong val. CheckInteger, // Fail if wrong val.
CheckChildInteger, // Fail if child is wrong val. CheckChildInteger, // Fail if child is wrong val.
CheckCondCode, // Fail if not condcode. CheckCondCode, // Fail if not condcode.
CheckChild2CondCode, // Fail if child is wrong condcode. CheckChild2CondCode, // Fail if child is wrong condcode.
CheckValueType, CheckValueType,
CheckComplexPat, CheckComplexPat,
CheckAndImm, CheckAndImm,
CheckOrImm, CheckOrImm,
CheckImmAllOnesV, CheckImmAllOnesV,
CheckImmAllZerosV, CheckImmAllZerosV,
CheckFoldableChainNode, CheckFoldableChainNode,
// Node creation/emisssion. // Node creation/emission.
EmitInteger, // Create a TargetConstant EmitInteger, // Create a TargetConstant
EmitStringInteger, // Create a TargetConstant from a string. EmitStringInteger, // Create a TargetConstant from a string.
EmitRegister, // Create a register. EmitRegister, // Create a register.
EmitConvertToTarget, // Convert a imm/fpimm to target imm/fpimm EmitConvertToTarget, // Convert a imm/fpimm to target imm/fpimm
EmitMergeInputChains, // Merge together a chains for an input. EmitMergeInputChains, // Merge together a chains for an input.
EmitCopyToReg, // Emit a copytoreg into a physreg. EmitCopyToReg, // Emit a copytoreg into a physreg.
EmitNode, // Create a DAG node EmitNode, // Create a DAG node
EmitNodeXForm, // Run a SDNodeXForm EmitNodeXForm, // Run a SDNodeXForm
▲ Show 20 Lines • Show All 1,038 Lines • Show Last 20 Lines

llvm/utils/TableGen/GlobalISelEmitter.cpp

Show First 20 Lines • Show All 3,487 Lines • ▼ Show 20 Lines return std::accumulate(
[](unsigned A, const std::unique_ptr<InstructionMatcher> &Matcher) { [](unsigned A, const std::unique_ptr<InstructionMatcher> &Matcher) {
return A + Matcher->countRendererFns(); return A + Matcher->countRendererFns();
}); });
} }
bool OperandPredicateMatcher::isHigherPriorityThan( bool OperandPredicateMatcher::isHigherPriorityThan(
const OperandPredicateMatcher &B) const { const OperandPredicateMatcher &B) const {
// Generally speaking, an instruction is more important than an Int or a // Generally speaking, an instruction is more important than an Int or a
// LiteralInt because it can cover more nodes but theres an exception to // LiteralInt because it can cover more nodes but there's an exception to
// this. G_CONSTANT's are less important than either of those two because they // this. G_CONSTANT's are less important than either of those two because they
// are more permissive. // are more permissive.
const InstructionOperandMatcher *AOM = const InstructionOperandMatcher *AOM =
dyn_cast<InstructionOperandMatcher>(this); dyn_cast<InstructionOperandMatcher>(this);
const InstructionOperandMatcher *BOM = const InstructionOperandMatcher *BOM =
dyn_cast<InstructionOperandMatcher>(&B); dyn_cast<InstructionOperandMatcher>(&B);
bool AIsConstantInsn = AOM && AOM->getInsnMatcher().isConstantInstruction(); bool AIsConstantInsn = AOM && AOM->getInsnMatcher().isConstantInstruction();
▲ Show 20 Lines • Show All 1,686 Lines • ▼ Show 20 LinesExpected<RuleMatcher> GlobalISelEmitter::runOnPattern(const PatternToMatch &P) {
// and // and
// 2. We need to reset the generation of the IDs in M somewhere between // 2. We need to reset the generation of the IDs in M somewhere between
// addInstructionMatcher and emit // addInstructionMatcher and emit
// //
// FIXME: Long term, we don't want to have to rely on this implicit // FIXME: Long term, we don't want to have to rely on this implicit
// naming being the same. One possible solution would be to have // naming being the same. One possible solution would be to have
// explicit operator for operation capture and reference those. // explicit operator for operation capture and reference those.
// The plus side is that it would expose opportunities to share // The plus side is that it would expose opportunities to share
// the capture accross rules. The downside is that it would // the capture across rules. The downside is that it would
// introduce a dependency between predicates (captures must happen // introduce a dependency between predicates (captures must happen
// before their first use.) // before their first use.)
InstructionMatcher &InsnMatcherTemp = M.addInstructionMatcher(Src->getName()); InstructionMatcher &InsnMatcherTemp = M.addInstructionMatcher(Src->getName());
unsigned TempOpIdx = 0; unsigned TempOpIdx = 0;
auto InsnMatcherOrError = auto InsnMatcherOrError =
createAndImportSelDAGMatcher(M, InsnMatcherTemp, Src, TempOpIdx); createAndImportSelDAGMatcher(M, InsnMatcherTemp, Src, TempOpIdx);
if (auto Error = InsnMatcherOrError.takeError()) if (auto Error = InsnMatcherOrError.takeError())
return std::move(Error); return std::move(Error);
▲ Show 20 Lines • Show All 1,096 Lines • Show Last 20 Lines

llvm/utils/UpdateTestChecks/common.py

Show First 20 Lines • Show All 593 Lines • ▼ Show 20 Lines for m in function_re.finditer(raw_tool_output):
args_and_sig, args_and_sig,
attrs, attrs,
is_backend): is_backend):
self._func_dict[prefix][func].scrub = scrubbed_extra self._func_dict[prefix][func].scrub = scrubbed_extra
self._func_dict[prefix][func].args_and_sig = args_and_sig self._func_dict[prefix][func].args_and_sig = args_and_sig
else: else:
# This means a previous RUN line produced a body for this function # This means a previous RUN line produced a body for this function
# that is different from the one produced by this current RUN line, # that is different from the one produced by this current RUN line,
# so the body can't be common accross RUN lines. We use None to # so the body can't be common across RUN lines. We use None to
# indicate that. # indicate that.
self._func_dict[prefix][func] = None self._func_dict[prefix][func] = None
else: else:
if prefix not in self._processed_prefixes: if prefix not in self._processed_prefixes:
self._func_dict[prefix][func] = function_body( self._func_dict[prefix][func] = function_body(
scrubbed_body, scrubbed_extra, args_and_sig, attrs, scrubbed_body, scrubbed_extra, args_and_sig, attrs,
func_name_separator) func_name_separator)
self._func_order[prefix].append(func) self._func_order[prefix].append(func)
▲ Show 20 Lines • Show All 660 Lines • Show Last 20 Lines

llvm/utils/docker/build_docker_image.sh

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Lines
For example, running: For example, running:
$ build_docker_image.sh -s debian10 -d mydocker/debian10-clang -t latest \ $ build_docker_image.sh -s debian10 -d mydocker/debian10-clang -t latest \
-p clang -i install-clang -i install-clang-resource-headers -p clang -i install-clang -i install-clang-resource-headers
will produce two docker images: will produce two docker images:
mydocker/debian10-clang-build:latest - an intermediate image used to compile mydocker/debian10-clang-build:latest - an intermediate image used to compile
clang. clang.
mydocker/clang-debian10:latest - a small image with preinstalled clang. mydocker/clang-debian10:latest - a small image with preinstalled clang.
Please note that this example produces a not very useful installation, since it Please note that this example produces a not very useful installation, since it
doesn't override CMake defaults, which produces a Debug and non-boostrapped doesn't override CMake defaults, which produces a Debug and non-bootstrapped
version of clang. version of clang.
To get a 2-stage clang build, you could use this command: To get a 2-stage clang build, you could use this command:
$ ./build_docker_image.sh -s debian10 -d mydocker/clang-debian10 -t "latest" \ $ ./build_docker_image.sh -s debian10 -d mydocker/clang-debian10 -t "latest" \
-p clang -i stage2-install-clang -i stage2-install-clang-resource-headers \ -p clang -i stage2-install-clang -i stage2-install-clang-resource-headers \
-- \ -- \
-DLLVM_TARGETS_TO_BUILD=Native -DCMAKE_BUILD_TYPE=Release \ -DLLVM_TARGETS_TO_BUILD=Native -DCMAKE_BUILD_TYPE=Release \
-DBOOTSTRAP_CMAKE_BUILD_TYPE=Release \ -DBOOTSTRAP_CMAKE_BUILD_TYPE=Release \
▲ Show 20 Lines • Show All 122 Lines • Show Last 20 Lines

llvm/utils/git/github-automation.py

Show First 20 Lines • Show All 395 Lines • ▼ Show 20 Lines def execute_command(self) -> bool:
branch = m.group(3) branch = m.group(3)
return self.create_pull_request(owner, repo, branch) return self.create_pull_request(owner, repo, branch)
print("Do not understand input:") print("Do not understand input:")
print(sys.stdin.readlines()) print(sys.stdin.readlines())
return False return False
parser = argparse.ArgumentParser() parser = argparse.ArgumentParser()
parser.add_argument('--token', type=str, required=True, help='GitHub authentiation token') parser.add_argument('--token', type=str, required=True, help='GitHub authentication token')
parser.add_argument('--repo', type=str, default=os.getenv('GITHUB_REPOSITORY', 'llvm/llvm-project'), parser.add_argument('--repo', type=str, default=os.getenv('GITHUB_REPOSITORY', 'llvm/llvm-project'),
help='The GitHub repository that we are working with in the form of <owner>/<repo> (e.g. llvm/llvm-project)') help='The GitHub repository that we are working with in the form of <owner>/<repo> (e.g. llvm/llvm-project)')
subparsers = parser.add_subparsers(dest='command') subparsers = parser.add_subparsers(dest='command')
issue_subscriber_parser = subparsers.add_parser('issue-subscriber') issue_subscriber_parser = subparsers.add_parser('issue-subscriber')
issue_subscriber_parser.add_argument('--label-name', type=str, required=True) issue_subscriber_parser.add_argument('--label-name', type=str, required=True)
issue_subscriber_parser.add_argument('--issue-number', type=int, required=True) issue_subscriber_parser.add_argument('--issue-number', type=int, required=True)
release_workflow_parser = subparsers.add_parser('release-workflow') release_workflow_parser = subparsers.add_parser('release-workflow')
release_workflow_parser.add_argument('--llvm-project-dir', type=str, default='.', help='directory containing the llvm-project checout') release_workflow_parser.add_argument('--llvm-project-dir', type=str, default='.', help='directory containing the llvm-project checkout')
release_workflow_parser.add_argument('--issue-number', type=int, required=True, help='The issue number to update') release_workflow_parser.add_argument('--issue-number', type=int, required=True, help='The issue number to update')
release_workflow_parser.add_argument('--phab-token', type=str, help='Phabricator conduit API token. See https://reviews.llvm.org/settings/user/<USER>/page/apitokens/') release_workflow_parser.add_argument('--phab-token', type=str, help='Phabricator conduit API token. See https://reviews.llvm.org/settings/user/<USER>/page/apitokens/')
release_workflow_parser.add_argument('--branch-repo-token', type=str, release_workflow_parser.add_argument('--branch-repo-token', type=str,
help='GitHub authentication token to use for the repository where new branches will be pushed. Defaults to TOKEN.') help='GitHub authentication token to use for the repository where new branches will be pushed. Defaults to TOKEN.')
release_workflow_parser.add_argument('--branch-repo', type=str, default='llvm/llvm-project-release-prs', release_workflow_parser.add_argument('--branch-repo', type=str, default='llvm/llvm-project-release-prs',
help='The name of the repo where new branches will be pushed (e.g. llvm/llvm-project)') help='The name of the repo where new branches will be pushed (e.g. llvm/llvm-project)')
release_workflow_parser.add_argument('sub_command', type=str, choices=['print-release-branch', 'auto'], release_workflow_parser.add_argument('sub_command', type=str, choices=['print-release-branch', 'auto'],
help='Print to stdout the name of the release branch ISSUE_NUMBER should be backported to') help='Print to stdout the name of the release branch ISSUE_NUMBER should be backported to')
Show All 22 Lines

llvm/utils/gn/secondary/lldb/tools/lldb-test/BUILD.gn

Show All 13 Lines deps = [
"//lldb/source/Plugins:LldbAllPlugins", "//lldb/source/Plugins:LldbAllPlugins",
"//lldb/source/Symbol", "//lldb/source/Symbol",
"//lldb/source/Target", "//lldb/source/Target",
"//lldb/source/Utility", "//lldb/source/Utility",
"//lldb/source/Version", "//lldb/source/Version",
"//llvm/lib/Support", "//llvm/lib/Support",
] ]
# XXX commment # XXX comment
include_dirs = [ "//lldb/source" ] include_dirs = [ "//lldb/source" ]
sources = [ sources = [
"FormatUtil.cpp", "FormatUtil.cpp",
"SystemInitializerTest.cpp", "SystemInitializerTest.cpp",
"lldb-test.cpp", "lldb-test.cpp",
] ]
} }

llvm/utils/lit/lit/ProgressBar.py

Show All 32 Linesclass TerminalController:
result, the above code will still work on terminals that do not result, the above code will still work on terminals that do not
support color, except that their output will not be colored. support color, except that their output will not be colored.
Also, this means that you can test whether the terminal supports a Also, this means that you can test whether the terminal supports a
given action by simply testing the truth value of the given action by simply testing the truth value of the
corresponding instance variable: corresponding instance variable:
>>> term = TerminalController() >>> term = TerminalController()
>>> if term.CLEAR_SCREEN: >>> if term.CLEAR_SCREEN:
... print('This terminal supports clearning the screen.') ... print('This terminal supports clearing the screen.')
Finally, if the width and height of the terminal are known, then Finally, if the width and height of the terminal are known, then
they will be stored in the `COLS` and `LINES` attributes. they will be stored in the `COLS` and `LINES` attributes.
""" """
# Cursor movement: # Cursor movement:
BOL = '' #: Move the cursor to the beginning of the line BOL = '' #: Move the cursor to the beginning of the line
UP = '' #: Move the cursor up one line UP = '' #: Move the cursor up one line
DOWN = '' #: Move the cursor down one line DOWN = '' #: Move the cursor down one line
▲ Show 20 Lines • Show All 248 Lines • Show Last 20 Lines

llvm/utils/lit/lit/TestRunner.py

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines
# command in the target shell so that the line number is seen in lit's verbose # command in the target shell so that the line number is seen in lit's verbose
# mode. # mode.
# #
# This regex captures ARG. ARG must not contain a right parenthesis, which # This regex captures ARG. ARG must not contain a right parenthesis, which
# terminates %dbg. ARG must not contain quotes, in which ARG might be enclosed # terminates %dbg. ARG must not contain quotes, in which ARG might be enclosed
# during expansion. # during expansion.
# #
# COMMAND that follows %dbg(ARG) is also captured. COMMAND can be # COMMAND that follows %dbg(ARG) is also captured. COMMAND can be
# empty as a result of conditinal substitution. # empty as a result of conditional substitution.
kPdbgRegex = '%dbg\\(([^)\'"]*)\\)(.*)' kPdbgRegex = '%dbg\\(([^)\'"]*)\\)(.*)'
class ShellEnvironment(object): class ShellEnvironment(object):
"""Mutable shell environment containing things like CWD and env vars. """Mutable shell environment containing things like CWD and env vars.
Environment variables are not implemented, but cwd tracking is. In addition, Environment variables are not implemented, but cwd tracking is. In addition,
we maintain a dir stack for pushd/popd. we maintain a dir stack for pushd/popd.
▲ Show 20 Lines • Show All 1,685 Lines • Show Last 20 Lines

llvm/utils/unicode-case-fold.py

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Lines
# Computes the stride of a list of mappings. The list should have at least two # Computes the stride of a list of mappings. The list should have at least two
# mappings. All mappings in the list are assumed to have the same stride. # mappings. All mappings in the list are assumed to have the same stride.
def stride(block): def stride(block):
return stride2(block[0], block[1]) return stride2(block[0], block[1])
# b is a list of mappings. All the mappings are assumed to have the same # b is a list of mappings. All the mappings are assumed to have the same
# shift and the stride between adjecant mappings (if any) is constant. # shift and the stride between adjacent mappings (if any) is constant.
def dump_block(b): def dump_block(b):
global body global body
if len(b) == 1: if len(b) == 1:
# Special case for handling blocks of length 1. We don't even need to # Special case for handling blocks of length 1. We don't even need to
# emit the "if (C < X) return C" check below as all characters in this # emit the "if (C < X) return C" check below as all characters in this
# range will be caught by the "C < X" check emitted by the first # range will be caught by the "C < X" check emitted by the first
# non-trivial block. # non-trivial block.
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

llvm/utils/update_analyze_test_checks.py

Show All 20 Lines
6. Apply your patch from step 1 and rebuild your local binaries. 6. Apply your patch from step 1 and rebuild your local binaries.
7. Re-run this script on affected regression tests. 7. Re-run this script on affected regression tests.
8. Check the diffs to ensure the script has done something reasonable. 8. Check the diffs to ensure the script has done something reasonable.
9. Submit a patch including the regression test diffs for review. 9. Submit a patch including the regression test diffs for review.
A common pattern is to have the script insert complete checking of every A common pattern is to have the script insert complete checking of every
instruction. Then, edit it down to only check the relevant instructions. instruction. Then, edit it down to only check the relevant instructions.
The script is designed to make adding checks to a test case fast, it is *not* The script is designed to make adding checks to a test case fast, it is *not*
designed to be authoratitive about what constitutes a good test! designed to be authoritative about what constitutes a good test!
""" """
from __future__ import print_function from __future__ import print_function
import argparse import argparse
import os # Used to advertise this file's name ("autogenerated_note"). import os # Used to advertise this file's name ("autogenerated_note").
import sys import sys
import re import re
▲ Show 20 Lines • Show All 147 Lines • Show Last 20 Lines

llvm/utils/update_cc_test_checks.py

Show First 20 Lines • Show All 365 Lines • ▼ Show 20 Lines else:
for line_info in ti.iterlines(output_lines): for line_info in ti.iterlines(output_lines):
idx = line_info.line_number idx = line_info.line_number
line = line_info.line line = line_info.line
args = line_info.args args = line_info.args
include_line = True include_line = True
m = common.CHECK_RE.match(line) m = common.CHECK_RE.match(line)
if m and m.group(1) in prefix_set: if m and m.group(1) in prefix_set:
continue # Don't append the existing CHECK lines continue # Don't append the existing CHECK lines
# Skip special separator comments added by commmon.add_global_checks. # Skip special separator comments added by common.add_global_checks.
if line.strip() == '//' + common.SEPARATOR: if line.strip() == '//' + common.SEPARATOR:
continue continue
if idx in line2func_list: if idx in line2func_list:
added = set() added = set()
for spell, mangled, search in line2func_list[idx]: for spell, mangled, search in line2func_list[idx]:
# One line may contain multiple function declarations. # One line may contain multiple function declarations.
# Skip if the mangled name has been added before. # Skip if the mangled name has been added before.
# The line number may come from an included file, we simply require # The line number may come from an included file, we simply require
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

mlir/docs/Bindings/Python.md

Show First 20 Lines • Show All 514 Lines • ▼ Show 20 Lines
- a generic `Value` object; or - a generic `Value` object; or
- a concrete `BlockArgument` or `OpResult` object. - a concrete `BlockArgument` or `OpResult` object.
The former provides all the generic functionality such as comparison, type The former provides all the generic functionality such as comparison, type
access and printing. The latter provide access to the defining block or access and printing. The latter provide access to the defining block or
operation and the position of the value within it. By default, the generic operation and the position of the value within it. By default, the generic
`Value` objects are returned from IR traversals. Downcasting is implemented `Value` objects are returned from IR traversals. Downcasting is implemented
through concrete subclass constructors, similarly to attribtues and types: through concrete subclass constructors, similarly to attributes and types:
```python ```python
from mlir.ir import BlockArgument, OpResult, Value from mlir.ir import BlockArgument, OpResult, Value
value = ... value = ...
# Set `concrete` to the specific value subclass. # Set `concrete` to the specific value subclass.
try: try:
▲ Show 20 Lines • Show All 642 Lines • Show Last 20 Lines

mlir/docs/TargetLLVMIR.md

Show First 20 Lines • Show All 547 Lines • ▼ Show 20 Lines
} }
``` ```
#### Bare Pointer Calling Convention For Unranked MemRef #### Bare Pointer Calling Convention For Unranked MemRef
The "bare pointer" calling convention does not support unranked memrefs as their The "bare pointer" calling convention does not support unranked memrefs as their
shape cannot be known at compile time. shape cannot be known at compile time.
### Generic alloction and deallocation functions ### Generic allocation and deallocation functions
When converting the Memref dialect, allocations and deallocations are converted When converting the Memref dialect, allocations and deallocations are converted
into calls to `malloc` (`aligned_alloc` if aligned allocations are requested) into calls to `malloc` (`aligned_alloc` if aligned allocations are requested)
and `free`. However, it is possible to convert them to more generic functions and `free`. However, it is possible to convert them to more generic functions
which can be implemented by a runtime library, thus allowing custom allocation which can be implemented by a runtime library, thus allowing custom allocation
strategies or runtime profiling. When the conversion pass is instructed to strategies or runtime profiling. When the conversion pass is instructed to
perform such operation, the names of the calles are `_mlir_alloc`, perform such operation, the names of the calles are `_mlir_alloc`,
`_mlir_aligned_alloc` and `_mlir_free`. Their signatures are the same of `_mlir_aligned_alloc` and `_mlir_free`. Their signatures are the same of
▲ Show 20 Lines • Show All 357 Lines • Show Last 20 Lines

mlir/include/mlir/Analysis/DataFlowFramework.h

Show First 20 Lines • Show All 373 Lines • ▼ Show 20 Linespublic:
/// calling `addDependency` between the input state and a program point, /// calling `addDependency` between the input state and a program point,
/// indicating that, if the state is updated, the solver should invoke `solve` /// indicating that, if the state is updated, the solver should invoke `solve`
/// on the program point. The dependent point does not have to be the same as /// on the program point. The dependent point does not have to be the same as
/// the provided point. An update to a state is propagated by calling /// the provided point. An update to a state is propagated by calling
/// `propagateIfChange` on the state. If the state has changed, then all its /// `propagateIfChange` on the state. If the state has changed, then all its
/// dependents are placed on the worklist. /// dependents are placed on the worklist.
/// ///
/// The dependency graph does not need to be static. Each invocation of /// The dependency graph does not need to be static. Each invocation of
/// `visit` can add new dependencies, but these dependecies will not be /// `visit` can add new dependencies, but these dependencies will not be
/// dynamically added to the worklist because the solver doesn't know what /// dynamically added to the worklist because the solver doesn't know what
/// will provide a value for then. /// will provide a value for then.
virtual LogicalResult visit(ProgramPoint point) = 0; virtual LogicalResult visit(ProgramPoint point) = 0;
protected: protected:
/// Create a dependency between the given analysis state and program point /// Create a dependency between the given analysis state and program point
/// on this analysis. /// on this analysis.
void addDependency(AnalysisState *state, ProgramPoint point); void addDependency(AnalysisState *state, ProgramPoint point);
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

mlir/include/mlir/Analysis/Presburger/PWMAFunction.h

Show First 20 Lines • Show All 68 Lines • ▼ Show 20 Linespublic:
/// corresponding to the added variables are initialized to zero. Return the /// corresponding to the added variables are initialized to zero. Return the
/// absolute column position (i.e., not relative to the kind of variable) /// absolute column position (i.e., not relative to the kind of variable)
/// of the first added variable. /// of the first added variable.
unsigned insertVar(VarKind kind, unsigned pos, unsigned num = 1); unsigned insertVar(VarKind kind, unsigned pos, unsigned num = 1);
/// Remove the specified range of vars. /// Remove the specified range of vars.
void removeVarRange(VarKind kind, unsigned varStart, unsigned varLimit); void removeVarRange(VarKind kind, unsigned varStart, unsigned varLimit);
/// Given a MAF `other`, merges local variables such that both funcitons /// Given a MAF `other`, merges local variables such that both functions
/// have union of local vars, without changing the set of points in domain or /// have union of local vars, without changing the set of points in domain or
/// the output. /// the output.
void mergeLocalVars(MultiAffineFunction &other); void mergeLocalVars(MultiAffineFunction &other);
/// Return whether the outputs of `this` and `other` agree wherever both /// Return whether the outputs of `this` and `other` agree wherever both
/// functions are defined, i.e., the outputs should be equal for all points in /// functions are defined, i.e., the outputs should be equal for all points in
/// the intersection of the domains. /// the intersection of the domains.
bool isEqualWhereDomainsOverlap(MultiAffineFunction other) const; bool isEqualWhereDomainsOverlap(MultiAffineFunction other) const;
▲ Show 20 Lines • Show All 136 Lines • Show Last 20 Lines

mlir/include/mlir/Analysis/Presburger/Simplex.h

Show First 20 Lines • Show All 557 Lines • ▼ Show 20 Lines
/// LexSimplex::findIntegerLexMin simultaneously for every value of the symbols /// LexSimplex::findIntegerLexMin simultaneously for every value of the symbols
/// in the domain. /// in the domain.
/// ///
/// Often, the pivot to be performed is the same for all values of the symbols, /// Often, the pivot to be performed is the same for all values of the symbols,
/// in which case we just do it. For example, if the symbolic sample of a row is /// in which case we just do it. For example, if the symbolic sample of a row is
/// negative for all values in the symbol domain, the row needs to be pivoted /// negative for all values in the symbol domain, the row needs to be pivoted
/// irrespective of the precise value of the symbols. To answer queries like /// irrespective of the precise value of the symbols. To answer queries like
/// "Is this symbolic sample always negative in the symbol domain?", we maintain /// "Is this symbolic sample always negative in the symbol domain?", we maintain
/// a `LexSimplex domainSimplex` correponding to the symbol domain. /// a `LexSimplex domainSimplex` corresponding to the symbol domain.
/// ///
/// In other cases, it may be that the symbolic sample is violated at some /// In other cases, it may be that the symbolic sample is violated at some
/// values in the symbol domain and not violated at others. In this case, /// values in the symbol domain and not violated at others. In this case,
/// the pivot to be performed does depend on the value of the symbols. We /// the pivot to be performed does depend on the value of the symbols. We
/// handle this by splitting the symbol domain. We run the algorithm for the /// handle this by splitting the symbol domain. We run the algorithm for the
/// case where the row isn't violated, and then come back and run the case /// case where the row isn't violated, and then come back and run the case
/// where it is. /// where it is.
class SymbolicLexSimplex : public LexSimplexBase { class SymbolicLexSimplex : public LexSimplexBase {
▲ Show 20 Lines • Show All 311 Lines • Show Last 20 Lines

mlir/include/mlir/Bindings/Python/Attributes.td

Show All 15 Lines
// A mapping between the attribute storage type and the corresponding Python // A mapping between the attribute storage type and the corresponding Python
// type. There is not necessarily a 1-1 match for non-builtin attributes. // type. There is not necessarily a 1-1 match for non-builtin attributes.
class PythonAttr<string c, string p> { class PythonAttr<string c, string p> {
string cppStorageType = c; string cppStorageType = c;
string pythonType = p; string pythonType = p;
} }
// Mappings between supported builtin attribtues and Python types. // Mappings between supported builtin attributes and Python types.
def : PythonAttr<"::mlir::Attribute", "_ods_ir.Attribute">; def : PythonAttr<"::mlir::Attribute", "_ods_ir.Attribute">;
def : PythonAttr<"::mlir::BoolAttr", "_ods_ir.BoolAttr">; def : PythonAttr<"::mlir::BoolAttr", "_ods_ir.BoolAttr">;
def : PythonAttr<"::mlir::IntegerAttr", "_ods_ir.IntegerAttr">; def : PythonAttr<"::mlir::IntegerAttr", "_ods_ir.IntegerAttr">;
def : PythonAttr<"::mlir::FloatAttr", "_ods_ir.FloatAttr">; def : PythonAttr<"::mlir::FloatAttr", "_ods_ir.FloatAttr">;
def : PythonAttr<"::mlir::StringAttr", "_ods_ir.StringAttr">; def : PythonAttr<"::mlir::StringAttr", "_ods_ir.StringAttr">;
def : PythonAttr<"::mlir::DenseElementsAttr", "_ods_ir.DenseElementsAttr">; def : PythonAttr<"::mlir::DenseElementsAttr", "_ods_ir.DenseElementsAttr">;
def : PythonAttr<"::mlir::DenseIntElementsAttr", "_ods_ir.DenseIntElementsAttr">; def : PythonAttr<"::mlir::DenseIntElementsAttr", "_ods_ir.DenseIntElementsAttr">;
def : PythonAttr<"::mlir::DenseFPElementsAttr", "_ods_ir.DenseFPElementsAttr">; def : PythonAttr<"::mlir::DenseFPElementsAttr", "_ods_ir.DenseFPElementsAttr">;
#endif #endif

mlir/include/mlir/Dialect/AMDGPU/AMDGPU.td

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines Results<(outs AnyTypeOf<[BF16, F16, F32, I32, I8,
VectorOfLengthAndType<[2, 4, 8], [F16, BF16]>, VectorOfLengthAndType<[2, 4, 8], [F16, BF16]>,
VectorOfLengthAndType<[2, 4, 8, 16], [I8]>]>:$value)> { VectorOfLengthAndType<[2, 4, 8, 16], [I8]>]>:$value)> {
let summary = "Raw Buffer load, exposing GCN features"; let summary = "Raw Buffer load, exposing GCN features";
let description = [{ let description = [{
The `amdgpu.raw_buffer_load` op is a wrapper around the buffer load intrinsics The `amdgpu.raw_buffer_load` op is a wrapper around the buffer load intrinsics
available on AMD GPUs, including extensions in newer GPUs. available on AMD GPUs, including extensions in newer GPUs.
The index into the buffer is computed as for `memref.load` with the additon The index into the buffer is computed as for `memref.load` with the addition
of `indexOffset` and `sgprOffset` (which **may or may not** be considered of `indexOffset` and `sgprOffset` (which **may or may not** be considered
in bounds checks and includes any offset present on the memref type if it's in bounds checks and includes any offset present on the memref type if it's
non-zero). non-zero).
All indices and offsets are in units of the memref's data type and are All indices and offsets are in units of the memref's data type and are
converted to bytes during lowering. converted to bytes during lowering.
When a load is out of bounds, the instruction returns zero. When a load is out of bounds, the instruction returns zero.
▲ Show 20 Lines • Show All 124 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/GPU/IR/GPUBase.td

Show First 20 Lines • Show All 78 Lines • ▼ Show 20 Lines
def GPU_AsyncOpInterface : OpInterface<"AsyncOpInterface"> { def GPU_AsyncOpInterface : OpInterface<"AsyncOpInterface"> {
let description = [{ let description = [{
Interface for GPU operations that execute asynchronously on the device. Interface for GPU operations that execute asynchronously on the device.
GPU operations implementing this interface take a list of dependencies GPU operations implementing this interface take a list of dependencies
as `gpu.async.token` arguments and optionally return a `gpu.async.token`. as `gpu.async.token` arguments and optionally return a `gpu.async.token`.
The op doesn't start executing until all depent ops producing the async The op doesn't start executing until all dependent ops producing the async
dependency tokens have finished executing. dependency tokens have finished executing.
If the op returns a token, the op merely schedules the execution on the If the op returns a token, the op merely schedules the execution on the
device and returns immediately, without waiting for the execution to device and returns immediately, without waiting for the execution to
complete. On the hand, if the op does not return a token, the op will wait complete. On the hand, if the op does not return a token, the op will wait
for the execution to complete. for the execution to complete.
}]; }];
let cppNamespace = "::mlir::gpu"; let cppNamespace = "::mlir::gpu";
Show All 39 Lines

mlir/include/mlir/Dialect/LLVMIR/NVVMOps.td

Show First 20 Lines • Show All 876 Lines • ▼ Show 20 Linesdef NVVM_MmaOp : NVVM_Op<"mma.sync", [AttrSizedOperandSegments]> {
let description = [{ let description = [{
The `nvvm.mma.sync` operation collectively performs the operation The `nvvm.mma.sync` operation collectively performs the operation
`D = matmul(A, B) + C` using all threads in a warp. `D = matmul(A, B) + C` using all threads in a warp.
All the threads in the warp must execute the same `mma.sync` operation. All the threads in the warp must execute the same `mma.sync` operation.
For each possible multiplicand PTX data type, there are one or more possible For each possible multiplicand PTX data type, there are one or more possible
instruction shapes given as "mMnNkK". The below table describes the posssibilities instruction shapes given as "mMnNkK". The below table describes the possibilities
as well as the types required for the operands. Note that the data type for as well as the types required for the operands. Note that the data type for
C (the accumulator) and D (the result) can vary independently when there are C (the accumulator) and D (the result) can vary independently when there are
multiple possibilities in the "C/D Type" column. multiple possibilities in the "C/D Type" column.
When an optional attribute cannot be immediately inferred from the types of When an optional attribute cannot be immediately inferred from the types of
the operands and the result during parsing or validation, an error will be the operands and the result during parsing or validation, an error will be
raised. raised.
`b1Op` is only relevant when the binary (b1) type is given to `b1Op` is only relevant when the binary (b1) type is given to
`multiplicandDataType`. It specifies how the multiply-and-acumulate is `multiplicandDataType`. It specifies how the multiply-and-accumulate is
performed and is either `xor_popc` or `and_poc`. The default is `xor_popc`. performed and is either `xor_popc` or `and_poc`. The default is `xor_popc`.
`intOverflowBehavior` is only relevant when the `multiplicandType` attribute `intOverflowBehavior` is only relevant when the `multiplicandType` attribute
is one of `u8, s8, u4, s4`, this attribute describes how overflow is handled is one of `u8, s8, u4, s4`, this attribute describes how overflow is handled
in the accumulator. When the attribute is `satfinite`, the accumulator values in the accumulator. When the attribute is `satfinite`, the accumulator values
are clamped in the int32 range on overflow. This is the default behavior. are clamped in the int32 range on overflow. This is the default behavior.
Alternatively, accumulator behavior `wrapped` can also be specified, in Alternatively, accumulator behavior `wrapped` can also be specified, in
which case overflow wraps from one end of the range to the other. which case overflow wraps from one end of the range to the other.
▲ Show 20 Lines • Show All 108 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/NVGPU/IR/NVGPU.td

//===-- NVGPU.td - NVGPU dialect operation definitions *- tablegen -*------===// //===-- NVGPU.td - NVGPU dialect operation definitions *- tablegen -*------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file defines the basic operations for the NVGPU dialect. // This file defines the basic operations for the NVGPU dialect.
// //
// This NVGPU provides a bridge between the target agnostic GPU and Vector // This NVGPU provides a bridge between the target agnostic GPU and Vector
// dialects and lower level NVVM dialect. This allow representing PTX specific // dialects and lower level NVVM dialect. This allow representing PTX specific
// operations while using MLIR high level concepts like memref and 2-D vector. // operations while using MLIR high level concepts like memref and 2-D vector.
// //
// Ops semantic are going to be based on vendor specific PTX defintion: // Ops semantic are going to be based on vendor specific PTX definition:
// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html // https://docs.nvidia.com/cuda/parallel-thread-execution/index.html
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef NVGPU #ifndef NVGPU
#define NVGPU #define NVGPU
include "mlir/Interfaces/SideEffectInterfaces.td" include "mlir/Interfaces/SideEffectInterfaces.td"
▲ Show 20 Lines • Show All 209 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/Vector/Transforms/VectorDistribution.h

Show All 14 Lines
class RewritePatternSet; class RewritePatternSet;
namespace vector { namespace vector {
struct WarpExecuteOnLane0LoweringOptions { struct WarpExecuteOnLane0LoweringOptions {
/// Lamdba function to let users allocate memory needed for the lowering of /// Lamdba function to let users allocate memory needed for the lowering of
/// WarpExecuteOnLane0Op. /// WarpExecuteOnLane0Op.
/// The function needs to return an allocation that the lowering can use as /// The function needs to return an allocation that the lowering can use as
/// temporary memory. The allocation needs to match the shape of the type (the /// temporary memory. The allocation needs to match the shape of the type (the
/// type may be VectorType or a scalar) and be availble for the current warp. /// type may be VectorType or a scalar) and be available for the current warp.
/// If there are several warps running in parallel the allocation needs to be /// If there are several warps running in parallel the allocation needs to be
/// split so that each warp has its own allocation. /// split so that each warp has its own allocation.
using WarpAllocationFn = using WarpAllocationFn =
std::function<Value(Location, OpBuilder &, WarpExecuteOnLane0Op, Type)>; std::function<Value(Location, OpBuilder &, WarpExecuteOnLane0Op, Type)>;
WarpAllocationFn warpAllocationFn = nullptr; WarpAllocationFn warpAllocationFn = nullptr;
/// Lamdba function to let user emit operation to syncronize all the thread /// Lamdba function to let user emit operation to syncronize all the thread
/// within a warp. After this operation all the threads can see any memory /// within a warp. After this operation all the threads can see any memory
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

mlir/include/mlir/IR/BuiltinAttributes.td

Show First 20 Lines • Show All 1,098 Lines • ▼ Show 20 Linesdef Builtin_SymbolRefAttr : Builtin_Attr<"SymbolRef", [
let extraClassDeclaration = [{ let extraClassDeclaration = [{
static SymbolRefAttr get(MLIRContext *ctx, StringRef value, static SymbolRefAttr get(MLIRContext *ctx, StringRef value,
ArrayRef<FlatSymbolRefAttr> nestedRefs); ArrayRef<FlatSymbolRefAttr> nestedRefs);
/// Convenience getters for building a SymbolRefAttr with no path, which is /// Convenience getters for building a SymbolRefAttr with no path, which is
/// known to produce a FlatSymbolRefAttr. /// known to produce a FlatSymbolRefAttr.
static FlatSymbolRefAttr get(StringAttr value); static FlatSymbolRefAttr get(StringAttr value);
static FlatSymbolRefAttr get(MLIRContext *ctx, StringRef value); static FlatSymbolRefAttr get(MLIRContext *ctx, StringRef value);
/// Convenience getter for buliding a SymbolRefAttr based on an operation /// Convenience getter for building a SymbolRefAttr based on an operation
/// that implements the SymbolTrait. /// that implements the SymbolTrait.
static FlatSymbolRefAttr get(Operation *symbol); static FlatSymbolRefAttr get(Operation *symbol);
/// Returns the name of the fully resolved symbol, i.e. the leaf of the /// Returns the name of the fully resolved symbol, i.e. the leaf of the
/// reference path. /// reference path.
StringAttr getLeafReference() const; StringAttr getLeafReference() const;
}]; }];
let skipDefaultBuilders = 1; let skipDefaultBuilders = 1;
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

mlir/include/mlir/Transforms/Passes.td

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Lines let description = [{
This pass implements control-flow sink on operations that implement This pass implements control-flow sink on operations that implement
`RegionBranchOpInterface` by moving dominating operations whose only uses `RegionBranchOpInterface` by moving dominating operations whose only uses
are in a conditionally-executed regions into those regions so that are in a conditionally-executed regions into those regions so that
executions paths where their results are not needed do not perform executions paths where their results are not needed do not perform
unnecessary computations. unnecessary computations.
This is similar (but opposite) to loop-invariant code motion, which hoists This is similar (but opposite) to loop-invariant code motion, which hoists
operations out of regions executed more than once. The implementation of operations out of regions executed more than once. The implementation of
control-flow sink uses a simple and conversative cost model: operations are control-flow sink uses a simple and conservative cost model: operations are
never duplicated and are only moved into singly-executed regions. never duplicated and are only moved into singly-executed regions.
It is recommended to run canonicalization first to remove unreachable It is recommended to run canonicalization first to remove unreachable
blocks: ops in unreachable blocks may prevent other operations from being blocks: ops in unreachable blocks may prevent other operations from being
sunk as they may contain uses of their results sunk as they may contain uses of their results
}]; }];
let constructor = "::mlir::createControlFlowSinkPass()"; let constructor = "::mlir::createControlFlowSinkPass()";
let statistics = [ let statistics = [
▲ Show 20 Lines • Show All 225 Lines • Show Last 20 Lines

mlir/lib/Conversion/GPUCommon/GPUOpsLowering.cpp

Show First 20 Lines • Show All 314 Lines • ▼ Show 20 Lines auto globalType =
LLVM::LLVMArrayType::get(llvmI8, formatString.size_in_bytes()); LLVM::LLVMArrayType::get(llvmI8, formatString.size_in_bytes());
LLVM::GlobalOp global; LLVM::GlobalOp global;
{ {
ConversionPatternRewriter::InsertionGuard guard(rewriter); ConversionPatternRewriter::InsertionGuard guard(rewriter);
rewriter.setInsertionPointToStart(moduleOp.getBody()); rewriter.setInsertionPointToStart(moduleOp.getBody());
global = rewriter.create<LLVM::GlobalOp>( global = rewriter.create<LLVM::GlobalOp>(
loc, globalType, loc, globalType,
/*isConstant=*/true, LLVM::Linkage::Internal, stringConstName, /*isConstant=*/true, LLVM::Linkage::Internal, stringConstName,
rewriter.getStringAttr(formatString), /*allignment=*/0, addressSpace); rewriter.getStringAttr(formatString), /*alignment=*/0, addressSpace);
} }
// Get a pointer to the format string's first element // Get a pointer to the format string's first element
Value globalPtr = rewriter.create<LLVM::AddressOfOp>(loc, global); Value globalPtr = rewriter.create<LLVM::AddressOfOp>(loc, global);
Value zero = rewriter.create<LLVM::ConstantOp>( Value zero = rewriter.create<LLVM::ConstantOp>(
loc, llvmIndex, rewriter.getIntegerAttr(llvmIndex, 0)); loc, llvmIndex, rewriter.getIntegerAttr(llvmIndex, 0));
Value stringStart = rewriter.create<LLVM::GEPOp>( Value stringStart = rewriter.create<LLVM::GEPOp>(
loc, i8Ptr, globalPtr, mlir::ValueRange({zero, zero})); loc, i8Ptr, globalPtr, mlir::ValueRange({zero, zero}));
Show All 12 Lines

mlir/lib/Dialect/Linalg/Transforms/Detensorize.cpp

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Linesbool shouldBeDetensored(Operation *op, TypeConverter typeConverter) {
GenericOp genericOp = dyn_cast_or_null<GenericOp>(op); GenericOp genericOp = dyn_cast_or_null<GenericOp>(op);
return genericOp && return genericOp &&
llvm::all_of( llvm::all_of(
genericOp.getInputAndOutputOperands(), [&](OpOperand *opOperand) { genericOp.getInputAndOutputOperands(), [&](OpOperand *opOperand) {
return !typeConverter.isLegal(opOperand->get().getType()); return !typeConverter.isLegal(opOperand->get().getType());
}); });
} }
/// A conversion patttern for detensoring `linalg.generic` ops. /// A conversion pattern for detensoring `linalg.generic` ops.
class DetensorizeGenericOp : public OpConversionPattern<GenericOp> { class DetensorizeGenericOp : public OpConversionPattern<GenericOp> {
public: public:
using OpConversionPattern::OpConversionPattern; using OpConversionPattern::OpConversionPattern;
LogicalResult LogicalResult
matchAndRewrite(GenericOp op, OpAdaptor adaptor, matchAndRewrite(GenericOp op, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const override { ConversionPatternRewriter &rewriter) const override {
Block *originalBlock = op->getBlock(); Block *originalBlock = op->getBlock();
▲ Show 20 Lines • Show All 339 Lines • ▼ Show 20 Lines void compute(FunctionOpInterface func,
// ops should not be detensored as well. // ops should not be detensored as well.
DenseSet<BlockArgument> blockArgsToRemove; DenseSet<BlockArgument> blockArgsToRemove;
for (auto &blockArg : blockArgsToDetensor) { for (auto &blockArg : blockArgsToDetensor) {
Block *block = blockArg.getParentBlock(); Block *block = blockArg.getParentBlock();
// For the potentially detensorable block argument, find the // For the potentially detensorable block argument, find the
// correpsonding operands in predecessor blocks. // corresponding operands in predecessor blocks.
for (PredecessorIterator pred = block->pred_begin(); for (PredecessorIterator pred = block->pred_begin();
pred != block->pred_end(); ++pred) { pred != block->pred_end(); ++pred) {
BranchOpInterface terminator = BranchOpInterface terminator =
dyn_cast<BranchOpInterface>((*pred)->getTerminator()); dyn_cast<BranchOpInterface>((*pred)->getTerminator());
auto blockOperands = auto blockOperands =
terminator.getSuccessorOperands(pred.getSuccessorIndex()); terminator.getSuccessorOperands(pred.getSuccessorIndex());
if (blockOperands.empty() || if (blockOperands.empty() ||
▲ Show 20 Lines • Show All 134 Lines • Show Last 20 Lines

mlir/lib/Dialect/Math/Transforms/PolynomialApproximation.cpp

Show First 20 Lines • Show All 667 Lines • ▼ Show 20 Lines Value zeroMask = builder.create<arith::CmpFOp>(arith::CmpFPredicate::OEQ,
op.getOperand(), cstZero); op.getOperand(), cstZero);
Value posInfMask = builder.create<arith::CmpFOp>(arith::CmpFPredicate::OEQ, Value posInfMask = builder.create<arith::CmpFOp>(arith::CmpFPredicate::OEQ,
op.getOperand(), cstPosInf); op.getOperand(), cstPosInf);
// Filter out invalid values: // Filter out invalid values:
// • x == 0 -> -INF // • x == 0 -> -INF
// • x < 0 -> NAN // • x < 0 -> NAN
// • x == +INF -> +INF // • x == +INF -> +INF
Value aproximation = builder.create<arith::SelectOp>( Value approximation = builder.create<arith::SelectOp>(
zeroMask, cstMinusInf, zeroMask, cstMinusInf,
builder.create<arith::SelectOp>( builder.create<arith::SelectOp>(
invalidMask, cstNan, invalidMask, cstNan,
builder.create<arith::SelectOp>(posInfMask, cstPosInf, x))); builder.create<arith::SelectOp>(posInfMask, cstPosInf, x)));
rewriter.replaceOp(op, aproximation); rewriter.replaceOp(op, approximation);
return success(); return success();
} }
namespace { namespace {
struct LogApproximation : public LogApproximationBase<math::LogOp> { struct LogApproximation : public LogApproximationBase<math::LogOp> {
using LogApproximationBase::LogApproximationBase; using LogApproximationBase::LogApproximationBase;
▲ Show 20 Lines • Show All 600 Lines • Show Last 20 Lines

mlir/lib/Dialect/Tosa/Transforms/TosaInferShapes.cpp

Show First 20 Lines • Show All 278 Lines • ▼ Show 20 Lines
public: public:
void runOnOperation() override { void runOnOperation() override {
func::FuncOp func = getOperation(); func::FuncOp func = getOperation();
IRRewriter rewriter(func.getContext()); IRRewriter rewriter(func.getContext());
propagateShapesInRegion(func.getBody()); propagateShapesInRegion(func.getBody());
// Insert UnrealizedConversionCasts to guarantee ReturnOp agress with // Insert UnrealizedConversionCasts to guarantee ReturnOp agrees with
// the FuncOp type. // the FuncOp type.
func.walk([&](func::ReturnOp op) { func.walk([&](func::ReturnOp op) {
func::FuncOp parent = dyn_cast<func::FuncOp>(op->getParentOp()); func::FuncOp parent = dyn_cast<func::FuncOp>(op->getParentOp());
if (!parent) if (!parent)
return; return;
rewriter.setInsertionPoint(op); rewriter.setInsertionPoint(op);
FunctionType funcTy = func.getFunctionType(); FunctionType funcTy = func.getFunctionType();
Show All 31 Lines

mlir/lib/ExecutionEngine/AsyncRuntime.cpp

Show First 20 Lines • Show All 280 Lines • ▼ Show 20 Linesextern "C" int64_t mlirAsyncRuntimeAddTokenToGroup(AsyncToken *token,
if (State(token->state).isAvailableOrError()) { if (State(token->state).isAvailableOrError()) {
// Update group pending tokens immediately and maybe run awaiters. // Update group pending tokens immediately and maybe run awaiters.
onTokenReady(); onTokenReady();
} else { } else {
// Update group pending tokens when token will become ready. Because this // Update group pending tokens when token will become ready. Because this
// will happen asynchronously we must ensure that `group` is alive until // will happen asynchronously we must ensure that `group` is alive until
// then, and re-ackquire the lock. // then, and re-acquire the lock.
group->addRef(); group->addRef();
token->awaiters.emplace_back([group, onTokenReady]() { token->awaiters.emplace_back([group, onTokenReady]() {
// Make sure that `dropRef` does not destroy the mutex owned by the lock. // Make sure that `dropRef` does not destroy the mutex owned by the lock.
{ {
std::unique_lock<std::mutex> lockGroup(group->mu); std::unique_lock<std::mutex> lockGroup(group->mu);
onTokenReady(); onTokenReady();
} }
▲ Show 20 Lines • Show All 237 Lines • Show Last 20 Lines

mlir/lib/Target/Cpp/TranslateToCpp.cpp

Show First 20 Lines • Show All 102 Lines • ▼ Show 20 Linesstruct CppEmitter {
/// - emits nothing if no value produced by op; /// - emits nothing if no value produced by op;
/// Emits final '=' operator where a type is produced. Returns failure if /// Emits final '=' operator where a type is produced. Returns failure if
/// any result type could not be converted. /// any result type could not be converted.
LogicalResult emitAssignPrefix(Operation &op); LogicalResult emitAssignPrefix(Operation &op);
/// Emits a label for the block. /// Emits a label for the block.
LogicalResult emitLabel(Block &block); LogicalResult emitLabel(Block &block);
/// Emits the operands and atttributes of the operation. All operands are /// Emits the operands and attributes of the operation. All operands are
/// emitted first and then all attributes in alphabetical order. /// emitted first and then all attributes in alphabetical order.
LogicalResult emitOperandsAndAttributes(Operation &op, LogicalResult emitOperandsAndAttributes(Operation &op,
ArrayRef<StringRef> exclude = {}); ArrayRef<StringRef> exclude = {});
/// Emits the operands of the operation. All operands are emitted in order. /// Emits the operands of the operation. All operands are emitted in order.
LogicalResult emitOperands(Operation &op); LogicalResult emitOperands(Operation &op);
/// Return the existing or a new name for a Value. /// Return the existing or a new name for a Value.
▲ Show 20 Lines • Show All 925 Lines • Show Last 20 Lines

mlir/lib/Target/LLVMIR/Dialect/OpenACC/OpenACCToLLVMIRTranslation.cpp

Show First 20 Lines • Show All 314 Lines • ▼ Show 20 Lines if (failed(processOperands(builder, moduleTranslation, op, op.copyOperands(),
names, index, mapperAllocas))) names, index, mapperAllocas)))
return failure(); return failure();
if (failed(processOperands( if (failed(processOperands(
builder, moduleTranslation, op, op.copyinOperands(), totalNbOperand, builder, moduleTranslation, op, op.copyinOperands(), totalNbOperand,
kDeviceCopyinFlag | kHoldFlag, flags, names, index, mapperAllocas))) kDeviceCopyinFlag | kHoldFlag, flags, names, index, mapperAllocas)))
return failure(); return failure();
// TODO copyin readonly currenlty handled as copyin. Update when extension // TODO copyin readonly currently handled as copyin. Update when extension
// available. // available.
if (failed(processOperands(builder, moduleTranslation, op, if (failed(processOperands(builder, moduleTranslation, op,
op.copyinReadonlyOperands(), totalNbOperand, op.copyinReadonlyOperands(), totalNbOperand,
kDeviceCopyinFlag | kHoldFlag, flags, names, index, kDeviceCopyinFlag | kHoldFlag, flags, names, index,
mapperAllocas))) mapperAllocas)))
return failure(); return failure();
if (failed(processOperands( if (failed(processOperands(
builder, moduleTranslation, op, op.copyoutOperands(), totalNbOperand, builder, moduleTranslation, op, op.copyoutOperands(), totalNbOperand,
kHostCopyoutFlag | kHoldFlag, flags, names, index, mapperAllocas))) kHostCopyoutFlag | kHoldFlag, flags, names, index, mapperAllocas)))
return failure(); return failure();
// TODO copyout zero currenlty handled as copyout. Update when extension // TODO copyout zero currently handled as copyout. Update when extension
// available. // available.
if (failed(processOperands(builder, moduleTranslation, op, if (failed(processOperands(builder, moduleTranslation, op,
op.copyoutZeroOperands(), totalNbOperand, op.copyoutZeroOperands(), totalNbOperand,
kHostCopyoutFlag | kHoldFlag, flags, names, index, kHostCopyoutFlag | kHoldFlag, flags, names, index,
mapperAllocas))) mapperAllocas)))
return failure(); return failure();
if (failed(processOperands( if (failed(processOperands(
builder, moduleTranslation, op, op.createOperands(), totalNbOperand, builder, moduleTranslation, op, op.createOperands(), totalNbOperand,
kCreateFlag | kHoldFlag, flags, names, index, mapperAllocas))) kCreateFlag | kHoldFlag, flags, names, index, mapperAllocas)))
return failure(); return failure();
// TODO create zero currenlty handled as create. Update when extension // TODO create zero currently handled as create. Update when extension
// available. // available.
if (failed(processOperands(builder, moduleTranslation, op, if (failed(processOperands(builder, moduleTranslation, op,
op.createZeroOperands(), totalNbOperand, op.createZeroOperands(), totalNbOperand,
kCreateFlag | kHoldFlag, flags, names, index, kCreateFlag | kHoldFlag, flags, names, index,
mapperAllocas))) mapperAllocas)))
return failure(); return failure();
if (failed(processOperands( if (failed(processOperands(
▲ Show 20 Lines • Show All 186 Lines • Show Last 20 Lines

mlir/lib/Transforms/Utils/RegionUtils.cpp

Show First 20 Lines • Show All 540 Lines • ▼ Show 20 Lines for (int operand : llvm::seq<int>(0, lhsIt->getNumOperands())) {
// Otherwise, these operands must have the same logical order within the // Otherwise, these operands must have the same logical order within the
// parent block. // parent block.
if (leaderData.getOrderOf(lhsOperand) != blockData.getOrderOf(rhsOperand)) if (leaderData.getOrderOf(lhsOperand) != blockData.getOrderOf(rhsOperand))
return failure(); return failure();
} }
// If the lhs or rhs has external uses, the blocks cannot be merged as the // If the lhs or rhs has external uses, the blocks cannot be merged as the
// merged version of this operation will not be either the lhs or rhs // merged version of this operation will not be either the lhs or rhs
// alone (thus semantically incorrect), but some mix dependending on which // alone (thus semantically incorrect), but some mix depending on which
// block preceeded this. // block preceeded this.
// TODO allow merging of operations when one block does not dominate the // TODO allow merging of operations when one block does not dominate the
// other // other
if (rhsIt->isUsedOutsideOfBlock(mergeBlock) || if (rhsIt->isUsedOutsideOfBlock(mergeBlock) ||
lhsIt->isUsedOutsideOfBlock(leaderBlock)) { lhsIt->isUsedOutsideOfBlock(leaderBlock)) {
return failure(); return failure();
} }
} }
▲ Show 20 Lines • Show All 181 Lines • Show Last 20 Lines

mlir/python/mlir/dialects/linalg/opdsl/lang/affine.py

Show First 20 Lines • Show All 95 Lines • ▼ Show 20 Linesclass AffineBuildState:
def get_dim(self, dimname: str) -> int: def get_dim(self, dimname: str) -> int:
"""Gets the dim position given a name.""" """Gets the dim position given a name."""
pos = self.all_dims.get(dimname) pos = self.all_dims.get(dimname)
if pos is None: if pos is None:
if not self.allow_new_dims: if not self.allow_new_dims:
raise ValueError( raise ValueError(
f"New dimensions not allowed in the current affine expression: " f"New dimensions not allowed in the current affine expression: "
f"Requested '{dimname}', Availble: {self.all_dims}") f"Requested '{dimname}', Available: {self.all_dims}")
pos = len(self.all_dims) pos = len(self.all_dims)
self.all_dims[dimname] = pos self.all_dims[dimname] = pos
self.local_dims[dimname] = pos self.local_dims[dimname] = pos
return pos return pos
def get_symbol(self, symname: str) -> int: def get_symbol(self, symname: str) -> int:
"""Geta a symbol position given a name.""" """Geta a symbol position given a name."""
pos = self.all_symbols.get(symname) pos = self.all_symbols.get(symname)
if pos is None: if pos is None:
if not self.allow_new_symbols: if not self.allow_new_symbols:
raise ValueError( raise ValueError(
f"New symbols not allowed in the current affine expression: " f"New symbols not allowed in the current affine expression: "
f"Requested '{symname}', Availble: {self.all_symbols}") f"Requested '{symname}', Available: {self.all_symbols}")
pos = len(self.all_symbols) pos = len(self.all_symbols)
self.all_symbols[symname] = pos self.all_symbols[symname] = pos
self.local_symbols[symname] = pos self.local_symbols[symname] = pos
return pos return pos
@property @property
def local_dim_count(self) -> int: def local_dim_count(self) -> int:
return len(self.local_dims) return len(self.local_dims)
▲ Show 20 Lines • Show All 182 Lines • Show Last 20 Lines

mlir/test/Conversion/NVGPUToNVVM/nvgpu-to-nvvm.mlir

Show All 18 Linesfunc.func @m16n8k16_fp16(%arg0: vector<4x2xf16>, %arg1: vector<2x2xf16>, %arg2: vector<2x2xf16>) -> vector<2x2xf16> {
// CHECK: llvm.mlir.undef : !llvm.array<2 x vector<2xf16>> // CHECK: llvm.mlir.undef : !llvm.array<2 x vector<2xf16>>
// CHECK-DAG: llvm.insertvalue {{%.+}}, {{%.+}}[0] : !llvm.array<2 x vector<2xf16>> // CHECK-DAG: llvm.insertvalue {{%.+}}, {{%.+}}[0] : !llvm.array<2 x vector<2xf16>>
// CHECK-DAG: llvm.insertvalue {{%.+}}, {{%.+}}[1] : !llvm.array<2 x vector<2xf16>> // CHECK-DAG: llvm.insertvalue {{%.+}}, {{%.+}}[1] : !llvm.array<2 x vector<2xf16>>
return %d : vector<2x2xf16> return %d : vector<2x2xf16>
} }
// ----- // -----
// Same as above but with fp32 acumulation type. // Same as above but with fp32 accumulation type.
// CHECK-LABEL: @m16n8k16_fp16_fp32 // CHECK-LABEL: @m16n8k16_fp16_fp32
func.func @m16n8k16_fp16_fp32(%arg0: vector<4x2xf16>, %arg1: vector<2x2xf16>, %arg2: vector<2x2xf32>) -> vector<2x2xf32> { func.func @m16n8k16_fp16_fp32(%arg0: vector<4x2xf16>, %arg1: vector<2x2xf16>, %arg2: vector<2x2xf32>) -> vector<2x2xf32> {
// We just need to check the mma instruction and the manipulatin of the result. // We just need to check the mma instruction and the manipulatin of the result.
// CHECK: [[d:%.+]] = nvvm.mma.sync // CHECK: [[d:%.+]] = nvvm.mma.sync
// CHECK-SAME: shape = #nvvm.shape<m = 16, n = 8, k = 16> // CHECK-SAME: shape = #nvvm.shape<m = 16, n = 8, k = 16>
// CHECK-SAME: (vector<2xf16>, vector<2xf16>, f32) -> !llvm.struct<(f32, f32, f32, f32)> // CHECK-SAME: (vector<2xf16>, vector<2xf16>, f32) -> !llvm.struct<(f32, f32, f32, f32)>
%d = nvgpu.mma.sync (%arg0, %arg1, %arg2) {mmaShape = [16, 8, 16]} : (vector<4x2xf16>, vector<2x2xf16>, vector<2x2xf32>) -> vector<2x2xf32> %d = nvgpu.mma.sync (%arg0, %arg1, %arg2) {mmaShape = [16, 8, 16]} : (vector<4x2xf16>, vector<2x2xf16>, vector<2x2xf32>) -> vector<2x2xf32>
▲ Show 20 Lines • Show All 264 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/SparseTensor/taco/tools/mlir_pytaco.py

Show First 20 Lines • Show All 941 Lines • ▼ Show 20 Linesclass _Stats:
def get_formats(self, idx: int) -> Tuple[ModeFormat]: def get_formats(self, idx: int) -> Tuple[ModeFormat]:
"""Gets the ModeFormats for the ith temporary tensor.""" """Gets the ModeFormats for the ith temporary tensor."""
return tuple(self._get_element(idx).dst_format.format_pack.formats) return tuple(self._get_element(idx).dst_format.format_pack.formats)
class _SparseValueInfo(enum.Enum): class _SparseValueInfo(enum.Enum):
"""Describes how a sparse tensor value is stored. """Describes how a sparse tensor value is stored.
_UNPACKED: The sparse tensor value is stored as (coordnates, values) in _UNPACKED: The sparse tensor value is stored as (coordinates, values) in
Python. Python.
_PACKED: The sparse tensor value is stored as a C pointer to a packed MLIR _PACKED: The sparse tensor value is stored as a C pointer to a packed MLIR
sparse tensor. sparse tensor.
""" """
_UNPACKED = 0 _UNPACKED = 0
_PACKED = 1 _PACKED = 1
▲ Show 20 Lines • Show All 201 Lines • ▼ Show 20 Linesclass Tensor:
def is_dense(self) -> bool: def is_dense(self) -> bool:
"""Returns true if the tensor doesn't have sparsity annotation.""" """Returns true if the tensor doesn't have sparsity annotation."""
return self.order == 0 or self._format is None return self.order == 0 or self._format is None
def to_array(self) -> np.ndarray: def to_array(self) -> np.ndarray:
"""Returns the numpy array for the Tensor. """Returns the numpy array for the Tensor.
This is currenly only implemented for dense Tensor. This is currently only implemented for dense Tensor.
""" """
if not self.is_dense(): if not self.is_dense():
raise ValueError("Conversion from non-dense Tensor " raise ValueError("Conversion from non-dense Tensor "
"to numpy array not supported yet.") "to numpy array not supported yet.")
self._sync_value() self._sync_value()
return self._dense_storage return self._dense_storage
▲ Show 20 Lines • Show All 1,019 Lines • Show Last 20 Lines

mlir/tools/mlir-linalg-ods-gen/mlir-linalg-ods-yaml-gen.cpp

Show First 20 Lines • Show All 496 Lines • ▼ Show 20 Lines
// Template for Linalg named ops' ODS definitions. Parameters: // Template for Linalg named ops' ODS definitions. Parameters:
// {0}: ODS/C++ op name // {0}: ODS/C++ op name
// {1}: assembly op mnemonic // {1}: assembly op mnemonic
// {2}: op interface list // {2}: op interface list
// {3}: documentation (summary + description) // {3}: documentation (summary + description)
// {4}: op attribute list // {4}: op attribute list
// {5}: builder methods taking standalone attribute parameters // {5}: builder methods taking standalone attribute parameters
// {6}: additional method defintions // {6}: additional method definitions
// {7}: additional methods for attributes used by indexing maps // {7}: additional methods for attributes used by indexing maps
static const char structuredOpOdsHeaderFormat[] = R"FMT( static const char structuredOpOdsHeaderFormat[] = R"FMT(
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Op definition for {0} // Op definition for {0}
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
def {0} : LinalgStructuredBase_Op<"{1}", !listconcat([AttrSizedOperandSegments], def {0} : LinalgStructuredBase_Op<"{1}", !listconcat([AttrSizedOperandSegments],
/*extraInterfaces=*/[{2}])> { /*extraInterfaces=*/[{2}])> {
▲ Show 20 Lines • Show All 748 Lines • Show Last 20 Lines

mlir/tools/mlir-tblgen/AttrOrTypeFormatGen.cpp

Show First 20 Lines • Show All 396 Lines • ▼ Show 20 Lines if (hasOptional) {
os << "do {\n"; os << "do {\n";
os.indent(); os.indent();
} }
ArrayRef<ParameterElement *> params = el->getParams(); ArrayRef<ParameterElement *> params = el->getParams();
using IteratorT = ParameterElement *const *; using IteratorT = ParameterElement *const *;
IteratorT it = params.begin(); IteratorT it = params.begin();
// Find the last required parameter. Commas become optional aftewards. // Find the last required parameter. Commas become optional afterwards.
// Note: IteratorT's copy assignment is deleted. // Note: IteratorT's copy assignment is deleted.
ParameterElement *lastReq = nullptr; ParameterElement *lastReq = nullptr;
for (ParameterElement *param : params) for (ParameterElement *param : params)
if (!param->isOptional()) if (!param->isOptional())
lastReq = param; lastReq = param;
IteratorT lastReqIt = lastReq ? llvm::find(params, lastReq) : params.begin(); IteratorT lastReqIt = lastReq ? llvm::find(params, lastReq) : params.begin();
auto eachFn = [&](ParameterElement *el) { genVariableParser(el, ctx, os); }; auto eachFn = [&](ParameterElement *el) { genVariableParser(el, ctx, os); };
▲ Show 20 Lines • Show All 751 Lines • Show Last 20 Lines

mlir/tools/mlir-tblgen/OpFormatGen.cpp

Show First 20 Lines • Show All 166 Lines • ▼ Show 20 Linesprivate:
/// The argument that is used to format the directive. /// The argument that is used to format the directive.
FormatElement *arg; FormatElement *arg;
bool shouldBeQualifiedFlag = false; bool shouldBeQualifiedFlag = false;
}; };
/// This class represents a group of order-independent optional clauses. Each /// This class represents a group of order-independent optional clauses. Each
/// clause starts with a literal element and has a coressponding parsing /// clause starts with a literal element and has a coressponding parsing
/// element. A parsing element is a continous sequence of format elements. /// element. A parsing element is a continuous sequence of format elements.
/// Each clause can appear 0 or 1 time. /// Each clause can appear 0 or 1 time.
class OIListElement : public DirectiveElementBase<DirectiveElement::OIList> { class OIListElement : public DirectiveElementBase<DirectiveElement::OIList> {
public: public:
OIListElement(std::vector<FormatElement *> &&literalElements, OIListElement(std::vector<FormatElement *> &&literalElements,
std::vector<std::vector<FormatElement *>> &&parsingElements) std::vector<std::vector<FormatElement *>> &&parsingElements)
: literalElements(std::move(literalElements)), : literalElements(std::move(literalElements)),
parsingElements(std::move(parsingElements)) {} parsingElements(std::move(parsingElements)) {}
▲ Show 20 Lines • Show All 3,027 Lines • Show Last 20 Lines

openmp/libomptarget/plugins/amdgpu/src/rtl.cpp

Show First 20 Lines • Show All 776 Lines • ▼ Show 20 Lines auto CbMem = [](hsa_amd_memory_pool_t Region, void *Data) -> hsa_status_t {
"Error returned from hsa_amd_memory_pool_get_info when obtaining " "Error returned from hsa_amd_memory_pool_get_info when obtaining "
"HSA_AMD_MEMORY_POOL_INFO_RUNTIME_ALLOC_ALIGNMENT\n"); "HSA_AMD_MEMORY_POOL_INFO_RUNTIME_ALLOC_ALIGNMENT\n");
printf(" Runtime Alloc alignment: \t %zu bytes\n", Size); printf(" Runtime Alloc alignment: \t %zu bytes\n", Size);
core::checkResult( core::checkResult(
hsa_amd_memory_pool_get_info( hsa_amd_memory_pool_get_info(
Region, HSA_AMD_MEMORY_POOL_INFO_ACCESSIBLE_BY_ALL, &Access), Region, HSA_AMD_MEMORY_POOL_INFO_ACCESSIBLE_BY_ALL, &Access),
"Error returned from hsa_amd_memory_pool_get_info when obtaining " "Error returned from hsa_amd_memory_pool_get_info when obtaining "
"HSA_AMD_MEMORY_POOL_INFO_ACCESSIBLE_BY_ALL\n"); "HSA_AMD_MEMORY_POOL_INFO_ACCESSIBLE_BY_ALL\n");
printf(" Accessable by all: \t\t %s\n", printf(" Accessible by all: \t\t %s\n",
(Access ? "TRUE" : "FALSE")); (Access ? "TRUE" : "FALSE"));
return HSA_STATUS_SUCCESS; return HSA_STATUS_SUCCESS;
}; };
// Iterate over all the memory regions for this agent. Get the memory region // Iterate over all the memory regions for this agent. Get the memory region
// type and size // type and size
hsa_amd_agent_iterate_memory_pools(Agent, CbMem, nullptr); hsa_amd_agent_iterate_memory_pools(Agent, CbMem, nullptr);
▲ Show 20 Lines • Show All 1,964 Lines • Show Last 20 Lines

openmp/runtime/src/i18n/en_US.txt

Show All 12 Lines
# Default messages, embedded into the OpenMP RTL, and source for English catalog. # Default messages, embedded into the OpenMP RTL, and source for English catalog.
# Compatible changes (which does not require version bumping): # Compatible changes (which does not require version bumping):
# * Editing message (number and type of placeholders must remain, relative order of # * Editing message (number and type of placeholders must remain, relative order of
# placeholders may be changed, e.g. "File %1$s line %2$d" may be safely edited to # placeholders may be changed, e.g. "File %1$s line %2$d" may be safely edited to
# "Line %2$d file %1$s"). # "Line %2$d file %1$s").
# * Adding new message to the end of section. # * Adding new message to the end of section.
# Incompatible changes (version must be bumbed by 1): # Incompatible changes (version must be bumped by 1):
# * Introducing new placeholders to existing messages. # * Introducing new placeholders to existing messages.
# * Changing type of placeholders (e.g. "line %1$d" -> "line %1$s"). # * Changing type of placeholders (e.g. "line %1$d" -> "line %1$s").
# * Rearranging order of messages. # * Rearranging order of messages.
# * Deleting messages. # * Deleting messages.
# Use special "OBSOLETE" pseudoidentifier for obsolete entries, which is kept only for backward # Use special "OBSOLETE" pseudoidentifier for obsolete entries, which is kept only for backward
# compatibility. When version is bumped, do not forget to delete all obsolete entries. # compatibility. When version is bumped, do not forget to delete all obsolete entries.
▲ Show 20 Lines • Show All 442 Lines • ▼ Show 20 Lines
AffEqualTopologyTypes "%1$s: topology layer \"%2$s\" is equivalent to \"%3$s\"." AffEqualTopologyTypes "%1$s: topology layer \"%2$s\" is equivalent to \"%3$s\"."
AffGranTooCoarseProcGroup "%1$s: granularity=%2$s is too coarse, setting granularity=group." AffGranTooCoarseProcGroup "%1$s: granularity=%2$s is too coarse, setting granularity=group."
StgDeprecatedValue "%1$s: \"%2$s\" value is deprecated. Please use \"%3$s\" instead." StgDeprecatedValue "%1$s: \"%2$s\" value is deprecated. Please use \"%3$s\" instead."
NumTeamsNotPositive "num_teams value must be positive, it is %1$d, using %2$d instead." NumTeamsNotPositive "num_teams value must be positive, it is %1$d, using %2$d instead."
AffHWSubsetIncompat "KMP_HW_SUBSET ignored: %1$s, %2$s: attributes are ambiguous, please only specify one." AffHWSubsetIncompat "KMP_HW_SUBSET ignored: %1$s, %2$s: attributes are ambiguous, please only specify one."
AffHWSubsetAttrRepeat "KMP_HW_SUBSET ignored: %1$s: attribute specified more than once." AffHWSubsetAttrRepeat "KMP_HW_SUBSET ignored: %1$s: attribute specified more than once."
AffHWSubsetAttrInvalid "KMP_HW_SUBSET ignored: %1$s: attribute value %2$s is invalid." AffHWSubsetAttrInvalid "KMP_HW_SUBSET ignored: %1$s: attribute value %2$s is invalid."
AffHWSubsetAllFiltered "KMP_HW_SUBSET ignored: all hardware resources would be filtered, please reduce the filter." AffHWSubsetAllFiltered "KMP_HW_SUBSET ignored: all hardware resources would be filtered, please reduce the filter."
AffHWSubsetAttrsNonHybrid "KMP_HW_SUBSET ignored: Too many attributes specified. This machine is not a hybrid architecutre." AffHWSubsetAttrsNonHybrid "KMP_HW_SUBSET ignored: Too many attributes specified. This machine is not a hybrid architecture."
AffHWSubsetIgnoringAttr "KMP_HW_SUBSET: ignoring %1$s attribute. This machine is not a hybrid architecutre." AffHWSubsetIgnoringAttr "KMP_HW_SUBSET: ignoring %1$s attribute. This machine is not a hybrid architecture."
# -------------------------------------------------------------------------------------------------- # --------------------------------------------------------------------------------------------------
-*- HINTS -*- -*- HINTS -*-
# -------------------------------------------------------------------------------------------------- # --------------------------------------------------------------------------------------------------
# Hints. Hint may be printed after a message. Usually it is longer explanation text or suggestion. # Hints. Hint may be printed after a message. Usually it is longer explanation text or suggestion.
# To maintain hint numbers (they are visible to customers), add new hints to the end. # To maintain hint numbers (they are visible to customers), add new hints to the end.
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

openmp/runtime/src/kmp_csupport.cpp

Show First 20 Lines • Show All 355 Lines • ▼ Show 20 Lines
@param global_tid global thread number @param global_tid global thread number
@param num_teams_lb lower bound on number of teams requested for the teams @param num_teams_lb lower bound on number of teams requested for the teams
construct construct
@param num_teams_ub upper bound on number of teams requested for the teams @param num_teams_ub upper bound on number of teams requested for the teams
construct construct
@param num_threads number of threads per team requested for the teams construct @param num_threads number of threads per team requested for the teams construct
Set the number of teams to be used by the teams construct. The number of initial Set the number of teams to be used by the teams construct. The number of initial
teams cretaed will be greater than or equal to the lower bound and less than or teams created will be greater than or equal to the lower bound and less than or
equal to the upper bound. equal to the upper bound.
This call is only required if the teams construct has a `num_teams` clause This call is only required if the teams construct has a `num_teams` clause
or a `thread_limit` clause (or both). or a `thread_limit` clause (or both).
*/ */
void __kmpc_push_num_teams_51(ident_t *loc, kmp_int32 global_tid, void __kmpc_push_num_teams_51(ident_t *loc, kmp_int32 global_tid,
kmp_int32 num_teams_lb, kmp_int32 num_teams_ub, kmp_int32 num_teams_lb, kmp_int32 num_teams_ub,
kmp_int32 num_threads) { kmp_int32 num_threads) {
KA_TRACE(20, ("__kmpc_push_num_teams_51: enter T#%d num_teams_lb=%d" KA_TRACE(20, ("__kmpc_push_num_teams_51: enter T#%d num_teams_lb=%d"
▲ Show 20 Lines • Show All 4,165 Lines • Show Last 20 Lines

openmp/runtime/src/kmp_itt.h

Show First 20 Lines • Show All 321 Lines • ▼ Show 20 Lines
#include "kmp_itt.inl" #include "kmp_itt.inl"
#endif #endif
#endif // KMP_ITT_H #endif // KMP_ITT_H
#else /* USE_ITT_BUILD */ #else /* USE_ITT_BUILD */
// Null definitions of the synchronization tracing functions. // Null definitions of the synchronization tracing functions.
// If USE_ITT_BULID is not enabled, USE_ITT_NOTIFY cannot be either. // If USE_ITT_BUILD is not enabled, USE_ITT_NOTIFY cannot be either.
// By defining these we avoid unpleasant ifdef tests in many places. // By defining these we avoid unpleasant ifdef tests in many places.
#define KMP_FSYNC_PREPARE(obj) ((void)0) #define KMP_FSYNC_PREPARE(obj) ((void)0)
#define KMP_FSYNC_CANCEL(obj) ((void)0) #define KMP_FSYNC_CANCEL(obj) ((void)0)
#define KMP_FSYNC_ACQUIRED(obj) ((void)0) #define KMP_FSYNC_ACQUIRED(obj) ((void)0)
#define KMP_FSYNC_RELEASING(obj) ((void)0) #define KMP_FSYNC_RELEASING(obj) ((void)0)
#define KMP_FSYNC_SPIN_INIT(obj, spin) ((void)0) #define KMP_FSYNC_SPIN_INIT(obj, spin) ((void)0)
#define KMP_FSYNC_SPIN_PREPARE(obj) ((void)0) #define KMP_FSYNC_SPIN_PREPARE(obj) ((void)0)
Show All 10 Lines

openmp/runtime/test/affinity/libomp_test_topology.h

Show First 20 Lines • Show All 526 Lines • ▼ Show 20 Lines if (proc_bind == omp_proc_bind_close) {
proc_bind, T, P, proc_bind, T, P,
"Not enough threads have place %d for their current place\n", "Not enough threads have place %d for their current place\n",
parent->place_nums[j]); parent->place_nums[j]);
} }
j = (j + 1) % parent->num_places; j = (j + 1) % parent->num_places;
if (current_place != parent->place_nums[j]) { if (current_place != parent->place_nums[j]) {
proc_bind_die( proc_bind_die(
proc_bind, T, P, proc_bind, T, P,
"Thread %d's place (%d) is not corret. Expected %d\n", i, "Thread %d's place (%d) is not correct. Expected %d\n", i,
partitions[i]->current_place, parent->place_nums[j]); partitions[i]->current_place, parent->place_nums[j]);
} }
count = 1; count = 1;
} }
} }
} }
} else { } else {
// proc_bind_primary // proc_bind_primary
Show All 33 Lines

openmp/runtime/tools/lib/tools.pm

Show First 20 Lines • Show All 229 Lines • ▼ Show 20 Lines
=head3 get_options =head3 get_options
B<Synopsis:> B<Synopsis:>
get_options( @arguments ) get_options( @arguments )
B<Description:> B<Description:>
It is very simple wrapper arounf Getopt::Long::GetOptions. It passes all arguments to GetOptions, It is very simple wrapper around Getopt::Long::GetOptions. It passes all arguments to GetOptions,
and add definitions for standard help options: --help, --doc, --verbose, and --quiet. and add definitions for standard help options: --help, --doc, --verbose, and --quiet.
When GetOptions finishes, this subroutine checks exit code, if it is non-zero, standard error When GetOptions finishes, this subroutine checks exit code, if it is non-zero, standard error
message is issued and script terminated. message is issued and script terminated.
If --verbose or --quiet option is specified, C<tools.pm_verbose> environment variable is set. If --verbose or --quiet option is specified, C<tools.pm_verbose> environment variable is set.
It is the way to propagate verbose/quiet mode to callee Perl scripts. It is the way to propagate verbose/quiet mode to callee Perl scripts.
=cut =cut
▲ Show 20 Lines • Show All 1,730 Lines • Show Last 20 Lines

polly/docs/HowToManuallyUseTheIndividualPiecesOfPolly.rst

Show All 23 Lines-------------------------------------
clang -S -emit-llvm matmul.c -Xclang -disable-O0-optnone -o matmul.ll clang -S -emit-llvm matmul.c -Xclang -disable-O0-optnone -o matmul.ll
2. **Prepare the LLVM-IR for Polly** 2. **Prepare the LLVM-IR for Polly**
------------------------------------ ------------------------------------
Polly is only able to work with code that matches a canonical form. Polly is only able to work with code that matches a canonical form.
To translate the LLVM-IR into this form we use a set of To translate the LLVM-IR into this form we use a set of
canonicalication passes. They are scheduled by using canonicalization passes. They are scheduled by using
'-polly-canonicalize'. '-polly-canonicalize'.
.. code-block:: console .. code-block:: console
opt -S -polly-canonicalize matmul.ll -o matmul.preopt.ll opt -S -polly-canonicalize matmul.ll -o matmul.preopt.ll
3. **Show the SCoPs detected by Polly (optional)** 3. **Show the SCoPs detected by Polly (optional)**
-------------------------------------------------- --------------------------------------------------
▲ Show 20 Lines • Show All 440 Lines • Show Last 20 Lines

polly/include/polly/Support/VirtualInstruction.h

Show First 20 Lines • Show All 88 Lines • ▼ Show 20 Lines
public: public:
/// Get a VirtualUse for an llvm::Use. /// Get a VirtualUse for an llvm::Use.
/// ///
/// @param S The Scop object. /// @param S The Scop object.
/// @param U The llvm::Use the get information for. /// @param U The llvm::Use the get information for.
/// @param LI The LoopInfo analysis. Needed to determine whether the /// @param LI The LoopInfo analysis. Needed to determine whether the
/// value is synthesizable. /// value is synthesizable.
/// @param Virtual Whether to ignore existing MemoryAcccess. /// @param Virtual Whether to ignore existing MemoryAccess.
/// ///
/// @return The VirtualUse representing the same use as @p U. /// @return The VirtualUse representing the same use as @p U.
static VirtualUse create(Scop *S, const Use &U, LoopInfo *LI, bool Virtual); static VirtualUse create(Scop *S, const Use &U, LoopInfo *LI, bool Virtual);
/// Get a VirtualUse for uses within statements. /// Get a VirtualUse for uses within statements.
/// ///
/// It is assumed that the user is not a PHINode. Such uses are always /// It is assumed that the user is not a PHINode. Such uses are always
/// VirtualUse::Inter unless in a regions statement. /// VirtualUse::Inter unless in a regions statement.
▲ Show 20 Lines • Show All 241 Lines • Show Last 20 Lines

polly/lib/CodeGen/ManagedMemoryRewrite.cpp

Show First 20 Lines • Show All 157 Lines • ▼ Show 20 Linesstatic void rewriteOldValToNew(Instruction *Inst, Value *OldVal, Value *NewVal,
for (Instruction *I : InstsToVisit) for (Instruction *I : InstsToVisit)
I->replaceUsesOfWith(OldVal, NewVal); I->replaceUsesOfWith(OldVal, NewVal);
} }
// Given a value `Current`, return all Instructions that may contain `Current` // Given a value `Current`, return all Instructions that may contain `Current`
// in an expression. // in an expression.
// We need this auxiliary function, because if we have a // We need this auxiliary function, because if we have a
// `Constant` that is a user of `V`, we need to recurse into the // `Constant` that is a user of `V`, we need to recurse into the
// `Constant`s uses to gather the root instruciton. // `Constant`s uses to gather the root instruction.
static void getInstructionUsersOfValue(Value *V, static void getInstructionUsersOfValue(Value *V,
SmallVector<Instruction *, 4> &Owners) { SmallVector<Instruction *, 4> &Owners) {
if (auto *I = dyn_cast<Instruction>(V)) { if (auto *I = dyn_cast<Instruction>(V)) {
Owners.push_back(I); Owners.push_back(I);
} else { } else {
// Anything that is a `User` must be a constant or an instruction. // Anything that is a `User` must be a constant or an instruction.
auto *C = cast<Constant>(V); auto *C = cast<Constant>(V);
for (Use &CUse : C->uses()) for (Use &CUse : C->uses())
▲ Show 20 Lines • Show All 253 Lines • Show Last 20 Lines

polly/lib/Transform/ManualOptimizer.cpp

Show First 20 Lines • Show All 183 Lines • ▼ Show 20 Lines if (ORE) {
TransformLoc, CodeRegion) TransformLoc, CodeRegion)
<< (Twine("not applying ") + TransformationName + << (Twine("not applying ") + TransformationName +
": cannot ensure semantic equivalence due to possible " ": cannot ensure semantic equivalence due to possible "
"dependency violations") "dependency violations")
.str()); .str());
} }
// If illegal, revert and remove the transformation to not risk re-trying // If illegal, revert and remove the transformation to not risk re-trying
// indefintely. // indefinitely.
MDNode *NewLoopMD = MDNode *NewLoopMD =
makePostTransformationMetadata(Ctx, LoopMD, {TransPrefix}, {}); makePostTransformationMetadata(Ctx, LoopMD, {TransPrefix}, {});
BandAttr *Attr = getBandAttr(OrigBand); BandAttr *Attr = getBandAttr(OrigBand);
Attr->Metadata = NewLoopMD; Attr->Metadata = NewLoopMD;
// Roll back old schedule. // Roll back old schedule.
return OrigBand.get_schedule(); return OrigBand.get_schedule();
} }
▲ Show 20 Lines • Show All 104 Lines • Show Last 20 Lines

polly/lib/Transform/ScheduleTreeTransform.cpp

Show First 20 Lines • Show All 567 Lines • ▼ Show 20 Lines
public: public:
isl::schedule visitBand(isl::schedule_node_band RootBand) { isl::schedule visitBand(isl::schedule_node_band RootBand) {
isl::schedule_node_band Band = RootBand; isl::schedule_node_band Band = RootBand;
isl::ctx Ctx = Band.ctx(); isl::ctx Ctx = Band.ctx();
// Do not merge permutable band to avoid loosing the permutability property. // Do not merge permutable band to avoid loosing the permutability property.
// Cannot collapse even two permutable loops, they might be permutable // Cannot collapse even two permutable loops, they might be permutable
// individually, but not necassarily accross. // individually, but not necassarily across.
if (unsignedFromIslSize(Band.n_member()) > 1u && Band.permutable()) if (unsignedFromIslSize(Band.n_member()) > 1u && Band.permutable())
return getBase().visitBand(Band); return getBase().visitBand(Band);
// Find collapsable bands. // Find collapsable bands.
SmallVector<isl::schedule_node_band> Nest; SmallVector<isl::schedule_node_band> Nest;
int NumTotalLoops = 0; int NumTotalLoops = 0;
isl::schedule_node Body; isl::schedule_node Body;
while (true) { while (true) {
▲ Show 20 Lines • Show All 659 Lines • Show Last 20 Lines

polly/test/CodeGen/non-affine-update.ll

; RUN: opt %loadPolly -polly-import-jscop \ ; RUN: opt %loadPolly -polly-import-jscop \
; RUN: -polly-codegen -S < %s | FileCheck %s ; RUN: -polly-codegen -S < %s | FileCheck %s
; ;
; void non-affine-update(double A[], double C[], double B[]) { ; void non-affine-update(double A[], double C[], double B[]) {
; for (int i = 0; i < 10; i++) { ; for (int i = 0; i < 10; i++) {
; if (A[i] >= 6) ; if (A[i] >= 6)
; B[i] += 42; ; B[i] += 42;
; else ; else
; C[i] += 3; ; C[i] += 3;
; } ; }
; } ; }
; Verify that all changed memory access functions are corectly code generated. ; Verify that all changed memory access functions are correctly code generated.
; At some point this did not work due to memory access identifiers not being ; At some point this did not work due to memory access identifiers not being
; unique within non-affine scop statements. ; unique within non-affine scop statements.
; CHECK: polly.stmt.bb2: ; CHECK: polly.stmt.bb2:
; CHECK: %scevgep = getelementptr double, double* %A, i64 %polly.indvar ; CHECK: %scevgep = getelementptr double, double* %A, i64 %polly.indvar
; CHECK: polly.stmt.bb9: ; CHECK: polly.stmt.bb9:
; CHECK: %polly.access.C{{.*}} = getelementptr double, double* %C, i64 42 ; CHECK: %polly.access.C{{.*}} = getelementptr double, double* %C, i64 42
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

polly/test/ForwardOpTree/changed-kind.ll

; RUN: opt %loadPolly -polly-print-optree -disable-output < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-print-optree -disable-output < %s | FileCheck %s -match-full-lines
; In the code below, %0 is known to be equal to the content of @c (constant 0). ; In the code below, %0 is known to be equal to the content of @c (constant 0).
; Thus, in order to save a scalar dependency, forward-optree replaces ; Thus, in order to save a scalar dependency, forward-optree replaces
; the use of %0 in Stmt_lor_end93 by a load from @c by changing the ; the use of %0 in Stmt_lor_end93 by a load from @c by changing the
; access find from a scalar access to a array accesses. ; access find from a scalar access to a array accesses.
; llvm.org/PR48034 decribes a crash caused by the mid-processing change. ; llvm.org/PR48034 describes a crash caused by the mid-processing change.
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@c = external dso_local global i64, align 8 @c = external dso_local global i64, align 8
define void @func() { define void @func() {
entry: entry:
Show All 32 Lines

polly/test/ScopDetect/non-affine-loop.ll

; RUN: opt %loadPolly -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=false -polly-print-detect -disable-output < %s | FileCheck %s --check-prefix=REJECTNONAFFINELOOPS ; RUN: opt %loadPolly -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=false -polly-print-detect -disable-output < %s | FileCheck %s --check-prefix=REJECTNONAFFINELOOPS
; RUN: opt %loadPolly -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true -polly-print-detect -disable-output < %s | FileCheck %s --check-prefix=ALLOWNONAFFINELOOPS ; RUN: opt %loadPolly -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true -polly-print-detect -disable-output < %s | FileCheck %s --check-prefix=ALLOWNONAFFINELOOPS
; RUN: opt %loadPolly -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=false -polly-allow-nonaffine -polly-print-detect -disable-output < %s | FileCheck %s --check-prefix=ALLOWNONAFFINEREGIONSANDACCESSES ; RUN: opt %loadPolly -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=false -polly-allow-nonaffine -polly-print-detect -disable-output < %s | FileCheck %s --check-prefix=ALLOWNONAFFINEREGIONSANDACCESSES
; RUN: opt %loadPolly -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true -polly-allow-nonaffine -polly-print-detect -disable-output < %s | FileCheck %s --check-prefix=ALLOWNONAFFINELOOPSANDACCESSES ; RUN: opt %loadPolly -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true -polly-allow-nonaffine -polly-print-detect -disable-output < %s | FileCheck %s --check-prefix=ALLOWNONAFFINELOOPSANDACCESSES
; RUN: opt %loadPolly -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true -polly-allow-nonaffine -polly-process-unprofitable=false -polly-print-detect -disable-output < %s | FileCheck %s --check-prefix=PROFIT ; RUN: opt %loadPolly -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true -polly-allow-nonaffine -polly-process-unprofitable=false -polly-print-detect -disable-output < %s | FileCheck %s --check-prefix=PROFIT
; ;
; This function/region does contain a loop, however it is non-affine, hence the access ; This function/region does contain a loop, however it is non-affine, hence the access
; A[i] is also. Furthermore, it is the only loop, thus when we over approximate ; A[i] is also. Furthermore, it is the only loop, thus when we over approximate
; non-affine loops __and__ accesses __and__ allow regins without a (affine) loop we will ; non-affine loops __and__ accesses __and__ allow regions without a (affine) loop we will
; detect it, otherwise we won't. ; detect it, otherwise we won't.
; ;
; void f(int *A) { ; void f(int *A) {
; for (int i = 0; i < A[i]; i++) ; for (int i = 0; i < A[i]; i++)
; A[-1]++; ; A[-1]++;
; } ; }
; ;
; REJECTNONAFFINELOOPS-NOT: Valid ; REJECTNONAFFINELOOPS-NOT: Valid
Show All 33 Lines

polly/test/ScopDetectionDiagnostics/ReportVariantBasePtr-01.ll

; RUN: opt %loadPolly -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-print-detect -disable-output < %s 2>&1| FileCheck %s ; RUN: opt %loadPolly -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-print-detect -disable-output < %s 2>&1| FileCheck %s
; struct b { ; struct b {
; double **b; ; double **b;
; }; ; };
; ;
; void a(struct b *A) { ; void a(struct b *A) {
; for (int i=0; i<32; i++) ; for (int i=0; i<32; i++)
; A[i].b[i] = 0; ; A[i].b[i] = 0;
; } ; }
; The loads are currently just adds %7 to the list of required invariant loads ; The loads are currently just adds %7 to the list of required invariant loads
; and only -polly-scops checks whether it is actionally possible the be load ; and only -polly-scops checks whether it is actionally possible the be load
; hoisted. The SCoP is still rejected by -polly-detect because it may alias ; hoisted. The SCoP is still rejected by -polly-detect because it may alias
; with %A and is not considered to be eligble for runtime alias checking. ; with %A and is not considered to be eligible for runtime alias checking.
; CHECK: remark: ReportVariantBasePtr01.c:6:8: The following errors keep this region from being a Scop. ; CHECK: remark: ReportVariantBasePtr01.c:6:8: The following errors keep this region from being a Scop.
; CHECK: remark: ReportVariantBasePtr01.c:7:5: Accesses to the arrays "A", " <unknown> " may access the same memory. ; CHECK: remark: ReportVariantBasePtr01.c:7:5: Accesses to the arrays "A", " <unknown> " may access the same memory.
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
%struct.b = type { double** } %struct.b = type { double** }
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

polly/test/ScopInfo/aliasing_conditional_alias_groups_2.ll

; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; Check that we create two alias groups since the mininmal/maximal accesses ; Check that we create two alias groups since the minimal/maximal accesses
; depend on %b. ; depend on %b.
; ;
; CHECK: Alias Groups (2): ; CHECK: Alias Groups (2):
; ;
; void jd(int b, int *A, int *B) { ; void jd(int b, int *A, int *B) {
; for (int i = 0; i < 1024; i++) { ; for (int i = 0; i < 1024; i++) {
; if (b) ; if (b)
; A[i] = B[5]; ; A[i] = B[5];
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

polly/test/ScopInfo/aliasing_many_parameters_not_all_involved.ll

; RUN: opt %loadPolly -polly-analysis-computeout=0 -polly-print-scops -polly-rtc-max-parameters=8 -disable-output < %s | FileCheck %s --check-prefix=MAX8 ; RUN: opt %loadPolly -polly-analysis-computeout=0 -polly-print-scops -polly-rtc-max-parameters=8 -disable-output < %s | FileCheck %s --check-prefix=MAX8
; RUN: opt %loadPolly -polly-analysis-computeout=0 -polly-print-scops -polly-rtc-max-parameters=7 -disable-output < %s | FileCheck %s --check-prefix=MAX7 ; RUN: opt %loadPolly -polly-analysis-computeout=0 -polly-print-scops -polly-rtc-max-parameters=7 -disable-output < %s | FileCheck %s --check-prefix=MAX7
; ;
; Check that we allow this SCoP even though it has 10 parameters involved in posisbly aliasing accesses. ; Check that we allow this SCoP even though it has 10 parameters involved in possibly aliasing accesses.
; However, only 7 are involved in accesses through B, 8 through C and none in accesses through A. ; However, only 7 are involved in accesses through B, 8 through C and none in accesses through A.
; ;
; MAX8-LABEL: Function: jd ; MAX8-LABEL: Function: jd
; MAX8-NEXT: Region: %for.cond---%for.end ; MAX8-NEXT: Region: %for.cond---%for.end
; MAX7: Invalid Scop! ; MAX7: Invalid Scop!
; ;
; void jd(int *A, int *B, int *C, long p1, long p2, long p3, long p4, long p5, ; void jd(int *A, int *B, int *C, long p1, long p2, long p3, long p4, long p5,
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

polly/test/ScopInfo/extract_constant_factor_introduces_new_parameter.ll

; RUN: opt %loadPolly -polly-print-detect -disable-output < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-detect -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-scops -disable-output < %s ; RUN: opt %loadPolly -polly-scops -disable-output < %s
; CHECK: Valid Region for Scop: bb10 => bb16 ; CHECK: Valid Region for Scop: bb10 => bb16
; Verify that -polly-scops does not crash. At some point this piece of ; Verify that -polly-scops does not crash. At some point this piece of
; code crashed as we extracted from the SCEV expression: ; code crashed as we extracted from the SCEV expression:
; ;
; ((8 * ((%a * %b) + %c)) + (-8 * %a))' ; ((8 * ((%a * %b) + %c)) + (-8 * %a))'
; ;
; the constant 8, which resulted in the new expression: ; the constant 8, which resulted in the new expression:
; ;
; (((-1 + %b) * %a) + %c) ; (((-1 + %b) * %a) + %c)
; ;
; which introduced a new parameter (-1 + %b) * %a which was not registered ; which introduced a new parameter (-1 + %b) * %a which was not registered
; correctly and consequently caused a crash due to an expression not being ; correctly and consequently caused a crash due to an expression not being
; regiustered as a parameter. ; registered as a parameter.
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
define void @barney(i32* %arg, i32* %arg1, double* %arg2, i32* %arg3, i32 %a, i32 %b, i32 %c) { define void @barney(i32* %arg, i32* %arg1, double* %arg2, i32* %arg3, i32 %a, i32 %b, i32 %c) {
bb: bb:
br label %bb10 br label %bb10
bb10: ; preds = %bb bb10: ; preds = %bb
Show All 16 Lines

polly/test/ScopInfo/invalid_add_rec_after_invariant_load_remapping.ll

; RUN: opt %loadPolly -polly-print-scops -disable-output < %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s
; ;
; This crased at some point as we place %1 and %4 in the same equivalence class ; This crashed at some point as we place %1 and %4 in the same equivalence class
; for invariant loads and when we remap SCEVs to use %4 instead of %1 AddRec SCEVs ; for invariant loads and when we remap SCEVs to use %4 instead of %1 AddRec SCEVs
; for the for.body.10 loop caused a crash as their operands were not invariant ; for the for.body.10 loop caused a crash as their operands were not invariant
; in the loop. While we know they are, ScalarEvolution does not. However, we can simply ; in the loop. While we know they are, ScalarEvolution does not. However, we can simply
; rewrite the AddRecs to hoist everything from the "start" out of the AddRec. ; rewrite the AddRecs to hoist everything from the "start" out of the AddRec.
; ;
; Check we do not crash. ; Check we do not crash.
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

polly/test/ScopInfo/invariant_load_canonicalize_array_baseptrs_3.ll

; RUN: opt %loadPolly -polly-print-scops -disable-output < %s \ ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s \
; RUN: -polly-invariant-load-hoisting \ ; RUN: -polly-invariant-load-hoisting \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
; Verify that we canonicalize accesses even tough one of the accesses (even ; Verify that we canonicalize accesses even tough one of the accesses (even
; the canonical base) has a partial execution context. This is correct as ; the canonical base) has a partial execution context. This is correct as
; the combined execution context still coveres both accesses. ; the combined execution context still covers both accesses.
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: { Stmt_body2[i0] -> MemRef_A[0] }; ; CHECK-NEXT: { Stmt_body2[i0] -> MemRef_A[0] };
; CHECK-NEXT: Execution Context: { : } ; CHECK-NEXT: Execution Context: { : }
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK: Stmt_body1 ; CHECK: Stmt_body1
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

polly/test/ScopInfo/invariant_load_canonicalize_array_baseptrs_4.ll

; RUN: opt %loadPolly -polly-print-scops -disable-output < %s \ ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s \
; RUN: -polly-invariant-load-hoisting \ ; RUN: -polly-invariant-load-hoisting \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
; Verify that a delinearized and a not delinearized access are not ; Verify that a delinearized and a not delinearized access are not
; canonizalized. ; canonicalized.
; CHECK: Stmt_body1 ; CHECK: Stmt_body1
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [n] -> { Stmt_body1[i0] : 0 <= i0 <= 1022 }; ; CHECK-NEXT: [n] -> { Stmt_body1[i0] : 0 <= i0 <= 1022 };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [n] -> { Stmt_body1[i0] -> [i0, 0] }; ; CHECK-NEXT: [n] -> { Stmt_body1[i0] -> [i0, 0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [n] -> { Stmt_body1[i0] -> MemRef_baseB[0] }; ; CHECK-NEXT: [n] -> { Stmt_body1[i0] -> MemRef_baseB[0] };
Show All 40 Lines

polly/test/ScopInfo/multidim_fold_constant_dim_zero.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-print-scops -debug -disable-output < %s 2>&1 | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-print-scops -debug -disable-output < %s 2>&1 | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
; This test case at some point crashed Polly due to a 'division by zero' ; This test case at some point crashed Polly due to a 'division by zero'
; when trying to fold the constant dimension into outer dimension. ; when trying to fold the constant dimension into outer dimension.
; We verify that this scop is detected without crash. We also test the ; We verify that this scop is detected without crash. We also test the
; output to undertand that the scop has been analyzed, but has also been ; output to understand that the scop has been analyzed, but has also been
; invalidated due to the zero size dimension. ; invalidated due to the zero size dimension.
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK-NEXT: { : false } ; CHECK-NEXT: { : false }
; CHECK-NEXT: Invalid Context: ; CHECK-NEXT: Invalid Context:
; CHECK-NEXT: { : false } ; CHECK-NEXT: { : false }
; CHECK: Arrays { ; CHECK: Arrays {
; CHECK-NEXT: i8 MemRef_arg[*][0]; // Element size 1 ; CHECK-NEXT: i8 MemRef_arg[*][0]; // Element size 1
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

polly/test/ScopInfo/multidim_many_references.ll

Show All 20 Lines
; for(k = 1 ; k < a1->deps-1; k++) ; for(k = 1 ; k < a1->deps-1; k++)
; M(a19,i,j,k) = M(a1,i,j,k) + ... + M(a18,i,j,k); ; M(a19,i,j,k) = M(a1,i,j,k) + ... + M(a18,i,j,k);
; } ; }
; ;
; We applied some loop invariant code motion to ensure the loads from m->data, ; We applied some loop invariant code motion to ensure the loads from m->data,
; m->rows, m->cols and m->deps happen before the scop. ; m->rows, m->cols and m->deps happen before the scop.
; This test case verifies that the construction of the assumed context finishes ; This test case verifies that the construction of the assumed context finishes
; successfully. Depending on how constraineds are accummulated in the assumed ; successfully. Depending on how constrained are accumulated in the assumed
; context, this test case can take even for a smaller number of arrays over a ; context, this test case can take even for a smaller number of arrays over a
; minute to complete. With the unrolling choosen in this test, an inefficient ; minute to complete. With the unrolling choosen in this test, an inefficient
; formulation of the assumption tracking cause LLVM to crash due to excessive ; formulation of the assumption tracking cause LLVM to crash due to excessive
; memory usage due to an overly large number of disjuncts being formed. ; memory usage due to an overly large number of disjuncts being formed.
%struct.Mat = type { float*, i64, i64, i64 } %struct.Mat = type { float*, i64, i64, i64 }
; CHECK: Assumed Context: ; CHECK: Assumed Context:
▲ Show 20 Lines • Show All 483 Lines • Show Last 20 Lines

polly/test/ScopInfo/ranged_parameter.ll

; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; Check that the contstraints on the paramater derived from the ; Check that the constraints on the parameter derived from the
; range metadata (see bottom of the file) are present: ; range metadata (see bottom of the file) are present:
; ;
; CHECK: Context: ; CHECK: Context:
; CHECK: [tmp] -> { : 0 <= tmp <= 255 } ; CHECK: [tmp] -> { : 0 <= tmp <= 255 }
; ;
; void jd(int *A, int *p /* in [0,256) */) { ; void jd(int *A, int *p /* in [0,256) */) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; A[i + *p] = i; ; A[i + *p] = i;
Show All 30 Lines

polly/test/ScopInfo/redundant_parameter_constraint.ll

; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; The constraint that r2 has to be bigger than r1 is implicitly containted in ; The constraint that r2 has to be bigger than r1 is implicitly contained in
; the domain, hence we do not want to see it explicitly. ; the domain, hence we do not want to see it explicitly.
; ;
; CHECK-NOT: r2 >= 1 + r1 ; CHECK-NOT: r2 >= 1 + r1
; ;
; void wraps(int *A, int p, short q, char r1, char r2) { ; void wraps(int *A, int p, short q, char r1, char r2) {
; for (char i = r1; i < r2; i++) ; for (char i = r1; i < r2; i++)
; A[p + q] = A[(int)r1 + (int)r2]; ; A[p + q] = A[(int)r1 + (int)r2];
; } ; }
Show All 32 Lines

polly/test/ScopInfo/scalar_to_array.ll

; RUN: opt %loadPolly -basic-aa -polly-print-scops -disable-output < %s | FileCheck %s ; RUN: opt %loadPolly -basic-aa -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -basic-aa -polly-print-function-scops -disable-output < %s | FileCheck %s ; RUN: opt %loadPolly -basic-aa -polly-print-function-scops -disable-output < %s | FileCheck %s
; ModuleID = 'scalar_to_array.ll' ; ModuleID = 'scalar_to_array.ll'
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
@A = common global [1024 x float] zeroinitializer, align 8 @A = common global [1024 x float] zeroinitializer, align 8
; Terminating loops without side-effects will be optimzied away, hence ; Terminating loops without side-effects will be optimized away, hence
; detecting a scop would be pointless. ; detecting a scop would be pointless.
; CHECK-NOT: Function: empty ; CHECK-NOT: Function: empty
; Function Attrs: nounwind ; Function Attrs: nounwind
define i32 @empty() #0 { define i32 @empty() #0 {
entry: entry:
fence seq_cst fence seq_cst
br label %for.cond br label %for.cond
▲ Show 20 Lines • Show All 178 Lines • Show Last 20 Lines

polly/test/Simplify/out-of-scop-use-in-region-entry-phi-node.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-print-scops -polly-print-simplify -disable-output < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-print-scops -polly-print-simplify -disable-output < %s | FileCheck %s
; ;
; %tmp5 must keep the Value WRITE MemoryAccess, because as an incoming value of ; %tmp5 must keep the Value WRITE MemoryAccess, because as an incoming value of
; %tmp4, it is an "external use". ; %tmp4, it is an "external use".
; ;
; A common mistake is to assume that %tmp5 is used by %tmp4 in bb3, when ; A common mistake is to assume that %tmp5 is used by %tmp4 in bb3, when
; practially it's the incoming block %bb9 which is the user. ; practically it's the incoming block %bb9 which is the user.
; ;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @hoge() { define void @hoge() {
bb: bb:
br label %bb2 br label %bb2
bb2: ; preds = %bb bb2: ; preds = %bb
Show All 29 Lines

polly/tools/GPURuntime/GPUJIT.h

Show All 10 Lines
/* */ /* */
/******************************************************************************/ /******************************************************************************/
#ifndef GPUJIT_H_ #ifndef GPUJIT_H_
#define GPUJIT_H_ #define GPUJIT_H_
#include "stddef.h" #include "stddef.h"
/* /*
* The following demostrates how we can use the GPURuntime library to * The following demonstrates how we can use the GPURuntime library to
* execute a GPU kernel. * execute a GPU kernel.
* *
* char KernelString[] = "\n\ * char KernelString[] = "\n\
* .version 1.4\n\ * .version 1.4\n\
* .target sm_10, map_f64_to_f32\n\ * .target sm_10, map_f64_to_f32\n\
* .entry _Z8myKernelPi (\n\ * .entry _Z8myKernelPi (\n\
* .param .u64 __cudaparm__Z8myKernelPi_data)\n\ * .param .u64 __cudaparm__Z8myKernelPi_data)\n\
* {\n\ * {\n\
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

polly/www/documentation/gpgpucodegen.html

Show First 20 Lines • Show All 189 Lines • ▼ Show 20 Lines
</tr> </tr>
<tr> <tr>
<th align="left">GPU Runtime Library Implementation</th> <th align="left">GPU Runtime Library Implementation</th>
<td align="center" class='inprogress'>Coding Finished, In Reviewing</td> <td align="center" class='inprogress'>Coding Finished, In Reviewing</td>
<td></td> <td></td>
</tr> </tr>
<tr> <tr>
<th align="left">llvm.codegen Intrinsic Implementation</th> <th align="left">llvm.codegen Intrinsic Implementation</th>
<td align="center" class='inprogress'>Codeing Finished, To Be Reviewed</td> <td align="center" class='inprogress'>Coding Finished, To Be Reviewed</td>
<td></td> <td></td>
</tr> </tr>
<tr> <tr>
<th align="left">Code Generation For Host</th> <th align="left">Code Generation For Host</th>
<td align="center" class='inprogress'>50% Done</td> <td align="center" class='inprogress'>50% Done</td>
<td></td> <td></td>
</tr> </tr>
Show All 23 Lines

polly/www/index.html

Show First 20 Lines • Show All 104 Lines • ▼ Show 20 Lines <ul>
<li><b>Isolation for full/partial tile separation:</b> We discuss native <li><b>Isolation for full/partial tile separation:</b> We discuss native
support for handling full/partial tile separation and -- in general -- support for handling full/partial tile separation and -- in general --
native support for isolation of boundary cases to enable smooth code native support for isolation of boundary cases to enable smooth code
generation for core computations. generation for core computations.
<li><b>AST generation with modulo constraints:</b> We discuss how modulo <li><b>AST generation with modulo constraints:</b> We discuss how modulo
mappings are lowered to efficient C/LLVM code. mappings are lowered to efficient C/LLVM code.
<li><b>User-defined constraint sets for run-time checks</b> We discuss how <li><b>User-defined constraint sets for run-time checks</b> We discuss how
arbitrary sets of constraints can be used to automatically create run-time arbitrary sets of constraints can be used to automatically create run-time
checks that ensure a set of constrainst actually hold. This feature is checks that ensure a set of constraints actually hold. This feature is
very useful to verify at run-time various assumptions that have been taken very useful to verify at run-time various assumptions that have been taken
program optimization. program optimization.
</ul> </ul>
<a href="https://www.grosser.es#pub-polyhedral-AST-generation"> <a href="https://www.grosser.es#pub-polyhedral-AST-generation">
<em>Polyhedral AST generation is more than scanning polyhedra</em></a><br /> <em>Polyhedral AST generation is more than scanning polyhedra</em></a><br />
Tobias Grosser, Sven Verdoolaege, Albert Cohen<br /> Tobias Grosser, Sven Verdoolaege, Albert Cohen<br />
ACM Transations on Programming Languages and Systems (TOPLAS), 37(4), ACM Transations on Programming Languages and Systems (TOPLAS), 37(4),
Show All 15 Lines<div id="content">
</tr> </tr>
<tr><td><b>2014</b></td></tr> <tr><td><b>2014</b></td></tr>
<tr><td width="120"><p>August</p></td> <tr><td width="120"><p>August</p></td>
<td> <td>
<h4>Polly drops the support of ScopLib and the external optimizer PoCC</h4> <h4>Polly drops the support of ScopLib and the external optimizer PoCC</h4>
The support for ScopLib as an exchange format has been removed as recent The support for ScopLib as an exchange format has been removed as recent
versions of clan, candl and pluto all support the OpenScop exchange format. versions of clan, candl and pluto all support the OpenScop exchange format.
The support of the external optmizer PoCC has been dropped in favor of the The support of the external optimizer PoCC has been dropped in favor of the
isl optimizer (default) and the still available pluto support. isl optimizer (default) and the still available pluto support.
</td> </td>
</tr> </tr>
<tr><td><b>2014</b></td></tr> <tr><td><b>2014</b></td></tr>
<tr><td width="120"><p>June</p></td> <tr><td width="120"><p>June</p></td>
<td> <td>
<h4>Polly can be built without GPL licensed software</h4> After Sebastian <h4>Polly can be built without GPL licensed software</h4> After Sebastian
Pop's Pop's
and David Peixotto's (both Qualcomm) recent <a and David Peixotto's (both Qualcomm) recent <a
href="https://repo.or.cz/w/isl.git/commit/60703e3ee89b9d5d4d1afb6a3f611292c0884574">commit</a> href="https://repo.or.cz/w/isl.git/commit/60703e3ee89b9d5d4d1afb6a3f611292c0884574">commit</a>
to isl, isl's latest development version can be built with imath instead of to isl, isl's latest development version can be built with imath instead of
GMP. With both CLooG and gmp having become optional, the last obilgatory GMP. With both CLooG and gmp having become optional, the last obligatory
dependency to GPL licensed software has been removed. Now Polly only depends dependency to GPL licensed software has been removed. Now Polly only depends
on isl (and the included imath), which are both MIT licensed. on isl (and the included imath), which are both MIT licensed.
</td> </td>
</tr> </tr>
<tr><td width="120"><p>April</p></td> <tr><td width="120"><p>April</p></td>
<td> <td>
<h4>Polly Phone Call - 23April</h4> <h4>Polly Phone Call - 23April</h4>
We had a polly phone call about delinearizing array accesses (II)<a We had a polly phone call about delinearizing array accesses (II)<a
▲ Show 20 Lines • Show All 206 Lines • ▼ Show 20 Linesresearch tool.<br \>
<tr> <tr>
<td><p> Januar</p></td> <td><p> Januar</p></td>
<td><p> Basic OpenMP support, Alias analysis integration, <td><p> Basic OpenMP support, Alias analysis integration,
Pluto/POCC support </p></td> Pluto/POCC support </p></td>
</tr> </tr>
<tr><td><b><br>2010</b></td></tr> <tr><td><b><br>2010</b></td></tr>
<tr> <tr>
<td><p> Dezember </p></td> <td><p> December </p></td>
<td><p>Basic vectorization support </p></td> <td><p>Basic vectorization support </p></td>
</tr> </tr>
<tr> <tr>
<td><p> November </p></td> <td><p> November </p></td>
<td><p>Talk at the <a <td><p>Talk at the <a
href="https://llvm.org/devmtg/2010-11/">LLVM Developer Meeting</a> </p></td> href="https://llvm.org/devmtg/2010-11/">LLVM Developer Meeting</a> </p></td>
</tr> </tr>
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

polly/www/performance.html

Show All 18 Lines
point values on an Intel Core Xeon X5670 CPU @ 2.93GHz (12 cores, 24 thread) point values on an Intel Core Xeon X5670 CPU @ 2.93GHz (12 cores, 24 thread)
system. We used <a href="https://sourceforge.net/projects/pocc/files/">PoCC</a> and the included <a system. We used <a href="https://sourceforge.net/projects/pocc/files/">PoCC</a> and the included <a
href="http://pluto-compiler.sf.net">Pluto</a> transformations to optimize the href="http://pluto-compiler.sf.net">Pluto</a> transformations to optimize the
code. The source code of Polly and LLVM/clang was checked out on code. The source code of Polly and LLVM/clang was checked out on
25/03/2011.</p> 25/03/2011.</p>
<p>The results shown were created fully automatically without manual <p>The results shown were created fully automatically without manual
interaction. We did not yet spend any time to tune the results. Hence interaction. We did not yet spend any time to tune the results. Hence
further improvments may be achieved by tuning the code generated by Polly, the further improvements may be achieved by tuning the code generated by Polly, the
heuristics used by Pluto or by investigating if more code could be optimized. heuristics used by Pluto or by investigating if more code could be optimized.
As Pluto was never used at such a low level, its heuristics are probably As Pluto was never used at such a low level, its heuristics are probably
far from perfect. Another area where we expect larger performance improvements far from perfect. Another area where we expect larger performance improvements
is the SIMD vector code generation. At the moment, it rarely yields to is the SIMD vector code generation. At the moment, it rarely yields to
performance improvements, as we did not yet include vectorization in our performance improvements, as we did not yet include vectorization in our
heuristics. By changing this we should be able to significantly increase the heuristics. By changing this we should be able to significantly increase the
number of test cases that show improvements.</p> number of test cases that show improvements.</p>
<p>The polybench test suite contains computation kernels from linear algebra <p>The polybench test suite contains computation kernels from linear algebra
routines, stencil computations, image processing and data mining. Polly routines, stencil computations, image processing and data mining. Polly
recognices the majority of them and is able to show good speedup. However, recognizes the majority of them and is able to show good speedup. However,
to show similar speedup on larger examples like the SPEC CPU benchmarks Polly to show similar speedup on larger examples like the SPEC CPU benchmarks Polly
still misses support for integer casts, variable-sized multi-dimensional arrays still misses support for integer casts, variable-sized multi-dimensional arrays
and probably several other construts. This support is necessary as such and probably several other constructs. This support is necessary as such
constructs appear in larger programs, but not in our limited test suite. constructs appear in larger programs, but not in our limited test suite.
<h2> Sequential runs</h2> <h2> Sequential runs</h2>
For the sequential runs we used Polly to create a program structure that is For the sequential runs we used Polly to create a program structure that is
optimized for data-locality. One of the major optimizations performed is tiling. optimized for data-locality. One of the major optimizations performed is tiling.
The speedups shown are without the use of any multi-core parallelism. No The speedups shown are without the use of any multi-core parallelism. No
additional hardware is used, but the single available core is used more additional hardware is used, but the single available core is used more
Show All 19 Lines

polly/www/projects.html

Show All 20 Lines
<div id="content"> <div id="content">
<!--*********************************************************************--> <!--*********************************************************************-->
<h1>Open Projects</h1> <h1>Open Projects</h1>
<!--*********************************************************************--> <!--*********************************************************************-->
LLVM Polly keeps here a list of open projects which each of themselves would LLVM Polly keeps here a list of open projects which each of themselves would
be a great contribution to Polly. All of these projects are meant to be self be a great contribution to Polly. All of these projects are meant to be self
contained and should take a newcomer around 3-4 months of work. The projects contained and should take a newcomer around 3-4 months of work. The projects
we propose are all suiteable as <a we propose are all suitable as <a
href="https://developers.google.com/open-source/gsoc/">Google Summer of href="https://developers.google.com/open-source/gsoc/">Google Summer of
Code</a> projects. In case you are interested in a Google Summer of code Code</a> projects. In case you are interested in a Google Summer of code
project make sure to reach out via the Polly <a project make sure to reach out via the Polly <a
href="https://groups.google.com/group/polly-dev">mailing list</a> early to href="https://groups.google.com/group/polly-dev">mailing list</a> early to
discuss your project proposal. discuss your project proposal.
<h3>Integrate Polly with the LLVM vectorizers</h3> <h3>Integrate Polly with the LLVM vectorizers</h3>
Polly is not only a self-contained optimizer, but also provides a powerful Polly is not only a self-contained optimizer, but also provides a powerful
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

polly/www/todo.html

Show First 20 Lines • Show All 100 Lines • ▼ Show 20 Lines
<tr> <tr>
<th align="left"> <th align="left">
Unsigned Integers Unsigned Integers
</th><td align="center" class='done'> Done </th><td align="center" class='done'> Done
</td><td> Johannes </td><td> Johannes
</td></tr> </td></tr>
<tr> <tr>
<th align="left"> <th align="left">
Pointer Comparisions Pointer Comparisons
</th><td align="center" class='done'> Done </th><td align="center" class='done'> Done
</td><td> Johannes </td><td> Johannes
</td></tr> </td></tr>
<tr> <tr>
<th align="left"> <th align="left">
Non-affine subregions Non-affine subregions
</th><td align="center" class='done'> Done </th><td align="center" class='done'> Done
</td><td> Johannes </td><td> Johannes
▲ Show 20 Lines • Show All 324 Lines • ▼ Show 20 Lines
</th><td> </th><td>
</td></tr> </td></tr>
</tbody></table> </tbody></table>
<h3 id="phase2"> Phase 2 - First Optimizations and Enhanced User Experience (Finished <h3 id="phase2"> Phase 2 - First Optimizations and Enhanced User Experience (Finished
February 2012)</h3> February 2012)</h3>
<p> <p>
First optimizations to show the usefullness of Polly and enhance the user First optimizations to show the usefulness of Polly and enhance the user
experience. We also try to increase the amount of code we can optimize. experience. We also try to increase the amount of code we can optimize.
</p> </p>
<table class="wikitable" cellpadding="2"> <table class="wikitable" cellpadding="2">
<tbody> <tbody>
<tr><th colspan="3" style="background: rgb(239, 239, 239);"> Frontend </th></tr> <tr><th colspan="3" style="background: rgb(239, 239, 239);"> Frontend </th></tr>
<tr style="background: rgb(239, 239, 239)"> <tr style="background: rgb(239, 239, 239)">
<th width="400px"> Task </th> <th width="400px"> Task </th>
▲ Show 20 Lines • Show All 188 Lines • Show Last 20 Lines

utils/arcanist/clang-format.sh

Show All 14 Lines
if ! hash clang-format >/dev/null; then if ! hash clang-format >/dev/null; then
echo "advice" echo "advice"
echo "clang-format not found in user’s local PATH; not linting file." echo "clang-format not found in user’s local PATH; not linting file."
echo "====" echo "===="
exit 0 exit 0
fi fi
if ! git rev-parse --git-dir >/dev/null; then if ! git rev-parse --git-dir >/dev/null; then
echo "advice" echo "advice"
echo "not in git repostitory; not linting file." echo "not in git repository; not linting file."
echo "====" echo "===="
exit 0 exit 0
fi fi
src_file="${1}" src_file="${1}"
original_file="$(mktemp)" original_file="$(mktemp)"
formatted_file="$(mktemp)" formatted_file="$(mktemp)"
readonly src_file readonly src_file
Show All 37 Lines

utils/bazel/README.md

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines
which will cache build results which will cache build results
```.bazelrc ```.bazelrc
build --disk_cache=~/.cache/bazel-disk-cache build --disk_cache=~/.cache/bazel-disk-cache
``` ```
You can instruct Bazel to use a ramdisk for its sandboxing operations via You can instruct Bazel to use a ramdisk for its sandboxing operations via
[--sandbox_base](https://docs.bazel.build/versions/main/command-line-reference.html#flag--sandbox_base), [--sandbox_base](https://docs.bazel.build/versions/main/command-line-reference.html#flag--sandbox_base),
which can help avoid IO bottlenecks for the symlink stragegy used for which can help avoid IO bottlenecks for the symlink strategy used for
sandboxing. This is especially important with many inputs and many cores (see sandboxing. This is especially important with many inputs and many cores (see
https://github.com/bazelbuild/bazel/issues/11868): https://github.com/bazelbuild/bazel/issues/11868):
```.bazelrc ```.bazelrc
build --sandbox_base=/dev/shm build --sandbox_base=/dev/shm
``` ```
Bear in mind that this requires that your ramdisk is of sufficient size to hold Bear in mind that this requires that your ramdisk is of sufficient size to hold
Show All 37 Lines

utils/bazel/deps_impl/terminfo_system.BUILD

# This file is licensed under the Apache License v2.0 with LLVM Exceptions. # This file is licensed under the Apache License v2.0 with LLVM Exceptions.
# See https://llvm.org/LICENSE.txt for license information. # See https://llvm.org/LICENSE.txt for license information.
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
# Wrapper library for some system terminfo. Using this only works if the # Wrapper library for some system terminfo. Using this only works if the
# toolchain already has the relevant library search paths configured. It also # toolchain already has the relevant library search paths configured. It also
# sets the relevant LLVM `#define`s to enoble using terminfo. # sets the relevant LLVM `#define`s to enable using terminfo.
cc_library( cc_library(
name = "terminfo", name = "terminfo",
defines = ["LLVM_ENABLE_TERMINFO=1"], defines = ["LLVM_ENABLE_TERMINFO=1"],
# Note that we will replace these link options with ones needed to # Note that we will replace these link options with ones needed to
# effectively link against a terminfo providing library on the system. # effectively link against a terminfo providing library on the system.
linkopts = {TERMINFO_LINKOPTS}, linkopts = {TERMINFO_LINKOPTS},
visibility = ["//visibility:public"], visibility = ["//visibility:public"],
) )