This is an archive of the discontinued LLVM Phabricator instance.

Differential D140896

Move from llvm::makeArrayRef to ArrayRef deduction guides - part 1
ClosedPublic

Authored by serge-sans-paille on Jan 3 2023, 7:17 AM.

Details

Reviewers
JDevlieghere
alexander-shaposhnikov
shafik
jhenderson
antiagainst
rriddle
aartbik
MaskRay
jpienaar
ftynse
awarzynski
bondhugula
rafauler
Amir
maksfb
ThomasRaoux
NoQ
njames93
nicolasvasilache
herhut
dcaballe
Commits
rG3677ee65d192: Move from llvm::makeArrayRef to ArrayRef deduction guides
Summary

Since we're now requiring C++17, Let's get rid of makeXXX functions like makeArrayRef, and use deduction guides instead.

Apart from codebase modernization, there isn't much benefit from that
move, but I can still mention that it would slightly (probably
negligibly) decrease the number of symbols / debug info, as deduction
guides don't generate new code.

The only non-automatic changes have been:

  1. Write the deduction guides
  2. ArrayRef(some_uint8_pointer, 0) needs to be changed into ArrayRef(some_uint8_pointer, (size_t)0) to avoid an ambiguous call with ArrayRef((uint8_t*), (uint8_t*))
  3. CVSymbol sym(makeArrayRef(symStorage)); needed to be rewritten as CVSymbol sym{ArrayRef(symStorage)}; otherwise the compiler is confused and thinks we have a (bad) function prototype. There was a few similar situation across the codebase.
  4. ADL doesn't seem to work the same for deductio-guides and functions, so at some point the llvm namespace must be explicitly stated.
  5. The "reference mode" of makeArrayRef(ArrayRef<T> &) that acts as no-op is not supported (a constructor cannot achieve that).

Diff Detail

Event Timeline

serge-sans-paille created this revision.Jan 3 2023, 7:17 AM
Herald added a reviewer: JDevlieghere. · View Herald TranscriptJan 3 2023, 7:17 AM
Herald added a reviewer: alexander-shaposhnikov. · View Herald Transcript
Herald added a reviewer: shafik. · View Herald Transcript
Herald added a reviewer: jhenderson. · View Herald Transcript
Herald added a reviewer: antiagainst. · View Herald Transcript
Herald added a reviewer: rriddle. · View Herald Transcript
Herald added a reviewer: antiagainst. · View Herald Transcript
Herald added a reviewer: aartbik. · View Herald Transcript
Herald added a reviewer: MaskRay. · View Herald Transcript
Herald added a reviewer: jpienaar. · View Herald Transcript
Herald added a reviewer: ftynse. · View Herald Transcript
Herald added a reviewer: awarzynski. · 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: ThomasRaoux. · View Herald Transcript
Herald added a reviewer: NoQ. · View Herald Transcript
Herald added a reviewer: njames93. · View Herald Transcript
Herald added projects: Restricted Project, Restricted Project, Restricted Project. · View Herald Transcript
Herald added subscribers: libc-commits, hanchung, kadircet and 91 others. · View Herald Transcript
serge-sans-paille requested review of this revision.Jan 3 2023, 7:17 AM
Herald added a reviewer: nicolasvasilache. · View Herald TranscriptJan 3 2023, 7:17 AM
Herald added a reviewer: herhut. · View Herald Transcript
Herald added a reviewer: dcaballe. · View Herald Transcript
Herald added projects: Restricted Project, Restricted Project, Restricted Project, Restricted Project, Restricted Project. · View Herald Transcript
Herald added subscribers: cfe-commits, llvm-commits, lldb-commits and 7 others. · View Herald Transcript
mehdi_amini added inline comments.Jan 3 2023, 7:52 AM
llvm/include/llvm/ADT/ArrayRef.h
502

Can we keep the makeArrayRef functions for now and mark them deprecated?

Herald added a subscriber: Michael137. · View Herald TranscriptJan 3 2023, 7:52 AM
Harbormaster completed remote builds in B205464: Diff 485988.Jan 3 2023, 8:58 AM
jpienaar added inline comments.Jan 3 2023, 11:15 AM
llvm/include/llvm/ADT/ArrayRef.h
502

+1 that would also allow for this change to broken up so that the deduction guides land first and then the updates (potentially even 3 hops, 1) add guides, 2) update, 3) mark deprecated - 1 & 2 could be combined but it'll greatly simplify review/enable sharding it)

serge-sans-paille updated this revision to Diff 486049.Jan 3 2023, 12:28 PM

+ keep deprecated version, flagged appropriately

Harbormaster completed remote builds in B205505: Diff 486049.Jan 3 2023, 12:28 PM
MaskRay accepted this revision.Jan 3 2023, 3:55 PM

LGTM if makeArrayRef is kept in this patch. Do we foresee compiler bugs (for supported compilers) in this area? If there may be a risk, consider migrate a part of the code base first.

serge-sans-paille updated this revision to Diff 486172.Jan 3 2023, 11:17 PM

Split the original patch in pieces: first just introduce the deduction guide.

This revision was not accepted when it landed; it landed in state Needs Review.Jan 3 2023, 11:20 PM
This revision was landed with ongoing or failed builds.
Closed by commit rG3677ee65d192: Move from llvm::makeArrayRef to ArrayRef deduction guides (authored by serge-sans-paille). · Explain Why
This revision was automatically updated to reflect the committed changes.
serge-sans-paille added a commit: rG3677ee65d192: Move from llvm::makeArrayRef to ArrayRef deduction guides.
serge-sans-paille retitled this revision from [WIP] Move from llvm::makeArrayRef to ArrayRef deduction guides to Move from llvm::makeArrayRef to ArrayRef deduction guides - part 1.Jan 3 2023, 11:32 PM
serge-sans-paille mentioned this in D140955: Move from llvm::makeArrayRef to ArrayRef deduction guides - llvm/ part.Jan 3 2023, 11:39 PM
Harbormaster completed remote builds in B205608: Diff 486172.Jan 4 2023, 12:50 AM
serge-sans-paille mentioned this in rG38818b60c58c: Move from llvm::makeArrayRef to ArrayRef deduction guides - llvm/ part.Jan 5 2023, 5:12 AM
serge-sans-paille mentioned this in rGa3c248db87eb: Move from llvm::makeArrayRef to ArrayRef deduction guides - clang/ part.Jan 9 2023, 3:16 AM
serge-sans-paille mentioned this in D141298: Move from llvm::makeArrayRef to ArrayRef deduction guides - last part.Jan 9 2023, 9:13 AM
jloser mentioned this in D141327: [llvm][ADT] Add deduction guides for `MutableArrayRef`.Jan 9 2023, 2:40 PM
serge-sans-paille mentioned this in rG984b800a036f: Move from llvm::makeArrayRef to ArrayRef deduction guides - last part.Jan 10 2023, 2:48 AM
serge-sans-paille mentioned this in D141378: [llvm] Declare llvm::makeArrayRef as obsolete.Jan 10 2023, 5:30 AM
serge-sans-paille mentioned this in rG36117cc46388: [llvm] Declare llvm::makeArrayRef as obsolete.Jan 10 2023, 9:20 AM
jloser mentioned this in rG38791259c116: [llvm][ADT] Add deduction guides for `MutableArrayRef`.Jan 10 2023, 12:05 PM

Revision Contents

PathSize
bolt/
tools/
bat-dump/
2 lines
driver/
6 lines
heatmap/
2 lines
clang-tools-extra/
clang-apply-replacements/
tool/
2 lines
clang-tidy/
bugprone/
4 lines
2 lines
concurrency/
2 lines
modernize/
4 lines
4 lines
readability/
4 lines
utils/
2 lines
clangd/
2 lines
4 lines
2 lines
2 lines
4 lines
4 lines
refactor/
tweaks/
2 lines
tool/
4 lines
unittests/
12 lines
include-cleaner/
lib/
2 lines
pseudo/
include/
clang-pseudo/
3 lines
4 lines
grammar/
8 lines
lib/
2 lines
2 lines
grammar/
4 lines
unittests/
clang-tidy/
2 lines
clang/
include/
clang/
AST/
2 lines
8 lines
3 lines
4 lines
10 lines
18 lines
18 lines
9 lines
4 lines
90 lines
2 lines
10 lines
7 lines
8 lines
2 lines
9 lines
6 lines
Analysis/
Analyses/
4 lines
Basic/
8 lines
4 lines
CodeGen/
4 lines
Lex/
4 lines
Parse/
2 lines
Sema/
4 lines
4 lines
10 lines
Serialization/
2 lines
Tooling/
Refactoring/
Rename/
2 lines
Transformer/
4 lines
lib/
AST/
4 lines
2 lines
2 lines
30 lines
27 lines
6 lines
6 lines
4 lines
2 lines
6 lines
2 lines
10 lines
2 lines
4 lines
2 lines
18 lines
ASTMatchers/
Dynamic/
12 lines
Analysis/
4 lines
8 lines
FlowSensitive/
4 lines
Basic/
2 lines
Targets/
8 lines
6 lines
2 lines
8 lines
4 lines
4 lines
4 lines
8 lines
4 lines
8 lines
2 lines
2 lines
2 lines
6 lines
4 lines
6 lines
10 lines
8 lines
4 lines
8 lines
4 lines
4 lines
4 lines
12 lines
2 lines
4 lines
CodeGen/
128 lines
6 lines
3 lines
8 lines
4 lines
4 lines
4 lines
2 lines
8 lines
4 lines
4 lines
19 lines
8 lines
2 lines
Driver/
4 lines
ToolChains/
4 lines
Format/
2 lines
Frontend/
3 lines
Interpreter/
5 lines
Lex/
4 lines
Parse/
4 lines
Sema/
2 lines
6 lines
2 lines
47 lines
13 lines
8 lines
63 lines
4 lines
28 lines
12 lines
2 lines
2 lines
7 lines
2 lines
3 lines
2 lines
13 lines
21 lines
Serialization/
14 lines
2 lines
7 lines
Tooling/
DependencyScanning/
2 lines
DumpTool/
2 lines
2 lines
Syntax/
8 lines
12 lines
20 lines
4 lines
tools/
diagtool/
4 lines
2 lines
driver/
9 lines
libclang/
13 lines
2 lines
5 lines
unittests/
Driver/
2 lines
Introspection/
41 lines
Lex/
2 lines
2 lines
Tooling/
Syntax/
23 lines
6 lines
2 lines
flang/
lib/
Lower/
2 lines
tools/
flang-driver/
2 lines
libc/
benchmarks/
12 lines
2 lines
automemcpy/
lib/
8 lines
unittests/
10 lines
lld/
COFF/
2 lines
9 lines
4 lines
8 lines
ELF/
Arch/
4 lines
2 lines
4 lines
4 lines
2 lines
2 lines
6 lines
2 lines
14 lines
4 lines
4 lines
6 lines
lldb/
include/
lldb/
Utility/
2 lines
2 lines
source/
API/
2 lines
Breakpoint/
2 lines
Commands/
20 lines
4 lines
12 lines
2 lines
2 lines
2 lines
6 lines
2 lines
4 lines
8 lines
2 lines
12 lines
16 lines
2 lines
2 lines
2 lines
8 lines
4 lines
2 lines
14 lines
20 lines
8 lines
22 lines
8 lines
2 lines
2 lines
Host/
common/
26 lines
Interpreter/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
Plugins/
ABI/
ARC/
2 lines
LanguageRuntime/
ObjC/
AppleObjCRuntime/
2 lines
RenderScript/
RenderScriptRuntime/
8 lines
ObjectFile/
ELF/
4 lines
wasm/
2 lines
Process/
FreeBSD/
4 lines
Linux/
4 lines
Utility/
6 lines
Windows/
Common/
4 lines
gdb-remote/
2 lines
minidump/
2 lines
scripted/
2 lines
StructuredData/
DarwinLog/
2 lines
SymbolFile/
DWARF/
6 lines
NativePDB/
2 lines
2 lines
Trace/
intel-pt/
4 lines
TraceExporter/
ctf/
2 lines
Symbol/
5 lines
Target/
6 lines
2 lines
Utility/
4 lines
2 lines
tools/
driver/
2 lines
lldb-vscode/
2 lines
unittests/
TestingSupport/
Host/
2 lines
llvm/
docs/
TableGen/
6 lines
include/
llvm/
ADT/
65 lines
2 lines
Analysis/
4 lines
4 lines
Bitcode/
2 lines
Bitstream/
20 lines
CodeGen/
4 lines
4 lines
4 lines
2 lines
6 lines
8 lines
4 lines
DebugInfo/
CodeView/
4 lines
DWARF/
4 lines
PDB/
Native/
4 lines
IR/
4 lines
2 lines
8 lines
6 lines
2 lines
4 lines
2 lines
2 lines
Object/
12 lines
5 lines
Support/
4 lines
4 lines
25 lines
16 lines
TableGen/
14 lines
lib/
Analysis/
9 lines
2 lines
5 lines
2 lines
2 lines
9 lines
AsmParser/
2 lines
Bitcode/
Reader/
18 lines
2 lines
Writer/
4 lines
CodeGen/
AsmPrinter/
2 lines
4 lines
9 lines
14 lines
12 lines
GlobalISel/
2 lines
2 lines
4 lines
2 lines
4 lines
6 lines
10 lines
2 lines
SelectionDAG/
2 lines
14 lines
3 lines
6 lines
2 lines
2 lines
12 lines
2 lines
2 lines
DebugInfo/
CodeView/
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
4 lines
2 lines
62 lines
2 lines
2 lines
5 lines
2 lines
38 lines
2 lines
39 lines
DWARF/
4 lines
8 lines
PDB/
Native/
6 lines
2 lines
10 lines
2 lines
2 lines
2 lines
ExecutionEngine/
Orc/
8 lines
2 lines
FuzzMutate/
10 lines
2 lines
IR/
2 lines
2 lines
24 lines
2 lines
2 lines
31 lines
4 lines
2 lines
2 lines
LTO/
2 lines
Linker/
2 lines
MC/
4 lines
2 lines
7 lines
2 lines
ObjCopy/
COFF/
6 lines
wasm/
2 lines
Object/
4 lines
5 lines
18 lines
2 lines
2 lines
ObjectYAML/
2 lines
7 lines
2 lines
Option/
2 lines
ProfileData/
Coverage/
2 lines
6 lines
4 lines
Support/
8 lines
4 lines
79 lines
3 lines
20 lines
2 lines
8 lines
8 lines
4 lines
2 lines
8 lines
5 lines
9 lines
TableGen/
15 lines
Target/
AArch64/
19 lines
6 lines
GISel/
2 lines
AMDGPU/
16 lines
10 lines
AsmParser/
12 lines
2 lines
7 lines
6 lines
4 lines
10 lines
Utils/
8 lines
ARM/
4 lines
10 lines
13 lines
6 lines
AVR/
16 lines
CSKY/
2 lines
DirectX/
DXILWriter/
4 lines
Hexagon/
4 lines
4 lines
4 lines
MCTargetDesc/
2 lines
Lanai/
2 lines
LoongArch/
2 lines
2 lines
M68k/
2 lines
Mips/
MCTargetDesc/
8 lines
2 lines
8 lines
NVPTX/
4 lines
PowerPC/
15 lines
4 lines
RISCV/
4 lines
2 lines
2 lines
SystemZ/
6 lines
WebAssembly/
2 lines
X86/
6 lines
8 lines
4 lines
22 lines
6 lines
6 lines
10 lines
2 lines
16 lines
2 lines
4 lines
Transforms/
IPO/
4 lines
9 lines
InstCombine/
2 lines
4 lines
12 lines
2 lines
4 lines
Instrumentation/
6 lines
8 lines
6 lines
Scalar/
2 lines
2 lines
2 lines
7 lines
2 lines
6 lines
Utils/
4 lines
2 lines
2 lines
Vectorize/
19 lines
tools/
dsymutil/
2 lines
2 lines
llvm-ar/
6 lines
llvm-cvtres/
2 lines
llvm-cxxdump/
10 lines
llvm-dwarfutil/
2 lines
llvm-exegesis/
lib/
2 lines
X86/
9 lines
llvm-lipo/
2 lines
llvm-ml/
2 lines
llvm-mt/
2 lines
llvm-nm/
2 lines
llvm-objcopy/
6 lines
2 lines
llvm-objdump/
8 lines
16 lines
8 lines
llvm-rc/
4 lines
llvm-readobj/
2 lines
55 lines
125 lines
31 lines
6 lines
6 lines
35 lines
llvm-stress/
2 lines
lto/
2 lines
obj2yaml/
5 lines
unittests/
ADT/
27 lines
4 lines
12 lines
4 lines
Analysis/
12 lines
53 lines
Bitstream/
2 lines
DebugInfo/
MSF/
2 lines
FuzzMutate/
2 lines
IR/
4 lines
2 lines
2 lines
Object/
2 lines
ObjectYAML/
2 lines
ProfileData/
4 lines
2 lines
Remarks/
4 lines
Support/
30 lines
2 lines
2 lines
14 lines
8 lines
2 lines
20 lines
31 lines
4 lines
TableGen/
16 lines
Target/
AArch64/
6 lines
utils/
TableGen/
6 lines
5 lines
4 lines
3 lines
2 lines
2 lines
2 lines
2 lines
8 lines
4 lines
4 lines
mlir/
examples/
toy/
Ch2/
mlir/
7 lines
Ch3/
mlir/
7 lines
Ch4/
mlir/
7 lines
Ch5/
mlir/
2 lines
7 lines
Ch6/
mlir/
2 lines
7 lines
Ch7/
mlir/
2 lines
9 lines
include/
mlir/
Dialect/
Shape/
IR/
8 lines
Tosa/
Utils/
2 lines
IR/
3 lines
2 lines
6 lines
8 lines
3 lines
lib/
Analysis/
Presburger/
5 lines
AsmParser/
4 lines
4 lines
Bindings/
Python/
2 lines
Bytecode/
Reader/
4 lines
CAPI/
Dialect/
2 lines
IR/
2 lines
11 lines
27 lines
2 lines
Conversion/
AffineToStandard/
4 lines
ArithToSPIRV/
10 lines
ControlFlowToLLVM/
2 lines
LLVMCommon/
2 lines
MemRefToLLVM/
2 lines
VectorToSPIRV/
2 lines
Dialect/
Affine/
IR/
2 lines
Utils/
6 lines
Func/
IR/
2 lines
GPU/
Transforms/
2 lines
4 lines
LLVMIR/
IR/
2 lines
Linalg/
IR/
4 lines
Utils/
2 lines
Math/
Transforms/
2 lines
MemRef/
IR/
2 lines
SPIRV/
IR/
4 lines
Transforms/
2 lines
Shape/
IR/
6 lines
Tensor/
Transforms/
2 lines
Transform/
IR/
2 lines
Vector/
IR/
12 lines
ExecutionEngine/
2 lines
Interfaces/
2 lines
TableGen/
2 lines
Target/
SPIRV/
Deserialization/
2 lines
4 lines
Tools/
PDLL/
AST/
2 lines
6 lines
Transforms/
Utils/
6 lines
test/
lib/
Dialect/
Test/
4 lines
4 lines
mlir-tblgen/
4 lines
tools/
mlir-tblgen/
4 lines
4 lines
2 lines
6 lines
unittests/
IR/
16 lines
2 lines

Diff 486049

bolt/tools/bat-dump/bat-dump.cpp

Context not available.
} }
int main(int argc, char **argv) { int main(int argc, char **argv) {
cl::HideUnrelatedOptions(makeArrayRef(opts::BatDumpCategories)); cl::HideUnrelatedOptions(ArrayRef(opts::BatDumpCategories));
cl::ParseCommandLineOptions(argc, argv, ""); cl::ParseCommandLineOptions(argc, argv, "");
if (!sys::fs::exists(opts::InputFilename)) if (!sys::fs::exists(opts::InputFilename))
Context not available.

bolt/tools/driver/llvm-bolt.cpp

Context not available.
} }
void perf2boltMode(int argc, char **argv) { void perf2boltMode(int argc, char **argv) {
cl::HideUnrelatedOptions(makeArrayRef(opts::Perf2BoltCategories)); cl::HideUnrelatedOptions(ArrayRef(opts::Perf2BoltCategories));
cl::AddExtraVersionPrinter(printBoltRevision); cl::AddExtraVersionPrinter(printBoltRevision);
cl::ParseCommandLineOptions( cl::ParseCommandLineOptions(
argc, argv, argc, argv,
Context not available.
} }
void boltDiffMode(int argc, char **argv) { void boltDiffMode(int argc, char **argv) {
cl::HideUnrelatedOptions(makeArrayRef(opts::BoltDiffCategories)); cl::HideUnrelatedOptions(ArrayRef(opts::BoltDiffCategories));
cl::AddExtraVersionPrinter(printBoltRevision); cl::AddExtraVersionPrinter(printBoltRevision);
cl::ParseCommandLineOptions( cl::ParseCommandLineOptions(
argc, argv, argc, argv,
Context not available.
} }
void boltMode(int argc, char **argv) { void boltMode(int argc, char **argv) {
cl::HideUnrelatedOptions(makeArrayRef(opts::BoltCategories)); cl::HideUnrelatedOptions(ArrayRef(opts::BoltCategories));
// Register the target printer for --version. // Register the target printer for --version.
cl::AddExtraVersionPrinter(printBoltRevision); cl::AddExtraVersionPrinter(printBoltRevision);
cl::AddExtraVersionPrinter(TargetRegistry::printRegisteredTargetsForVersion); cl::AddExtraVersionPrinter(TargetRegistry::printRegisteredTargetsForVersion);
Context not available.

bolt/tools/heatmap/heatmap.cpp

Context not available.
} }
int main(int argc, char **argv) { int main(int argc, char **argv) {
cl::HideUnrelatedOptions(makeArrayRef(opts::HeatmapCategories)); cl::HideUnrelatedOptions(ArrayRef(opts::HeatmapCategories));
cl::ParseCommandLineOptions(argc, argv, ""); cl::ParseCommandLineOptions(argc, argv, "");
if (opts::PerfData.empty()) { if (opts::PerfData.empty()) {
Context not available.

clang-tools-extra/clang-apply-replacements/tool/ClangApplyReplacementsMain.cpp

Context not available.
} }
int main(int argc, char **argv) { int main(int argc, char **argv) {
cl::HideUnrelatedOptions(makeArrayRef(VisibleCategories)); cl::HideUnrelatedOptions(ArrayRef(VisibleCategories));
cl::SetVersionPrinter(printVersion); cl::SetVersionPrinter(printVersion);
cl::ParseCommandLineOptions(argc, argv); cl::ParseCommandLineOptions(argc, argv);
Context not available.

clang-tools-extra/clang-tidy/bugprone/ArgumentCommentCheck.cpp

Context not available.
return; return;
checkCallArgs(Result.Context, Callee, Call->getCallee()->getEndLoc(), checkCallArgs(Result.Context, Callee, Call->getCallee()->getEndLoc(),
llvm::makeArrayRef(Call->getArgs(), Call->getNumArgs())); llvm::ArrayRef(Call->getArgs(), Call->getNumArgs()));
} else { } else {
const auto *Construct = cast<CXXConstructExpr>(E); const auto *Construct = cast<CXXConstructExpr>(E);
if (Construct->getNumArgs() > 0 && if (Construct->getNumArgs() > 0 &&
Context not available.
checkCallArgs( checkCallArgs(
Result.Context, Construct->getConstructor(), Result.Context, Construct->getConstructor(),
Construct->getParenOrBraceRange().getBegin(), Construct->getParenOrBraceRange().getBegin(),
llvm::makeArrayRef(Construct->getArgs(), Construct->getNumArgs())); llvm::ArrayRef(Construct->getArgs(), Construct->getNumArgs()));
} }
} }
Context not available.

clang-tools-extra/clang-tidy/bugprone/SignalHandlerCheck.cpp

Context not available.
{bugprone::SignalHandlerCheck::AsyncSafeFunctionSetKind::POSIX, {bugprone::SignalHandlerCheck::AsyncSafeFunctionSetKind::POSIX,
"POSIX"}, "POSIX"},
}; };
return makeArrayRef(Mapping); return ArrayRef(Mapping);
} }
}; };
Context not available.

clang-tools-extra/clang-tidy/concurrency/MtUnsafeCheck.cpp

Context not available.
Mapping[] = {{concurrency::MtUnsafeCheck::FunctionSet::Posix, "posix"}, Mapping[] = {{concurrency::MtUnsafeCheck::FunctionSet::Posix, "posix"},
{concurrency::MtUnsafeCheck::FunctionSet::Glibc, "glibc"}, {concurrency::MtUnsafeCheck::FunctionSet::Glibc, "glibc"},
{concurrency::MtUnsafeCheck::FunctionSet::Any, "any"}}; {concurrency::MtUnsafeCheck::FunctionSet::Any, "any"}};
return makeArrayRef(Mapping); return ArrayRef(Mapping);
} }
}; };
Context not available.

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

Context not available.
static ArrayRef<BindArgument> static ArrayRef<BindArgument>
getForwardedArgumentList(const LambdaProperties &P) { getForwardedArgumentList(const LambdaProperties &P) {
ArrayRef<BindArgument> Args = makeArrayRef(P.BindArguments); ArrayRef<BindArgument> Args = ArrayRef(P.BindArguments);
if (P.Callable.Type != CT_MemberFunction) if (P.Callable.Type != CT_MemberFunction)
return Args; return Args;
Context not available.
emitCaptureList(LP, Result, Stream); emitCaptureList(LP, Result, Stream);
Stream << "]"; Stream << "]";
ArrayRef<BindArgument> FunctionCallArgs = makeArrayRef(LP.BindArguments); ArrayRef<BindArgument> FunctionCallArgs = ArrayRef(LP.BindArguments);
addPlaceholderArgs(LP, Stream, PermissiveParameterList); addPlaceholderArgs(LP, Stream, PermissiveParameterList);
Context not available.

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

Context not available.
Mapping[] = {{modernize::Confidence::CL_Reasonable, "reasonable"}, Mapping[] = {{modernize::Confidence::CL_Reasonable, "reasonable"},
{modernize::Confidence::CL_Safe, "safe"}, {modernize::Confidence::CL_Safe, "safe"},
{modernize::Confidence::CL_Risky, "risky"}}; {modernize::Confidence::CL_Risky, "risky"}};
return makeArrayRef(Mapping); return ArrayRef(Mapping);
} }
}; };
Context not available.
{modernize::VariableNamer::NS_CamelBack, "camelBack"}, {modernize::VariableNamer::NS_CamelBack, "camelBack"},
{modernize::VariableNamer::NS_LowerCase, "lower_case"}, {modernize::VariableNamer::NS_LowerCase, "lower_case"},
{modernize::VariableNamer::NS_UpperCase, "UPPER_CASE"}}; {modernize::VariableNamer::NS_UpperCase, "UPPER_CASE"}};
return makeArrayRef(Mapping); return ArrayRef(Mapping);
} }
}; };
Context not available.

clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.cpp

Context not available.
"Camel_Snake_Case"}, "Camel_Snake_Case"},
{readability::IdentifierNamingCheck::CT_CamelSnakeBack, {readability::IdentifierNamingCheck::CT_CamelSnakeBack,
"camel_Snake_Back"}}; "camel_Snake_Back"}};
return llvm::makeArrayRef(Mapping); return llvm::ArrayRef(Mapping);
} }
template <> template <>
Context not available.
{HungarianPrefixType::HPT_On, "On"}, {HungarianPrefixType::HPT_On, "On"},
{HungarianPrefixType::HPT_LowerCase, "LowerCase"}, {HungarianPrefixType::HPT_LowerCase, "LowerCase"},
{HungarianPrefixType::HPT_CamelCase, "CamelCase"}}; {HungarianPrefixType::HPT_CamelCase, "CamelCase"}};
return llvm::makeArrayRef(Mapping); return llvm::ArrayRef(Mapping);
} }
}; };
Context not available.

clang-tools-extra/clang-tidy/utils/IncludeSorter.cpp

Context not available.
Mapping[] = {{utils::IncludeSorter::IS_LLVM, "llvm"}, Mapping[] = {{utils::IncludeSorter::IS_LLVM, "llvm"},
{utils::IncludeSorter::IS_Google, "google"}, {utils::IncludeSorter::IS_Google, "google"},
{utils::IncludeSorter::IS_Google_ObjC, "google-objc"}}; {utils::IncludeSorter::IS_Google_ObjC, "google-objc"}};
return makeArrayRef(Mapping); return ArrayRef(Mapping);
} }
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
Context not available.

clang-tools-extra/clangd/ClangdLSPServer.cpp

Context not available.
} }
auto Mangler = CommandMangler::detect(); auto Mangler = CommandMangler::detect();
Mangler.SystemIncludeExtractor = Mangler.SystemIncludeExtractor =
getSystemIncludeExtractor(llvm::makeArrayRef(Opts.QueryDriverGlobs)); getSystemIncludeExtractor(llvm::ArrayRef(Opts.QueryDriverGlobs));
if (Opts.ResourceDir) if (Opts.ResourceDir)
Mangler.ResourceDir = *Opts.ResourceDir; Mangler.ResourceDir = *Opts.ResourceDir;
CDB.emplace(BaseCDB.get(), Params.initializationOptions.fallbackFlags, CDB.emplace(BaseCDB.get(), Params.initializationOptions.fallbackFlags,
Context not available.

clang-tools-extra/clangd/CompileCommands.cpp

Context not available.
for (const auto &S : Cmd) for (const auto &S : Cmd)
OriginalArgs.push_back(S.c_str()); OriginalArgs.push_back(S.c_str());
bool IsCLMode = driver::IsClangCL(driver::getDriverMode( bool IsCLMode = driver::IsClangCL(driver::getDriverMode(
OriginalArgs[0], llvm::makeArrayRef(OriginalArgs).slice(1))); OriginalArgs[0], llvm::ArrayRef(OriginalArgs).slice(1)));
// ParseArgs propagates missig arg/opt counts on error, but preserves // ParseArgs propagates missig arg/opt counts on error, but preserves
// everything it could parse in ArgList. So we just ignore those counts. // everything it could parse in ArgList. So we just ignore those counts.
unsigned IgnoredCount; unsigned IgnoredCount;
Context not available.
// indices are actually of by one between ArgList and OriginalArgs. // indices are actually of by one between ArgList and OriginalArgs.
llvm::opt::InputArgList ArgList; llvm::opt::InputArgList ArgList;
ArgList = OptTable.ParseArgs( ArgList = OptTable.ParseArgs(
llvm::makeArrayRef(OriginalArgs).drop_front(), IgnoredCount, IgnoredCount, llvm::ArrayRef(OriginalArgs).drop_front(), IgnoredCount, IgnoredCount,
/*FlagsToInclude=*/ /*FlagsToInclude=*/
IsCLMode ? (driver::options::CLOption | driver::options::CoreOption | IsCLMode ? (driver::options::CLOption | driver::options::CoreOption |
driver::options::CLDXCOption) driver::options::CLDXCOption)
Context not available.

clang-tools-extra/clangd/FindSymbols.cpp

Context not available.
DocumentSymbol Root; DocumentSymbol Root;
Root.children = std::move(Syms); Root.children = std::move(Syms);
Root.range = EntireFile; Root.range = EntireFile;
mergePragmas(Root, llvm::makeArrayRef(Pragmas)); mergePragmas(Root, llvm::ArrayRef(Pragmas));
return Root.children; return Root.children;
} }
Context not available.

clang-tools-extra/clangd/Preamble.cpp

Context not available.
const tooling::CompileCommand &RHS) { const tooling::CompileCommand &RHS) {
// We don't check for Output, it should not matter to clangd. // We don't check for Output, it should not matter to clangd.
return LHS.Directory == RHS.Directory && LHS.Filename == RHS.Filename && return LHS.Directory == RHS.Directory && LHS.Filename == RHS.Filename &&
llvm::makeArrayRef(LHS.CommandLine).equals(RHS.CommandLine); llvm::ArrayRef(LHS.CommandLine).equals(RHS.CommandLine);
} }
class CppFilePreambleCallbacks : public PreambleCallbacks { class CppFilePreambleCallbacks : public PreambleCallbacks {
Context not available.

clang-tools-extra/clangd/Selection.cpp

Context not available.
SelFirst, AllSpelledTokens.end(), [&](const syntax::Token &Tok) { SelFirst, AllSpelledTokens.end(), [&](const syntax::Token &Tok) {
return SM.getFileOffset(Tok.location()) < SelEnd; return SM.getFileOffset(Tok.location()) < SelEnd;
}); });
auto Sel = llvm::makeArrayRef(SelFirst, SelLimit); auto Sel = llvm::ArrayRef(SelFirst, SelLimit);
// Find which of these are preprocessed to nothing and should be ignored. // Find which of these are preprocessed to nothing and should be ignored.
llvm::BitVector PPIgnored(Sel.size(), false); llvm::BitVector PPIgnored(Sel.size(), false);
for (const syntax::TokenBuffer::Expansion &X : for (const syntax::TokenBuffer::Expansion &X :
Context not available.
if (EndInvalid) if (EndInvalid)
End = Toks.expandedTokens().end(); End = Toks.expandedTokens().end();
return llvm::makeArrayRef(Start, End); return llvm::ArrayRef(Start, End);
} }
// Hit-test a consecutive range of tokens from a single file ID. // Hit-test a consecutive range of tokens from a single file ID.
Context not available.

clang-tools-extra/clangd/XRefs.cpp

Context not available.
return T.location() < Word.Location; // Comparison OK: same file. return T.location() < Word.Location; // Comparison OK: same file.
}); });
// Search for matches after the cursor. // Search for matches after the cursor.
for (const syntax::Token &Tok : llvm::makeArrayRef(I, SpelledTokens.end())) for (const syntax::Token &Tok : llvm::ArrayRef(I, SpelledTokens.end()))
if (Consider(Tok)) if (Consider(Tok))
break; // costs of later tokens are greater... break; // costs of later tokens are greater...
// Search for matches before the cursor. // Search for matches before the cursor.
for (const syntax::Token &Tok : for (const syntax::Token &Tok :
llvm::reverse(llvm::makeArrayRef(SpelledTokens.begin(), I))) llvm::reverse(llvm::ArrayRef(SpelledTokens.begin(), I)))
if (Consider(Tok)) if (Consider(Tok))
break; break;
Context not available.

clang-tools-extra/clangd/refactor/tweaks/DefineOutline.cpp

Context not available.
if (Tok.kind() != Kind) if (Tok.kind() != Kind)
continue; continue;
FoundAny = true; FoundAny = true;
auto Spelling = TokBuf.spelledForExpanded(llvm::makeArrayRef(Tok)); auto Spelling = TokBuf.spelledForExpanded(llvm::ArrayRef(Tok));
if (!Spelling) { if (!Spelling) {
Errors = llvm::joinErrors( Errors = llvm::joinErrors(
std::move(Errors), std::move(Errors),
Context not available.

clang-tools-extra/clangd/tool/Check.cpp

Context not available.
std::make_unique<DirectoryBasedGlobalCompilationDatabase>(CDBOpts); std::make_unique<DirectoryBasedGlobalCompilationDatabase>(CDBOpts);
auto Mangler = CommandMangler::detect(); auto Mangler = CommandMangler::detect();
Mangler.SystemIncludeExtractor = Mangler.SystemIncludeExtractor =
getSystemIncludeExtractor(llvm::makeArrayRef(Opts.QueryDriverGlobs)); getSystemIncludeExtractor(llvm::ArrayRef(Opts.QueryDriverGlobs));
if (Opts.ResourceDir) if (Opts.ResourceDir)
Mangler.ResourceDir = *Opts.ResourceDir; Mangler.ResourceDir = *Opts.ResourceDir;
auto CDB = std::make_unique<OverlayCDB>( auto CDB = std::make_unique<OverlayCDB>(
Context not available.
elog("Failed to build AST"); elog("Failed to build AST");
return false; return false;
} }
ErrCount += showErrors(llvm::makeArrayRef(*AST->getDiagnostics()) ErrCount += showErrors(llvm::ArrayRef(*AST->getDiagnostics())
.drop_front(Preamble->Diags.size())); .drop_front(Preamble->Diags.size()));
if (Opts.BuildDynamicSymbolIndex) { if (Opts.BuildDynamicSymbolIndex) {
Context not available.

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

Context not available.
tooling::CompileCommand Cmd; tooling::CompileCommand Cmd;
Cmd.CommandLine = {"clang", "/Users/foo.cc"}; Cmd.CommandLine = {"clang", "/Users/foo.cc"};
Mangler(Cmd, "/Users/foo.cc"); Mangler(Cmd, "/Users/foo.cc");
EXPECT_THAT(llvm::makeArrayRef(Cmd.CommandLine).take_back(2), EXPECT_THAT(llvm::ArrayRef(Cmd.CommandLine).take_back(2),
ElementsAre("--", "/Users/foo.cc")); ElementsAre("--", "/Users/foo.cc"));
EXPECT_THAT(llvm::makeArrayRef(Cmd.CommandLine).drop_back(2), EXPECT_THAT(llvm::ArrayRef(Cmd.CommandLine).drop_back(2),
Not(Contains("/Users/foo.cc"))); Not(Contains("/Users/foo.cc")));
} }
// In CL mode /U triggers an undef operation, hence `/Users/foo.cc` shouldn't // In CL mode /U triggers an undef operation, hence `/Users/foo.cc` shouldn't
Context not available.
tooling::CompileCommand Cmd; tooling::CompileCommand Cmd;
Cmd.CommandLine = {"clang", "--driver-mode=cl", "bar.cc", "/Users/foo.cc"}; Cmd.CommandLine = {"clang", "--driver-mode=cl", "bar.cc", "/Users/foo.cc"};
Mangler(Cmd, "bar.cc"); Mangler(Cmd, "bar.cc");
EXPECT_THAT(llvm::makeArrayRef(Cmd.CommandLine).take_back(2), EXPECT_THAT(llvm::ArrayRef(Cmd.CommandLine).take_back(2),
ElementsAre("--", "bar.cc")); ElementsAre("--", "bar.cc"));
EXPECT_THAT(llvm::makeArrayRef(Cmd.CommandLine).drop_back(2), EXPECT_THAT(llvm::ArrayRef(Cmd.CommandLine).drop_back(2),
Not(Contains("bar.cc"))); Not(Contains("bar.cc")));
} }
// All inputs but the main file is dropped. // All inputs but the main file is dropped.
Context not available.
tooling::CompileCommand Cmd; tooling::CompileCommand Cmd;
Cmd.CommandLine = {"clang", "foo.cc", "bar.cc"}; Cmd.CommandLine = {"clang", "foo.cc", "bar.cc"};
Mangler(Cmd, "baz.cc"); Mangler(Cmd, "baz.cc");
EXPECT_THAT(llvm::makeArrayRef(Cmd.CommandLine).take_back(2), EXPECT_THAT(llvm::ArrayRef(Cmd.CommandLine).take_back(2),
ElementsAre("--", "baz.cc")); ElementsAre("--", "baz.cc"));
EXPECT_THAT( EXPECT_THAT(
llvm::makeArrayRef(Cmd.CommandLine).drop_back(2), llvm::ArrayRef(Cmd.CommandLine).drop_back(2),
testing::AllOf(Not(Contains("foo.cc")), Not(Contains("bar.cc")))); testing::AllOf(Not(Contains("foo.cc")), Not(Contains("bar.cc"))));
} }
} }
Context not available.

clang-tools-extra/include-cleaner/lib/HTMLReport.cpp

Context not available.
return std::make_pair(Refs[A].Offset, Refs[A].Type != RefType::Implicit) < return std::make_pair(Refs[A].Offset, Refs[A].Type != RefType::Implicit) <
std::make_pair(Refs[B].Offset, Refs[B].Type != RefType::Implicit); std::make_pair(Refs[B].Offset, Refs[B].Type != RefType::Implicit);
}); });
auto Rest = llvm::makeArrayRef(RefOrder); auto Rest = llvm::ArrayRef(RefOrder);
unsigned End = 0; unsigned End = 0;
StartLine(); StartLine();
for (unsigned I = 0; I < Code.size(); ++I) { for (unsigned I = 0; I < Code.size(); ++I) {
Context not available.

clang-tools-extra/pseudo/include/clang-pseudo/Forest.h

Context not available.
// Retrieves the trailing array. // Retrieves the trailing array.
llvm::ArrayRef<const ForestNode *> children(uint16_t Num) const { llvm::ArrayRef<const ForestNode *> children(uint16_t Num) const {
return llvm::makeArrayRef(reinterpret_cast<ForestNode *const *>(this + 1), return llvm::ArrayRef(reinterpret_cast<ForestNode *const *>(this + 1), Num);
Num);
} }
llvm::MutableArrayRef<ForestNode *> children(uint16_t Num) { llvm::MutableArrayRef<ForestNode *> children(uint16_t Num) {
return llvm::makeMutableArrayRef(reinterpret_cast<ForestNode **>(this + 1), return llvm::makeMutableArrayRef(reinterpret_cast<ForestNode **>(this + 1),
Context not available.

clang-tools-extra/pseudo/include/clang-pseudo/GLR.h

Context not available.
const ForestNode *Payload = nullptr; const ForestNode *Payload = nullptr;
llvm::ArrayRef<const Node *> parents() const { llvm::ArrayRef<const Node *> parents() const {
return llvm::makeArrayRef(reinterpret_cast<const Node *const *>(this + 1), return llvm::ArrayRef(reinterpret_cast<const Node *const *>(this + 1),
ParentCount); ParentCount);
}; };
// Parents are stored as a trailing array of Node*. // Parents are stored as a trailing array of Node*.
}; };
Context not available.

clang-tools-extra/pseudo/include/clang-pseudo/grammar/LRTable.h

Context not available.
// } // }
llvm::ArrayRef<RuleID> getReduceRules(StateID State) const { llvm::ArrayRef<RuleID> getReduceRules(StateID State) const {
assert(State + 1u < ReduceOffset.size()); assert(State + 1u < ReduceOffset.size());
return llvm::makeArrayRef(Reduces.data() + ReduceOffset[State], return llvm::ArrayRef(Reduces.data() + ReduceOffset[State],
Reduces.data() + ReduceOffset[State+1]); Reduces.data() + ReduceOffset[State + 1]);
} }
// Returns whether Terminal can follow Nonterminal in a valid source file. // Returns whether Terminal can follow Nonterminal in a valid source file.
bool canFollow(SymbolID Nonterminal, SymbolID Terminal) const { bool canFollow(SymbolID Nonterminal, SymbolID Terminal) const {
Context not available.
// Looks up available recovery actions if we stopped parsing in this state. // Looks up available recovery actions if we stopped parsing in this state.
llvm::ArrayRef<Recovery> getRecovery(StateID State) const { llvm::ArrayRef<Recovery> getRecovery(StateID State) const {
return llvm::makeArrayRef(Recoveries.data() + RecoveryOffset[State], return llvm::ArrayRef(Recoveries.data() + RecoveryOffset[State],
Recoveries.data() + RecoveryOffset[State + 1]); Recoveries.data() + RecoveryOffset[State + 1]);
} }
// Returns the state from which the LR parser should start to parse the input // Returns the state from which the LR parser should start to parse the input
Context not available.

clang-tools-extra/pseudo/lib/Forest.cpp

Context not available.
/*Start=*/Index, /*TerminalData*/ 0); /*Start=*/Index, /*TerminalData*/ 0);
++Index; ++Index;
NodeCount = Index; NodeCount = Index;
return llvm::makeArrayRef(Terminals, Index); return llvm::ArrayRef(Terminals, Index);
} }
} // namespace pseudo } // namespace pseudo
Context not available.

clang-tools-extra/pseudo/lib/GLR.cpp

Context not available.
Shifts.push_back({*S, H}); Shifts.push_back({*S, H});
llvm::stable_sort(Shifts, llvm::less_first{}); llvm::stable_sort(Shifts, llvm::less_first{});
auto Rest = llvm::makeArrayRef(Shifts); auto Rest = llvm::ArrayRef(Shifts);
llvm::SmallVector<const GSS::Node *> Parents; llvm::SmallVector<const GSS::Node *> Parents;
while (!Rest.empty()) { while (!Rest.empty()) {
// Collect the batch of PendingShift that have compatible shift states. // Collect the batch of PendingShift that have compatible shift states.
Context not available.

clang-tools-extra/pseudo/lib/grammar/Grammar.cpp

Context not available.
assert(isNonterminal(SID)); assert(isNonterminal(SID));
const auto &R = T->Nonterminals[SID].RuleRange; const auto &R = T->Nonterminals[SID].RuleRange;
assert(R.End <= T->Rules.size()); assert(R.End <= T->Rules.size());
return llvm::makeArrayRef(&T->Rules[R.Start], R.End - R.Start); return llvm::ArrayRef(&T->Rules[R.Start], R.End - R.Start);
} }
const Rule &Grammar::lookupRule(RuleID RID) const { const Rule &Grammar::lookupRule(RuleID RID) const {
Context not available.
TerminalNames[tok::kw_##Keyword] = llvm::StringRef(#Keyword).upper(); TerminalNames[tok::kw_##Keyword] = llvm::StringRef(#Keyword).upper();
#define TOK(Tok) TerminalNames[tok::Tok] = llvm::StringRef(#Tok).upper(); #define TOK(Tok) TerminalNames[tok::Tok] = llvm::StringRef(#Tok).upper();
#include "clang/Basic/TokenKinds.def" #include "clang/Basic/TokenKinds.def"
return llvm::makeArrayRef(TerminalNames, NumTerminals); return llvm::ArrayRef(TerminalNames, NumTerminals);
}(); }();
return TerminalNames; return TerminalNames;
} }
Context not available.

clang-tools-extra/unittests/clang-tidy/ClangTidyOptionsTest.cpp

Context not available.
{Colours::Yellow, "Yellow"}, {Colours::Green, "Green"}, {Colours::Yellow, "Yellow"}, {Colours::Green, "Green"},
{Colours::Blue, "Blue"}, {Colours::Indigo, "Indigo"}, {Colours::Blue, "Blue"}, {Colours::Indigo, "Indigo"},
{Colours::Violet, "Violet"}}; {Colours::Violet, "Violet"}};
return makeArrayRef(Mapping); return ArrayRef(Mapping);
} }
}; };
Context not available.

clang/include/clang/AST/Decl.h

Context not available.
using chain_iterator = ArrayRef<NamedDecl *>::const_iterator; using chain_iterator = ArrayRef<NamedDecl *>::const_iterator;
ArrayRef<NamedDecl *> chain() const { ArrayRef<NamedDecl *> chain() const {
return llvm::makeArrayRef(Chaining, ChainingSize); return llvm::ArrayRef(Chaining, ChainingSize);
} }
chain_iterator chain_begin() const { return chain().begin(); } chain_iterator chain_begin() const { return chain().begin(); }
chain_iterator chain_end() const { return chain().end(); } chain_iterator chain_end() const { return chain().end(); }
Context not available.

clang/include/clang/AST/DeclCXX.h

Context not available.
} }
ArrayRef<CXXBaseSpecifier> bases() const { ArrayRef<CXXBaseSpecifier> bases() const {
return llvm::makeArrayRef(getBases(), NumBases); return llvm::ArrayRef(getBases(), NumBases);
} }
ArrayRef<CXXBaseSpecifier> vbases() const { ArrayRef<CXXBaseSpecifier> vbases() const {
return llvm::makeArrayRef(getVBases(), NumVBases); return llvm::ArrayRef(getVBases(), NumVBases);
} }
private: private:
Context not available.
/// Get the set of using declarations that this pack expanded into. Note that /// Get the set of using declarations that this pack expanded into. Note that
/// some of these may still be unresolved. /// some of these may still be unresolved.
ArrayRef<NamedDecl *> expansions() const { ArrayRef<NamedDecl *> expansions() const {
return llvm::makeArrayRef(getTrailingObjects<NamedDecl *>(), NumExpansions); return llvm::ArrayRef(getTrailingObjects<NamedDecl *>(), NumExpansions);
} }
static UsingPackDecl *Create(ASTContext &C, DeclContext *DC, static UsingPackDecl *Create(ASTContext &C, DeclContext *DC,
Context not available.
unsigned NumBindings); unsigned NumBindings);
ArrayRef<BindingDecl *> bindings() const { ArrayRef<BindingDecl *> bindings() const {
return llvm::makeArrayRef(getTrailingObjects<BindingDecl *>(), NumBindings); return llvm::ArrayRef(getTrailingObjects<BindingDecl *>(), NumBindings);
} }
void printName(raw_ostream &OS, const PrintingPolicy &Policy) const override; void printName(raw_ostream &OS, const PrintingPolicy &Policy) const override;
Context not available.

clang/include/clang/AST/DeclObjC.h

Context not available.
// ArrayRef access to formal parameters. This should eventually // ArrayRef access to formal parameters. This should eventually
// replace the iterator interface above. // replace the iterator interface above.
ArrayRef<ParmVarDecl*> parameters() const { ArrayRef<ParmVarDecl*> parameters() const {
return llvm::makeArrayRef(const_cast<ParmVarDecl**>(getParams()), return llvm::ArrayRef(const_cast<ParmVarDecl **>(getParams()), NumParams);
NumParams);
} }
ParmVarDecl *getParamDecl(unsigned Idx) { ParmVarDecl *getParamDecl(unsigned Idx) {
Context not available.

clang/include/clang/AST/DeclOpenMP.h

Context not available.
ArrayRef<const Expr *> getVars() const { ArrayRef<const Expr *> getVars() const {
auto **Storage = reinterpret_cast<Expr **>(Data->getChildren().data()); auto **Storage = reinterpret_cast<Expr **>(Data->getChildren().data());
return llvm::makeArrayRef(Storage, Data->getNumChildren()); return llvm::ArrayRef(Storage, Data->getNumChildren());
} }
MutableArrayRef<Expr *> getVars() { MutableArrayRef<Expr *> getVars() {
Context not available.
ArrayRef<const Expr *> getVars() const { ArrayRef<const Expr *> getVars() const {
auto **Storage = reinterpret_cast<Expr **>(Data->getChildren().data()); auto **Storage = reinterpret_cast<Expr **>(Data->getChildren().data());
return llvm::makeArrayRef(Storage, Data->getNumChildren()); return llvm::ArrayRef(Storage, Data->getNumChildren());
} }
MutableArrayRef<Expr *> getVars() { MutableArrayRef<Expr *> getVars() {
Context not available.

clang/include/clang/AST/DeclTemplate.h

Context not available.
unsigned size() const { return NumParams; } unsigned size() const { return NumParams; }
ArrayRef<NamedDecl*> asArray() { ArrayRef<NamedDecl *> asArray() { return llvm::ArrayRef(begin(), end()); }
return llvm::makeArrayRef(begin(), end());
}
ArrayRef<const NamedDecl*> asArray() const { ArrayRef<const NamedDecl*> asArray() const {
return llvm::makeArrayRef(begin(), size()); return llvm::ArrayRef(begin(), size());
} }
NamedDecl* getParam(unsigned Idx) { NamedDecl* getParam(unsigned Idx) {
Context not available.
/// Produce this as an array ref. /// Produce this as an array ref.
ArrayRef<TemplateArgument> asArray() const { ArrayRef<TemplateArgument> asArray() const {
return llvm::makeArrayRef(data(), size()); return llvm::ArrayRef(data(), size());
} }
/// Retrieve the number of template arguments in this /// Retrieve the number of template arguments in this
Context not available.
unsigned getNumTemplateArgs() const { return NumArgs; } unsigned getNumTemplateArgs() const { return NumArgs; }
llvm::ArrayRef<TemplateArgumentLoc> arguments() const { llvm::ArrayRef<TemplateArgumentLoc> arguments() const {
return llvm::makeArrayRef(getTemplateArgs(), getNumTemplateArgs()); return llvm::ArrayRef(getTemplateArgs(), getNumTemplateArgs());
} }
/// Returns the nth template argument. /// Returns the nth template argument.
Context not available.

clang/include/clang/AST/Expr.h

Context not available.
/// Compute and set dependence bits. /// Compute and set dependence bits.
void computeDependence() { void computeDependence() {
setDependence(clang::computeDependence( setDependence(clang::computeDependence(
this, llvm::makeArrayRef( this, llvm::ArrayRef(
reinterpret_cast<Expr **>(getTrailingStmts() + PREARGS_START), reinterpret_cast<Expr **>(getTrailingStmts() + PREARGS_START),
getNumPreArgs()))); getNumPreArgs())));
} }
Context not available.
/// interface. This provides efficient reverse iteration of the /// interface. This provides efficient reverse iteration of the
/// subexpressions. This is currently used for CFG construction. /// subexpressions. This is currently used for CFG construction.
ArrayRef<Stmt *> getRawSubExprs() { ArrayRef<Stmt *> getRawSubExprs() {
return llvm::makeArrayRef(getTrailingStmts(), return llvm::ArrayRef(getTrailingStmts(),
PREARGS_START + getNumPreArgs() + getNumArgs()); PREARGS_START + getNumPreArgs() + getNumArgs());
} }
/// Get FPOptionsOverride from trailing storage. /// Get FPOptionsOverride from trailing storage.
Context not available.
return reinterpret_cast<Expr * const *>(InitExprs.data()); return reinterpret_cast<Expr * const *>(InitExprs.data());
} }
ArrayRef<Expr *> inits() { ArrayRef<Expr *> inits() { return llvm::ArrayRef(getInits(), getNumInits()); }
return llvm::makeArrayRef(getInits(), getNumInits());
}
ArrayRef<Expr *> inits() const { ArrayRef<Expr *> inits() const {
return llvm::makeArrayRef(getInits(), getNumInits()); return llvm::ArrayRef(getInits(), getNumInits());
} }
const Expr *getInit(unsigned Init) const { const Expr *getInit(unsigned Init) const {
Context not available.
return reinterpret_cast<Expr **>(getTrailingObjects<Stmt *>()); return reinterpret_cast<Expr **>(getTrailingObjects<Stmt *>());
} }
ArrayRef<Expr *> exprs() { ArrayRef<Expr *> exprs() { return llvm::ArrayRef(getExprs(), getNumExprs()); }
return llvm::makeArrayRef(getExprs(), getNumExprs());
}
SourceLocation getLParenLoc() const { return LParenLoc; } SourceLocation getLParenLoc() const { return LParenLoc; }
SourceLocation getRParenLoc() const { return RParenLoc; } SourceLocation getRParenLoc() const { return RParenLoc; }
Context not available.
ArrayRef<Expr *> subExpressions() { ArrayRef<Expr *> subExpressions() {
auto *B = getTrailingObjects<Expr *>(); auto *B = getTrailingObjects<Expr *>();
return llvm::makeArrayRef(B, B + NumExprs); return llvm::ArrayRef(B, B + NumExprs);
} }
ArrayRef<const Expr *> subExpressions() const { ArrayRef<const Expr *> subExpressions() const {
Context not available.

clang/include/clang/AST/ExprCXX.h

Context not available.
/// Retrieve the argument types. /// Retrieve the argument types.
ArrayRef<TypeSourceInfo *> getArgs() const { ArrayRef<TypeSourceInfo *> getArgs() const {
return llvm::makeArrayRef(getTrailingObjects<TypeSourceInfo *>(), return llvm::ArrayRef(getTrailingObjects<TypeSourceInfo *>(), getNumArgs());
getNumArgs());
} }
SourceLocation getBeginLoc() const LLVM_READONLY { return Loc; } SourceLocation getBeginLoc() const LLVM_READONLY { return Loc; }
Context not available.
ArrayRef<CleanupObject> objects); ArrayRef<CleanupObject> objects);
ArrayRef<CleanupObject> getObjects() const { ArrayRef<CleanupObject> getObjects() const {
return llvm::makeArrayRef(getTrailingObjects<CleanupObject>(), return llvm::ArrayRef(getTrailingObjects<CleanupObject>(), getNumObjects());
getNumObjects());
} }
unsigned getNumObjects() const { return ExprWithCleanupsBits.NumObjects; } unsigned getNumObjects() const { return ExprWithCleanupsBits.NumObjects; }
Context not available.
ArrayRef<TemplateArgument> getPartialArguments() const { ArrayRef<TemplateArgument> getPartialArguments() const {
assert(isPartiallySubstituted()); assert(isPartiallySubstituted());
const auto *Args = getTrailingObjects<TemplateArgument>(); const auto *Args = getTrailingObjects<TemplateArgument>();
return llvm::makeArrayRef(Args, Args + Length); return llvm::ArrayRef(Args, Args + Length);
} }
SourceLocation getBeginLoc() const LLVM_READONLY { return OperatorLoc; } SourceLocation getBeginLoc() const LLVM_READONLY { return OperatorLoc; }
Context not available.
void updateDependence() { setDependence(computeDependence(this)); } void updateDependence() { setDependence(computeDependence(this)); }
ArrayRef<Expr *> getInitExprs() { ArrayRef<Expr *> getInitExprs() {
return llvm::makeArrayRef(getTrailingObjects<Expr *>(), NumExprs); return llvm::ArrayRef(getTrailingObjects<Expr *>(), NumExprs);
} }
const ArrayRef<Expr *> getInitExprs() const { const ArrayRef<Expr *> getInitExprs() const {
return llvm::makeArrayRef(getTrailingObjects<Expr *>(), NumExprs); return llvm::ArrayRef(getTrailingObjects<Expr *>(), NumExprs);
} }
ArrayRef<Expr *> getUserSpecifiedInitExprs() { ArrayRef<Expr *> getUserSpecifiedInitExprs() {
return llvm::makeArrayRef(getTrailingObjects<Expr *>(), return llvm::ArrayRef(getTrailingObjects<Expr *>(), NumUserSpecifiedExprs);
NumUserSpecifiedExprs);
} }
const ArrayRef<Expr *> getUserSpecifiedInitExprs() const { const ArrayRef<Expr *> getUserSpecifiedInitExprs() const {
return llvm::makeArrayRef(getTrailingObjects<Expr *>(), return llvm::ArrayRef(getTrailingObjects<Expr *>(), NumUserSpecifiedExprs);
NumUserSpecifiedExprs);
} }
SourceLocation getBeginLoc() const LLVM_READONLY { return LParenLoc; } SourceLocation getBeginLoc() const LLVM_READONLY { return LParenLoc; }
Context not available.

clang/include/clang/AST/ExprObjC.h

Context not available.
SourceLocation getSelectorLoc(unsigned Index) const { SourceLocation getSelectorLoc(unsigned Index) const {
assert(Index < getNumSelectorLocs() && "Index out of range!"); assert(Index < getNumSelectorLocs() && "Index out of range!");
if (hasStandardSelLocs()) if (hasStandardSelLocs())
return getStandardSelectorLoc(Index, getSelector(), return getStandardSelectorLoc(
getSelLocsKind() == SelLoc_StandardWithSpace, Index, getSelector(), getSelLocsKind() == SelLoc_StandardWithSpace,
llvm::makeArrayRef(const_cast<Expr**>(getArgs()), llvm::ArrayRef(const_cast<Expr **>(getArgs()), getNumArgs()),
getNumArgs()), RBracLoc);
RBracLoc);
return getStoredSelLocs()[Index]; return getStoredSelLocs()[Index];
} }
Context not available.

clang/include/clang/AST/ExprOpenMP.h

Context not available.
/// Fetches the dimensions for array shaping expression. /// Fetches the dimensions for array shaping expression.
ArrayRef<Expr *> getDimensions() const { ArrayRef<Expr *> getDimensions() const {
return llvm::makeArrayRef(getTrailingObjects<Expr *>(), NumDims); return llvm::ArrayRef(getTrailingObjects<Expr *>(), NumDims);
} }
/// Fetches source ranges for the brackets os the array shaping expression. /// Fetches source ranges for the brackets os the array shaping expression.
ArrayRef<SourceRange> getBracketsRanges() const { ArrayRef<SourceRange> getBracketsRanges() const {
return llvm::makeArrayRef(getTrailingObjects<SourceRange>(), NumDims); return llvm::ArrayRef(getTrailingObjects<SourceRange>(), NumDims);
} }
/// Fetches base expression of array shaping expression. /// Fetches base expression of array shaping expression.
Context not available.

clang/include/clang/AST/OpenMPClause.h

Context not available.
/// Fetches list of all variables in the clause. /// Fetches list of all variables in the clause.
ArrayRef<const Expr *> getVarRefs() const { ArrayRef<const Expr *> getVarRefs() const {
return llvm::makeArrayRef( return llvm::ArrayRef(
static_cast<const T *>(this)->template getTrailingObjects<Expr *>(), static_cast<const T *>(this)->template getTrailingObjects<Expr *>(),
NumVars); NumVars);
} }
Context not available.
return MutableArrayRef<Expr *>(varlist_end(), varlist_size()); return MutableArrayRef<Expr *>(varlist_end(), varlist_size());
} }
ArrayRef<const Expr *> getPrivateCopies() const { ArrayRef<const Expr *> getPrivateCopies() const {
return llvm::makeArrayRef(varlist_end(), varlist_size()); return llvm::ArrayRef(varlist_end(), varlist_size());
} }
public: public:
Context not available.
return MutableArrayRef<Expr *>(varlist_end(), varlist_size()); return MutableArrayRef<Expr *>(varlist_end(), varlist_size());
} }
ArrayRef<const Expr *> getPrivateCopies() const { ArrayRef<const Expr *> getPrivateCopies() const {
return llvm::makeArrayRef(varlist_end(), varlist_size()); return llvm::ArrayRef(varlist_end(), varlist_size());
} }
/// Sets the list of references to initializer variables for new /// Sets the list of references to initializer variables for new
Context not available.
return MutableArrayRef<Expr *>(getPrivateCopies().end(), varlist_size()); return MutableArrayRef<Expr *>(getPrivateCopies().end(), varlist_size());
} }
ArrayRef<const Expr *> getInits() const { ArrayRef<const Expr *> getInits() const {
return llvm::makeArrayRef(getPrivateCopies().end(), varlist_size()); return llvm::ArrayRef(getPrivateCopies().end(), varlist_size());
} }
public: public:
Context not available.
return MutableArrayRef<Expr *>(varlist_end(), varlist_size()); return MutableArrayRef<Expr *>(varlist_end(), varlist_size());
} }
ArrayRef<const Expr *> getPrivateCopies() const { ArrayRef<const Expr *> getPrivateCopies() const {
return llvm::makeArrayRef(varlist_end(), varlist_size()); return llvm::ArrayRef(varlist_end(), varlist_size());
} }
/// Set list of helper expressions, required for proper codegen of the /// Set list of helper expressions, required for proper codegen of the
Context not available.
return MutableArrayRef<Expr *>(getPrivateCopies().end(), varlist_size()); return MutableArrayRef<Expr *>(getPrivateCopies().end(), varlist_size());
} }
ArrayRef<const Expr *> getSourceExprs() const { ArrayRef<const Expr *> getSourceExprs() const {
return llvm::makeArrayRef(getPrivateCopies().end(), varlist_size()); return llvm::ArrayRef(getPrivateCopies().end(), varlist_size());
} }
/// Set list of helper expressions, required for proper codegen of the /// Set list of helper expressions, required for proper codegen of the
Context not available.
return MutableArrayRef<Expr *>(getSourceExprs().end(), varlist_size()); return MutableArrayRef<Expr *>(getSourceExprs().end(), varlist_size());
} }
ArrayRef<const Expr *> getDestinationExprs() const { ArrayRef<const Expr *> getDestinationExprs() const {
return llvm::makeArrayRef(getSourceExprs().end(), varlist_size()); return llvm::ArrayRef(getSourceExprs().end(), varlist_size());
} }
/// Set list of helper assignment expressions, required for proper /// Set list of helper assignment expressions, required for proper
Context not available.
return MutableArrayRef<Expr *>(getDestinationExprs().end(), varlist_size()); return MutableArrayRef<Expr *>(getDestinationExprs().end(), varlist_size());
} }
ArrayRef<const Expr *> getAssignmentOps() const { ArrayRef<const Expr *> getAssignmentOps() const {
return llvm::makeArrayRef(getDestinationExprs().end(), varlist_size()); return llvm::ArrayRef(getDestinationExprs().end(), varlist_size());
} }
/// Sets lastprivate kind. /// Sets lastprivate kind.
Context not available.
return MutableArrayRef<Expr *>(varlist_end(), varlist_size()); return MutableArrayRef<Expr *>(varlist_end(), varlist_size());
} }
ArrayRef<const Expr *> getPrivates() const { ArrayRef<const Expr *> getPrivates() const {
return llvm::makeArrayRef(varlist_end(), varlist_size()); return llvm::ArrayRef(varlist_end(), varlist_size());
} }
/// Set list of helper expressions, required for proper codegen of the /// Set list of helper expressions, required for proper codegen of the
Context not available.
return MutableArrayRef<Expr *>(getPrivates().end(), varlist_size()); return MutableArrayRef<Expr *>(getPrivates().end(), varlist_size());
} }
ArrayRef<const Expr *> getLHSExprs() const { ArrayRef<const Expr *> getLHSExprs() const {
return llvm::makeArrayRef(getPrivates().end(), varlist_size()); return llvm::ArrayRef(getPrivates().end(), varlist_size());
} }
/// Set list of helper expressions, required for proper codegen of the /// Set list of helper expressions, required for proper codegen of the
Context not available.
return MutableArrayRef<Expr *>(getLHSExprs().end(), varlist_size()); return MutableArrayRef<Expr *>(getLHSExprs().end(), varlist_size());
} }
ArrayRef<const Expr *> getRHSExprs() const { ArrayRef<const Expr *> getRHSExprs() const {
return llvm::makeArrayRef(getLHSExprs().end(), varlist_size()); return llvm::ArrayRef(getLHSExprs().end(), varlist_size());
} }
/// Set list of helper reduction expressions, required for proper /// Set list of helper reduction expressions, required for proper
Context not available.
return MutableArrayRef<Expr *>(getRHSExprs().end(), varlist_size()); return MutableArrayRef<Expr *>(getRHSExprs().end(), varlist_size());
} }
ArrayRef<const Expr *> getReductionOps() const { ArrayRef<const Expr *> getReductionOps() const {
return llvm::makeArrayRef(getRHSExprs().end(), varlist_size()); return llvm::ArrayRef(getRHSExprs().end(), varlist_size());
} }
/// Set list of helper copy operations for inscan reductions. /// Set list of helper copy operations for inscan reductions.
Context not available.
return MutableArrayRef<Expr *>(getReductionOps().end(), varlist_size()); return MutableArrayRef<Expr *>(getReductionOps().end(), varlist_size());
} }
ArrayRef<const Expr *> getInscanCopyOps() const { ArrayRef<const Expr *> getInscanCopyOps() const {
return llvm::makeArrayRef(getReductionOps().end(), varlist_size()); return llvm::ArrayRef(getReductionOps().end(), varlist_size());
} }
/// Set list of helper temp vars for inscan copy array operations. /// Set list of helper temp vars for inscan copy array operations.
Context not available.
return MutableArrayRef<Expr *>(getInscanCopyOps().end(), varlist_size()); return MutableArrayRef<Expr *>(getInscanCopyOps().end(), varlist_size());
} }
ArrayRef<const Expr *> getInscanCopyArrayTemps() const { ArrayRef<const Expr *> getInscanCopyArrayTemps() const {
return llvm::makeArrayRef(getInscanCopyOps().end(), varlist_size()); return llvm::ArrayRef(getInscanCopyOps().end(), varlist_size());
} }
/// Set list of helper temp elements vars for inscan copy array operations. /// Set list of helper temp elements vars for inscan copy array operations.
Context not available.
varlist_size()); varlist_size());
} }
ArrayRef<const Expr *> getInscanCopyArrayElems() const { ArrayRef<const Expr *> getInscanCopyArrayElems() const {
return llvm::makeArrayRef(getInscanCopyArrayTemps().end(), varlist_size()); return llvm::ArrayRef(getInscanCopyArrayTemps().end(), varlist_size());
} }
public: public:
Context not available.
return MutableArrayRef<Expr *>(varlist_end(), varlist_size()); return MutableArrayRef<Expr *>(varlist_end(), varlist_size());
} }
ArrayRef<const Expr *> getPrivates() const { ArrayRef<const Expr *> getPrivates() const {
return llvm::makeArrayRef(varlist_end(), varlist_size()); return llvm::ArrayRef(varlist_end(), varlist_size());
} }
/// Set list of helper expressions, required for proper codegen of the clause. /// Set list of helper expressions, required for proper codegen of the clause.
Context not available.
return MutableArrayRef<Expr *>(getPrivates().end(), varlist_size()); return MutableArrayRef<Expr *>(getPrivates().end(), varlist_size());
} }
ArrayRef<const Expr *> getLHSExprs() const { ArrayRef<const Expr *> getLHSExprs() const {
return llvm::makeArrayRef(getPrivates().end(), varlist_size()); return llvm::ArrayRef(getPrivates().end(), varlist_size());
} }
/// Set list of helper expressions, required for proper codegen of the clause. /// Set list of helper expressions, required for proper codegen of the clause.
Context not available.
return MutableArrayRef<Expr *>(getLHSExprs().end(), varlist_size()); return MutableArrayRef<Expr *>(getLHSExprs().end(), varlist_size());
} }
ArrayRef<const Expr *> getRHSExprs() const { ArrayRef<const Expr *> getRHSExprs() const {
return llvm::makeArrayRef(getLHSExprs().end(), varlist_size()); return llvm::ArrayRef(getLHSExprs().end(), varlist_size());
} }
/// Set list of helper reduction expressions, required for proper /// Set list of helper reduction expressions, required for proper
Context not available.
return MutableArrayRef<Expr *>(getRHSExprs().end(), varlist_size()); return MutableArrayRef<Expr *>(getRHSExprs().end(), varlist_size());
} }
ArrayRef<const Expr *> getReductionOps() const { ArrayRef<const Expr *> getReductionOps() const {
return llvm::makeArrayRef(getRHSExprs().end(), varlist_size()); return llvm::ArrayRef(getRHSExprs().end(), varlist_size());
} }
public: public:
Context not available.
return MutableArrayRef<Expr *>(varlist_end(), varlist_size()); return MutableArrayRef<Expr *>(varlist_end(), varlist_size());
} }
ArrayRef<const Expr *> getPrivates() const { ArrayRef<const Expr *> getPrivates() const {
return llvm::makeArrayRef(varlist_end(), varlist_size()); return llvm::ArrayRef(varlist_end(), varlist_size());
} }
/// Set list of helper expressions, required for proper codegen of the clause. /// Set list of helper expressions, required for proper codegen of the clause.
Context not available.
return MutableArrayRef<Expr *>(getPrivates().end(), varlist_size()); return MutableArrayRef<Expr *>(getPrivates().end(), varlist_size());
} }
ArrayRef<const Expr *> getLHSExprs() const { ArrayRef<const Expr *> getLHSExprs() const {
return llvm::makeArrayRef(getPrivates().end(), varlist_size()); return llvm::ArrayRef(getPrivates().end(), varlist_size());
} }
/// Set list of helper expressions, required for proper codegen of the clause. /// Set list of helper expressions, required for proper codegen of the clause.
Context not available.
return MutableArrayRef<Expr *>(getLHSExprs().end(), varlist_size()); return MutableArrayRef<Expr *>(getLHSExprs().end(), varlist_size());
} }
ArrayRef<const Expr *> getRHSExprs() const { ArrayRef<const Expr *> getRHSExprs() const {
return llvm::makeArrayRef(getLHSExprs().end(), varlist_size()); return llvm::ArrayRef(getLHSExprs().end(), varlist_size());
} }
/// Set list of helper reduction expressions, required for proper /// Set list of helper reduction expressions, required for proper
Context not available.
return MutableArrayRef<Expr *>(getRHSExprs().end(), varlist_size()); return MutableArrayRef<Expr *>(getRHSExprs().end(), varlist_size());
} }
ArrayRef<const Expr *> getReductionOps() const { ArrayRef<const Expr *> getReductionOps() const {
return llvm::makeArrayRef(getRHSExprs().end(), varlist_size()); return llvm::ArrayRef(getRHSExprs().end(), varlist_size());
} }
/// Set list of helper reduction taskgroup descriptors. /// Set list of helper reduction taskgroup descriptors.
Context not available.
return MutableArrayRef<Expr *>(getReductionOps().end(), varlist_size()); return MutableArrayRef<Expr *>(getReductionOps().end(), varlist_size());
} }
ArrayRef<const Expr *> getTaskgroupDescriptors() const { ArrayRef<const Expr *> getTaskgroupDescriptors() const {
return llvm::makeArrayRef(getReductionOps().end(), varlist_size()); return llvm::ArrayRef(getReductionOps().end(), varlist_size());
} }
public: public:
Context not available.
return MutableArrayRef<Expr *>(varlist_end(), varlist_size()); return MutableArrayRef<Expr *>(varlist_end(), varlist_size());
} }
ArrayRef<const Expr *> getPrivates() const { ArrayRef<const Expr *> getPrivates() const {
return llvm::makeArrayRef(varlist_end(), varlist_size()); return llvm::ArrayRef(varlist_end(), varlist_size());
} }
MutableArrayRef<Expr *> getInits() { MutableArrayRef<Expr *> getInits() {
return MutableArrayRef<Expr *>(getPrivates().end(), varlist_size()); return MutableArrayRef<Expr *>(getPrivates().end(), varlist_size());
} }
ArrayRef<const Expr *> getInits() const { ArrayRef<const Expr *> getInits() const {
return llvm::makeArrayRef(getPrivates().end(), varlist_size()); return llvm::ArrayRef(getPrivates().end(), varlist_size());
} }
/// Sets the list of update expressions for linear variables. /// Sets the list of update expressions for linear variables.
Context not available.
return MutableArrayRef<Expr *>(getInits().end(), varlist_size()); return MutableArrayRef<Expr *>(getInits().end(), varlist_size());
} }
ArrayRef<const Expr *> getUpdates() const { ArrayRef<const Expr *> getUpdates() const {
return llvm::makeArrayRef(getInits().end(), varlist_size()); return llvm::ArrayRef(getInits().end(), varlist_size());
} }
/// Sets the list of final update expressions for linear variables. /// Sets the list of final update expressions for linear variables.
Context not available.
return MutableArrayRef<Expr *>(getUpdates().end(), varlist_size()); return MutableArrayRef<Expr *>(getUpdates().end(), varlist_size());
} }
ArrayRef<const Expr *> getFinals() const { ArrayRef<const Expr *> getFinals() const {
return llvm::makeArrayRef(getUpdates().end(), varlist_size()); return llvm::ArrayRef(getUpdates().end(), varlist_size());
} }
/// Gets the list of used expressions for linear variables. /// Gets the list of used expressions for linear variables.
Context not available.
return MutableArrayRef<Expr *>(getFinals().end() + 2, varlist_size() + 1); return MutableArrayRef<Expr *>(getFinals().end() + 2, varlist_size() + 1);
} }
ArrayRef<const Expr *> getUsedExprs() const { ArrayRef<const Expr *> getUsedExprs() const {
return llvm::makeArrayRef(getFinals().end() + 2, varlist_size() + 1); return llvm::ArrayRef(getFinals().end() + 2, varlist_size() + 1);
} }
/// Sets the list of the copies of original linear variables. /// Sets the list of the copies of original linear variables.
Context not available.
return MutableArrayRef<Expr *>(varlist_end(), varlist_size()); return MutableArrayRef<Expr *>(varlist_end(), varlist_size());
} }
ArrayRef<const Expr *> getSourceExprs() const { ArrayRef<const Expr *> getSourceExprs() const {
return llvm::makeArrayRef(varlist_end(), varlist_size()); return llvm::ArrayRef(varlist_end(), varlist_size());
} }
/// Set list of helper expressions, required for proper codegen of the /// Set list of helper expressions, required for proper codegen of the
Context not available.
return MutableArrayRef<Expr *>(getSourceExprs().end(), varlist_size()); return MutableArrayRef<Expr *>(getSourceExprs().end(), varlist_size());
} }
ArrayRef<const Expr *> getDestinationExprs() const { ArrayRef<const Expr *> getDestinationExprs() const {
return llvm::makeArrayRef(getSourceExprs().end(), varlist_size()); return llvm::ArrayRef(getSourceExprs().end(), varlist_size());
} }
/// Set list of helper assignment expressions, required for proper /// Set list of helper assignment expressions, required for proper
Context not available.
return MutableArrayRef<Expr *>(getDestinationExprs().end(), varlist_size()); return MutableArrayRef<Expr *>(getDestinationExprs().end(), varlist_size());
} }
ArrayRef<const Expr *> getAssignmentOps() const { ArrayRef<const Expr *> getAssignmentOps() const {
return llvm::makeArrayRef(getDestinationExprs().end(), varlist_size()); return llvm::ArrayRef(getDestinationExprs().end(), varlist_size());
} }
public: public:
Context not available.
return MutableArrayRef<Expr *>(varlist_end(), varlist_size()); return MutableArrayRef<Expr *>(varlist_end(), varlist_size());
} }
ArrayRef<const Expr *> getSourceExprs() const { ArrayRef<const Expr *> getSourceExprs() const {
return llvm::makeArrayRef(varlist_end(), varlist_size()); return llvm::ArrayRef(varlist_end(), varlist_size());
} }
/// Set list of helper expressions, required for proper codegen of the /// Set list of helper expressions, required for proper codegen of the
Context not available.
return MutableArrayRef<Expr *>(getSourceExprs().end(), varlist_size()); return MutableArrayRef<Expr *>(getSourceExprs().end(), varlist_size());
} }
ArrayRef<const Expr *> getDestinationExprs() const { ArrayRef<const Expr *> getDestinationExprs() const {
return llvm::makeArrayRef(getSourceExprs().end(), varlist_size()); return llvm::ArrayRef(getSourceExprs().end(), varlist_size());
} }
/// Set list of helper assignment expressions, required for proper /// Set list of helper assignment expressions, required for proper
Context not available.
return MutableArrayRef<Expr *>(getDestinationExprs().end(), varlist_size()); return MutableArrayRef<Expr *>(getDestinationExprs().end(), varlist_size());
} }
ArrayRef<const Expr *> getAssignmentOps() const { ArrayRef<const Expr *> getAssignmentOps() const {
return llvm::makeArrayRef(getDestinationExprs().end(), varlist_size()); return llvm::ArrayRef(getDestinationExprs().end(), varlist_size());
} }
public: public:
Context not available.
ArrayRef<Expr *> getUDMapperRefs() const { ArrayRef<Expr *> getUDMapperRefs() const {
assert(SupportsMapper && assert(SupportsMapper &&
"Must be a clause that is possible to have user-defined mappers"); "Must be a clause that is possible to have user-defined mappers");
return llvm::makeArrayRef<Expr *>( return llvm::ArrayRef<Expr *>(
static_cast<const T *>(this)->template getTrailingObjects<Expr *>() + static_cast<const T *>(this)->template getTrailingObjects<Expr *>() +
OMPVarListClause<T>::varlist_size(), OMPVarListClause<T>::varlist_size(),
OMPVarListClause<T>::varlist_size()); OMPVarListClause<T>::varlist_size());
Context not available.
/// Fetches ArrayRef of map-type-modifiers. /// Fetches ArrayRef of map-type-modifiers.
ArrayRef<OpenMPMapModifierKind> getMapTypeModifiers() const LLVM_READONLY { ArrayRef<OpenMPMapModifierKind> getMapTypeModifiers() const LLVM_READONLY {
return llvm::makeArrayRef(MapTypeModifiers); return llvm::ArrayRef(MapTypeModifiers);
} }
/// Fetches ArrayRef of location of map-type-modifiers. /// Fetches ArrayRef of location of map-type-modifiers.
ArrayRef<SourceLocation> getMapTypeModifiersLoc() const LLVM_READONLY { ArrayRef<SourceLocation> getMapTypeModifiersLoc() const LLVM_READONLY {
return llvm::makeArrayRef(MapTypeModifiersLoc); return llvm::ArrayRef(MapTypeModifiersLoc);
} }
/// Fetches location of clause mapping kind. /// Fetches location of clause mapping kind.
Context not available.
/// Fetches ArrayRef of motion-modifiers. /// Fetches ArrayRef of motion-modifiers.
ArrayRef<OpenMPMotionModifierKind> getMotionModifiers() const LLVM_READONLY { ArrayRef<OpenMPMotionModifierKind> getMotionModifiers() const LLVM_READONLY {
return llvm::makeArrayRef(MotionModifiers); return llvm::ArrayRef(MotionModifiers);
} }
/// Fetches ArrayRef of location of motion-modifiers. /// Fetches ArrayRef of location of motion-modifiers.
ArrayRef<SourceLocation> getMotionModifiersLoc() const LLVM_READONLY { ArrayRef<SourceLocation> getMotionModifiersLoc() const LLVM_READONLY {
return llvm::makeArrayRef(MotionModifiersLoc); return llvm::ArrayRef(MotionModifiersLoc);
} }
/// Get colon location. /// Get colon location.
Context not available.
/// Fetches ArrayRef of motion-modifiers. /// Fetches ArrayRef of motion-modifiers.
ArrayRef<OpenMPMotionModifierKind> getMotionModifiers() const LLVM_READONLY { ArrayRef<OpenMPMotionModifierKind> getMotionModifiers() const LLVM_READONLY {
return llvm::makeArrayRef(MotionModifiers); return llvm::ArrayRef(MotionModifiers);
} }
/// Fetches ArrayRef of location of motion-modifiers. /// Fetches ArrayRef of location of motion-modifiers.
ArrayRef<SourceLocation> getMotionModifiersLoc() const LLVM_READONLY { ArrayRef<SourceLocation> getMotionModifiersLoc() const LLVM_READONLY {
return llvm::makeArrayRef(MotionModifiersLoc); return llvm::ArrayRef(MotionModifiersLoc);
} }
/// Get colon location. /// Get colon location.
Context not available.
return MutableArrayRef<Expr *>(varlist_end(), varlist_size()); return MutableArrayRef<Expr *>(varlist_end(), varlist_size());
} }
ArrayRef<const Expr *> getPrivateCopies() const { ArrayRef<const Expr *> getPrivateCopies() const {
return llvm::makeArrayRef(varlist_end(), varlist_size()); return llvm::ArrayRef(varlist_end(), varlist_size());
} }
/// Sets the list of references to initializer variables for new private /// Sets the list of references to initializer variables for new private
Context not available.
return MutableArrayRef<Expr *>(getPrivateCopies().end(), varlist_size()); return MutableArrayRef<Expr *>(getPrivateCopies().end(), varlist_size());
} }
ArrayRef<const Expr *> getInits() const { ArrayRef<const Expr *> getInits() const {
return llvm::makeArrayRef(getPrivateCopies().end(), varlist_size()); return llvm::ArrayRef(getPrivateCopies().end(), varlist_size());
} }
public: public:
Context not available.
return MutableArrayRef<Expr *>(varlist_end(), varlist_size()); return MutableArrayRef<Expr *>(varlist_end(), varlist_size());
} }
ArrayRef<const Expr *> getPrivateRefs() const { ArrayRef<const Expr *> getPrivateRefs() const {
return llvm::makeArrayRef(varlist_end(), varlist_size()); return llvm::ArrayRef(varlist_end(), varlist_size());
} }
public: public:
Context not available.

clang/include/clang/AST/PropertiesBase.td

Context not available.
TemplateArgument *ctxElements = new (ctx) TemplateArgument[elements.size()]; TemplateArgument *ctxElements = new (ctx) TemplateArgument[elements.size()];
for (size_t i = 0, e = elements.size(); i != e; ++i) for (size_t i = 0, e = elements.size(); i != e; ++i)
ctxElements[i] = elements[i]; ctxElements[i] = elements[i];
return TemplateArgument(llvm::makeArrayRef(ctxElements, elements.size())); return TemplateArgument(llvm::ArrayRef(ctxElements, elements.size()));
}]>; }]>;
} }
Context not available.

clang/include/clang/AST/Stmt.h

Context not available.
SourceLocation getAttrLoc() const { return AttributedStmtBits.AttrLoc; } SourceLocation getAttrLoc() const { return AttributedStmtBits.AttrLoc; }
ArrayRef<const Attr *> getAttrs() const { ArrayRef<const Attr *> getAttrs() const {
return llvm::makeArrayRef(getAttrArrayPtr(), AttributedStmtBits.NumAttrs); return llvm::ArrayRef(getAttrArrayPtr(), AttributedStmtBits.NumAttrs);
} }
Stmt *getSubStmt() { return SubStmt; } Stmt *getSubStmt() { return SubStmt; }
Context not available.
//===--- Other ---===// //===--- Other ---===//
ArrayRef<StringRef> getAllConstraints() const { ArrayRef<StringRef> getAllConstraints() const {
return llvm::makeArrayRef(Constraints, NumInputs + NumOutputs); return llvm::ArrayRef(Constraints, NumInputs + NumOutputs);
} }
ArrayRef<StringRef> getClobbers() const { ArrayRef<StringRef> getClobbers() const {
return llvm::makeArrayRef(Clobbers, NumClobbers); return llvm::ArrayRef(Clobbers, NumClobbers);
} }
ArrayRef<Expr*> getAllExprs() const { ArrayRef<Expr*> getAllExprs() const {
return llvm::makeArrayRef(reinterpret_cast<Expr**>(Exprs), return llvm::ArrayRef(reinterpret_cast<Expr **>(Exprs),
NumInputs + NumOutputs); NumInputs + NumOutputs);
} }
StringRef getClobber(unsigned i) const { return getClobbers()[i]; } StringRef getClobber(unsigned i) const { return getClobbers()[i]; }
Context not available.

clang/include/clang/AST/StmtOpenMP.h

Context not available.
static llvm::iterator_range<used_clauses_child_iterator> static llvm::iterator_range<used_clauses_child_iterator>
used_clauses_children(ArrayRef<OMPClause *> Clauses) { used_clauses_children(ArrayRef<OMPClause *> Clauses) {
return {used_clauses_child_iterator(Clauses), return {
used_clauses_child_iterator(llvm::makeArrayRef(Clauses.end(), 0))}; used_clauses_child_iterator(Clauses),
used_clauses_child_iterator(llvm::ArrayRef(Clauses.end(), (size_t)0))};
} }
/// Iterates over a filtered subrange of clauses applied to a /// Iterates over a filtered subrange of clauses applied to a
Context not available.
getClausesOfKind(ArrayRef<OMPClause *> Clauses) { getClausesOfKind(ArrayRef<OMPClause *> Clauses) {
return {specific_clause_iterator<SpecificClause>(Clauses), return {specific_clause_iterator<SpecificClause>(Clauses),
specific_clause_iterator<SpecificClause>( specific_clause_iterator<SpecificClause>(
llvm::makeArrayRef(Clauses.end(), 0))}; llvm::ArrayRef(Clauses.end(), (size_t)0))};
} }
template <typename SpecificClause> template <typename SpecificClause>
Context not available.

clang/include/clang/AST/TemplateBase.h

Context not available.
return APSInt(APInt(Integer.BitWidth, Integer.VAL), Integer.IsUnsigned); return APSInt(APInt(Integer.BitWidth, Integer.VAL), Integer.IsUnsigned);
unsigned NumWords = APInt::getNumWords(Integer.BitWidth); unsigned NumWords = APInt::getNumWords(Integer.BitWidth);
return APSInt(APInt(Integer.BitWidth, makeArrayRef(Integer.pVal, NumWords)), return APSInt(APInt(Integer.BitWidth, ArrayRef(Integer.pVal, NumWords)),
Integer.IsUnsigned); Integer.IsUnsigned);
} }
Context not available.
/// Iterator range referencing all of the elements of a template /// Iterator range referencing all of the elements of a template
/// argument pack. /// argument pack.
ArrayRef<TemplateArgument> pack_elements() const { ArrayRef<TemplateArgument> pack_elements() const {
return llvm::makeArrayRef(pack_begin(), pack_end()); return llvm::ArrayRef(pack_begin(), pack_end());
} }
/// The number of template arguments in the given template argument /// The number of template arguments in the given template argument
Context not available.
/// Return the array of arguments in this template argument pack. /// Return the array of arguments in this template argument pack.
ArrayRef<TemplateArgument> getPackAsArray() const { ArrayRef<TemplateArgument> getPackAsArray() const {
assert(getKind() == Pack); assert(getKind() == Pack);
return llvm::makeArrayRef(Args.Args, Args.NumArgs); return llvm::ArrayRef(Args.Args, Args.NumArgs);
} }
/// Determines whether two template arguments are superficially the /// Determines whether two template arguments are superficially the
Context not available.
unsigned getNumTemplateArgs() const { return NumTemplateArgs; } unsigned getNumTemplateArgs() const { return NumTemplateArgs; }
llvm::ArrayRef<TemplateArgumentLoc> arguments() const { llvm::ArrayRef<TemplateArgumentLoc> arguments() const {
return llvm::makeArrayRef(getTemplateArgs(), getNumTemplateArgs()); return llvm::ArrayRef(getTemplateArgs(), getNumTemplateArgs());
} }
const TemplateArgumentLoc &operator[](unsigned I) const { const TemplateArgumentLoc &operator[](unsigned I) const {
Context not available.

clang/include/clang/AST/TemplateName.h

Context not available.
iterator end() const { return getStorage() + Bits.Data; } iterator end() const { return getStorage() + Bits.Data; }
llvm::ArrayRef<NamedDecl*> decls() const { llvm::ArrayRef<NamedDecl*> decls() const {
return llvm::makeArrayRef(begin(), end()); return llvm::ArrayRef(begin(), end());
} }
}; };
Context not available.

clang/include/clang/AST/Type.h

Context not available.
} }
ArrayRef<QualType> getParamTypes() const { ArrayRef<QualType> getParamTypes() const {
return llvm::makeArrayRef(param_type_begin(), param_type_end()); return llvm::ArrayRef(param_type_begin(), param_type_end());
} }
ExtProtoInfo getExtProtoInfo() const { ExtProtoInfo getExtProtoInfo() const {
Context not available.
using param_type_iterator = const QualType *; using param_type_iterator = const QualType *;
ArrayRef<QualType> param_types() const { ArrayRef<QualType> param_types() const {
return llvm::makeArrayRef(param_type_begin(), param_type_end()); return llvm::ArrayRef(param_type_begin(), param_type_end());
} }
param_type_iterator param_type_begin() const { param_type_iterator param_type_begin() const {
Context not available.
using exception_iterator = const QualType *; using exception_iterator = const QualType *;
ArrayRef<QualType> exceptions() const { ArrayRef<QualType> exceptions() const {
return llvm::makeArrayRef(exception_begin(), exception_end()); return llvm::ArrayRef(exception_begin(), exception_end());
} }
exception_iterator exception_begin() const { exception_iterator exception_begin() const {
Context not available.
/// Retrieve the type arguments of this object type as they were /// Retrieve the type arguments of this object type as they were
/// written. /// written.
ArrayRef<QualType> getTypeArgsAsWritten() const { ArrayRef<QualType> getTypeArgsAsWritten() const {
return llvm::makeArrayRef(getTypeArgStorage(), return llvm::ArrayRef(getTypeArgStorage(), ObjCObjectTypeBits.NumTypeArgs);
ObjCObjectTypeBits.NumTypeArgs);
} }
/// Whether this is a "__kindof" type as written. /// Whether this is a "__kindof" type as written.
Context not available.

clang/include/clang/AST/TypeLoc.h

Context not available.
} }
ArrayRef<SourceLocation> getProtocolLocs() const { ArrayRef<SourceLocation> getProtocolLocs() const {
return llvm::makeArrayRef(getProtocolLocArray(), getNumProtocols()); return llvm::ArrayRef(getProtocolLocArray(), getNumProtocols());
} }
void initializeLocal(ASTContext &Context, SourceLocation Loc); void initializeLocal(ASTContext &Context, SourceLocation Loc);
Context not available.
ArrayRef<SourceLocation> getProtocolLocs() const { ArrayRef<SourceLocation> getProtocolLocs() const {
return llvm::makeArrayRef(getProtocolLocArray(), getNumProtocols()); return llvm::ArrayRef(getProtocolLocArray(), getNumProtocols());
} }
bool hasBaseTypeAsWritten() const { bool hasBaseTypeAsWritten() const {
Context not available.
} }
ArrayRef<ParmVarDecl *> getParams() const { ArrayRef<ParmVarDecl *> getParams() const {
return llvm::makeArrayRef(getParmArray(), getNumParams()); return llvm::ArrayRef(getParmArray(), getNumParams());
} }
// ParmVarDecls* are stored after Info, one for each parameter. // ParmVarDecls* are stored after Info, one for each parameter.
Context not available.

clang/include/clang/Analysis/Analyses/ThreadSafetyTIL.h

Context not available.
BasicBlock *elseBlock() { return Branches[1]; } BasicBlock *elseBlock() { return Branches[1]; }
/// Return the list of basic blocks that this terminator can branch to. /// Return the list of basic blocks that this terminator can branch to.
ArrayRef<BasicBlock*> successors() { ArrayRef<BasicBlock *> successors() { return llvm::ArrayRef(Branches); }
return llvm::makeArrayRef(Branches);
}
template <class V> template <class V>
typename V::R_SExpr traverse(V &Vs, typename V::R_Ctx Ctx) { typename V::R_SExpr traverse(V &Vs, typename V::R_Ctx Ctx) {
Context not available.

clang/include/clang/Basic/Diagnostic.h

Context not available.
range_iterator range_end() const { return Ranges.end(); } range_iterator range_end() const { return Ranges.end(); }
unsigned range_size() const { return Ranges.size(); } unsigned range_size() const { return Ranges.size(); }
ArrayRef<CharSourceRange> getRanges() const { ArrayRef<CharSourceRange> getRanges() const { return llvm::ArrayRef(Ranges); }
return llvm::makeArrayRef(Ranges);
}
using fixit_iterator = std::vector<FixItHint>::const_iterator; using fixit_iterator = std::vector<FixItHint>::const_iterator;
Context not available.
fixit_iterator fixit_end() const { return FixIts.end(); } fixit_iterator fixit_end() const { return FixIts.end(); }
unsigned fixit_size() const { return FixIts.size(); } unsigned fixit_size() const { return FixIts.size(); }
ArrayRef<FixItHint> getFixIts() const { ArrayRef<FixItHint> getFixIts() const { return llvm::ArrayRef(FixIts); }
return llvm::makeArrayRef(FixIts);
}
}; };
// Simple debug printing of StoredDiagnostic. // Simple debug printing of StoredDiagnostic.
Context not available.

clang/include/clang/Basic/SyncScope.h

Context not available.
static const unsigned Scopes[] = { static const unsigned Scopes[] = {
static_cast<unsigned>(WorkGroup), static_cast<unsigned>(Device), static_cast<unsigned>(WorkGroup), static_cast<unsigned>(Device),
static_cast<unsigned>(AllSVMDevices), static_cast<unsigned>(SubGroup)}; static_cast<unsigned>(AllSVMDevices), static_cast<unsigned>(SubGroup)};
return llvm::makeArrayRef(Scopes); return llvm::ArrayRef(Scopes);
} }
unsigned getFallBackValue() const override { unsigned getFallBackValue() const override {
Context not available.
static_cast<unsigned>(SingleThread), static_cast<unsigned>(Wavefront), static_cast<unsigned>(SingleThread), static_cast<unsigned>(Wavefront),
static_cast<unsigned>(Workgroup), static_cast<unsigned>(Agent), static_cast<unsigned>(Workgroup), static_cast<unsigned>(Agent),
static_cast<unsigned>(System)}; static_cast<unsigned>(System)};
return llvm::makeArrayRef(Scopes); return llvm::ArrayRef(Scopes);
} }
unsigned getFallBackValue() const override { unsigned getFallBackValue() const override {
Context not available.

clang/include/clang/CodeGen/CGFunctionInfo.h

Context not available.
dyn_cast<llvm::StructType>(UnpaddedCoerceAndExpandType)) { dyn_cast<llvm::StructType>(UnpaddedCoerceAndExpandType)) {
return structTy->elements(); return structTy->elements();
} else { } else {
return llvm::makeArrayRef(&UnpaddedCoerceAndExpandType, 1); return llvm::ArrayRef(&UnpaddedCoerceAndExpandType, 1);
} }
} }
Context not available.
ArrayRef<ExtParameterInfo> getExtParameterInfos() const { ArrayRef<ExtParameterInfo> getExtParameterInfos() const {
if (!HasExtParameterInfos) return {}; if (!HasExtParameterInfos) return {};
return llvm::makeArrayRef(getExtParameterInfosBuffer(), NumArgs); return llvm::ArrayRef(getExtParameterInfosBuffer(), NumArgs);
} }
ExtParameterInfo getExtParameterInfo(unsigned argIndex) const { ExtParameterInfo getExtParameterInfo(unsigned argIndex) const {
assert(argIndex <= NumArgs); assert(argIndex <= NumArgs);
Context not available.

clang/include/clang/Lex/MacroInfo.h

Context not available.
} }
bool tokens_empty() const { return NumReplacementTokens == 0; } bool tokens_empty() const { return NumReplacementTokens == 0; }
ArrayRef<Token> tokens() const { ArrayRef<Token> tokens() const {
return llvm::makeArrayRef(ReplacementTokens, NumReplacementTokens); return llvm::ArrayRef(ReplacementTokens, NumReplacementTokens);
} }
llvm::MutableArrayRef<Token> llvm::MutableArrayRef<Token>
Context not available.
} }
ArrayRef<ModuleMacro *> overrides() const { ArrayRef<ModuleMacro *> overrides() const {
return llvm::makeArrayRef(overrides_begin(), overrides_end()); return llvm::ArrayRef(overrides_begin(), overrides_end());
} }
/// \} /// \}
Context not available.

clang/include/clang/Parse/Parser.h

Context not available.
/// returns false. /// returns false.
bool SkipUntil(tok::TokenKind T, bool SkipUntil(tok::TokenKind T,
SkipUntilFlags Flags = static_cast<SkipUntilFlags>(0)) { SkipUntilFlags Flags = static_cast<SkipUntilFlags>(0)) {
return SkipUntil(llvm::makeArrayRef(T), Flags); return SkipUntil(llvm::ArrayRef(T), Flags);
} }
bool SkipUntil(tok::TokenKind T1, tok::TokenKind T2, bool SkipUntil(tok::TokenKind T1, tok::TokenKind T2,
SkipUntilFlags Flags = static_cast<SkipUntilFlags>(0)) { SkipUntilFlags Flags = static_cast<SkipUntilFlags>(0)) {
Context not available.

clang/include/clang/Sema/DeclSpec.h

Context not available.
/// prototype. Typically these are tag declarations. /// prototype. Typically these are tag declarations.
ArrayRef<NamedDecl *> getDeclsInPrototype() const { ArrayRef<NamedDecl *> getDeclsInPrototype() const {
assert(ExceptionSpecType == EST_None); assert(ExceptionSpecType == EST_None);
return llvm::makeArrayRef(DeclsInPrototype, NumExceptionsOrDecls); return llvm::ArrayRef(DeclsInPrototype, NumExceptionsOrDecls);
} }
/// Determine whether this function declarator had a /// Determine whether this function declarator had a
Context not available.
} }
ArrayRef<Binding> bindings() const { ArrayRef<Binding> bindings() const {
return llvm::makeArrayRef(Bindings, NumBindings); return llvm::ArrayRef(Bindings, NumBindings);
} }
bool isSet() const { return LSquareLoc.isValid(); } bool isSet() const { return LSquareLoc.isValid(); }
Context not available.

clang/include/clang/Sema/DelayedDiagnostic.h

Context not available.
ArrayRef<SourceLocation> getAvailabilitySelectorLocs() const { ArrayRef<SourceLocation> getAvailabilitySelectorLocs() const {
assert(Kind == Availability && "Not an availability diagnostic."); assert(Kind == Availability && "Not an availability diagnostic.");
return llvm::makeArrayRef(AvailabilityData.SelectorLocs, return llvm::ArrayRef(AvailabilityData.SelectorLocs,
AvailabilityData.NumSelectorLocs); AvailabilityData.NumSelectorLocs);
} }
AvailabilityResult getAvailabilityResult() const { AvailabilityResult getAvailabilityResult() const {
Context not available.

clang/include/clang/Sema/Sema.h

Context not available.
unsigned FunctionScopesStart = 0; unsigned FunctionScopesStart = 0;
ArrayRef<sema::FunctionScopeInfo*> getFunctionScopes() const { ArrayRef<sema::FunctionScopeInfo*> getFunctionScopes() const {
return llvm::makeArrayRef(FunctionScopes.begin() + FunctionScopesStart, return llvm::ArrayRef(FunctionScopes.begin() + FunctionScopesStart,
FunctionScopes.end()); FunctionScopes.end());
} }
/// Stack containing information needed when in C++2a an 'auto' is encountered /// Stack containing information needed when in C++2a an 'auto' is encountered
Context not available.
unsigned InventedParameterInfosStart = 0; unsigned InventedParameterInfosStart = 0;
ArrayRef<InventedTemplateParameterInfo> getInventedParameterInfos() const { ArrayRef<InventedTemplateParameterInfo> getInventedParameterInfos() const {
return llvm::makeArrayRef(InventedParameterInfos.begin() + return llvm::ArrayRef(InventedParameterInfos.begin() +
InventedParameterInfosStart, InventedParameterInfosStart,
InventedParameterInfos.end()); InventedParameterInfos.end());
} }
typedef LazyVector<TypedefNameDecl *, ExternalSemaSource, typedef LazyVector<TypedefNameDecl *, ExternalSemaSource,
Context not available.

clang/include/clang/Serialization/ASTRecordReader.h

Context not available.
uint64_t readInt() { return Record[Idx++]; } uint64_t readInt() { return Record[Idx++]; }
ArrayRef<uint64_t> readIntArray(unsigned Len) { ArrayRef<uint64_t> readIntArray(unsigned Len) {
auto Array = llvm::makeArrayRef(Record).slice(Idx, Len); auto Array = llvm::ArrayRef(Record).slice(Idx, Len);
Idx += Len; Idx += Len;
return Array; return Array;
} }
Context not available.

clang/include/clang/Tooling/Refactoring/Rename/SymbolOccurrences.h

Context not available.
ArrayRef<SourceRange> getNameRanges() const { ArrayRef<SourceRange> getNameRanges() const {
if (MultipleRanges) if (MultipleRanges)
return llvm::makeArrayRef(MultipleRanges.get(), NumRanges); return llvm::ArrayRef(MultipleRanges.get(), NumRanges);
return SingleRange; return SingleRange;
} }
Context not available.

clang/include/clang/Tooling/Transformer/RewriteRule.h

Context not available.
template <typename MetadataT> template <typename MetadataT>
RewriteRuleWith<MetadataT> RewriteRuleWith<MetadataT>
applyFirst(const std::vector<RewriteRuleWith<MetadataT>> &Rules) { applyFirst(const std::vector<RewriteRuleWith<MetadataT>> &Rules) {
return applyFirst(llvm::makeArrayRef(Rules)); return applyFirst(llvm::ArrayRef(Rules));
} }
template <typename MetadataT> template <typename MetadataT>
RewriteRuleWith<MetadataT> RewriteRuleWith<MetadataT>
applyFirst(std::initializer_list<RewriteRuleWith<MetadataT>> Rules) { applyFirst(std::initializer_list<RewriteRuleWith<MetadataT>> Rules) {
return applyFirst(llvm::makeArrayRef(Rules.begin(), Rules.end())); return applyFirst(llvm::ArrayRef(Rules.begin(), Rules.end()));
} }
/// @} /// @}
Context not available.

clang/lib/AST/APValue.cpp

Context not available.
ArrayRef<APValue::LValuePathEntry> APValue::getLValuePath() const { ArrayRef<APValue::LValuePathEntry> APValue::getLValuePath() const {
assert(isLValue() && hasLValuePath() && "Invalid accessor"); assert(isLValue() && hasLValuePath() && "Invalid accessor");
const LV &LVal = *((const LV *)(const char *)&Data); const LV &LVal = *((const LV *)(const char *)&Data);
return llvm::makeArrayRef(LVal.getPath(), LVal.PathLength); return llvm::ArrayRef(LVal.getPath(), LVal.PathLength);
} }
unsigned APValue::getLValueCallIndex() const { unsigned APValue::getLValueCallIndex() const {
Context not available.
assert(isMemberPointer() && "Invalid accessor"); assert(isMemberPointer() && "Invalid accessor");
const MemberPointerData &MPD = const MemberPointerData &MPD =
*((const MemberPointerData *)(const char *)&Data); *((const MemberPointerData *)(const char *)&Data);
return llvm::makeArrayRef(MPD.getPath(), MPD.PathLength); return llvm::ArrayRef(MPD.getPath(), MPD.PathLength);
} }
void APValue::MakeLValue() { void APValue::MakeLValue() {
Context not available.

clang/lib/AST/ASTContext.cpp

Context not available.
ObjCProtocolDecl * const *Protocols, ObjCProtocolDecl * const *Protocols,
unsigned NumProtocols) const { unsigned NumProtocols) const {
return getObjCObjectType(BaseType, {}, return getObjCObjectType(BaseType, {},
llvm::makeArrayRef(Protocols, NumProtocols), llvm::ArrayRef(Protocols, NumProtocols),
/*isKindOf=*/false); /*isKindOf=*/false);
} }
Context not available.

clang/lib/AST/ASTDiagnostic.cpp

Context not available.
desugarForDiagnostic(Context, Ty->getBaseType(), ShouldAKA); desugarForDiagnostic(Context, Ty->getBaseType(), ShouldAKA);
QT = Context.getObjCObjectType( QT = Context.getObjCObjectType(
BaseType, Ty->getTypeArgsAsWritten(), BaseType, Ty->getTypeArgsAsWritten(),
llvm::makeArrayRef(Ty->qual_begin(), Ty->getNumProtocols()), llvm::ArrayRef(Ty->qual_begin(), Ty->getNumProtocols()),
Ty->isKindOfTypeAsWritten()); Ty->isKindOfTypeAsWritten());
} }
} }
Context not available.

clang/lib/AST/ASTImporter.cpp

Context not available.
return std::move(Err); return std::move(Err);
return TemplateArgument( return TemplateArgument(
llvm::makeArrayRef(ToPack).copy(Importer.getToContext())); llvm::ArrayRef(ToPack).copy(Importer.getToContext()));
} }
} }
Context not available.
// Import TemplateArgumentListInfo. // Import TemplateArgumentListInfo.
TemplateArgumentListInfo ToTAInfo; TemplateArgumentListInfo ToTAInfo;
if (Error Err = ImportTemplateArgumentListInfo( if (Error Err = ImportTemplateArgumentListInfo(
FromInfo->getLAngleLoc(), FromInfo->getRAngleLoc(), FromInfo->getLAngleLoc(), FromInfo->getRAngleLoc(),
llvm::makeArrayRef( llvm::ArrayRef(FromInfo->getTemplateArgs(),
FromInfo->getTemplateArgs(), FromInfo->getNumTemplateArgs()), FromInfo->getNumTemplateArgs()),
ToTAInfo)) ToTAInfo))
return Err; return Err;
ToFD->setDependentTemplateSpecialization(Importer.getToContext(), ToFD->setDependentTemplateSpecialization(Importer.getToContext(),
Context not available.
CanonInjType = CanonInjType.getCanonicalType(); CanonInjType = CanonInjType.getCanonicalType();
if (GetImportedOrCreateDecl<ClassTemplatePartialSpecializationDecl>( if (GetImportedOrCreateDecl<ClassTemplatePartialSpecializationDecl>(
D2, D, Importer.getToContext(), D->getTagKind(), DC, D2, D, Importer.getToContext(), D->getTagKind(), DC, *BeginLocOrErr,
*BeginLocOrErr, *IdLocOrErr, ToTPList, ClassTemplate, *IdLocOrErr, ToTPList, ClassTemplate,
llvm::makeArrayRef(TemplateArgs.data(), TemplateArgs.size()), llvm::ArrayRef(TemplateArgs.data(), TemplateArgs.size()), ToTAInfo,
ToTAInfo, CanonInjType, CanonInjType,
cast_or_null<ClassTemplatePartialSpecializationDecl>(PrevDecl))) cast_or_null<ClassTemplatePartialSpecializationDecl>(PrevDecl)))
return D2; return D2;
Context not available.
const ASTContext &ToCtx = Importer.getToContext(); const ASTContext &ToCtx = Importer.getToContext();
if (E->isResultDependent()) { if (E->isResultDependent()) {
return GenericSelectionExpr::Create( return GenericSelectionExpr::Create(
ToCtx, ToGenericLoc, ToControllingExpr, ToCtx, ToGenericLoc, ToControllingExpr, llvm::ArrayRef(ToAssocTypes),
llvm::makeArrayRef(ToAssocTypes), llvm::makeArrayRef(ToAssocExprs), llvm::ArrayRef(ToAssocExprs), ToDefaultLoc, ToRParenLoc,
ToDefaultLoc, ToRParenLoc, E->containsUnexpandedParameterPack()); E->containsUnexpandedParameterPack());
} }
return GenericSelectionExpr::Create( return GenericSelectionExpr::Create(
ToCtx, ToGenericLoc, ToControllingExpr, llvm::makeArrayRef(ToAssocTypes), ToCtx, ToGenericLoc, ToControllingExpr, llvm::ArrayRef(ToAssocTypes),
llvm::makeArrayRef(ToAssocExprs), ToDefaultLoc, ToRParenLoc, llvm::ArrayRef(ToAssocExprs), ToDefaultLoc, ToRParenLoc,
E->containsUnexpandedParameterPack(), E->getResultIndex()); E->containsUnexpandedParameterPack(), E->getResultIndex());
} }
Context not available.
return CXXUnresolvedConstructExpr::Create( return CXXUnresolvedConstructExpr::Create(
Importer.getToContext(), ToType, ToTypeSourceInfo, ToLParenLoc, Importer.getToContext(), ToType, ToTypeSourceInfo, ToLParenLoc,
llvm::makeArrayRef(ToArgs), ToRParenLoc); llvm::ArrayRef(ToArgs), ToRParenLoc);
} }
ExpectedStmt ExpectedStmt
Context not available.

clang/lib/AST/CommentParser.cpp

Context not available.
Pos.CurToken++; Pos.CurToken++;
} }
P.putBack(llvm::makeArrayRef(Toks.begin() + Pos.CurToken, Toks.end())); P.putBack(llvm::ArrayRef(Toks.begin() + Pos.CurToken, Toks.end()));
Pos.CurToken = Toks.size(); Pos.CurToken = Toks.size();
if (HavePartialTok) if (HavePartialTok)
Context not available.
ParsedArgs++; ParsedArgs++;
} }
return llvm::makeArrayRef(Args, ParsedArgs); return llvm::ArrayRef(Args, ParsedArgs);
} }
BlockCommandComment *Parser::parseBlockCommand() { BlockCommandComment *Parser::parseBlockCommand() {
Context not available.
} }
case tok::html_greater: case tok::html_greater:
S.actOnHTMLStartTagFinish(HST, S.actOnHTMLStartTagFinish(HST, S.copyArray(llvm::ArrayRef(Attrs)),
S.copyArray(llvm::makeArrayRef(Attrs)),
Tok.getLocation(), Tok.getLocation(),
/* IsSelfClosing = */ false); /* IsSelfClosing = */ false);
consumeToken(); consumeToken();
return HST; return HST;
case tok::html_slash_greater: case tok::html_slash_greater:
S.actOnHTMLStartTagFinish(HST, S.actOnHTMLStartTagFinish(HST, S.copyArray(llvm::ArrayRef(Attrs)),
S.copyArray(llvm::makeArrayRef(Attrs)),
Tok.getLocation(), Tok.getLocation(),
/* IsSelfClosing = */ true); /* IsSelfClosing = */ true);
consumeToken(); consumeToken();
Context not available.
Tok.is(tok::html_slash_greater)) Tok.is(tok::html_slash_greater))
continue; continue;
S.actOnHTMLStartTagFinish(HST, S.actOnHTMLStartTagFinish(HST, S.copyArray(llvm::ArrayRef(Attrs)),
S.copyArray(llvm::makeArrayRef(Attrs)),
SourceLocation(), SourceLocation(),
/* IsSelfClosing = */ false); /* IsSelfClosing = */ false);
return HST; return HST;
default: default:
// Not a token from an HTML start tag. Thus HTML tag prematurely ended. // Not a token from an HTML start tag. Thus HTML tag prematurely ended.
S.actOnHTMLStartTagFinish(HST, S.actOnHTMLStartTagFinish(HST, S.copyArray(llvm::ArrayRef(Attrs)),
S.copyArray(llvm::makeArrayRef(Attrs)),
SourceLocation(), SourceLocation(),
/* IsSelfClosing = */ false); /* IsSelfClosing = */ false);
bool StartLineInvalid; bool StartLineInvalid;
Context not available.
break; break;
} }
return S.actOnParagraphComment(S.copyArray(llvm::makeArrayRef(Content))); return S.actOnParagraphComment(S.copyArray(llvm::ArrayRef(Content)));
} }
VerbatimBlockComment *Parser::parseVerbatimBlock() { VerbatimBlockComment *Parser::parseVerbatimBlock() {
Context not available.
if (Tok.is(tok::verbatim_block_end)) { if (Tok.is(tok::verbatim_block_end)) {
const CommandInfo *Info = Traits.getCommandInfo(Tok.getVerbatimBlockID()); const CommandInfo *Info = Traits.getCommandInfo(Tok.getVerbatimBlockID());
S.actOnVerbatimBlockFinish(VB, Tok.getLocation(), S.actOnVerbatimBlockFinish(VB, Tok.getLocation(), Info->Name,
Info->Name, S.copyArray(llvm::ArrayRef(Lines)));
S.copyArray(llvm::makeArrayRef(Lines)));
consumeToken(); consumeToken();
} else { } else {
// Unterminated \\verbatim block // Unterminated \\verbatim block
S.actOnVerbatimBlockFinish(VB, SourceLocation(), "", S.actOnVerbatimBlockFinish(VB, SourceLocation(), "",
S.copyArray(llvm::makeArrayRef(Lines))); S.copyArray(llvm::ArrayRef(Lines)));
} }
return VB; return VB;
Context not available.
while (Tok.is(tok::newline)) while (Tok.is(tok::newline))
consumeToken(); consumeToken();
} }
return S.actOnFullComment(S.copyArray(llvm::makeArrayRef(Blocks))); return S.actOnFullComment(S.copyArray(llvm::ArrayRef(Blocks)));
} }
} // end namespace comments } // end namespace comments
Context not available.

clang/lib/AST/CommentSema.cpp

Context not available.
} }
auto *A = new (Allocator) auto *A = new (Allocator)
Comment::Argument{SourceRange(ArgLocBegin, ArgLocEnd), Arg}; Comment::Argument{SourceRange(ArgLocBegin, ArgLocEnd), Arg};
Command->setArgs(llvm::makeArrayRef(A, 1)); Command->setArgs(llvm::ArrayRef(A, 1));
} }
void Sema::actOnParamCommandFinish(ParamCommandComment *Command, void Sema::actOnParamCommandFinish(ParamCommandComment *Command,
Context not available.
auto *A = new (Allocator) auto *A = new (Allocator)
Comment::Argument{SourceRange(ArgLocBegin, ArgLocEnd), Arg}; Comment::Argument{SourceRange(ArgLocBegin, ArgLocEnd), Arg};
Command->setArgs(llvm::makeArrayRef(A, 1)); Command->setArgs(llvm::ArrayRef(A, 1));
if (!isTemplateOrSpecialization()) { if (!isTemplateOrSpecialization()) {
// We already warned that this \\tparam is not attached to a template decl. // We already warned that this \\tparam is not attached to a template decl.
Context not available.
ThisDeclInfo->TemplateParameters; ThisDeclInfo->TemplateParameters;
SmallVector<unsigned, 2> Position; SmallVector<unsigned, 2> Position;
if (resolveTParamReference(Arg, TemplateParameters, &Position)) { if (resolveTParamReference(Arg, TemplateParameters, &Position)) {
Command->setPosition(copyArray(llvm::makeArrayRef(Position))); Command->setPosition(copyArray(llvm::ArrayRef(Position)));
TParamCommandComment *&PrevCommand = TemplateParameterDocs[Arg]; TParamCommandComment *&PrevCommand = TemplateParameterDocs[Arg];
if (PrevCommand) { if (PrevCommand) {
SourceRange ArgRange(ArgLocBegin, ArgLocEnd); SourceRange ArgRange(ArgLocBegin, ArgLocEnd);
Context not available.

clang/lib/AST/ComputeDependence.cpp

Context not available.
ExprDependence clang::computeDependence(CallExpr *E, ExprDependence clang::computeDependence(CallExpr *E,
llvm::ArrayRef<Expr *> PreArgs) { llvm::ArrayRef<Expr *> PreArgs) {
auto D = E->getCallee()->getDependence(); auto D = E->getCallee()->getDependence();
for (auto *A : llvm::makeArrayRef(E->getArgs(), E->getNumArgs())) { for (auto *A : llvm::ArrayRef(E->getArgs(), E->getNumArgs())) {
if (A) if (A)
D |= A->getDependence(); D |= A->getDependence();
} }
Context not available.
ExprDependence clang::computeDependence(ShuffleVectorExpr *E) { ExprDependence clang::computeDependence(ShuffleVectorExpr *E) {
auto D = toExprDependenceForImpliedType(E->getType()->getDependence()); auto D = toExprDependenceForImpliedType(E->getType()->getDependence());
for (auto *C : llvm::makeArrayRef(E->getSubExprs(), E->getNumSubExprs())) for (auto *C : llvm::ArrayRef(E->getSubExprs(), E->getNumSubExprs()))
D |= C->getDependence(); D |= C->getDependence();
return D; return D;
} }
Context not available.
ExprDependence clang::computeDependence(AtomicExpr *A) { ExprDependence clang::computeDependence(AtomicExpr *A) {
auto D = ExprDependence::None; auto D = ExprDependence::None;
for (auto *E : llvm::makeArrayRef(A->getSubExprs(), A->getNumSubExprs())) for (auto *E : llvm::ArrayRef(A->getSubExprs(), A->getNumSubExprs()))
D |= E->getDependence(); D |= E->getDependence();
return D; return D;
} }
Context not available.

clang/lib/AST/Decl.cpp

Context not available.
return std::nullopt; return std::nullopt;
const auto *StoredLocs = getTrailingObjects<SourceLocation>(); const auto *StoredLocs = getTrailingObjects<SourceLocation>();
return llvm::makeArrayRef(StoredLocs, return llvm::ArrayRef(StoredLocs,
getNumModuleIdentifiers(getImportedModule())); getNumModuleIdentifiers(getImportedModule()));
} }
SourceRange ImportDecl::getSourceRange() const { SourceRange ImportDecl::getSourceRange() const {
Context not available.

clang/lib/AST/DeclCXX.cpp

Context not available.
const auto ExplicitEnd = llvm::partition_point( const auto ExplicitEnd = llvm::partition_point(
*List, [](const NamedDecl *D) { return !D->isImplicit(); }); *List, [](const NamedDecl *D) { return !D->isImplicit(); });
return llvm::makeArrayRef(List->begin(), ExplicitEnd); return llvm::ArrayRef(List->begin(), ExplicitEnd);
} }
Decl *CXXRecordDecl::getLambdaContextDecl() const { Decl *CXXRecordDecl::getLambdaContextDecl() const {
Context not available.

clang/lib/AST/DeclTemplate.cpp

Context not available.
CommonPtr->InjectedArgs); CommonPtr->InjectedArgs);
} }
return llvm::makeArrayRef(CommonPtr->InjectedArgs, Params->size()); return llvm::ArrayRef(CommonPtr->InjectedArgs, Params->size());
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
Context not available.
// template <std::size_t Index, typename ...T> // template <std::size_t Index, typename ...T>
NamedDecl *Params[] = {Index, Ts}; NamedDecl *Params[] = {Index, Ts};
return TemplateParameterList::Create(C, SourceLocation(), SourceLocation(), return TemplateParameterList::Create(C, SourceLocation(), SourceLocation(),
llvm::makeArrayRef(Params), llvm::ArrayRef(Params), SourceLocation(),
SourceLocation(), nullptr); nullptr);
} }
static TemplateParameterList *createBuiltinTemplateParameterList( static TemplateParameterList *createBuiltinTemplateParameterList(
Context not available.

clang/lib/AST/ExprCXX.cpp

Context not available.
} }
TemplateArgument SubstNonTypeTemplateParmPackExpr::getArgumentPack() const { TemplateArgument SubstNonTypeTemplateParmPackExpr::getArgumentPack() const {
return TemplateArgument(llvm::makeArrayRef(Arguments, NumArguments)); return TemplateArgument(llvm::ArrayRef(Arguments, NumArguments));
} }
FunctionParmPackExpr::FunctionParmPackExpr(QualType T, VarDecl *ParamPack, FunctionParmPackExpr::FunctionParmPackExpr(QualType T, VarDecl *ParamPack,
Context not available.

clang/lib/AST/ExprConstant.cpp

Context not available.
if ((ObjType.isConstQualified() || ObjType.isVolatileQualified()) && if ((ObjType.isConstQualified() || ObjType.isVolatileQualified()) &&
ObjType->isRecordType() && ObjType->isRecordType() &&
Info.isEvaluatingCtorDtor( Info.isEvaluatingCtorDtor(
Obj.Base, llvm::makeArrayRef(Sub.Entries.begin(), Obj.Base,
Sub.Entries.begin() + I)) != llvm::ArrayRef(Sub.Entries.begin(), Sub.Entries.begin() + I)) !=
ConstructionPhase::None) { ConstructionPhase::None) {
ObjType = Info.Ctx.getCanonicalType(ObjType); ObjType = Info.Ctx.getCanonicalType(ObjType);
ObjType.removeLocalConst(); ObjType.removeLocalConst();
ObjType.removeLocalVolatile(); ObjType.removeLocalVolatile();
Context not available.
const FunctionDecl *FD = nullptr; const FunctionDecl *FD = nullptr;
LValue *This = nullptr, ThisVal; LValue *This = nullptr, ThisVal;
auto Args = llvm::makeArrayRef(E->getArgs(), E->getNumArgs()); auto Args = llvm::ArrayRef(E->getArgs(), E->getNumArgs());
bool HasQualifier = false; bool HasQualifier = false;
CallRef Call; CallRef Call;
Context not available.
if (ZeroInit && !ZeroInitialization(E, T)) if (ZeroInit && !ZeroInitialization(E, T))
return false; return false;
auto Args = llvm::makeArrayRef(E->getArgs(), E->getNumArgs()); auto Args = llvm::ArrayRef(E->getArgs(), E->getNumArgs());
return HandleConstructorCall(E, This, Args, return HandleConstructorCall(E, This, Args,
cast<CXXConstructorDecl>(Definition), Info, cast<CXXConstructorDecl>(Definition), Info,
Result); Result);
Context not available.

clang/lib/AST/OpenMPClause.cpp

Context not available.
} }
ArrayRef<Expr *> OMPOrderedClause::getLoopNumIterations() const { ArrayRef<Expr *> OMPOrderedClause::getLoopNumIterations() const {
return llvm::makeArrayRef(getTrailingObjects<Expr *>(), NumberOfLoops); return llvm::ArrayRef(getTrailingObjects<Expr *>(), NumberOfLoops);
} }
void OMPOrderedClause::setLoopCounter(unsigned NumLoop, Expr *Counter) { void OMPOrderedClause::setLoopCounter(unsigned NumLoop, Expr *Counter) {
Context not available.

clang/lib/AST/ParentMapContext.cpp

Context not available.
return llvm::ArrayRef<DynTypedNode>(); return llvm::ArrayRef<DynTypedNode>();
} }
if (const auto *V = I->second.template dyn_cast<ParentVector *>()) { if (const auto *V = I->second.template dyn_cast<ParentVector *>()) {
return llvm::makeArrayRef(*V); return llvm::ArrayRef(*V);
} }
return getSingleDynTypedNodeFromParentMap(I->second); return getSingleDynTypedNodeFromParentMap(I->second);
} }
Context not available.
const auto *S = It->second.dyn_cast<const Stmt *>(); const auto *S = It->second.dyn_cast<const Stmt *>();
if (!S) { if (!S) {
if (auto *Vec = It->second.dyn_cast<ParentVector *>()) if (auto *Vec = It->second.dyn_cast<ParentVector *>())
return llvm::makeArrayRef(*Vec); return llvm::ArrayRef(*Vec);
return getSingleDynTypedNodeFromParentMap(It->second); return getSingleDynTypedNodeFromParentMap(It->second);
} }
const auto *P = dyn_cast<Expr>(S); const auto *P = dyn_cast<Expr>(S);
Context not available.

clang/lib/AST/TemplateName.cpp

Context not available.
TemplateArgument TemplateArgument
SubstTemplateTemplateParmPackStorage::getArgumentPack() const { SubstTemplateTemplateParmPackStorage::getArgumentPack() const {
return TemplateArgument(llvm::makeArrayRef(Arguments, Bits.Data)); return TemplateArgument(llvm::ArrayRef(Arguments, Bits.Data));
} }
TemplateTemplateParmDecl * TemplateTemplateParmDecl *
Context not available.

clang/lib/AST/Type.cpp

Context not available.
if (exceptionChanged) { if (exceptionChanged) {
info.ExceptionSpec.Exceptions = info.ExceptionSpec.Exceptions =
llvm::makeArrayRef(exceptionTypes).copy(Ctx); llvm::ArrayRef(exceptionTypes).copy(Ctx);
} }
} }
Context not available.
!typeArgChanged) !typeArgChanged)
return QualType(T, 0); return QualType(T, 0);
return Ctx.getObjCObjectType(baseType, typeArgs, return Ctx.getObjCObjectType(
llvm::makeArrayRef(T->qual_begin(), baseType, typeArgs,
T->getNumProtocols()), llvm::ArrayRef(T->qual_begin(), T->getNumProtocols()),
T->isKindOfTypeAsWritten()); T->isKindOfTypeAsWritten());
} }
TRIVIAL_TYPE_CLASS(ObjCInterface) TRIVIAL_TYPE_CLASS(ObjCInterface)
Context not available.
if (exceptionChanged) { if (exceptionChanged) {
info.ExceptionSpec.Exceptions = info.ExceptionSpec.Exceptions =
llvm::makeArrayRef(exceptionTypes).copy(Ctx); llvm::ArrayRef(exceptionTypes).copy(Ctx);
} }
} }
Context not available.
} }
TemplateArgument SubstTemplateTypeParmPackType::getArgumentPack() const { TemplateArgument SubstTemplateTypeParmPackType::getArgumentPack() const {
return TemplateArgument(llvm::makeArrayRef(Arguments, getNumArgs())); return TemplateArgument(llvm::ArrayRef(Arguments, getNumArgs()));
} }
void SubstTemplateTypeParmPackType::Profile(llvm::FoldingSetNodeID &ID) { void SubstTemplateTypeParmPackType::Profile(llvm::FoldingSetNodeID &ID) {
Context not available.
void ObjCObjectTypeImpl::Profile(llvm::FoldingSetNodeID &ID) { void ObjCObjectTypeImpl::Profile(llvm::FoldingSetNodeID &ID) {
Profile(ID, getBaseType(), getTypeArgsAsWritten(), Profile(ID, getBaseType(), getTypeArgsAsWritten(),
llvm::makeArrayRef(qual_begin(), getNumProtocols()), llvm::ArrayRef(qual_begin(), getNumProtocols()),
isKindOfTypeAsWritten()); isKindOfTypeAsWritten());
} }
Context not available.
void ObjCTypeParamType::Profile(llvm::FoldingSetNodeID &ID) { void ObjCTypeParamType::Profile(llvm::FoldingSetNodeID &ID) {
Profile(ID, getDecl(), getCanonicalTypeInternal(), Profile(ID, getDecl(), getCanonicalTypeInternal(),
llvm::makeArrayRef(qual_begin(), getNumProtocols())); llvm::ArrayRef(qual_begin(), getNumProtocols()));
} }
namespace { namespace {
Context not available.

clang/lib/ASTMatchers/Dynamic/Marshallers.cpp

Context not available.
#include "clang/Basic/AttrList.inc" #include "clang/Basic/AttrList.inc"
}; };
if (Value.isString()) if (Value.isString())
return ::getBestGuess(Value.getString(), llvm::makeArrayRef(Allowed), return ::getBestGuess(Value.getString(), llvm::ArrayRef(Allowed), "attr::");
"attr::");
return std::nullopt; return std::nullopt;
} }
Context not available.
#include "clang/AST/OperationKinds.def" #include "clang/AST/OperationKinds.def"
}; };
if (Value.isString()) if (Value.isString())
return ::getBestGuess(Value.getString(), llvm::makeArrayRef(Allowed), return ::getBestGuess(Value.getString(), llvm::ArrayRef(Allowed), "CK_");
"CK_");
return std::nullopt; return std::nullopt;
} }
Context not available.
#include "llvm/Frontend/OpenMP/OMP.inc" #include "llvm/Frontend/OpenMP/OMP.inc"
}; };
if (Value.isString()) if (Value.isString())
return ::getBestGuess(Value.getString(), llvm::makeArrayRef(Allowed), return ::getBestGuess(Value.getString(), llvm::ArrayRef(Allowed), "OMPC_");
"OMPC_");
return std::nullopt; return std::nullopt;
} }
Context not available.
#include "clang/Basic/TokenKinds.def" #include "clang/Basic/TokenKinds.def"
}; };
if (Value.isString()) if (Value.isString())
return ::getBestGuess(Value.getString(), llvm::makeArrayRef(Allowed), return ::getBestGuess(Value.getString(), llvm::ArrayRef(Allowed), "UETT_");
"UETT_");
return std::nullopt; return std::nullopt;
} }
Context not available.

clang/lib/Analysis/CFG.cpp

Context not available.
// Note: Fill in this switch with more cases we want to optimize. // Note: Fill in this switch with more cases we want to optimize.
case Stmt::InitListExprClass: { case Stmt::InitListExprClass: {
InitListExpr *IE = cast<InitListExpr>(S); InitListExpr *IE = cast<InitListExpr>(S);
children = llvm::makeArrayRef(reinterpret_cast<Stmt**>(IE->getInits()), children = llvm::ArrayRef(reinterpret_cast<Stmt **>(IE->getInits()),
IE->getNumInits()); IE->getNumInits());
return; return;
} }
default: default:
Context not available.

clang/lib/Analysis/CalledOnceCheck.cpp

Context not available.
template <class CallLikeExpr> template <class CallLikeExpr>
void checkIndirectCall(const CallLikeExpr *CallOrMessage) { void checkIndirectCall(const CallLikeExpr *CallOrMessage) {
// CallExpr::arguments does not interact nicely with llvm::enumerate. // CallExpr::arguments does not interact nicely with llvm::enumerate.
llvm::ArrayRef<const Expr *> Arguments = llvm::makeArrayRef( llvm::ArrayRef<const Expr *> Arguments =
CallOrMessage->getArgs(), CallOrMessage->getNumArgs()); llvm::ArrayRef(CallOrMessage->getArgs(), CallOrMessage->getNumArgs());
// Let's check if any of the call arguments is a point of interest. // Let's check if any of the call arguments is a point of interest.
for (const auto &Argument : llvm::enumerate(Arguments)) { for (const auto &Argument : llvm::enumerate(Arguments)) {
Context not available.
bool shouldBlockArgumentBeCalledOnce(const CallLikeExpr *CallOrMessage, bool shouldBlockArgumentBeCalledOnce(const CallLikeExpr *CallOrMessage,
const Stmt *BlockArgument) const { const Stmt *BlockArgument) const {
// CallExpr::arguments does not interact nicely with llvm::enumerate. // CallExpr::arguments does not interact nicely with llvm::enumerate.
llvm::ArrayRef<const Expr *> Arguments = llvm::makeArrayRef( llvm::ArrayRef<const Expr *> Arguments =
CallOrMessage->getArgs(), CallOrMessage->getNumArgs()); llvm::ArrayRef(CallOrMessage->getArgs(), CallOrMessage->getNumArgs());
for (const auto &Argument : llvm::enumerate(Arguments)) { for (const auto &Argument : llvm::enumerate(Arguments)) {
if (Argument.value() == BlockArgument) { if (Argument.value() == BlockArgument) {
Context not available.

clang/lib/Analysis/FlowSensitive/DataflowEnvironment.cpp

Context not available.
} }
Env.pushCallInternal(Call->getDirectCallee(), Env.pushCallInternal(Call->getDirectCallee(),
llvm::makeArrayRef(Call->getArgs(), Call->getNumArgs())); llvm::ArrayRef(Call->getArgs(), Call->getNumArgs()));
return Env; return Env;
} }
Context not available.
Env.ThisPointeeLoc = Env.ReturnLoc; Env.ThisPointeeLoc = Env.ReturnLoc;
Env.pushCallInternal(Call->getConstructor(), Env.pushCallInternal(Call->getConstructor(),
llvm::makeArrayRef(Call->getArgs(), Call->getNumArgs())); llvm::ArrayRef(Call->getArgs(), Call->getNumArgs()));
return Env; return Env;
} }
Context not available.

clang/lib/Basic/Module.cpp

Context not available.
TopHeaderNames.clear(); TopHeaderNames.clear();
} }
return llvm::makeArrayRef(TopHeaders.begin(), TopHeaders.end()); return llvm::ArrayRef(TopHeaders.begin(), TopHeaders.end());
} }
bool Module::directlyUses(const Module *Requested) { bool Module::directlyUses(const Module *Requested) {
Context not available.

clang/lib/Basic/Targets/AArch64.cpp

Context not available.
} }
ArrayRef<Builtin::Info> AArch64TargetInfo::getTargetBuiltins() const { ArrayRef<Builtin::Info> AArch64TargetInfo::getTargetBuiltins() const {
return llvm::makeArrayRef(BuiltinInfo, clang::AArch64::LastTSBuiltin - return llvm::ArrayRef(BuiltinInfo, clang::AArch64::LastTSBuiltin -
Builtin::FirstTSBuiltin); Builtin::FirstTSBuiltin);
} }
Optional<std::pair<unsigned, unsigned>> Optional<std::pair<unsigned, unsigned>>
Context not available.
}; };
ArrayRef<const char *> AArch64TargetInfo::getGCCRegNames() const { ArrayRef<const char *> AArch64TargetInfo::getGCCRegNames() const {
return llvm::makeArrayRef(GCCRegNames); return llvm::ArrayRef(GCCRegNames);
} }
const TargetInfo::GCCRegAlias AArch64TargetInfo::GCCRegAliases[] = { const TargetInfo::GCCRegAlias AArch64TargetInfo::GCCRegAliases[] = {
Context not available.
}; };
ArrayRef<TargetInfo::GCCRegAlias> AArch64TargetInfo::getGCCRegAliases() const { ArrayRef<TargetInfo::GCCRegAlias> AArch64TargetInfo::getGCCRegAliases() const {
return llvm::makeArrayRef(GCCRegAliases); return llvm::ArrayRef(GCCRegAliases);
} }
bool AArch64TargetInfo::validateAsmConstraint( bool AArch64TargetInfo::validateAsmConstraint(
Context not available.

clang/lib/Basic/Targets/AMDGPU.cpp

Context not available.
}; };
ArrayRef<const char *> AMDGPUTargetInfo::getGCCRegNames() const { ArrayRef<const char *> AMDGPUTargetInfo::getGCCRegNames() const {
return llvm::makeArrayRef(GCCRegNames); return llvm::ArrayRef(GCCRegNames);
} }
bool AMDGPUTargetInfo::initFeatureMap( bool AMDGPUTargetInfo::initFeatureMap(
Context not available.
} }
ArrayRef<Builtin::Info> AMDGPUTargetInfo::getTargetBuiltins() const { ArrayRef<Builtin::Info> AMDGPUTargetInfo::getTargetBuiltins() const {
return llvm::makeArrayRef(BuiltinInfo, clang::AMDGPU::LastTSBuiltin - return llvm::ArrayRef(BuiltinInfo,
Builtin::FirstTSBuiltin); clang::AMDGPU::LastTSBuiltin - Builtin::FirstTSBuiltin);
} }
void AMDGPUTargetInfo::getTargetDefines(const LangOptions &Opts, void AMDGPUTargetInfo::getTargetDefines(const LangOptions &Opts,
Context not available.

clang/lib/Basic/Targets/ARC.h

Context not available.
"r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
"r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23", "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
"r24", "r25", "gp", "sp", "fp", "ilink1", "r30", "blink"}; "r24", "r25", "gp", "sp", "fp", "ilink1", "r30", "blink"};
return llvm::makeArrayRef(GCCRegNames); return llvm::ArrayRef(GCCRegNames);
} }
ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override { ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
Context not available.

clang/lib/Basic/Targets/ARM.cpp

Context not available.
}; };
ArrayRef<Builtin::Info> ARMTargetInfo::getTargetBuiltins() const { ArrayRef<Builtin::Info> ARMTargetInfo::getTargetBuiltins() const {
return llvm::makeArrayRef(BuiltinInfo, clang::ARM::LastTSBuiltin - return llvm::ArrayRef(BuiltinInfo,
Builtin::FirstTSBuiltin); clang::ARM::LastTSBuiltin - Builtin::FirstTSBuiltin);
} }
bool ARMTargetInfo::isCLZForZeroUndef() const { return false; } bool ARMTargetInfo::isCLZForZeroUndef() const { return false; }
Context not available.
"q12", "q13", "q14", "q15"}; "q12", "q13", "q14", "q15"};
ArrayRef<const char *> ARMTargetInfo::getGCCRegNames() const { ArrayRef<const char *> ARMTargetInfo::getGCCRegNames() const {
return llvm::makeArrayRef(GCCRegNames); return llvm::ArrayRef(GCCRegNames);
} }
const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = { const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
Context not available.
}; };
ArrayRef<TargetInfo::GCCRegAlias> ARMTargetInfo::getGCCRegAliases() const { ArrayRef<TargetInfo::GCCRegAlias> ARMTargetInfo::getGCCRegAliases() const {
return llvm::makeArrayRef(GCCRegAliases); return llvm::ArrayRef(GCCRegAliases);
} }
bool ARMTargetInfo::validateAsmConstraint( bool ARMTargetInfo::validateAsmConstraint(
Context not available.

clang/lib/Basic/Targets/AVR.h

Context not available.
"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9",
"r10", "r11", "r12", "r13", "r14", "r15", "r16", "r17", "r18", "r19", "r10", "r11", "r12", "r13", "r14", "r15", "r16", "r17", "r18", "r19",
"r20", "r21", "r22", "r23", "r24", "r25", "X", "Y", "Z", "SP"}; "r20", "r21", "r22", "r23", "r24", "r25", "X", "Y", "Z", "SP"};
return llvm::makeArrayRef(GCCRegNames); return llvm::ArrayRef(GCCRegNames);
} }
ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override { ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
Context not available.
{{"r30", "r31"}, 28}, {{"r30", "r31"}, 28},
{{"SPL", "SPH"}, 29}, {{"SPL", "SPH"}, 29},
}; };
return llvm::makeArrayRef(AddlRegNames); return llvm::ArrayRef(AddlRegNames);
} }
bool validateAsmConstraint(const char *&Name, bool validateAsmConstraint(const char *&Name,
Context not available.

clang/lib/Basic/Targets/BPF.cpp

Context not available.
} }
ArrayRef<Builtin::Info> BPFTargetInfo::getTargetBuiltins() const { ArrayRef<Builtin::Info> BPFTargetInfo::getTargetBuiltins() const {
return llvm::makeArrayRef(BuiltinInfo, clang::BPF::LastTSBuiltin - return llvm::ArrayRef(BuiltinInfo,
Builtin::FirstTSBuiltin); clang::BPF::LastTSBuiltin - Builtin::FirstTSBuiltin);
} }
bool BPFTargetInfo::handleTargetFeatures(std::vector<std::string> &Features, bool BPFTargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
Context not available.

clang/lib/Basic/Targets/CSKY.cpp

Context not available.
"fr31", "fr31",
}; };
return llvm::makeArrayRef(GCCRegNames); return llvm::ArrayRef(GCCRegNames);
} }
ArrayRef<TargetInfo::GCCRegAlias> CSKYTargetInfo::getGCCRegAliases() const { ArrayRef<TargetInfo::GCCRegAlias> CSKYTargetInfo::getGCCRegAliases() const {
Context not available.
{{"vr31"}, "fr31"}, {{"vr31"}, "fr31"},
}; };
return llvm::makeArrayRef(GCCRegAliases); return llvm::ArrayRef(GCCRegAliases);
} }
bool CSKYTargetInfo::validateAsmConstraint( bool CSKYTargetInfo::validateAsmConstraint(
Context not available.

clang/lib/Basic/Targets/Hexagon.cpp

Context not available.
}; };
ArrayRef<const char *> HexagonTargetInfo::getGCCRegNames() const { ArrayRef<const char *> HexagonTargetInfo::getGCCRegNames() const {
return llvm::makeArrayRef(GCCRegNames); return llvm::ArrayRef(GCCRegNames);
} }
const TargetInfo::GCCRegAlias HexagonTargetInfo::GCCRegAliases[] = { const TargetInfo::GCCRegAlias HexagonTargetInfo::GCCRegAliases[] = {
Context not available.
}; };
ArrayRef<TargetInfo::GCCRegAlias> HexagonTargetInfo::getGCCRegAliases() const { ArrayRef<TargetInfo::GCCRegAlias> HexagonTargetInfo::getGCCRegAliases() const {
return llvm::makeArrayRef(GCCRegAliases); return llvm::ArrayRef(GCCRegAliases);
} }
static constexpr Builtin::Info BuiltinInfo[] = { static constexpr Builtin::Info BuiltinInfo[] = {
Context not available.
} }
ArrayRef<Builtin::Info> HexagonTargetInfo::getTargetBuiltins() const { ArrayRef<Builtin::Info> HexagonTargetInfo::getTargetBuiltins() const {
return llvm::makeArrayRef(BuiltinInfo, clang::Hexagon::LastTSBuiltin - return llvm::ArrayRef(BuiltinInfo, clang::Hexagon::LastTSBuiltin -
Builtin::FirstTSBuiltin); Builtin::FirstTSBuiltin);
} }
Context not available.

clang/lib/Basic/Targets/Lanai.cpp

Context not available.
}; };
ArrayRef<const char *> LanaiTargetInfo::getGCCRegNames() const { ArrayRef<const char *> LanaiTargetInfo::getGCCRegNames() const {
return llvm::makeArrayRef(GCCRegNames); return llvm::ArrayRef(GCCRegNames);
} }
const TargetInfo::GCCRegAlias LanaiTargetInfo::GCCRegAliases[] = { const TargetInfo::GCCRegAlias LanaiTargetInfo::GCCRegAliases[] = {
Context not available.
}; };
ArrayRef<TargetInfo::GCCRegAlias> LanaiTargetInfo::getGCCRegAliases() const { ArrayRef<TargetInfo::GCCRegAlias> LanaiTargetInfo::getGCCRegAliases() const {
return llvm::makeArrayRef(GCCRegAliases); return llvm::ArrayRef(GCCRegAliases);
} }
bool LanaiTargetInfo::isValidCPUName(StringRef Name) const { bool LanaiTargetInfo::isValidCPUName(StringRef Name) const {
Context not available.

clang/lib/Basic/Targets/LoongArch.cpp

Context not available.
"$f10", "$f11", "$f12", "$f13", "$f14", "$f15", "$f16", "$f17", "$f18", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15", "$f16", "$f17", "$f18",
"$f19", "$f20", "$f21", "$f22", "$f23", "$f24", "$f25", "$f26", "$f27", "$f19", "$f20", "$f21", "$f22", "$f23", "$f24", "$f25", "$f26", "$f27",
"$f28", "$f29", "$f30", "$f31"}; "$f28", "$f29", "$f30", "$f31"};
return llvm::makeArrayRef(GCCRegNames); return llvm::ArrayRef(GCCRegNames);
} }
ArrayRef<TargetInfo::GCCRegAlias> ArrayRef<TargetInfo::GCCRegAlias>
Context not available.
{{"$fs2"}, "$f26"}, {{"$fs3"}, "$f27"}, {{"$fs4"}, "$f28"}, {{"$fs2"}, "$f26"}, {{"$fs3"}, "$f27"}, {{"$fs4"}, "$f28"},
{{"$fs5"}, "$f29"}, {{"$fs6"}, "$f30"}, {{"$fs7"}, "$f31"}, {{"$fs5"}, "$f29"}, {{"$fs6"}, "$f30"}, {{"$fs7"}, "$f31"},
}; };
return llvm::makeArrayRef(GCCRegAliases); return llvm::ArrayRef(GCCRegAliases);
} }
bool LoongArchTargetInfo::validateAsmConstraint( bool LoongArchTargetInfo::validateAsmConstraint(
Context not available.
} }
ArrayRef<Builtin::Info> LoongArchTargetInfo::getTargetBuiltins() const { ArrayRef<Builtin::Info> LoongArchTargetInfo::getTargetBuiltins() const {
return llvm::makeArrayRef(BuiltinInfo, clang::LoongArch::LastTSBuiltin - return llvm::ArrayRef(BuiltinInfo, clang::LoongArch::LastTSBuiltin -
Builtin::FirstTSBuiltin); Builtin::FirstTSBuiltin);
} }
bool LoongArchTargetInfo::handleTargetFeatures( bool LoongArchTargetInfo::handleTargetFeatures(
Context not available.

clang/lib/Basic/Targets/M68k.cpp

Context not available.
"pc"}; "pc"};
ArrayRef<const char *> M68kTargetInfo::getGCCRegNames() const { ArrayRef<const char *> M68kTargetInfo::getGCCRegNames() const {
return llvm::makeArrayRef(GCCRegNames); return llvm::ArrayRef(GCCRegNames);
} }
ArrayRef<TargetInfo::GCCRegAlias> M68kTargetInfo::getGCCRegAliases() const { ArrayRef<TargetInfo::GCCRegAlias> M68kTargetInfo::getGCCRegAliases() const {
Context not available.

clang/lib/Basic/Targets/MSP430.h

Context not available.
{{"r2"}, "sr"}, {{"r2"}, "sr"},
{{"r3"}, "cg"}, {{"r3"}, "cg"},
}; };
return llvm::makeArrayRef(GCCRegAliases); return llvm::ArrayRef(GCCRegAliases);
} }
bool validateAsmConstraint(const char *&Name, bool validateAsmConstraint(const char *&Name,
Context not available.

clang/lib/Basic/Targets/MSP430.cpp

Context not available.
}; };
ArrayRef<const char *> MSP430TargetInfo::getGCCRegNames() const { ArrayRef<const char *> MSP430TargetInfo::getGCCRegNames() const {
return llvm::makeArrayRef(GCCRegNames); return llvm::ArrayRef(GCCRegNames);
} }
void MSP430TargetInfo::getTargetDefines(const LangOptions &Opts, void MSP430TargetInfo::getTargetDefines(const LangOptions &Opts,
Context not available.

clang/lib/Basic/Targets/Mips.h

Context not available.
"$msair", "$msacsr", "$msaaccess", "$msasave", "$msamodify", "$msair", "$msacsr", "$msaaccess", "$msasave", "$msamodify",
"$msarequest", "$msamap", "$msaunmap" "$msarequest", "$msamap", "$msaunmap"
}; };
return llvm::makeArrayRef(GCCRegNames); return llvm::ArrayRef(GCCRegNames);
} }
bool validateAsmConstraint(const char *&Name, bool validateAsmConstraint(const char *&Name,
Context not available.
{{"ra"}, "$31"} {{"ra"}, "$31"}
}; };
if (ABI == "o32") if (ABI == "o32")
return llvm::makeArrayRef(O32RegAliases); return llvm::ArrayRef(O32RegAliases);
return llvm::makeArrayRef(NewABIRegAliases); return llvm::ArrayRef(NewABIRegAliases);
} }
bool hasInt128Type() const override { bool hasInt128Type() const override {
Context not available.

clang/lib/Basic/Targets/Mips.cpp

Context not available.
} }
ArrayRef<Builtin::Info> MipsTargetInfo::getTargetBuiltins() const { ArrayRef<Builtin::Info> MipsTargetInfo::getTargetBuiltins() const {
return llvm::makeArrayRef(BuiltinInfo, clang::Mips::LastTSBuiltin - return llvm::ArrayRef(BuiltinInfo,
Builtin::FirstTSBuiltin); clang::Mips::LastTSBuiltin - Builtin::FirstTSBuiltin);
} }
unsigned MipsTargetInfo::getUnwindWordWidth() const { unsigned MipsTargetInfo::getUnwindWordWidth() const {
Context not available.

clang/lib/Basic/Targets/NVPTX.cpp

Context not available.
} }
ArrayRef<const char *> NVPTXTargetInfo::getGCCRegNames() const { ArrayRef<const char *> NVPTXTargetInfo::getGCCRegNames() const {
return llvm::makeArrayRef(GCCRegNames); return llvm::ArrayRef(GCCRegNames);
} }
bool NVPTXTargetInfo::hasFeature(StringRef Feature) const { bool NVPTXTargetInfo::hasFeature(StringRef Feature) const {
Context not available.
} }
ArrayRef<Builtin::Info> NVPTXTargetInfo::getTargetBuiltins() const { ArrayRef<Builtin::Info> NVPTXTargetInfo::getTargetBuiltins() const {
return llvm::makeArrayRef(BuiltinInfo, clang::NVPTX::LastTSBuiltin - return llvm::ArrayRef(BuiltinInfo,
Builtin::FirstTSBuiltin); clang::NVPTX::LastTSBuiltin - Builtin::FirstTSBuiltin);
} }
Context not available.

clang/lib/Basic/Targets/PPC.cpp

Context not available.
}; };
ArrayRef<const char *> PPCTargetInfo::getGCCRegNames() const { ArrayRef<const char *> PPCTargetInfo::getGCCRegNames() const {
return llvm::makeArrayRef(GCCRegNames); return llvm::ArrayRef(GCCRegNames);
} }
const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = { const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
Context not available.
}; };
ArrayRef<TargetInfo::GCCRegAlias> PPCTargetInfo::getGCCRegAliases() const { ArrayRef<TargetInfo::GCCRegAlias> PPCTargetInfo::getGCCRegAliases() const {
return llvm::makeArrayRef(GCCRegAliases); return llvm::ArrayRef(GCCRegAliases);
} }
// PPC ELFABIv2 DWARF Definitoin "Table 2.26. Mappings of Common Registers". // PPC ELFABIv2 DWARF Definitoin "Table 2.26. Mappings of Common Registers".
Context not available.
ArrayRef<TargetInfo::AddlRegName> PPCTargetInfo::getGCCAddlRegNames() const { ArrayRef<TargetInfo::AddlRegName> PPCTargetInfo::getGCCAddlRegNames() const {
if (ABI == "elfv2") if (ABI == "elfv2")
return llvm::makeArrayRef(GCCAddlRegNames); return llvm::ArrayRef(GCCAddlRegNames);
else else
return TargetInfo::getGCCAddlRegNames(); return TargetInfo::getGCCAddlRegNames();
} }
Context not available.
} }
ArrayRef<Builtin::Info> PPCTargetInfo::getTargetBuiltins() const { ArrayRef<Builtin::Info> PPCTargetInfo::getTargetBuiltins() const {
return llvm::makeArrayRef(BuiltinInfo, clang::PPC::LastTSBuiltin - return llvm::ArrayRef(BuiltinInfo,
Builtin::FirstTSBuiltin); clang::PPC::LastTSBuiltin - Builtin::FirstTSBuiltin);
} }
Context not available.

clang/lib/Basic/Targets/RISCV.cpp

Context not available.
"v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15", "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
"v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23", "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
"v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31"}; "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31"};
return llvm::makeArrayRef(GCCRegNames); return llvm::ArrayRef(GCCRegNames);
} }
ArrayRef<TargetInfo::GCCRegAlias> RISCVTargetInfo::getGCCRegAliases() const { ArrayRef<TargetInfo::GCCRegAlias> RISCVTargetInfo::getGCCRegAliases() const {
Context not available.
{{"fs4"}, "f20"}, {{"fs5"}, "f21"}, {{"fs6"}, "f22"}, {{"fs7"}, "f23"}, {{"fs4"}, "f20"}, {{"fs5"}, "f21"}, {{"fs6"}, "f22"}, {{"fs7"}, "f23"},
{{"fs8"}, "f24"}, {{"fs9"}, "f25"}, {{"fs10"}, "f26"}, {{"fs11"}, "f27"}, {{"fs8"}, "f24"}, {{"fs9"}, "f25"}, {{"fs10"}, "f26"}, {{"fs11"}, "f27"},
{{"ft8"}, "f28"}, {{"ft9"}, "f29"}, {{"ft10"}, "f30"}, {{"ft11"}, "f31"}}; {{"ft8"}, "f28"}, {{"ft9"}, "f29"}, {{"ft10"}, "f30"}, {{"ft11"}, "f31"}};
return llvm::makeArrayRef(GCCRegAliases); return llvm::ArrayRef(GCCRegAliases);
} }
bool RISCVTargetInfo::validateAsmConstraint( bool RISCVTargetInfo::validateAsmConstraint(
Context not available.
}; };
ArrayRef<Builtin::Info> RISCVTargetInfo::getTargetBuiltins() const { ArrayRef<Builtin::Info> RISCVTargetInfo::getTargetBuiltins() const {
return llvm::makeArrayRef(BuiltinInfo, clang::RISCV::LastTSBuiltin - return llvm::ArrayRef(BuiltinInfo,
Builtin::FirstTSBuiltin); clang::RISCV::LastTSBuiltin - Builtin::FirstTSBuiltin);
} }
bool RISCVTargetInfo::initFeatureMap( bool RISCVTargetInfo::initFeatureMap(
Context not available.

clang/lib/Basic/Targets/Sparc.cpp

Context not available.
}; };
ArrayRef<const char *> SparcTargetInfo::getGCCRegNames() const { ArrayRef<const char *> SparcTargetInfo::getGCCRegNames() const {
return llvm::makeArrayRef(GCCRegNames); return llvm::ArrayRef(GCCRegNames);
} }
const TargetInfo::GCCRegAlias SparcTargetInfo::GCCRegAliases[] = { const TargetInfo::GCCRegAlias SparcTargetInfo::GCCRegAliases[] = {
Context not available.
}; };
ArrayRef<TargetInfo::GCCRegAlias> SparcTargetInfo::getGCCRegAliases() const { ArrayRef<TargetInfo::GCCRegAlias> SparcTargetInfo::getGCCRegAliases() const {
return llvm::makeArrayRef(GCCRegAliases); return llvm::ArrayRef(GCCRegAliases);
} }
bool SparcTargetInfo::hasFeature(StringRef Feature) const { bool SparcTargetInfo::hasFeature(StringRef Feature) const {
Context not available.

clang/lib/Basic/Targets/SystemZ.cpp

Context not available.
}; };
ArrayRef<const char *> SystemZTargetInfo::getGCCRegNames() const { ArrayRef<const char *> SystemZTargetInfo::getGCCRegNames() const {
return llvm::makeArrayRef(GCCRegNames); return llvm::ArrayRef(GCCRegNames);
} }
ArrayRef<TargetInfo::AddlRegName> SystemZTargetInfo::getGCCAddlRegNames() const { ArrayRef<TargetInfo::AddlRegName> SystemZTargetInfo::getGCCAddlRegNames() const {
return llvm::makeArrayRef(GCCAddlRegNames); return llvm::ArrayRef(GCCAddlRegNames);
} }
bool SystemZTargetInfo::validateAsmConstraint( bool SystemZTargetInfo::validateAsmConstraint(
Context not available.
} }
ArrayRef<Builtin::Info> SystemZTargetInfo::getTargetBuiltins() const { ArrayRef<Builtin::Info> SystemZTargetInfo::getTargetBuiltins() const {
return llvm::makeArrayRef(BuiltinInfo, clang::SystemZ::LastTSBuiltin - return llvm::ArrayRef(BuiltinInfo, clang::SystemZ::LastTSBuiltin -
Builtin::FirstTSBuiltin); Builtin::FirstTSBuiltin);
} }
Context not available.

clang/lib/Basic/Targets/VE.h

Context not available.
"sx48", "sx49", "sx50", "sx51", "sx52", "sx53", "sx54", "sx55", "sx48", "sx49", "sx50", "sx51", "sx52", "sx53", "sx54", "sx55",
"sx56", "sx57", "sx58", "sx59", "sx60", "sx61", "sx62", "sx63", "sx56", "sx57", "sx58", "sx59", "sx60", "sx61", "sx62", "sx63",
}; };
return llvm::makeArrayRef(GCCRegNames); return llvm::ArrayRef(GCCRegNames);
} }
ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override { ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
Context not available.
{{"s62"}, "sx62"}, {{"s62"}, "sx62"},
{{"s63"}, "sx63"}, {{"s63"}, "sx63"},
}; };
return llvm::makeArrayRef(GCCRegAliases); return llvm::ArrayRef(GCCRegAliases);
} }
bool validateAsmConstraint(const char *&Name, bool validateAsmConstraint(const char *&Name,
Context not available.

clang/lib/Basic/Targets/VE.cpp

Context not available.
} }
ArrayRef<Builtin::Info> VETargetInfo::getTargetBuiltins() const { ArrayRef<Builtin::Info> VETargetInfo::getTargetBuiltins() const {
return llvm::makeArrayRef(BuiltinInfo, return llvm::ArrayRef(BuiltinInfo,
clang::VE::LastTSBuiltin - Builtin::FirstTSBuiltin); clang::VE::LastTSBuiltin - Builtin::FirstTSBuiltin);
} }
Context not available.

clang/lib/Basic/Targets/WebAssembly.cpp

Context not available.
} }
ArrayRef<Builtin::Info> WebAssemblyTargetInfo::getTargetBuiltins() const { ArrayRef<Builtin::Info> WebAssemblyTargetInfo::getTargetBuiltins() const {
return llvm::makeArrayRef(BuiltinInfo, clang::WebAssembly::LastTSBuiltin - return llvm::ArrayRef(BuiltinInfo, clang::WebAssembly::LastTSBuiltin -
Builtin::FirstTSBuiltin); Builtin::FirstTSBuiltin);
} }
void WebAssemblyTargetInfo::adjust(DiagnosticsEngine &Diags, void WebAssemblyTargetInfo::adjust(DiagnosticsEngine &Diags,
Context not available.

clang/lib/Basic/Targets/X86.cpp

Context not available.
} }
ArrayRef<const char *> X86TargetInfo::getGCCRegNames() const { ArrayRef<const char *> X86TargetInfo::getGCCRegNames() const {
return llvm::makeArrayRef(GCCRegNames); return llvm::ArrayRef(GCCRegNames);
} }
ArrayRef<TargetInfo::AddlRegName> X86TargetInfo::getGCCAddlRegNames() const { ArrayRef<TargetInfo::AddlRegName> X86TargetInfo::getGCCAddlRegNames() const {
return llvm::makeArrayRef(AddlRegNames); return llvm::ArrayRef(AddlRegNames);
} }
ArrayRef<Builtin::Info> X86_32TargetInfo::getTargetBuiltins() const { ArrayRef<Builtin::Info> X86_32TargetInfo::getTargetBuiltins() const {
return llvm::makeArrayRef(BuiltinInfoX86, clang::X86::LastX86CommonBuiltin - return llvm::ArrayRef(BuiltinInfoX86, clang::X86::LastX86CommonBuiltin -
Builtin::FirstTSBuiltin + 1); Builtin::FirstTSBuiltin + 1);
} }
ArrayRef<Builtin::Info> X86_64TargetInfo::getTargetBuiltins() const { ArrayRef<Builtin::Info> X86_64TargetInfo::getTargetBuiltins() const {
return llvm::makeArrayRef(BuiltinInfoX86, return llvm::ArrayRef(BuiltinInfoX86,
X86::LastTSBuiltin - Builtin::FirstTSBuiltin); X86::LastTSBuiltin - Builtin::FirstTSBuiltin);
} }
Context not available.

clang/lib/Basic/Targets/XCore.h

Context not available.
"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
"r8", "r9", "r10", "r11", "cp", "dp", "sp", "lr" "r8", "r9", "r10", "r11", "cp", "dp", "sp", "lr"
}; };
return llvm::makeArrayRef(GCCRegNames); return llvm::ArrayRef(GCCRegNames);
} }
ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override { ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
Context not available.

clang/lib/Basic/Targets/XCore.cpp

Context not available.
} }
ArrayRef<Builtin::Info> XCoreTargetInfo::getTargetBuiltins() const { ArrayRef<Builtin::Info> XCoreTargetInfo::getTargetBuiltins() const {
return llvm::makeArrayRef(BuiltinInfo, clang::XCore::LastTSBuiltin - return llvm::ArrayRef(BuiltinInfo,
Builtin::FirstTSBuiltin); clang::XCore::LastTSBuiltin - Builtin::FirstTSBuiltin);
} }
Context not available.

clang/lib/CodeGen/CGBuiltin.cpp

Context not available.
StringRef WideBytes = Str->getBytes(); StringRef WideBytes = Str->getBytes();
std::string StrUtf8; std::string StrUtf8;
if (!convertUTF16ToUTF8String( if (!convertUTF16ToUTF8String(
makeArrayRef(WideBytes.data(), WideBytes.size()), StrUtf8)) { ArrayRef(WideBytes.data(), WideBytes.size()), StrUtf8)) {
CGM.ErrorUnsupported(E, "non-UTF16 __annotation argument"); CGM.ErrorUnsupported(E, "non-UTF16 __annotation argument");
continue; continue;
} }
Context not available.
for (unsigned I = 2; I < Ops.size() - 1; ++I) for (unsigned I = 2; I < Ops.size() - 1; ++I)
Ops[I] = Builder.CreateBitCast(Ops[I], Ty); Ops[I] = Builder.CreateBitCast(Ops[I], Ty);
Ops.push_back(getAlignmentValue32(PtrOp1)); Ops.push_back(getAlignmentValue32(PtrOp1));
Ops[1] = Builder.CreateCall(F, makeArrayRef(Ops).slice(1), NameHint); Ops[1] = Builder.CreateCall(F, ArrayRef(Ops).slice(1), NameHint);
Ty = llvm::PointerType::getUnqual(Ops[1]->getType()); Ty = llvm::PointerType::getUnqual(Ops[1]->getType());
Ops[0] = Builder.CreateBitCast(Ops[0], Ty); Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]); return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
Context not available.
// Many NEON builtins have identical semantics and uses in ARM and // Many NEON builtins have identical semantics and uses in ARM and
// AArch64. Emit these in a single function. // AArch64. Emit these in a single function.
auto IntrinsicMap = makeArrayRef(ARMSIMDIntrinsicMap); auto IntrinsicMap = ArrayRef(ARMSIMDIntrinsicMap);
const ARMVectorIntrinsicInfo *Builtin = findARMVectorIntrinsicInMap( const ARMVectorIntrinsicInfo *Builtin = findARMVectorIntrinsicInMap(
IntrinsicMap, BuiltinID, NEONSIMDIntrinsicsProvenSorted); IntrinsicMap, BuiltinID, NEONSIMDIntrinsicsProvenSorted);
if (Builtin) if (Builtin)
Context not available.
Ops.push_back(EmitScalarExpr(Addr)); Ops.push_back(EmitScalarExpr(Addr));
Tys.push_back(ConvertType(Addr->getType())); Tys.push_back(ConvertType(Addr->getType()));
Function *F = CGM.getIntrinsic(IRIntr, makeArrayRef(Tys)); Function *F = CGM.getIntrinsic(IRIntr, ArrayRef(Tys));
Value *LoadResult = Builder.CreateCall(F, Ops); Value *LoadResult = Builder.CreateCall(F, Ops);
Value *MvecOut = PoisonValue::get(MvecLType); Value *MvecOut = PoisonValue::get(MvecLType);
for (unsigned i = 0; i < NumVectors; ++i) { for (unsigned i = 0; i < NumVectors; ++i) {
Context not available.
for (unsigned i = 0; i < NumVectors; i++) for (unsigned i = 0; i < NumVectors; i++)
Ops.push_back(Builder.CreateExtractValue(Mvec, {0, i})); Ops.push_back(Builder.CreateExtractValue(Mvec, {0, i}));
Function *F = CGM.getIntrinsic(IRIntr, makeArrayRef(Tys)); Function *F = CGM.getIntrinsic(IRIntr, ArrayRef(Tys));
Value *ToReturn = nullptr; Value *ToReturn = nullptr;
for (unsigned i = 0; i < NumVectors; i++) { for (unsigned i = 0; i < NumVectors; i++) {
Ops.push_back(llvm::ConstantInt::get(Int32Ty, i)); Ops.push_back(llvm::ConstantInt::get(Int32Ty, i));
Context not available.
// argument that specifies the vector type, need to handle each case. // argument that specifies the vector type, need to handle each case.
switch (BuiltinID) { switch (BuiltinID) {
case NEON::BI__builtin_neon_vtbl1_v: { case NEON::BI__builtin_neon_vtbl1_v: {
return packTBLDVectorList(CGF, makeArrayRef(Ops).slice(0, 1), nullptr, return packTBLDVectorList(CGF, ArrayRef(Ops).slice(0, 1), nullptr, Ops[1],
Ops[1], Ty, Intrinsic::aarch64_neon_tbl1, Ty, Intrinsic::aarch64_neon_tbl1, "vtbl1");
"vtbl1");
} }
case NEON::BI__builtin_neon_vtbl2_v: { case NEON::BI__builtin_neon_vtbl2_v: {
return packTBLDVectorList(CGF, makeArrayRef(Ops).slice(0, 2), nullptr, return packTBLDVectorList(CGF, ArrayRef(Ops).slice(0, 2), nullptr, Ops[2],
Ops[2], Ty, Intrinsic::aarch64_neon_tbl1, Ty, Intrinsic::aarch64_neon_tbl1, "vtbl1");
"vtbl1");
} }
case NEON::BI__builtin_neon_vtbl3_v: { case NEON::BI__builtin_neon_vtbl3_v: {
return packTBLDVectorList(CGF, makeArrayRef(Ops).slice(0, 3), nullptr, return packTBLDVectorList(CGF, ArrayRef(Ops).slice(0, 3), nullptr, Ops[3],
Ops[3], Ty, Intrinsic::aarch64_neon_tbl2, Ty, Intrinsic::aarch64_neon_tbl2, "vtbl2");
"vtbl2");
} }
case NEON::BI__builtin_neon_vtbl4_v: { case NEON::BI__builtin_neon_vtbl4_v: {
return packTBLDVectorList(CGF, makeArrayRef(Ops).slice(0, 4), nullptr, return packTBLDVectorList(CGF, ArrayRef(Ops).slice(0, 4), nullptr, Ops[4],
Ops[4], Ty, Intrinsic::aarch64_neon_tbl2, Ty, Intrinsic::aarch64_neon_tbl2, "vtbl2");
"vtbl2");
} }
case NEON::BI__builtin_neon_vtbx1_v: { case NEON::BI__builtin_neon_vtbx1_v: {
Value *TblRes = Value *TblRes =
packTBLDVectorList(CGF, makeArrayRef(Ops).slice(1, 1), nullptr, Ops[2], packTBLDVectorList(CGF, ArrayRef(Ops).slice(1, 1), nullptr, Ops[2], Ty,
Ty, Intrinsic::aarch64_neon_tbl1, "vtbl1"); Intrinsic::aarch64_neon_tbl1, "vtbl1");
llvm::Constant *EightV = ConstantInt::get(Ty, 8); llvm::Constant *EightV = ConstantInt::get(Ty, 8);
Value *CmpRes = Builder.CreateICmp(ICmpInst::ICMP_UGE, Ops[2], EightV); Value *CmpRes = Builder.CreateICmp(ICmpInst::ICMP_UGE, Ops[2], EightV);
Context not available.
return Builder.CreateOr(EltsFromInput, EltsFromTbl, "vtbx"); return Builder.CreateOr(EltsFromInput, EltsFromTbl, "vtbx");
} }
case NEON::BI__builtin_neon_vtbx2_v: { case NEON::BI__builtin_neon_vtbx2_v: {
return packTBLDVectorList(CGF, makeArrayRef(Ops).slice(1, 2), Ops[0], return packTBLDVectorList(CGF, ArrayRef(Ops).slice(1, 2), Ops[0], Ops[3],
Ops[3], Ty, Intrinsic::aarch64_neon_tbx1, Ty, Intrinsic::aarch64_neon_tbx1, "vtbx1");
"vtbx1");
} }
case NEON::BI__builtin_neon_vtbx3_v: { case NEON::BI__builtin_neon_vtbx3_v: {
Value *TblRes = Value *TblRes =
packTBLDVectorList(CGF, makeArrayRef(Ops).slice(1, 3), nullptr, Ops[4], packTBLDVectorList(CGF, ArrayRef(Ops).slice(1, 3), nullptr, Ops[4], Ty,
Ty, Intrinsic::aarch64_neon_tbl2, "vtbl2"); Intrinsic::aarch64_neon_tbl2, "vtbl2");
llvm::Constant *TwentyFourV = ConstantInt::get(Ty, 24); llvm::Constant *TwentyFourV = ConstantInt::get(Ty, 24);
Value *CmpRes = Builder.CreateICmp(ICmpInst::ICMP_UGE, Ops[4], Value *CmpRes = Builder.CreateICmp(ICmpInst::ICMP_UGE, Ops[4],
Context not available.
return Builder.CreateOr(EltsFromInput, EltsFromTbl, "vtbx"); return Builder.CreateOr(EltsFromInput, EltsFromTbl, "vtbx");
} }
case NEON::BI__builtin_neon_vtbx4_v: { case NEON::BI__builtin_neon_vtbx4_v: {
return packTBLDVectorList(CGF, makeArrayRef(Ops).slice(1, 4), Ops[0], return packTBLDVectorList(CGF, ArrayRef(Ops).slice(1, 4), Ops[0], Ops[5],
Ops[5], Ty, Intrinsic::aarch64_neon_tbx2, Ty, Intrinsic::aarch64_neon_tbx2, "vtbx2");
"vtbx2");
} }
case NEON::BI__builtin_neon_vqtbl1_v: case NEON::BI__builtin_neon_vqtbl1_v:
case NEON::BI__builtin_neon_vqtbl1q_v: case NEON::BI__builtin_neon_vqtbl1q_v:
Context not available.
} }
} }
auto SISDMap = makeArrayRef(AArch64SISDIntrinsicMap); auto SISDMap = ArrayRef(AArch64SISDIntrinsicMap);
const ARMVectorIntrinsicInfo *Builtin = findARMVectorIntrinsicInMap( const ARMVectorIntrinsicInfo *Builtin = findARMVectorIntrinsicInMap(
SISDMap, BuiltinID, AArch64SISDIntrinsicsProvenSorted); SISDMap, BuiltinID, AArch64SISDIntrinsicsProvenSorted);
Context not available.
Ops[1] = Builder.CreateBitCast(Ops[1], Ty); Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
Ops[2] = Builder.CreateBitCast(Ops[2], Ty); Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
Ops[3] = Builder.CreateZExt(Ops[3], Int64Ty); Ops[3] = Builder.CreateZExt(Ops[3], Int64Ty);
Ops[1] = Builder.CreateCall(F, makeArrayRef(Ops).slice(1), "vld2_lane"); Ops[1] = Builder.CreateCall(F, ArrayRef(Ops).slice(1), "vld2_lane");
Ty = llvm::PointerType::getUnqual(Ops[1]->getType()); Ty = llvm::PointerType::getUnqual(Ops[1]->getType());
Ops[0] = Builder.CreateBitCast(Ops[0], Ty); Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]); return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
Context not available.
Ops[2] = Builder.CreateBitCast(Ops[2], Ty); Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
Ops[3] = Builder.CreateBitCast(Ops[3], Ty); Ops[3] = Builder.CreateBitCast(Ops[3], Ty);
Ops[4] = Builder.CreateZExt(Ops[4], Int64Ty); Ops[4] = Builder.CreateZExt(Ops[4], Int64Ty);
Ops[1] = Builder.CreateCall(F, makeArrayRef(Ops).slice(1), "vld3_lane"); Ops[1] = Builder.CreateCall(F, ArrayRef(Ops).slice(1), "vld3_lane");
Ty = llvm::PointerType::getUnqual(Ops[1]->getType()); Ty = llvm::PointerType::getUnqual(Ops[1]->getType());
Ops[0] = Builder.CreateBitCast(Ops[0], Ty); Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]); return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
Context not available.
Ops[3] = Builder.CreateBitCast(Ops[3], Ty); Ops[3] = Builder.CreateBitCast(Ops[3], Ty);
Ops[4] = Builder.CreateBitCast(Ops[4], Ty); Ops[4] = Builder.CreateBitCast(Ops[4], Ty);
Ops[5] = Builder.CreateZExt(Ops[5], Int64Ty); Ops[5] = Builder.CreateZExt(Ops[5], Int64Ty);
Ops[1] = Builder.CreateCall(F, makeArrayRef(Ops).slice(1), "vld4_lane"); Ops[1] = Builder.CreateCall(F, ArrayRef(Ops).slice(1), "vld4_lane");
Ty = llvm::PointerType::getUnqual(Ops[1]->getType()); Ty = llvm::PointerType::getUnqual(Ops[1]->getType());
Ops[0] = Builder.CreateBitCast(Ops[0], Ty); Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]); return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
Context not available.
int Indices[4]; int Indices[4];
for (unsigned i = 0; i != NumElts; ++i) for (unsigned i = 0; i != NumElts; ++i)
Indices[i] = i; Indices[i] = i;
MaskVec = CGF.Builder.CreateShuffleVector(MaskVec, MaskVec, MaskVec = CGF.Builder.CreateShuffleVector(
makeArrayRef(Indices, NumElts), MaskVec, MaskVec, ArrayRef(Indices, NumElts), "extract");
"extract");
} }
return MaskVec; return MaskVec;
} }
Context not available.
for (unsigned i = 0; i != NumElts; ++i) for (unsigned i = 0; i != NumElts; ++i)
Indices[i] = i + Index; Indices[i] = i + Index;
Value *Res = Builder.CreateShuffleVector(Ops[0], Value *Res = Builder.CreateShuffleVector(Ops[0], ArrayRef(Indices, NumElts),
makeArrayRef(Indices, NumElts),
"extract"); "extract");
if (Ops.size() == 4) if (Ops.size() == 4)
Context not available.
for (unsigned i = 0; i != DstNumElts; ++i) for (unsigned i = 0; i != DstNumElts; ++i)
Indices[i] = (i >= SrcNumElts) ? SrcNumElts + (i % SrcNumElts) : i; Indices[i] = (i >= SrcNumElts) ? SrcNumElts + (i % SrcNumElts) : i;
Value *Op1 = Builder.CreateShuffleVector(Ops[1], Value *Op1 = Builder.CreateShuffleVector(
makeArrayRef(Indices, DstNumElts), Ops[1], ArrayRef(Indices, DstNumElts), "widen");
"widen");
for (unsigned i = 0; i != DstNumElts; ++i) { for (unsigned i = 0; i != DstNumElts; ++i) {
if (i >= Index && i < (Index + SrcNumElts)) if (i >= Index && i < (Index + SrcNumElts))
Context not available.
} }
return Builder.CreateShuffleVector(Ops[0], Op1, return Builder.CreateShuffleVector(Ops[0], Op1,
makeArrayRef(Indices, DstNumElts), ArrayRef(Indices, DstNumElts), "insert");
"insert");
} }
case X86::BI__builtin_ia32_pmovqd512_mask: case X86::BI__builtin_ia32_pmovqd512_mask:
case X86::BI__builtin_ia32_pmovwb512_mask: { case X86::BI__builtin_ia32_pmovwb512_mask: {
Context not available.
Indices[i] = ((Imm >> (i % 8)) & 0x1) ? NumElts + i : i; Indices[i] = ((Imm >> (i % 8)) & 0x1) ? NumElts + i : i;
return Builder.CreateShuffleVector(Ops[0], Ops[1], return Builder.CreateShuffleVector(Ops[0], Ops[1],
makeArrayRef(Indices, NumElts), ArrayRef(Indices, NumElts), "blend");
"blend");
} }
case X86::BI__builtin_ia32_pshuflw: case X86::BI__builtin_ia32_pshuflw:
case X86::BI__builtin_ia32_pshuflw256: case X86::BI__builtin_ia32_pshuflw256:
Context not available.
Indices[l + i] = l + i; Indices[l + i] = l + i;
} }
return Builder.CreateShuffleVector(Ops[0], makeArrayRef(Indices, NumElts), return Builder.CreateShuffleVector(Ops[0], ArrayRef(Indices, NumElts),
"pshuflw"); "pshuflw");
} }
case X86::BI__builtin_ia32_pshufhw: case X86::BI__builtin_ia32_pshufhw:
Context not available.
} }
} }
return Builder.CreateShuffleVector(Ops[0], makeArrayRef(Indices, NumElts), return Builder.CreateShuffleVector(Ops[0], ArrayRef(Indices, NumElts),
"pshufhw"); "pshufhw");
} }
case X86::BI__builtin_ia32_pshufd: case X86::BI__builtin_ia32_pshufd:
Context not available.
} }
} }
return Builder.CreateShuffleVector(Ops[0], makeArrayRef(Indices, NumElts), return Builder.CreateShuffleVector(Ops[0], ArrayRef(Indices, NumElts),
"permil"); "permil");
} }
case X86::BI__builtin_ia32_shufpd: case X86::BI__builtin_ia32_shufpd:
Context not available.
} }
return Builder.CreateShuffleVector(Ops[0], Ops[1], return Builder.CreateShuffleVector(Ops[0], Ops[1],
makeArrayRef(Indices, NumElts), ArrayRef(Indices, NumElts), "shufp");
"shufp");
} }
case X86::BI__builtin_ia32_permdi256: case X86::BI__builtin_ia32_permdi256:
case X86::BI__builtin_ia32_permdf256: case X86::BI__builtin_ia32_permdf256:
Context not available.
for (unsigned i = 0; i != 4; ++i) for (unsigned i = 0; i != 4; ++i)
Indices[l + i] = l + ((Imm >> (2 * i)) & 0x3); Indices[l + i] = l + ((Imm >> (2 * i)) & 0x3);
return Builder.CreateShuffleVector(Ops[0], makeArrayRef(Indices, NumElts), return Builder.CreateShuffleVector(Ops[0], ArrayRef(Indices, NumElts),
"perm"); "perm");
} }
case X86::BI__builtin_ia32_palignr128: case X86::BI__builtin_ia32_palignr128:
Context not available.
} }
return Builder.CreateShuffleVector(Ops[1], Ops[0], return Builder.CreateShuffleVector(Ops[1], Ops[0],
makeArrayRef(Indices, NumElts), ArrayRef(Indices, NumElts), "palignr");
"palignr");
} }
case X86::BI__builtin_ia32_alignd128: case X86::BI__builtin_ia32_alignd128:
case X86::BI__builtin_ia32_alignd256: case X86::BI__builtin_ia32_alignd256:
Context not available.
Indices[i] = i + ShiftVal; Indices[i] = i + ShiftVal;
return Builder.CreateShuffleVector(Ops[1], Ops[0], return Builder.CreateShuffleVector(Ops[1], Ops[0],
makeArrayRef(Indices, NumElts), ArrayRef(Indices, NumElts), "valign");
"valign");
} }
case X86::BI__builtin_ia32_shuf_f32x4_256: case X86::BI__builtin_ia32_shuf_f32x4_256:
case X86::BI__builtin_ia32_shuf_f64x2_256: case X86::BI__builtin_ia32_shuf_f64x2_256:
Context not available.
} }
return Builder.CreateShuffleVector(Ops[0], Ops[1], return Builder.CreateShuffleVector(Ops[0], Ops[1],
makeArrayRef(Indices, NumElts), ArrayRef(Indices, NumElts), "shuf");
"shuf");
} }
case X86::BI__builtin_ia32_vperm2f128_pd256: case X86::BI__builtin_ia32_vperm2f128_pd256:
Context not available.
} }
return Builder.CreateShuffleVector(OutOps[0], OutOps[1], return Builder.CreateShuffleVector(OutOps[0], OutOps[1],
makeArrayRef(Indices, NumElts), ArrayRef(Indices, NumElts), "vperm");
"vperm");
} }
case X86::BI__builtin_ia32_pslldqi128_byteshift: case X86::BI__builtin_ia32_pslldqi128_byteshift:
Context not available.
auto *VecTy = llvm::FixedVectorType::get(Int8Ty, NumElts); auto *VecTy = llvm::FixedVectorType::get(Int8Ty, NumElts);
Value *Cast = Builder.CreateBitCast(Ops[0], VecTy, "cast"); Value *Cast = Builder.CreateBitCast(Ops[0], VecTy, "cast");
Value *Zero = llvm::Constant::getNullValue(VecTy); Value *Zero = llvm::Constant::getNullValue(VecTy);
Value *SV = Builder.CreateShuffleVector(Zero, Cast, Value *SV = Builder.CreateShuffleVector(
makeArrayRef(Indices, NumElts), Zero, Cast, ArrayRef(Indices, NumElts), "pslldq");
"pslldq");
return Builder.CreateBitCast(SV, Ops[0]->getType(), "cast"); return Builder.CreateBitCast(SV, Ops[0]->getType(), "cast");
} }
case X86::BI__builtin_ia32_psrldqi128_byteshift: case X86::BI__builtin_ia32_psrldqi128_byteshift:
Context not available.
auto *VecTy = llvm::FixedVectorType::get(Int8Ty, NumElts); auto *VecTy = llvm::FixedVectorType::get(Int8Ty, NumElts);
Value *Cast = Builder.CreateBitCast(Ops[0], VecTy, "cast"); Value *Cast = Builder.CreateBitCast(Ops[0], VecTy, "cast");
Value *Zero = llvm::Constant::getNullValue(VecTy); Value *Zero = llvm::Constant::getNullValue(VecTy);
Value *SV = Builder.CreateShuffleVector(Cast, Zero, Value *SV = Builder.CreateShuffleVector(
makeArrayRef(Indices, NumElts), Cast, Zero, ArrayRef(Indices, NumElts), "psrldq");
"psrldq");
return Builder.CreateBitCast(SV, ResultType, "cast"); return Builder.CreateBitCast(SV, ResultType, "cast");
} }
case X86::BI__builtin_ia32_kshiftliqi: case X86::BI__builtin_ia32_kshiftliqi:
Context not available.
Indices[i] = NumElts + i - ShiftVal; Indices[i] = NumElts + i - ShiftVal;
Value *Zero = llvm::Constant::getNullValue(In->getType()); Value *Zero = llvm::Constant::getNullValue(In->getType());
Value *SV = Builder.CreateShuffleVector(Zero, In, Value *SV = Builder.CreateShuffleVector(
makeArrayRef(Indices, NumElts), Zero, In, ArrayRef(Indices, NumElts), "kshiftl");
"kshiftl");
return Builder.CreateBitCast(SV, Ops[0]->getType()); return Builder.CreateBitCast(SV, Ops[0]->getType());
} }
case X86::BI__builtin_ia32_kshiftriqi: case X86::BI__builtin_ia32_kshiftriqi:
Context not available.
Indices[i] = i + ShiftVal; Indices[i] = i + ShiftVal;
Value *Zero = llvm::Constant::getNullValue(In->getType()); Value *Zero = llvm::Constant::getNullValue(In->getType());
Value *SV = Builder.CreateShuffleVector(In, Zero, Value *SV = Builder.CreateShuffleVector(
makeArrayRef(Indices, NumElts), In, Zero, ArrayRef(Indices, NumElts), "kshiftr");
"kshiftr");
return Builder.CreateBitCast(SV, Ops[0]->getType()); return Builder.CreateBitCast(SV, Ops[0]->getType());
} }
case X86::BI__builtin_ia32_movnti: case X86::BI__builtin_ia32_movnti:
Context not available.
// First extract half of each vector. This gives better codegen than // First extract half of each vector. This gives better codegen than
// doing it in a single shuffle. // doing it in a single shuffle.
LHS = Builder.CreateShuffleVector(LHS, LHS, LHS = Builder.CreateShuffleVector(LHS, LHS, ArrayRef(Indices, NumElts / 2));
makeArrayRef(Indices, NumElts / 2)); RHS = Builder.CreateShuffleVector(RHS, RHS, ArrayRef(Indices, NumElts / 2));
RHS = Builder.CreateShuffleVector(RHS, RHS,
makeArrayRef(Indices, NumElts / 2));
// Concat the vectors. // Concat the vectors.
// NOTE: Operands are swapped to match the intrinsic definition. // NOTE: Operands are swapped to match the intrinsic definition.
Value *Res = Builder.CreateShuffleVector(RHS, LHS, Value *Res =
makeArrayRef(Indices, NumElts)); Builder.CreateShuffleVector(RHS, LHS, ArrayRef(Indices, NumElts));
return Builder.CreateBitCast(Res, Ops[0]->getType()); return Builder.CreateBitCast(Res, Ops[0]->getType());
} }
Context not available.

clang/lib/CodeGen/CGExprConstant.cpp

Context not available.
} }
llvm::Constant *Replacement = buildFrom( llvm::Constant *Replacement = buildFrom(
CGM, makeArrayRef(Elems).slice(First, Length), CGM, ArrayRef(Elems).slice(First, Length),
makeArrayRef(Offsets).slice(First, Length), Offset, getSize(DesiredTy), ArrayRef(Offsets).slice(First, Length), Offset, getSize(DesiredTy),
/*known to have natural layout=*/false, DesiredTy, false); /*known to have natural layout=*/false, DesiredTy, false);
replace(Elems, First, Last, {Replacement}); replace(Elems, First, Last, {Replacement});
replace(Offsets, First, Last, {Offset}); replace(Offsets, First, Last, {Offset});
Context not available.
if (CommonElementType && NonzeroLength >= 8) { if (CommonElementType && NonzeroLength >= 8) {
llvm::Constant *Initial = llvm::ConstantArray::get( llvm::Constant *Initial = llvm::ConstantArray::get(
llvm::ArrayType::get(CommonElementType, NonzeroLength), llvm::ArrayType::get(CommonElementType, NonzeroLength),
makeArrayRef(Elements).take_front(NonzeroLength)); ArrayRef(Elements).take_front(NonzeroLength));
Elements.resize(2); Elements.resize(2);
Elements[0] = Initial; Elements[0] = Initial;
} else { } else {
Context not available.

clang/lib/CodeGen/CGExprScalar.cpp

Context not available.
static Value *ConvertVec3AndVec4(CGBuilderTy &Builder, CodeGenFunction &CGF, static Value *ConvertVec3AndVec4(CGBuilderTy &Builder, CodeGenFunction &CGF,
Value *Src, unsigned NumElementsDst) { Value *Src, unsigned NumElementsDst) {
static constexpr int Mask[] = {0, 1, 2, -1}; static constexpr int Mask[] = {0, 1, 2, -1};
return Builder.CreateShuffleVector(Src, return Builder.CreateShuffleVector(Src, llvm::ArrayRef(Mask, NumElementsDst));
llvm::makeArrayRef(Mask, NumElementsDst));
} }
// Create cast instructions for converting LLVM value \p Src to LLVM type \p // Create cast instructions for converting LLVM value \p Src to LLVM type \p
Context not available.

clang/lib/CodeGen/CGObjCGNU.cpp

Context not available.
// Hash. Not currently initialised by the compiler. // Hash. Not currently initialised by the compiler.
Fields.addInt(Int32Ty, 0); Fields.addInt(Int32Ty, 0);
// pointer to the data string. // pointer to the data string.
auto Arr = llvm::makeArrayRef(&ToBuf[0], ToPtr+1); auto Arr = llvm::ArrayRef(&ToBuf[0], ToPtr + 1);
auto *C = llvm::ConstantDataArray::get(VMContext, Arr); auto *C = llvm::ConstantDataArray::get(VMContext, Arr);
auto *Buffer = new llvm::GlobalVariable(TheModule, C->getType(), auto *Buffer = new llvm::GlobalVariable(TheModule, C->getType(),
/*isConstant=*/true, llvm::GlobalValue::PrivateLinkage, C, ".str"); /*isConstant=*/true, llvm::GlobalValue::PrivateLinkage, C, ".str");
Context not available.
llvm::Type *moduleEltTys[] = { llvm::Type *moduleEltTys[] = {
LongTy, LongTy, PtrToInt8Ty, symtab->getType(), IntTy LongTy, LongTy, PtrToInt8Ty, symtab->getType(), IntTy
}; };
llvm::StructType *moduleTy = llvm::StructType *moduleTy = llvm::StructType::get(
llvm::StructType::get(CGM.getLLVMContext(), CGM.getLLVMContext(),
makeArrayRef(moduleEltTys).drop_back(unsigned(RuntimeVersion < 10))); ArrayRef(moduleEltTys).drop_back(unsigned(RuntimeVersion < 10)));
ConstantInitBuilder builder(CGM); ConstantInitBuilder builder(CGM);
auto module = builder.beginStruct(moduleTy); auto module = builder.beginStruct(moduleTy);
Context not available.

clang/lib/CodeGen/CGOpenMPRuntime.cpp

Context not available.
std::tie(Components, MapType, MapModifiers, IsImplicit, Mapper, VarRef) = std::tie(Components, MapType, MapModifiers, IsImplicit, Mapper, VarRef) =
L; L;
++Count; ++Count;
for (const MapData &L1 : makeArrayRef(DeclComponentLists).slice(Count)) { for (const MapData &L1 : ArrayRef(DeclComponentLists).slice(Count)) {
OMPClauseMappableExprCommon::MappableExprComponentListRef Components1; OMPClauseMappableExprCommon::MappableExprComponentListRef Components1;
std::tie(Components1, MapType, MapModifiers, IsImplicit, Mapper, std::tie(Components1, MapType, MapModifiers, IsImplicit, Mapper,
VarRef) = L1; VarRef) = L1;
Context not available.
llvm::FunctionCallee FiniRTLFn = OMPBuilder.getOrCreateRuntimeFunction( llvm::FunctionCallee FiniRTLFn = OMPBuilder.getOrCreateRuntimeFunction(
CGM.getModule(), OMPRTL___kmpc_doacross_fini); CGM.getModule(), OMPRTL___kmpc_doacross_fini);
CGF.EHStack.pushCleanup<DoacrossCleanupTy>(NormalAndEHCleanup, FiniRTLFn, CGF.EHStack.pushCleanup<DoacrossCleanupTy>(NormalAndEHCleanup, FiniRTLFn,
llvm::makeArrayRef(FiniArgs)); llvm::ArrayRef(FiniArgs));
} }
void CGOpenMPRuntime::emitDoacrossOrdered(CodeGenFunction &CGF, void CGOpenMPRuntime::emitDoacrossOrdered(CodeGenFunction &CGF,
Context not available.

clang/lib/CodeGen/CGStmtOpenMP.cpp

Context not available.
*this, *this,
[&S]() -> ArrayRef<const Expr *> { [&S]() -> ArrayRef<const Expr *> {
if (const auto *FlushClause = S.getSingleClause<OMPFlushClause>()) if (const auto *FlushClause = S.getSingleClause<OMPFlushClause>())
return llvm::makeArrayRef(FlushClause->varlist_begin(), return llvm::ArrayRef(FlushClause->varlist_begin(),
FlushClause->varlist_end()); FlushClause->varlist_end());
return std::nullopt; return std::nullopt;
}(), }(),
S.getBeginLoc(), AO); S.getBeginLoc(), AO);
Context not available.

clang/lib/CodeGen/CodeGenFunction.cpp

Context not available.
auto FuncGroups = CGM.getCodeGenOpts().XRayTotalFunctionGroups; auto FuncGroups = CGM.getCodeGenOpts().XRayTotalFunctionGroups;
if (FuncGroups > 1) { if (FuncGroups > 1) {
auto FuncName = llvm::makeArrayRef<uint8_t>( auto FuncName = llvm::ArrayRef<uint8_t>(CurFn->getName().bytes_begin(),
CurFn->getName().bytes_begin(), CurFn->getName().bytes_end()); CurFn->getName().bytes_end());
auto Group = crc32(FuncName) % FuncGroups; auto Group = crc32(FuncName) % FuncGroups;
if (Group != CGM.getCodeGenOpts().XRaySelectedFunctionGroup && if (Group != CGM.getCodeGenOpts().XRaySelectedFunctionGroup &&
!AlwaysXRayAttr) !AlwaysXRayAttr)
Context not available.

clang/lib/CodeGen/CodeGenModule.cpp

Context not available.
// String pointer. // String pointer.
llvm::Constant *C = nullptr; llvm::Constant *C = nullptr;
if (isUTF16) { if (isUTF16) {
auto Arr = llvm::makeArrayRef( auto Arr = llvm::ArrayRef(
reinterpret_cast<uint16_t *>(const_cast<char *>(Entry.first().data())), reinterpret_cast<uint16_t *>(const_cast<char *>(Entry.first().data())),
Entry.first().size() / 2); Entry.first().size() / 2);
C = llvm::ConstantDataArray::get(VMContext, Arr); C = llvm::ConstantDataArray::get(VMContext, Arr);
Context not available.

clang/lib/CodeGen/CodeGenPGO.cpp

Context not available.
if (Count && Count % NumTypesPerWord == 0) { if (Count && Count % NumTypesPerWord == 0) {
using namespace llvm::support; using namespace llvm::support;
uint64_t Swapped = endian::byte_swap<uint64_t, little>(Working); uint64_t Swapped = endian::byte_swap<uint64_t, little>(Working);
MD5.update(llvm::makeArrayRef((uint8_t *)&Swapped, sizeof(Swapped))); MD5.update(llvm::ArrayRef((uint8_t *)&Swapped, sizeof(Swapped)));
Working = 0; Working = 0;
} }
Context not available.
} else { } else {
using namespace llvm::support; using namespace llvm::support;
uint64_t Swapped = endian::byte_swap<uint64_t, little>(Working); uint64_t Swapped = endian::byte_swap<uint64_t, little>(Working);
MD5.update(llvm::makeArrayRef((uint8_t *)&Swapped, sizeof(Swapped))); MD5.update(llvm::ArrayRef((uint8_t *)&Swapped, sizeof(Swapped)));
} }
} }
Context not available.
Builder.getInt32(Counter), StepV}; Builder.getInt32(Counter), StepV};
if (!StepV) if (!StepV)
Builder.CreateCall(CGM.getIntrinsic(llvm::Intrinsic::instrprof_increment), Builder.CreateCall(CGM.getIntrinsic(llvm::Intrinsic::instrprof_increment),
makeArrayRef(Args, 4)); ArrayRef(Args, 4));
else else
Builder.CreateCall( Builder.CreateCall(
CGM.getIntrinsic(llvm::Intrinsic::instrprof_increment_step), CGM.getIntrinsic(llvm::Intrinsic::instrprof_increment_step),
makeArrayRef(Args)); ArrayRef(Args));
} }
void CodeGenPGO::setValueProfilingFlag(llvm::Module &M) { void CodeGenPGO::setValueProfilingFlag(llvm::Module &M) {
Context not available.

clang/lib/CodeGen/CodeGenTypes.cpp

Context not available.
ResultType, ResultType,
llvm::ArrayType::get(CGM.Int8Ty, (atomicSize - valueSize) / 8) llvm::ArrayType::get(CGM.Int8Ty, (atomicSize - valueSize) / 8)
}; };
ResultType = llvm::StructType::get(getLLVMContext(), ResultType =
llvm::makeArrayRef(elts)); llvm::StructType::get(getLLVMContext(), llvm::ArrayRef(elts));
} }
break; break;
} }
Context not available.

clang/lib/CodeGen/ConstantInitBuilder.cpp

Context not available.
assert((Begin < buffer.size() || assert((Begin < buffer.size() ||
(Begin == buffer.size() && eltTy)) (Begin == buffer.size() && eltTy))
&& "didn't add any array elements without element type"); && "didn't add any array elements without element type");
auto elts = llvm::makeArrayRef(buffer).slice(Begin); auto elts = llvm::ArrayRef(buffer).slice(Begin);
if (!eltTy) eltTy = elts[0]->getType(); if (!eltTy) eltTy = elts[0]->getType();
auto type = llvm::ArrayType::get(eltTy, elts.size()); auto type = llvm::ArrayType::get(eltTy, elts.size());
auto constant = llvm::ConstantArray::get(type, elts); auto constant = llvm::ConstantArray::get(type, elts);
Context not available.
markFinished(); markFinished();
auto &buffer = getBuffer(); auto &buffer = getBuffer();
auto elts = llvm::makeArrayRef(buffer).slice(Begin); auto elts = llvm::ArrayRef(buffer).slice(Begin);
if (ty == nullptr && elts.empty()) if (ty == nullptr && elts.empty())
ty = llvm::StructType::get(Builder.CGM.getLLVMContext(), {}, Packed); ty = llvm::StructType::get(Builder.CGM.getLLVMContext(), {}, Packed);
Context not available.

clang/lib/CodeGen/CoverageMappingGen.cpp

Context not available.
#include "llvm/ProfileData/InstrProfData.inc" #include "llvm/ProfileData/InstrProfData.inc"
}; };
auto *FunctionRecordTy = auto *FunctionRecordTy =
llvm::StructType::get(Ctx, makeArrayRef(FunctionRecordTypes), llvm::StructType::get(Ctx, ArrayRef(FunctionRecordTypes),
/*isPacked=*/true); /*isPacked=*/true);
// Create the function record constant. // Create the function record constant.
Context not available.
llvm::Constant *FunctionRecordVals[] = { llvm::Constant *FunctionRecordVals[] = {
#include "llvm/ProfileData/InstrProfData.inc" #include "llvm/ProfileData/InstrProfData.inc"
}; };
auto *FuncRecordConstant = llvm::ConstantStruct::get( auto *FuncRecordConstant =
FunctionRecordTy, makeArrayRef(FunctionRecordVals)); llvm::ConstantStruct::get(FunctionRecordTy, ArrayRef(FunctionRecordVals));
// Create the function record global. // Create the function record global.
auto *FuncRecord = new llvm::GlobalVariable( auto *FuncRecord = new llvm::GlobalVariable(
Context not available.
auto I = Entry.second; auto I = Entry.second;
FilenameStrs[I] = normalizeFilename(Entry.first->getName()); FilenameStrs[I] = normalizeFilename(Entry.first->getName());
} }
ArrayRef<std::string> FilenameRefs = llvm::makeArrayRef(FilenameStrs); ArrayRef<std::string> FilenameRefs = llvm::ArrayRef(FilenameStrs);
RawCoverageMappingReader Reader(CoverageMapping, FilenameRefs, Filenames, RawCoverageMappingReader Reader(CoverageMapping, FilenameRefs, Filenames,
Expressions, Regions); Expressions, Regions);
if (Reader.read()) if (Reader.read())
Context not available.
#include "llvm/ProfileData/InstrProfData.inc" #include "llvm/ProfileData/InstrProfData.inc"
}; };
auto CovDataHeaderTy = auto CovDataHeaderTy =
llvm::StructType::get(Ctx, makeArrayRef(CovDataHeaderTypes)); llvm::StructType::get(Ctx, ArrayRef(CovDataHeaderTypes));
llvm::Constant *CovDataHeaderVals[] = { llvm::Constant *CovDataHeaderVals[] = {
#define COVMAP_HEADER(Type, LLVMType, Name, Init) Init, #define COVMAP_HEADER(Type, LLVMType, Name, Init) Init,
#include "llvm/ProfileData/InstrProfData.inc" #include "llvm/ProfileData/InstrProfData.inc"
}; };
auto CovDataHeaderVal = llvm::ConstantStruct::get( auto CovDataHeaderVal =
CovDataHeaderTy, makeArrayRef(CovDataHeaderVals)); llvm::ConstantStruct::get(CovDataHeaderTy, ArrayRef(CovDataHeaderVals));
// Create the coverage data record // Create the coverage data record
llvm::Type *CovDataTypes[] = {CovDataHeaderTy, FilenamesVal->getType()}; llvm::Type *CovDataTypes[] = {CovDataHeaderTy, FilenamesVal->getType()};
auto CovDataTy = llvm::StructType::get(Ctx, makeArrayRef(CovDataTypes)); auto CovDataTy = llvm::StructType::get(Ctx, ArrayRef(CovDataTypes));
llvm::Constant *TUDataVals[] = {CovDataHeaderVal, FilenamesVal}; llvm::Constant *TUDataVals[] = {CovDataHeaderVal, FilenamesVal};
auto CovDataVal = auto CovDataVal = llvm::ConstantStruct::get(CovDataTy, ArrayRef(TUDataVals));
llvm::ConstantStruct::get(CovDataTy, makeArrayRef(TUDataVals));
auto CovData = new llvm::GlobalVariable( auto CovData = new llvm::GlobalVariable(
CGM.getModule(), CovDataTy, true, llvm::GlobalValue::PrivateLinkage, CGM.getModule(), CovDataTy, true, llvm::GlobalValue::PrivateLinkage,
CovDataVal, llvm::getCoverageMappingVarName()); CovDataVal, llvm::getCoverageMappingVarName());
Context not available.

clang/lib/CodeGen/MicrosoftCXXABI.cpp

Context not available.
CodeGenFunction::RunCleanupsScope Cleanups(CGF); CodeGenFunction::RunCleanupsScope Cleanups(CGF);
const auto *FPT = CD->getType()->castAs<FunctionProtoType>(); const auto *FPT = CD->getType()->castAs<FunctionProtoType>();
CGF.EmitCallArgs(Args, FPT, llvm::makeArrayRef(ArgVec), CD, IsCopy ? 1 : 0); CGF.EmitCallArgs(Args, FPT, llvm::ArrayRef(ArgVec), CD, IsCopy ? 1 : 0);
// Insert any ABI-specific implicit constructor arguments. // Insert any ABI-specific implicit constructor arguments.
AddedStructorArgCounts ExtraArgs = AddedStructorArgCounts ExtraArgs =
Context not available.
llvm::ArrayType *AT = llvm::ArrayType::get(CTType, NumEntries); llvm::ArrayType *AT = llvm::ArrayType::get(CTType, NumEntries);
llvm::StructType *CTAType = getCatchableTypeArrayType(NumEntries); llvm::StructType *CTAType = getCatchableTypeArrayType(NumEntries);
llvm::Constant *Fields[] = { llvm::Constant *Fields[] = {
llvm::ConstantInt::get(CGM.IntTy, NumEntries), // NumEntries llvm::ConstantInt::get(CGM.IntTy, NumEntries), // NumEntries
llvm::ConstantArray::get( llvm::ConstantArray::get(
AT, llvm::makeArrayRef(CatchableTypes.begin(), AT, llvm::ArrayRef(CatchableTypes.begin(),
CatchableTypes.end())) // CatchableTypes CatchableTypes.end())) // CatchableTypes
}; };
SmallString<256> MangledName; SmallString<256> MangledName;
{ {
Context not available.

clang/lib/CodeGen/TargetInfo.cpp

Context not available.
// Check if Ty is a usable substitute for the coercion type. // Check if Ty is a usable substitute for the coercion type.
bool isUsableType(llvm::StructType *Ty) const { bool isUsableType(llvm::StructType *Ty) const {
return llvm::makeArrayRef(Elems) == Ty->elements(); return llvm::ArrayRef(Elems) == Ty->elements();
} }
// Get the coercion type as a literal struct type. // Get the coercion type as a literal struct type.
Context not available.

clang/lib/Driver/Job.cpp

Context not available.
assert(Environment.back() == nullptr && assert(Environment.back() == nullptr &&
"Environment vector should be null-terminated by now"); "Environment vector should be null-terminated by now");
ArgvVectorStorage = llvm::toStringRefArray(Environment.data()); ArgvVectorStorage = llvm::toStringRefArray(Environment.data());
Env = makeArrayRef(ArgvVectorStorage); Env = ArrayRef(ArgvVectorStorage);
} }
auto Args = llvm::toStringRefArray(Argv.data()); auto Args = llvm::toStringRefArray(Argv.data());
Context not available.
RedirectFilesOptional.push_back(std::nullopt); RedirectFilesOptional.push_back(std::nullopt);
return llvm::sys::ExecuteAndWait(Executable, Args, Env, return llvm::sys::ExecuteAndWait(Executable, Args, Env,
makeArrayRef(RedirectFilesOptional), ArrayRef(RedirectFilesOptional),
/*secondsToWait=*/0, /*memoryLimit=*/0, /*secondsToWait=*/0, /*memoryLimit=*/0,
ErrMsg, ExecutionFailed, &ProcStat); ErrMsg, ExecutionFailed, &ProcStat);
} }
Context not available.

clang/lib/Driver/ToolChains/Darwin.cpp

Context not available.
}; };
static_assert(std::size(EnvVars) == Darwin::LastDarwinPlatform + 1, static_assert(std::size(EnvVars) == Darwin::LastDarwinPlatform + 1,
"Missing platform"); "Missing platform");
for (const auto &I : llvm::enumerate(llvm::makeArrayRef(EnvVars))) { for (const auto &I : llvm::enumerate(llvm::ArrayRef(EnvVars))) {
if (char *Env = ::getenv(I.value())) if (char *Env = ::getenv(I.value()))
Targets[I.index()] = Env; Targets[I.index()] = Env;
} }
Context not available.
} }
} }
for (const auto &Target : llvm::enumerate(llvm::makeArrayRef(Targets))) { for (const auto &Target : llvm::enumerate(llvm::ArrayRef(Targets))) {
if (!Target.value().empty()) if (!Target.value().empty())
return DarwinPlatform::createDeploymentTargetEnv( return DarwinPlatform::createDeploymentTargetEnv(
(Darwin::DarwinPlatformKind)Target.index(), EnvVars[Target.index()], (Darwin::DarwinPlatformKind)Target.index(), EnvVars[Target.index()],
Context not available.

clang/lib/Format/MacroCallReconstructor.cpp

Context not available.
// Note that the token's expanded from stack is inside-to-outside, and the // Note that the token's expanded from stack is inside-to-outside, and the
// expansions for which this token is not the first are the outermost ones. // expansions for which this token is not the first are the outermost ones.
ArrayRef<FormatToken *> StartedMacros = ArrayRef<FormatToken *> StartedMacros =
makeArrayRef(Token->MacroCtx->ExpandedFrom) ArrayRef(Token->MacroCtx->ExpandedFrom)
.drop_back(ActiveExpansions.size()); .drop_back(ActiveExpansions.size());
assert(StartedMacros.size() == Token->MacroCtx->StartOfExpansion); assert(StartedMacros.size() == Token->MacroCtx->StartOfExpansion);
// We reconstruct macro calls outside-to-inside. // We reconstruct macro calls outside-to-inside.
Context not available.

clang/lib/Frontend/ASTUnit.cpp

Context not available.
CIOpts.VFS = VFS; CIOpts.VFS = VFS;
CIOpts.Diags = Diags; CIOpts.Diags = Diags;
CIOpts.ProbePrecompiled = true; // FIXME: historical default. Needed? CIOpts.ProbePrecompiled = true; // FIXME: historical default. Needed?
CI = createInvocation(llvm::makeArrayRef(ArgBegin, ArgEnd), CI = createInvocation(llvm::ArrayRef(ArgBegin, ArgEnd), std::move(CIOpts));
std::move(CIOpts));
if (!CI) if (!CI)
return nullptr; return nullptr;
} }
Context not available.

clang/lib/Interpreter/Interpreter.cpp

Context not available.
TextDiagnosticBuffer *DiagsBuffer = new TextDiagnosticBuffer; TextDiagnosticBuffer *DiagsBuffer = new TextDiagnosticBuffer;
DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagsBuffer); DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagsBuffer);
bool Success = CompilerInvocation::CreateFromArgs( bool Success = CompilerInvocation::CreateFromArgs(
Clang->getInvocation(), llvm::makeArrayRef(Argv.begin(), Argv.size()), Clang->getInvocation(), llvm::ArrayRef(Argv.begin(), Argv.size()), Diags);
Diags);
// Infer the builtin include path if unspecified. // Infer the builtin include path if unspecified.
if (Clang->getHeaderSearchOpts().UseBuiltinIncludes && if (Clang->getHeaderSearchOpts().UseBuiltinIncludes &&
Context not available.
driver::Driver Driver(/*MainBinaryName=*/ClangArgv[0], driver::Driver Driver(/*MainBinaryName=*/ClangArgv[0],
llvm::sys::getProcessTriple(), Diags); llvm::sys::getProcessTriple(), Diags);
Driver.setCheckInputsExist(false); // the input comes from mem buffers Driver.setCheckInputsExist(false); // the input comes from mem buffers
llvm::ArrayRef<const char *> RF = llvm::makeArrayRef(ClangArgv); llvm::ArrayRef<const char *> RF = llvm::ArrayRef(ClangArgv);
std::unique_ptr<driver::Compilation> Compilation(Driver.BuildCompilation(RF)); std::unique_ptr<driver::Compilation> Compilation(Driver.BuildCompilation(RF));
if (Compilation->getArgs().hasArg(driver::options::OPT_v)) if (Compilation->getArgs().hasArg(driver::options::OPT_v))
Context not available.

clang/lib/Lex/TokenLexer.cpp

Context not available.
assert(CurTokenIdx != 0 && assert(CurTokenIdx != 0 &&
"Can not have __VAOPT__ contents begin with a ##"); "Can not have __VAOPT__ contents begin with a ##");
Token &LHS = VAOPTTokens[CurTokenIdx - 1]; Token &LHS = VAOPTTokens[CurTokenIdx - 1];
pasteTokens(LHS, llvm::makeArrayRef(VAOPTTokens, NumVAOptTokens), pasteTokens(LHS, llvm::ArrayRef(VAOPTTokens, NumVAOptTokens),
CurTokenIdx); CurTokenIdx);
// Replace the token prior to the first ## in this iteration. // Replace the token prior to the first ## in this iteration.
ConcatenatedVAOPTResultToks.back() = LHS; ConcatenatedVAOPTResultToks.back() = LHS;
Context not available.
} }
bool TokenLexer::pasteTokens(Token &Tok) { bool TokenLexer::pasteTokens(Token &Tok) {
return pasteTokens(Tok, llvm::makeArrayRef(Tokens, NumTokens), CurTokenIdx); return pasteTokens(Tok, llvm::ArrayRef(Tokens, NumTokens), CurTokenIdx);
} }
/// LHSTok is the LHS of a ## operator, and CurTokenIdx is the ## /// LHSTok is the LHS of a ## operator, and CurTokenIdx is the ##
Context not available.

clang/lib/Parse/ParsePragma.cpp

Context not available.
ValueList.push_back(EOFTok); // Terminates expression for parsing. ValueList.push_back(EOFTok); // Terminates expression for parsing.
markAsReinjectedForRelexing(ValueList); markAsReinjectedForRelexing(ValueList);
Info.Toks = llvm::makeArrayRef(ValueList).copy(PP.getPreprocessorAllocator()); Info.Toks = llvm::ArrayRef(ValueList).copy(PP.getPreprocessorAllocator());
Info.PragmaName = PragmaName; Info.PragmaName = PragmaName;
Info.Option = Option; Info.Option = Option;
Context not available.
markAsReinjectedForRelexing(AttributeTokens); markAsReinjectedForRelexing(AttributeTokens);
Info->Tokens = Info->Tokens =
llvm::makeArrayRef(AttributeTokens).copy(PP.getPreprocessorAllocator()); llvm::ArrayRef(AttributeTokens).copy(PP.getPreprocessorAllocator());
} }
if (Tok.isNot(tok::eod)) if (Tok.isNot(tok::eod))
Context not available.

clang/lib/Sema/ParsedAttr.cpp

Context not available.
} }
ArrayRef<const ParsedAttrInfo *> ParsedAttrInfo::getAllBuiltin() { ArrayRef<const ParsedAttrInfo *> ParsedAttrInfo::getAllBuiltin() {
return llvm::makeArrayRef(AttrInfoMap); return llvm::ArrayRef(AttrInfoMap);
} }
unsigned ParsedAttr::getMinArgs() const { return getInfo().NumArgs; } unsigned ParsedAttr::getMinArgs() const { return getInfo().NumArgs; }
Context not available.

clang/lib/Sema/SemaChecking.cpp

Context not available.
ThisTypeFromDecl); ThisTypeFromDecl);
} }
checkCall(FDecl, Proto, ImplicitThis, llvm::makeArrayRef(Args, NumArgs), checkCall(FDecl, Proto, ImplicitThis, llvm::ArrayRef(Args, NumArgs),
IsMemberFunction, TheCall->getRParenLoc(), IsMemberFunction, TheCall->getRParenLoc(),
TheCall->getCallee()->getSourceRange(), CallType); TheCall->getCallee()->getSourceRange(), CallType);
Context not available.
} }
checkCall(NDecl, Proto, /*ThisArg=*/nullptr, checkCall(NDecl, Proto, /*ThisArg=*/nullptr,
llvm::makeArrayRef(TheCall->getArgs(), TheCall->getNumArgs()), llvm::ArrayRef(TheCall->getArgs(), TheCall->getNumArgs()),
/*IsMemberFunction=*/false, TheCall->getRParenLoc(), /*IsMemberFunction=*/false, TheCall->getRParenLoc(),
TheCall->getCallee()->getSourceRange(), CallType); TheCall->getCallee()->getSourceRange(), CallType);
Context not available.
VariadicCallType CallType = getVariadicCallType(/*FDecl=*/nullptr, Proto, VariadicCallType CallType = getVariadicCallType(/*FDecl=*/nullptr, Proto,
TheCall->getCallee()); TheCall->getCallee());
checkCall(/*FDecl=*/nullptr, Proto, /*ThisArg=*/nullptr, checkCall(/*FDecl=*/nullptr, Proto, /*ThisArg=*/nullptr,
llvm::makeArrayRef(TheCall->getArgs(), TheCall->getNumArgs()), llvm::ArrayRef(TheCall->getArgs(), TheCall->getNumArgs()),
/*IsMemberFunction=*/false, TheCall->getRParenLoc(), /*IsMemberFunction=*/false, TheCall->getRParenLoc(),
TheCall->getCallee()->getSourceRange(), CallType); TheCall->getCallee()->getSourceRange(), CallType);
Context not available.

clang/lib/Sema/SemaCodeComplete.cpp

Context not available.
CodeCompletionContext::CCC_Other); CodeCompletionContext::CCC_Other);
Results.EnterNewScope(); Results.EnterNewScope();
static const char *Platforms[] = {"macOS", "iOS", "watchOS", "tvOS"}; static const char *Platforms[] = {"macOS", "iOS", "watchOS", "tvOS"};
for (const char *Platform : llvm::makeArrayRef(Platforms)) { for (const char *Platform : llvm::ArrayRef(Platforms)) {
Results.AddResult(CodeCompletionResult(Platform)); Results.AddResult(CodeCompletionResult(Platform));
Results.AddResult(CodeCompletionResult(Results.getAllocator().CopyString( Results.AddResult(CodeCompletionResult(Results.getAllocator().CopyString(
Twine(Platform) + "ApplicationExtension"))); Twine(Platform) + "ApplicationExtension")));
Context not available.

clang/lib/Sema/SemaDeclCXX.cpp

Context not available.
FunctionProtoType::ExtProtoInfo EPI = Type->getExtProtoInfo(); FunctionProtoType::ExtProtoInfo EPI = Type->getExtProtoInfo();
EPI.ExceptionSpec.Type = EST_Unevaluated; EPI.ExceptionSpec.Type = EST_Unevaluated;
EPI.ExceptionSpec.SourceDecl = MD; EPI.ExceptionSpec.SourceDecl = MD;
MD->setType(Context.getFunctionType(ReturnType, MD->setType(Context.getFunctionType(
llvm::makeArrayRef(&ArgType, ReturnType, llvm::ArrayRef(&ArgType, ExpectedParams), EPI));
ExpectedParams),
EPI));
} }
} }
Context not available.
Diag(AL.getLoc(), diag::warn_attribute_after_definition_ignored) << AL; Diag(AL.getLoc(), diag::warn_attribute_after_definition_ignored) << AL;
} }
ActOnFields(S, RLoc, TagDecl, llvm::makeArrayRef( ActOnFields(S, RLoc, TagDecl,
// strict aliasing violation! llvm::ArrayRef(
reinterpret_cast<Decl**>(FieldCollector->getCurFields()), // strict aliasing violation!
FieldCollector->getCurNumFields()), LBrac, RBrac, AttrList); reinterpret_cast<Decl **>(FieldCollector->getCurFields()),
FieldCollector->getCurNumFields()),
LBrac, RBrac, AttrList);
CheckCompletedCXXClass(S, cast<CXXRecordDecl>(TagDecl)); CheckCompletedCXXClass(S, cast<CXXRecordDecl>(TagDecl));
} }
Context not available.
VariadicCallType CallType = VariadicCallType CallType =
Proto->isVariadic() ? VariadicConstructor : VariadicDoesNotApply; Proto->isVariadic() ? VariadicConstructor : VariadicDoesNotApply;
SmallVector<Expr *, 8> AllArgs; SmallVector<Expr *, 8> AllArgs;
bool Invalid = GatherArgumentsForCall(Loc, Constructor, bool Invalid = GatherArgumentsForCall(
Proto, 0, Loc, Constructor, Proto, 0, llvm::ArrayRef(Args, NumArgs), AllArgs,
llvm::makeArrayRef(Args, NumArgs), CallType, AllowExplicit, IsListInitialization);
AllArgs,
CallType, AllowExplicit,
IsListInitialization);
ConvertedArgs.append(AllArgs.begin(), AllArgs.end()); ConvertedArgs.append(AllArgs.begin(), AllArgs.end());
DiagnoseSentinelCalls(Constructor, Loc, AllArgs); DiagnoseSentinelCalls(Constructor, Loc, AllArgs);
CheckConstructorCall(Constructor, DeclInitType, CheckConstructorCall(Constructor, DeclInitType,
llvm::makeArrayRef(AllArgs.data(), AllArgs.size()), llvm::ArrayRef(AllArgs.data(), AllArgs.size()), Proto,
Proto, Loc); Loc);
return Invalid; return Invalid;
} }
Context not available.
else if (const auto *G = dyn_cast<PtGuardedByAttr>(A)) else if (const auto *G = dyn_cast<PtGuardedByAttr>(A))
Arg = G->getArg(); Arg = G->getArg();
else if (const auto *AA = dyn_cast<AcquiredAfterAttr>(A)) else if (const auto *AA = dyn_cast<AcquiredAfterAttr>(A))
Args = llvm::makeArrayRef(AA->args_begin(), AA->args_size()); Args = llvm::ArrayRef(AA->args_begin(), AA->args_size());
else if (const auto *AB = dyn_cast<AcquiredBeforeAttr>(A)) else if (const auto *AB = dyn_cast<AcquiredBeforeAttr>(A))
Args = llvm::makeArrayRef(AB->args_begin(), AB->args_size()); Args = llvm::ArrayRef(AB->args_begin(), AB->args_size());
else if (const auto *ETLF = dyn_cast<ExclusiveTrylockFunctionAttr>(A)) { else if (const auto *ETLF = dyn_cast<ExclusiveTrylockFunctionAttr>(A)) {
Arg = ETLF->getSuccessValue(); Arg = ETLF->getSuccessValue();
Args = llvm::makeArrayRef(ETLF->args_begin(), ETLF->args_size()); Args = llvm::ArrayRef(ETLF->args_begin(), ETLF->args_size());
} else if (const auto *STLF = dyn_cast<SharedTrylockFunctionAttr>(A)) { } else if (const auto *STLF = dyn_cast<SharedTrylockFunctionAttr>(A)) {
Arg = STLF->getSuccessValue(); Arg = STLF->getSuccessValue();
Args = llvm::makeArrayRef(STLF->args_begin(), STLF->args_size()); Args = llvm::ArrayRef(STLF->args_begin(), STLF->args_size());
} else if (const auto *LR = dyn_cast<LockReturnedAttr>(A)) } else if (const auto *LR = dyn_cast<LockReturnedAttr>(A))
Arg = LR->getArg(); Arg = LR->getArg();
else if (const auto *LE = dyn_cast<LocksExcludedAttr>(A)) else if (const auto *LE = dyn_cast<LocksExcludedAttr>(A))
Args = llvm::makeArrayRef(LE->args_begin(), LE->args_size()); Args = llvm::ArrayRef(LE->args_begin(), LE->args_size());
else if (const auto *RC = dyn_cast<RequiresCapabilityAttr>(A)) else if (const auto *RC = dyn_cast<RequiresCapabilityAttr>(A))
Args = llvm::makeArrayRef(RC->args_begin(), RC->args_size()); Args = llvm::ArrayRef(RC->args_begin(), RC->args_size());
else if (const auto *AC = dyn_cast<AcquireCapabilityAttr>(A)) else if (const auto *AC = dyn_cast<AcquireCapabilityAttr>(A))
Args = llvm::makeArrayRef(AC->args_begin(), AC->args_size()); Args = llvm::ArrayRef(AC->args_begin(), AC->args_size());
else if (const auto *AC = dyn_cast<TryAcquireCapabilityAttr>(A)) else if (const auto *AC = dyn_cast<TryAcquireCapabilityAttr>(A))
Args = llvm::makeArrayRef(AC->args_begin(), AC->args_size()); Args = llvm::ArrayRef(AC->args_begin(), AC->args_size());
else if (const auto *RC = dyn_cast<ReleaseCapabilityAttr>(A)) else if (const auto *RC = dyn_cast<ReleaseCapabilityAttr>(A))
Args = llvm::makeArrayRef(RC->args_begin(), RC->args_size()); Args = llvm::ArrayRef(RC->args_begin(), RC->args_size());
if (Arg && !Finder.TraverseStmt(Arg)) if (Arg && !Finder.TraverseStmt(Arg))
return true; return true;
Context not available.

clang/lib/Sema/SemaExpr.cpp

Context not available.
Types[i] = nullptr; Types[i] = nullptr;
} }
ExprResult ER = CreateGenericSelectionExpr(KeyLoc, DefaultLoc, RParenLoc, ExprResult ER =
ControllingExpr, CreateGenericSelectionExpr(KeyLoc, DefaultLoc, RParenLoc, ControllingExpr,
llvm::makeArrayRef(Types, NumAssocs), llvm::ArrayRef(Types, NumAssocs), ArgExprs);
ArgExprs);
delete [] Types; delete [] Types;
return ER; return ER;
} }
Context not available.
OpNameInfo.setCXXLiteralOperatorNameLoc(UDSuffixLoc); OpNameInfo.setCXXLiteralOperatorNameLoc(UDSuffixLoc);
LookupResult R(S, OpName, UDSuffixLoc, Sema::LookupOrdinaryName); LookupResult R(S, OpName, UDSuffixLoc, Sema::LookupOrdinaryName);
if (S.LookupLiteralOperator(Scope, R, llvm::makeArrayRef(ArgTy, Args.size()), if (S.LookupLiteralOperator(Scope, R, llvm::ArrayRef(ArgTy, Args.size()),
/*AllowRaw*/ false, /*AllowTemplate*/ false, /*AllowRaw*/ false, /*AllowTemplate*/ false,
/*AllowStringTemplatePack*/ false, /*AllowStringTemplatePack*/ false,
/*DiagnoseMissing*/ true) == Sema::LOLR_Error) /*DiagnoseMissing*/ true) == Sema::LOLR_Error)
Context not available.
TheCall = dyn_cast<CallExpr>(Result.get()); TheCall = dyn_cast<CallExpr>(Result.get());
bool CorrectedTypos = TheCall != TheOldCall; bool CorrectedTypos = TheCall != TheOldCall;
if (!TheCall) return Result; if (!TheCall) return Result;
Args = llvm::makeArrayRef(TheCall->getArgs(), TheCall->getNumArgs()); Args = llvm::ArrayRef(TheCall->getArgs(), TheCall->getNumArgs());
// A new call expression node was created if some typos were corrected. // A new call expression node was created if some typos were corrected.
// However it may not have been constructed with enough storage. In this // However it may not have been constructed with enough storage. In this
Context not available.
bool Sema::DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement, bool Sema::DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement,
const PartialDiagnostic &PD) { const PartialDiagnostic &PD) {
return DiagRuntimeBehavior( return DiagRuntimeBehavior(
Loc, Statement ? llvm::makeArrayRef(Statement) : std::nullopt, PD); Loc, Statement ? llvm::ArrayRef(Statement) : std::nullopt, PD);
} }
bool Sema::CheckCallReturnType(QualType ReturnType, SourceLocation Loc, bool Sema::CheckCallReturnType(QualType ReturnType, SourceLocation Loc,
Context not available.

clang/lib/Sema/SemaExprCXX.cpp

Context not available.
for (auto *P : Func->parameters()) for (auto *P : Func->parameters())
FuncParams.push_back( FuncParams.push_back(
Context.getCanonicalType(P->getType().getUnqualifiedType())); Context.getCanonicalType(P->getType().getUnqualifiedType()));
if (llvm::makeArrayRef(FuncParams) == Params) { if (llvm::ArrayRef(FuncParams) == Params) {
// Make the function visible to name lookup, even if we found it in // Make the function visible to name lookup, even if we found it in
// an unimported module. It either is an implicitly-declared global // an unimported module. It either is an implicitly-declared global
// allocation function, or is suppressing that function. // allocation function, or is suppressing that function.
Context not available.
BadAllocType = Context.getTypeDeclType(getStdBadAlloc()); BadAllocType = Context.getTypeDeclType(getStdBadAlloc());
assert(StdBadAlloc && "Must have std::bad_alloc declared"); assert(StdBadAlloc && "Must have std::bad_alloc declared");
EPI.ExceptionSpec.Type = EST_Dynamic; EPI.ExceptionSpec.Type = EST_Dynamic;
EPI.ExceptionSpec.Exceptions = llvm::makeArrayRef(BadAllocType); EPI.ExceptionSpec.Exceptions = llvm::ArrayRef(BadAllocType);
} }
if (getLangOpts().NewInfallible) { if (getLangOpts().NewInfallible) {
EPI.ExceptionSpec.Type = EST_DynamicNone; EPI.ExceptionSpec.Type = EST_DynamicNone;
Context not available.
if (!Cleanup.exprNeedsCleanups()) if (!Cleanup.exprNeedsCleanups())
return SubExpr; return SubExpr;
auto Cleanups = llvm::makeArrayRef(ExprCleanupObjects.begin() + FirstCleanup, auto Cleanups = llvm::ArrayRef(ExprCleanupObjects.begin() + FirstCleanup,
ExprCleanupObjects.size() - FirstCleanup); ExprCleanupObjects.size() - FirstCleanup);
auto *E = ExprWithCleanups::Create( auto *E = ExprWithCleanups::Create(
Context, SubExpr, Cleanup.cleanupsHaveSideEffects(), Cleanups); Context, SubExpr, Cleanup.cleanupsHaveSideEffects(), Cleanups);
Context not available.

clang/lib/Sema/SemaExprObjC.cpp

Context not available.
using namespace clang; using namespace clang;
using namespace sema; using namespace sema;
using llvm::makeArrayRef; using llvm::ArrayRef;
ExprResult Sema::ParseObjCStringLiteral(SourceLocation *AtLocs, ExprResult Sema::ParseObjCStringLiteral(SourceLocation *AtLocs,
ArrayRef<Expr *> Strings) { ArrayRef<Expr *> Strings) {
Context not available.
if (ObjCProtocolDecl *NSCopyingPDecl = if (ObjCProtocolDecl *NSCopyingPDecl =
LookupProtocol(&Context.Idents.get("NSCopying"), SR.getBegin())) { LookupProtocol(&Context.Idents.get("NSCopying"), SR.getBegin())) {
ObjCProtocolDecl *PQ[] = {NSCopyingPDecl}; ObjCProtocolDecl *PQ[] = {NSCopyingPDecl};
QIDNSCopying = QIDNSCopying = Context.getObjCObjectType(
Context.getObjCObjectType(Context.ObjCBuiltinIdTy, { }, Context.ObjCBuiltinIdTy, {},
llvm::makeArrayRef( llvm::ArrayRef((ObjCProtocolDecl **)PQ, 1), false);
(ObjCProtocolDecl**) PQ,
1),
false);
QIDNSCopying = Context.getObjCObjectPointerType(QIDNSCopying); QIDNSCopying = Context.getObjCObjectPointerType(QIDNSCopying);
} }
} }
Context not available.
DiagnoseSentinelCalls(Method, SelLoc, Args); DiagnoseSentinelCalls(Method, SelLoc, Args);
// Do additional checkings on method. // Do additional checkings on method.
IsError |= CheckObjCMethodCall( IsError |=
Method, SelLoc, makeArrayRef(Args.data(), Args.size())); CheckObjCMethodCall(Method, SelLoc, ArrayRef(Args.data(), Args.size()));
return IsError; return IsError;
} }
Context not available.
unsigned NumArgs = ArgsIn.size(); unsigned NumArgs = ArgsIn.size();
Expr **Args = ArgsIn.data(); Expr **Args = ArgsIn.data();
assert(SuperLoc.isInvalid() && "Message to super with dependent type"); assert(SuperLoc.isInvalid() && "Message to super with dependent type");
return ObjCMessageExpr::Create( return ObjCMessageExpr::Create(Context, ReceiverType, VK_PRValue, LBracLoc,
Context, ReceiverType, VK_PRValue, LBracLoc, ReceiverTypeInfo, Sel, ReceiverTypeInfo, Sel, SelectorLocs,
SelectorLocs, /*Method=*/nullptr, makeArrayRef(Args, NumArgs), RBracLoc, /*Method=*/nullptr, ArrayRef(Args, NumArgs),
isImplicit); RBracLoc, isImplicit);
} }
// Find the class to which we are sending this message. // Find the class to which we are sending this message.
Context not available.
// Construct the appropriate ObjCMessageExpr. // Construct the appropriate ObjCMessageExpr.
ObjCMessageExpr *Result; ObjCMessageExpr *Result;
if (SuperLoc.isValid()) if (SuperLoc.isValid())
Result = ObjCMessageExpr::Create(Context, ReturnType, VK, LBracLoc, Result = ObjCMessageExpr::Create(
SuperLoc, /*IsInstanceSuper=*/false, Context, ReturnType, VK, LBracLoc, SuperLoc, /*IsInstanceSuper=*/false,
ReceiverType, Sel, SelectorLocs, ReceiverType, Sel, SelectorLocs, Method, ArrayRef(Args, NumArgs),
Method, makeArrayRef(Args, NumArgs), RBracLoc, isImplicit);
RBracLoc, isImplicit);
else { else {
Result = ObjCMessageExpr::Create(Context, ReturnType, VK, LBracLoc, Result = ObjCMessageExpr::Create(
ReceiverTypeInfo, Sel, SelectorLocs, Context, ReturnType, VK, LBracLoc, ReceiverTypeInfo, Sel, SelectorLocs,
Method, makeArrayRef(Args, NumArgs), Method, ArrayRef(Args, NumArgs), RBracLoc, isImplicit);
RBracLoc, isImplicit);
if (!isImplicit) if (!isImplicit)
checkCocoaAPI(*this, Result); checkCocoaAPI(*this, Result);
} }
if (Method) if (Method)
checkFoundationAPI(*this, SelLoc, Method, makeArrayRef(Args, NumArgs), checkFoundationAPI(*this, SelLoc, Method, ArrayRef(Args, NumArgs),
ReceiverType, /*IsClassObjectCall=*/true); ReceiverType, /*IsClassObjectCall=*/true);
return MaybeBindToTemporary(Result); return MaybeBindToTemporary(Result);
} }
Context not available.
assert(SuperLoc.isInvalid() && "Message to super with dependent type"); assert(SuperLoc.isInvalid() && "Message to super with dependent type");
return ObjCMessageExpr::Create( return ObjCMessageExpr::Create(
Context, Context.DependentTy, VK_PRValue, LBracLoc, Receiver, Sel, Context, Context.DependentTy, VK_PRValue, LBracLoc, Receiver, Sel,
SelectorLocs, /*Method=*/nullptr, makeArrayRef(Args, NumArgs), SelectorLocs, /*Method=*/nullptr, ArrayRef(Args, NumArgs), RBracLoc,
RBracLoc, isImplicit); isImplicit);
} }
// If necessary, apply function/array conversion to the receiver. // If necessary, apply function/array conversion to the receiver.
Context not available.
// Construct the appropriate ObjCMessageExpr instance. // Construct the appropriate ObjCMessageExpr instance.
ObjCMessageExpr *Result; ObjCMessageExpr *Result;
if (SuperLoc.isValid()) if (SuperLoc.isValid())
Result = ObjCMessageExpr::Create(Context, ReturnType, VK, LBracLoc, Result = ObjCMessageExpr::Create(
SuperLoc, /*IsInstanceSuper=*/true, Context, ReturnType, VK, LBracLoc, SuperLoc, /*IsInstanceSuper=*/true,
ReceiverType, Sel, SelectorLocs, Method, ReceiverType, Sel, SelectorLocs, Method, ArrayRef(Args, NumArgs),
makeArrayRef(Args, NumArgs), RBracLoc, RBracLoc, isImplicit);
isImplicit);
else { else {
Result = ObjCMessageExpr::Create(Context, ReturnType, VK, LBracLoc, Result = ObjCMessageExpr::Create(
Receiver, Sel, SelectorLocs, Method, Context, ReturnType, VK, LBracLoc, Receiver, Sel, SelectorLocs, Method,
makeArrayRef(Args, NumArgs), RBracLoc, ArrayRef(Args, NumArgs), RBracLoc, isImplicit);
isImplicit);
if (!isImplicit) if (!isImplicit)
checkCocoaAPI(*this, Result); checkCocoaAPI(*this, Result);
} }
Context not available.
} }
} }
} }
checkFoundationAPI(*this, SelLoc, Method, makeArrayRef(Args, NumArgs), checkFoundationAPI(*this, SelLoc, Method, ArrayRef(Args, NumArgs),
ReceiverType, IsClassObjectCall); ReceiverType, IsClassObjectCall);
} }
Context not available.

clang/lib/Sema/SemaInit.cpp

Context not available.
if (auto *CE = dyn_cast<CallExpr>(Call)) { if (auto *CE = dyn_cast<CallExpr>(Call)) {
Callee = CE->getDirectCallee(); Callee = CE->getDirectCallee();
Args = llvm::makeArrayRef(CE->getArgs(), CE->getNumArgs()); Args = llvm::ArrayRef(CE->getArgs(), CE->getNumArgs());
} else { } else {
auto *CCE = cast<CXXConstructExpr>(Call); auto *CCE = cast<CXXConstructExpr>(Call);
Callee = CCE->getConstructor(); Callee = CCE->getConstructor();
Args = llvm::makeArrayRef(CCE->getArgs(), CCE->getNumArgs()); Args = llvm::ArrayRef(CCE->getArgs(), CCE->getNumArgs());
} }
if (!Callee) if (!Callee)
return; return;
Context not available.

clang/lib/Sema/SemaLookup.cpp

Context not available.
if (CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(Cand->getUnderlyingDecl())) { if (CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(Cand->getUnderlyingDecl())) {
if (SM == CXXCopyAssignment || SM == CXXMoveAssignment) if (SM == CXXCopyAssignment || SM == CXXMoveAssignment)
AddMethodCandidate(M, Cand, RD, ThisTy, Classification, AddMethodCandidate(M, Cand, RD, ThisTy, Classification,
llvm::makeArrayRef(&Arg, NumArgs), OCS, true); llvm::ArrayRef(&Arg, NumArgs), OCS, true);
else if (CtorInfo) else if (CtorInfo)
AddOverloadCandidate(CtorInfo.Constructor, CtorInfo.FoundDecl, AddOverloadCandidate(CtorInfo.Constructor, CtorInfo.FoundDecl,
llvm::makeArrayRef(&Arg, NumArgs), OCS, llvm::ArrayRef(&Arg, NumArgs), OCS,
/*SuppressUserConversions*/ true); /*SuppressUserConversions*/ true);
else else
AddOverloadCandidate(M, Cand, llvm::makeArrayRef(&Arg, NumArgs), OCS, AddOverloadCandidate(M, Cand, llvm::ArrayRef(&Arg, NumArgs), OCS,
/*SuppressUserConversions*/ true); /*SuppressUserConversions*/ true);
} else if (FunctionTemplateDecl *Tmpl = } else if (FunctionTemplateDecl *Tmpl =
dyn_cast<FunctionTemplateDecl>(Cand->getUnderlyingDecl())) { dyn_cast<FunctionTemplateDecl>(Cand->getUnderlyingDecl())) {
if (SM == CXXCopyAssignment || SM == CXXMoveAssignment) if (SM == CXXCopyAssignment || SM == CXXMoveAssignment)
AddMethodTemplateCandidate( AddMethodTemplateCandidate(Tmpl, Cand, RD, nullptr, ThisTy,
Tmpl, Cand, RD, nullptr, ThisTy, Classification, Classification,
llvm::makeArrayRef(&Arg, NumArgs), OCS, true); llvm::ArrayRef(&Arg, NumArgs), OCS, true);
else if (CtorInfo) else if (CtorInfo)
AddTemplateOverloadCandidate( AddTemplateOverloadCandidate(CtorInfo.ConstructorTmpl,
CtorInfo.ConstructorTmpl, CtorInfo.FoundDecl, nullptr, CtorInfo.FoundDecl, nullptr,
llvm::makeArrayRef(&Arg, NumArgs), OCS, true); llvm::ArrayRef(&Arg, NumArgs), OCS, true);
else else
AddTemplateOverloadCandidate( AddTemplateOverloadCandidate(Tmpl, Cand, nullptr,
Tmpl, Cand, nullptr, llvm::makeArrayRef(&Arg, NumArgs), OCS, true); llvm::ArrayRef(&Arg, NumArgs), OCS, true);
} else { } else {
assert(isa<UsingDecl>(Cand.getDecl()) && assert(isa<UsingDecl>(Cand.getDecl()) &&
"illegal Kind of operator = Decl"); "illegal Kind of operator = Decl");
Context not available.
if (NNS && !CurNameSpecifierIdentifiers.empty()) { if (NNS && !CurNameSpecifierIdentifiers.empty()) {
SmallVector<const IdentifierInfo*, 4> NewNameSpecifierIdentifiers; SmallVector<const IdentifierInfo*, 4> NewNameSpecifierIdentifiers;
getNestedNameSpecifierIdentifiers(NNS, NewNameSpecifierIdentifiers); getNestedNameSpecifierIdentifiers(NNS, NewNameSpecifierIdentifiers);
NumSpecifiers = llvm::ComputeEditDistance( NumSpecifiers =
llvm::makeArrayRef(CurNameSpecifierIdentifiers), llvm::ComputeEditDistance(llvm::ArrayRef(CurNameSpecifierIdentifiers),
llvm::makeArrayRef(NewNameSpecifierIdentifiers)); llvm::ArrayRef(NewNameSpecifierIdentifiers));
} }
SpecifierInfo SI = {Ctx, NNS, NumSpecifiers}; SpecifierInfo SI = {Ctx, NNS, NumSpecifiers};
Context not available.

clang/lib/Sema/SemaOverload.cpp

Context not available.
if (Info.ConstructorTmpl) if (Info.ConstructorTmpl)
S.AddTemplateOverloadCandidate( S.AddTemplateOverloadCandidate(
Info.ConstructorTmpl, Info.FoundDecl, Info.ConstructorTmpl, Info.FoundDecl,
/*ExplicitArgs*/ nullptr, llvm::makeArrayRef(Args, NumArgs), /*ExplicitArgs*/ nullptr, llvm::ArrayRef(Args, NumArgs),
CandidateSet, SuppressUserConversions, CandidateSet, SuppressUserConversions,
/*PartialOverloading*/ false, /*PartialOverloading*/ false,
AllowExplicit == AllowedExplicit::All); AllowExplicit == AllowedExplicit::All);
Context not available.
// Allow one user-defined conversion when user specifies a // Allow one user-defined conversion when user specifies a
// From->ToType conversion via an static cast (c-style, etc). // From->ToType conversion via an static cast (c-style, etc).
S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl, S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl,
llvm::makeArrayRef(Args, NumArgs), llvm::ArrayRef(Args, NumArgs), CandidateSet,
CandidateSet, SuppressUserConversions, SuppressUserConversions,
/*PartialOverloading*/ false, /*PartialOverloading*/ false,
AllowExplicit == AllowedExplicit::All); AllowExplicit == AllowedExplicit::All);
} }
Context not available.
// very difficult. Ideally, we should handle them more gracefully. // very difficult. Ideally, we should handle them more gracefully.
if (EIA->getCond()->isValueDependent() || if (EIA->getCond()->isValueDependent() ||
!EIA->getCond()->EvaluateWithSubstitution( !EIA->getCond()->EvaluateWithSubstitution(
Result, Context, Function, llvm::makeArrayRef(ConvertedArgs))) Result, Context, Function, llvm::ArrayRef(ConvertedArgs)))
return EIA; return EIA;
if (!Result.isInt() || !Result.getInt().getBoolValue()) if (!Result.isInt() || !Result.getInt().getBoolValue())
Context not available.
ResultTy = ResultTy.getNonLValueExprType(Context); ResultTy = ResultTy.getNonLValueExprType(Context);
UserDefinedLiteral *UDL = UserDefinedLiteral::Create( UserDefinedLiteral *UDL = UserDefinedLiteral::Create(
Context, Fn.get(), llvm::makeArrayRef(ConvArgs, Args.size()), ResultTy, Context, Fn.get(), llvm::ArrayRef(ConvArgs, Args.size()), ResultTy, VK,
VK, LitEndLoc, UDSuffixLoc, CurFPFeatureOverrides()); LitEndLoc, UDSuffixLoc, CurFPFeatureOverrides());
if (CheckCallReturnType(FD->getReturnType(), UDSuffixLoc, UDL, FD)) if (CheckCallReturnType(FD->getReturnType(), UDSuffixLoc, UDL, FD))
return ExprError(); return ExprError();
Context not available.

clang/lib/Sema/SemaRISCVVectorLookup.cpp

Context not available.
// Get subsequence of signature table. // Get subsequence of signature table.
static ArrayRef<PrototypeDescriptor> ProtoSeq2ArrayRef(uint16_t Index, static ArrayRef<PrototypeDescriptor> ProtoSeq2ArrayRef(uint16_t Index,
uint8_t Length) { uint8_t Length) {
return makeArrayRef(&RVVSignatureTable[Index], Length); return ArrayRef(&RVVSignatureTable[Index], Length);
} }
static QualType RVVType2Qual(ASTContext &Context, const RVVType *Type) { static QualType RVVType2Qual(ASTContext &Context, const RVVType *Type) {
Context not available.

clang/lib/Sema/SemaStmt.cpp

Context not available.
// type of the left operand could be used for SFINAE, so technically it is // type of the left operand could be used for SFINAE, so technically it is
// *used*. // *used*.
if (DiagID != diag::warn_unused_comma_left_operand || !isSFINAEContext()) if (DiagID != diag::warn_unused_comma_left_operand || !isSFINAEContext())
DiagIfReachable(Loc, S ? llvm::makeArrayRef(S) : std::nullopt, DiagIfReachable(Loc, S ? llvm::ArrayRef(S) : std::nullopt,
PDiag(DiagID) << R1 << R2); PDiag(DiagID) << R1 << R2);
} }
Context not available.

clang/lib/Sema/SemaTemplate.cpp

Context not available.
return TemplateParameterList::Create( return TemplateParameterList::Create(
Context, TemplateLoc, LAngleLoc, Context, TemplateLoc, LAngleLoc,
llvm::makeArrayRef(Params.data(), Params.size()), llvm::ArrayRef(Params.data(), Params.size()), RAngleLoc, RequiresClause);
RAngleLoc, RequiresClause);
} }
static void SetNestedNameSpecifier(Sema &S, TagDecl *T, static void SetNestedNameSpecifier(Sema &S, TagDecl *T,
Context not available.
SetNestedNameSpecifier(*this, NewClass, SS); SetNestedNameSpecifier(*this, NewClass, SS);
if (NumOuterTemplateParamLists > 0) if (NumOuterTemplateParamLists > 0)
NewClass->setTemplateParameterListsInfo( NewClass->setTemplateParameterListsInfo(
Context, llvm::makeArrayRef(OuterTemplateParamLists, Context,
NumOuterTemplateParamLists)); llvm::ArrayRef(OuterTemplateParamLists, NumOuterTemplateParamLists));
// Add alignment attributes if necessary; these attributes are checked when // Add alignment attributes if necessary; these attributes are checked when
// the ASTContext lays out the structure. // the ASTContext lays out the structure.
Context not available.

clang/lib/Sema/SemaTemplateDeduction.cpp

Context not available.
new (S.Context) TemplateArgument[Pack.New.size()]; new (S.Context) TemplateArgument[Pack.New.size()];
std::copy(Pack.New.begin(), Pack.New.end(), ArgumentPack); std::copy(Pack.New.begin(), Pack.New.end(), ArgumentPack);
NewPack = DeducedTemplateArgument( NewPack = DeducedTemplateArgument(
TemplateArgument(llvm::makeArrayRef(ArgumentPack, Pack.New.size())), TemplateArgument(llvm::ArrayRef(ArgumentPack, Pack.New.size())),
// FIXME: This is wrong, it's possible that some pack elements are // FIXME: This is wrong, it's possible that some pack elements are
// deduced from an array bound and others are not: // deduced from an array bound and others are not:
// template<typename ...T, T ...V> void g(const T (&...p)[V]); // template<typename ...T, T ...V> void g(const T (&...p)[V]);
Context not available.

clang/lib/Sema/SemaTemplateInstantiate.cpp

Context not available.
Diags.Report(Active->PointOfInstantiation, Diags.Report(Active->PointOfInstantiation,
diag::note_building_builtin_dump_struct_call) diag::note_building_builtin_dump_struct_call)
<< convertCallArgsToString( << convertCallArgsToString(
*this, *this, llvm::ArrayRef(Active->CallArgs, Active->NumCallArgs));
llvm::makeArrayRef(Active->CallArgs, Active->NumCallArgs));
break; break;
case CodeSynthesisContext::Memoization: case CodeSynthesisContext::Memoization:
Context not available.

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

Context not available.
if (NumTempParamLists) if (NumTempParamLists)
Method->setTemplateParameterListsInfo( Method->setTemplateParameterListsInfo(
SemaRef.Context, SemaRef.Context,
llvm::makeArrayRef(TempParamLists.data(), NumTempParamLists)); llvm::ArrayRef(TempParamLists.data(), NumTempParamLists));
Method->setLexicalDeclContext(Owner); Method->setLexicalDeclContext(Owner);
Method->setObjectOfFriendDecl(); Method->setObjectOfFriendDecl();
Context not available.

clang/lib/Sema/SemaType.cpp

Context not available.
SourceLocation rAngleLoc) { SourceLocation rAngleLoc) {
// Form id<protocol-list>. // Form id<protocol-list>.
QualType Result = Context.getObjCObjectType( QualType Result = Context.getObjCObjectType(
Context.ObjCBuiltinIdTy, { }, Context.ObjCBuiltinIdTy, {},
llvm::makeArrayRef( llvm::ArrayRef((ObjCProtocolDecl *const *)protocols.data(),
(ObjCProtocolDecl * const *)protocols.data(), protocols.size()),
protocols.size()), false);
false);
Result = Context.getObjCObjectPointerType(Result); Result = Context.getObjCObjectPointerType(Result);
TypeSourceInfo *ResultTInfo = Context.CreateTypeSourceInfo(Result); TypeSourceInfo *ResultTInfo = Context.CreateTypeSourceInfo(Result);
Context not available.
T, BaseTypeInfo->getTypeLoc().getSourceRange().getBegin(), T, BaseTypeInfo->getTypeLoc().getSourceRange().getBegin(),
TypeArgsLAngleLoc, ActualTypeArgInfos, TypeArgsRAngleLoc, TypeArgsLAngleLoc, ActualTypeArgInfos, TypeArgsRAngleLoc,
ProtocolLAngleLoc, ProtocolLAngleLoc,
llvm::makeArrayRef((ObjCProtocolDecl *const *)Protocols.data(), llvm::ArrayRef((ObjCProtocolDecl *const *)Protocols.data(),
Protocols.size()), Protocols.size()),
ProtocolLocs, ProtocolRAngleLoc, ProtocolLocs, ProtocolRAngleLoc,
/*FailOnError=*/false, /*FailOnError=*/false,
/*Rebuilding=*/false); /*Rebuilding=*/false);
Context not available.

clang/lib/Sema/TreeTransform.h

Context not available.
if (auto NewExtParamInfos = if (auto NewExtParamInfos =
ExtParamInfos.getPointerOrNull(ParamTypes.size())) { ExtParamInfos.getPointerOrNull(ParamTypes.size())) {
if (!EPI.ExtParameterInfos || if (!EPI.ExtParameterInfos ||
llvm::makeArrayRef(EPI.ExtParameterInfos, TL.getNumParams()) llvm::ArrayRef(EPI.ExtParameterInfos, TL.getNumParams()) !=
!= llvm::makeArrayRef(NewExtParamInfos, ParamTypes.size())) { llvm::ArrayRef(NewExtParamInfos, ParamTypes.size())) {
EPIChanged = true; EPIChanged = true;
} }
EPI.ExtParameterInfos = NewExtParamInfos; EPI.ExtParameterInfos = NewExtParamInfos;
Context not available.
QualType Result = TL.getType(); QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() || ResultType != T->getReturnType() || if (getDerived().AlwaysRebuild() || ResultType != T->getReturnType() ||
T->getParamTypes() != llvm::makeArrayRef(ParamTypes) || EPIChanged) { T->getParamTypes() != llvm::ArrayRef(ParamTypes) || EPIChanged) {
Result = getDerived().RebuildFunctionProtoType(ResultType, ParamTypes, EPI); Result = getDerived().RebuildFunctionProtoType(ResultType, ParamTypes, EPI);
if (Result.isNull()) if (Result.isNull())
return QualType(); return QualType();
Context not available.
QualType Result = TL.getType(); QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() || if (getDerived().AlwaysRebuild() ||
OTP != T->getDecl()) { OTP != T->getDecl()) {
Result = getDerived().RebuildObjCTypeParamType(OTP, Result = getDerived().RebuildObjCTypeParamType(
TL.getProtocolLAngleLoc(), OTP, TL.getProtocolLAngleLoc(),
llvm::makeArrayRef(TL.getTypePtr()->qual_begin(), llvm::ArrayRef(TL.getTypePtr()->qual_begin(), TL.getNumProtocols()),
TL.getNumProtocols()), TL.getProtocolLocs(), TL.getProtocolRAngleLoc());
TL.getProtocolLocs(),
TL.getProtocolRAngleLoc());
if (Result.isNull()) if (Result.isNull())
return QualType(); return QualType();
} }
Context not available.
Result = getDerived().RebuildObjCObjectType( Result = getDerived().RebuildObjCObjectType(
BaseType, TL.getBeginLoc(), TL.getTypeArgsLAngleLoc(), NewTypeArgInfos, BaseType, TL.getBeginLoc(), TL.getTypeArgsLAngleLoc(), NewTypeArgInfos,
TL.getTypeArgsRAngleLoc(), TL.getProtocolLAngleLoc(), TL.getTypeArgsRAngleLoc(), TL.getProtocolLAngleLoc(),
llvm::makeArrayRef(TL.getTypePtr()->qual_begin(), TL.getNumProtocols()), llvm::ArrayRef(TL.getTypePtr()->qual_begin(), TL.getNumProtocols()),
TL.getProtocolLocs(), TL.getProtocolRAngleLoc()); TL.getProtocolLocs(), TL.getProtocolRAngleLoc());
if (Result.isNull()) if (Result.isNull())
Context not available.
template<typename Derived> template<typename Derived>
StmtResult StmtResult
TreeTransform<Derived>::TransformMSAsmStmt(MSAsmStmt *S) { TreeTransform<Derived>::TransformMSAsmStmt(MSAsmStmt *S) {
ArrayRef<Token> AsmToks = ArrayRef<Token> AsmToks = llvm::ArrayRef(S->getAsmToks(), S->getNumAsmToks());
llvm::makeArrayRef(S->getAsmToks(), S->getNumAsmToks());
bool HadError = false, HadChange = false; bool HadError = false, HadChange = false;
Context not available.

clang/lib/Serialization/ASTReader.cpp

Context not available.
auto &Lex = LexicalDecls[DC]; auto &Lex = LexicalDecls[DC];
if (!Lex.first) { if (!Lex.first) {
Lex = std::make_pair( Lex = std::make_pair(
&M, llvm::makeArrayRef( &M, llvm::ArrayRef(
reinterpret_cast<const llvm::support::unaligned_uint32_t *>( reinterpret_cast<const llvm::support::unaligned_uint32_t *>(
Blob.data()), Blob.data()),
Blob.size() / 4)); Blob.size() / 4));
Context not available.
if (NumFileDecls && ContextObj) { if (NumFileDecls && ContextObj) {
const DeclID *FirstDecl = F->FileSortedDecls + Record[6]; const DeclID *FirstDecl = F->FileSortedDecls + Record[6];
assert(F->FileSortedDecls && "FILE_SORTED_DECLS not encountered yet ?"); assert(F->FileSortedDecls && "FILE_SORTED_DECLS not encountered yet ?");
FileDeclIDs[FID] = FileDeclsInfo(F, llvm::makeArrayRef(FirstDecl, FileDeclIDs[FID] =
NumFileDecls)); FileDeclsInfo(F, llvm::ArrayRef(FirstDecl, NumFileDecls));
} }
const SrcMgr::ContentCache &ContentCache = const SrcMgr::ContentCache &ContentCache =
Context not available.
Toks.reserve(NumTokens); Toks.reserve(NumTokens);
for (unsigned I = 0; I < NumTokens; ++I) for (unsigned I = 0; I < NumTokens; ++I)
Toks.push_back(ReadToken(F, Record, Idx)); Toks.push_back(ReadToken(F, Record, Idx));
Info->Toks = llvm::makeArrayRef(Toks).copy(PP.getPreprocessorAllocator()); Info->Toks = llvm::ArrayRef(Toks).copy(PP.getPreprocessorAllocator());
Tok.setAnnotationValue(static_cast<void *>(Info)); Tok.setAnnotationValue(static_cast<void *>(Info));
break; break;
} }
Context not available.
PragmaAlignPackStack.front().PushLocation); PragmaAlignPackStack.front().PushLocation);
DropFirst = true; DropFirst = true;
} }
for (const auto &Entry : llvm::makeArrayRef(PragmaAlignPackStack) for (const auto &Entry :
.drop_front(DropFirst ? 1 : 0)) { llvm::ArrayRef(PragmaAlignPackStack).drop_front(DropFirst ? 1 : 0)) {
SemaObj->AlignPackStack.Stack.emplace_back( SemaObj->AlignPackStack.Stack.emplace_back(
Entry.SlotLabel, Entry.Value, Entry.Location, Entry.PushLocation); Entry.SlotLabel, Entry.Value, Entry.Location, Entry.PushLocation);
} }
Context not available.
DropFirst = true; DropFirst = true;
} }
for (const auto &Entry : for (const auto &Entry :
llvm::makeArrayRef(FpPragmaStack).drop_front(DropFirst ? 1 : 0)) llvm::ArrayRef(FpPragmaStack).drop_front(DropFirst ? 1 : 0))
SemaObj->FpPragmaStack.Stack.emplace_back( SemaObj->FpPragmaStack.Stack.emplace_back(
Entry.SlotLabel, Entry.Value, Entry.Location, Entry.PushLocation); Entry.SlotLabel, Entry.Value, Entry.Location, Entry.PushLocation);
if (FpPragmaCurrentLocation.isInvalid()) { if (FpPragmaCurrentLocation.isInvalid()) {
Context not available.

clang/lib/Serialization/ASTWriter.cpp

Context not available.
break; break;
case UPD_ADDED_ATTR_TO_RECORD: case UPD_ADDED_ATTR_TO_RECORD:
Record.AddAttributes(llvm::makeArrayRef(Update.getAttr())); Record.AddAttributes(llvm::ArrayRef(Update.getAttr()));
break; break;
} }
} }
Context not available.

clang/lib/Serialization/ASTWriterDecl.cpp

Context not available.
ArrayRef<DeclID> LazySpecializations; ArrayRef<DeclID> LazySpecializations;
if (auto *LS = Common->LazySpecializations) if (auto *LS = Common->LazySpecializations)
LazySpecializations = llvm::makeArrayRef(LS + 1, LS[0]); LazySpecializations = llvm::ArrayRef(LS + 1, LS[0]);
// Add a slot to the record for the number of specializations. // Add a slot to the record for the number of specializations.
unsigned I = Record.size(); unsigned I = Record.size();
Context not available.
Record.push_back(D->NumIvarInitializers); Record.push_back(D->NumIvarInitializers);
if (D->NumIvarInitializers) if (D->NumIvarInitializers)
Record.AddCXXCtorInitializers( Record.AddCXXCtorInitializers(
llvm::makeArrayRef(D->init_begin(), D->init_end())); llvm::ArrayRef(D->init_begin(), D->init_end()));
Code = serialization::DECL_OBJC_IMPLEMENTATION; Code = serialization::DECL_OBJC_IMPLEMENTATION;
} }
Context not available.
if (auto *CD = dyn_cast<CXXConstructorDecl>(FD)) { if (auto *CD = dyn_cast<CXXConstructorDecl>(FD)) {
Record->push_back(CD->getNumCtorInitializers()); Record->push_back(CD->getNumCtorInitializers());
if (CD->getNumCtorInitializers()) if (CD->getNumCtorInitializers())
AddCXXCtorInitializers( AddCXXCtorInitializers(llvm::ArrayRef(CD->init_begin(), CD->init_end()));
llvm::makeArrayRef(CD->init_begin(), CD->init_end()));
} }
AddStmt(FD->getBody()); AddStmt(FD->getBody());
} }
Context not available.

clang/lib/Tooling/DependencyScanning/DependencyScanningWorker.cpp

Context not available.
Argv.push_back(Arg.c_str()); Argv.push_back(Arg.c_str());
const std::unique_ptr<driver::Compilation> Compilation( const std::unique_ptr<driver::Compilation> Compilation(
Driver->BuildCompilation(llvm::makeArrayRef(Argv))); Driver->BuildCompilation(llvm::ArrayRef(Argv)));
if (!Compilation) if (!Compilation)
return false; return false;
Context not available.

clang/lib/Tooling/DumpTool/ClangSrcLocDump.cpp

Context not available.
"ast-api-dump-tool", OFS); "ast-api-dump-tool", OFS);
std::unique_ptr<clang::driver::Compilation> Comp( std::unique_ptr<clang::driver::Compilation> Comp(
Driver->BuildCompilation(llvm::makeArrayRef(Argv))); Driver->BuildCompilation(llvm::ArrayRef(Argv)));
if (!Comp) if (!Comp)
return 1; return 1;
Context not available.

clang/lib/Tooling/InterpolatingCompilationDatabase.cpp

Context not available.
TmpArgv.push_back(S.c_str()); TmpArgv.push_back(S.c_str());
ClangCLMode = !TmpArgv.empty() && ClangCLMode = !TmpArgv.empty() &&
driver::IsClangCL(driver::getDriverMode( driver::IsClangCL(driver::getDriverMode(
TmpArgv.front(), llvm::makeArrayRef(TmpArgv).slice(1))); TmpArgv.front(), llvm::ArrayRef(TmpArgv).slice(1)));
ArgList = {TmpArgv.begin(), TmpArgv.end()}; ArgList = {TmpArgv.begin(), TmpArgv.end()};
} }
Context not available.

clang/lib/Tooling/Syntax/BuildTree.cpp

Context not available.
assert(Last.isValid()); assert(Last.isValid());
assert(First == Last || assert(First == Last ||
TBTM.sourceManager().isBeforeInTranslationUnit(First, Last)); TBTM.sourceManager().isBeforeInTranslationUnit(First, Last));
return llvm::makeArrayRef(findToken(First), std::next(findToken(Last))); return llvm::ArrayRef(findToken(First), std::next(findToken(Last)));
} }
ArrayRef<syntax::Token> ArrayRef<syntax::Token>
Context not available.
assert(Tokens.back().kind() != tok::eof); assert(Tokens.back().kind() != tok::eof);
// We never consume 'eof', so looking at the next token is ok. // We never consume 'eof', so looking at the next token is ok.
if (Tokens.back().kind() != tok::semi && Tokens.end()->kind() == tok::semi) if (Tokens.back().kind() != tok::semi && Tokens.end()->kind() == tok::semi)
return llvm::makeArrayRef(Tokens.begin(), Tokens.end() + 1); return llvm::ArrayRef(Tokens.begin(), Tokens.end() + 1);
return Tokens; return Tokens;
} }
Context not available.
// Build TemplateDeclaration nodes if we had template parameters. // Build TemplateDeclaration nodes if we had template parameters.
auto ConsumeTemplateParameters = [&](const TemplateParameterList &L) { auto ConsumeTemplateParameters = [&](const TemplateParameterList &L) {
const auto *TemplateKW = Builder.findToken(L.getTemplateLoc()); const auto *TemplateKW = Builder.findToken(L.getTemplateLoc());
auto R = llvm::makeArrayRef(TemplateKW, DeclarationRange.end()); auto R = llvm::ArrayRef(TemplateKW, DeclarationRange.end());
Result = Result =
foldTemplateDeclaration(R, TemplateKW, DeclarationRange, nullptr); foldTemplateDeclaration(R, TemplateKW, DeclarationRange, nullptr);
DeclarationRange = R; DeclarationRange = R;
Context not available.
auto Return = Builder.getRange(ReturnedType.getSourceRange()); auto Return = Builder.getRange(ReturnedType.getSourceRange());
const auto *Arrow = Return.begin() - 1; const auto *Arrow = Return.begin() - 1;
assert(Arrow->kind() == tok::arrow); assert(Arrow->kind() == tok::arrow);
auto Tokens = llvm::makeArrayRef(Arrow, Return.end()); auto Tokens = llvm::ArrayRef(Arrow, Return.end());
Builder.markChildToken(Arrow, syntax::NodeRole::ArrowToken); Builder.markChildToken(Arrow, syntax::NodeRole::ArrowToken);
if (ReturnDeclarator) if (ReturnDeclarator)
Builder.markChild(ReturnDeclarator, syntax::NodeRole::Declarator); Builder.markChild(ReturnDeclarator, syntax::NodeRole::Declarator);
Context not available.

clang/lib/Tooling/Syntax/ComputeReplacements.cpp

Context not available.
process(Root); process(Root);
// Report the last span to the user. // Report the last span to the user.
if (SpanBegin) if (SpanBegin)
Callback(llvm::makeArrayRef(SpanBegin, SpanEnd), SpanIsOriginal); Callback(llvm::ArrayRef(SpanBegin, SpanEnd), SpanIsOriginal);
} }
private: private:
Context not available.
} }
// Report the current span to the user. // Report the current span to the user.
if (SpanBegin) if (SpanBegin)
Callback(llvm::makeArrayRef(SpanBegin, SpanEnd), SpanIsOriginal); Callback(llvm::ArrayRef(SpanBegin, SpanEnd), SpanIsOriginal);
// Start recording a new span. // Start recording a new span.
SpanBegin = STM.getToken(L->getTokenKey()); SpanBegin = STM.getToken(L->getTokenKey());
SpanEnd = SpanBegin + 1; SpanEnd = SpanBegin + 1;
Context not available.
// We are looking at a span of original tokens. // We are looking at a span of original tokens.
if (NextOriginal != Tokens.begin()) { if (NextOriginal != Tokens.begin()) {
// There is a gap, record a replacement or deletion. // There is a gap, record a replacement or deletion.
emitReplacement(llvm::makeArrayRef(NextOriginal, Tokens.begin())); emitReplacement(llvm::ArrayRef(NextOriginal, Tokens.begin()));
} else { } else {
// No gap, but we may have pending insertions. Emit them now. // No gap, but we may have pending insertions. Emit them now.
emitReplacement(llvm::makeArrayRef(NextOriginal, /*Length=*/0)); emitReplacement(llvm::ArrayRef(NextOriginal, /*Length=*/(size_t)0));
} }
NextOriginal = Tokens.end(); NextOriginal = Tokens.end();
}); });
// We might have pending replacements at the end of file. If so, emit them. // We might have pending replacements at the end of file. If so, emit them.
emitReplacement(llvm::makeArrayRef( emitReplacement(
NextOriginal, Buffer.expandedTokens().drop_back().end())); llvm::ArrayRef(NextOriginal, Buffer.expandedTokens().drop_back().end()));
return Replacements; return Replacements;
} }
Context not available.

clang/lib/Tooling/Syntax/Tokens.cpp

Context not available.
// Avoid returning empty ranges. // Avoid returning empty ranges.
if (ExpandedBegin == ExpandedEnd) if (ExpandedBegin == ExpandedEnd)
return {}; return {};
return {llvm::makeArrayRef(ExpandedTokens.data() + ExpandedBegin, return {llvm::ArrayRef(ExpandedTokens.data() + ExpandedBegin,
ExpandedTokens.data() + ExpandedEnd)}; ExpandedTokens.data() + ExpandedEnd)};
} }
llvm::ArrayRef<syntax::Token> TokenBuffer::spelledTokens(FileID FID) const { llvm::ArrayRef<syntax::Token> TokenBuffer::spelledTokens(FileID FID) const {
Context not available.
return std::nullopt; return std::nullopt;
if (LastMapping && LastMapping->EndExpanded != LastExpanded) if (LastMapping && LastMapping->EndExpanded != LastExpanded)
return std::nullopt; return std::nullopt;
return llvm::makeArrayRef( return llvm::ArrayRef(
FirstMapping ? File.SpelledTokens.data() + FirstMapping->BeginSpelled FirstMapping ? File.SpelledTokens.data() + FirstMapping->BeginSpelled
: FirstSpelled, : FirstSpelled,
LastMapping ? File.SpelledTokens.data() + LastMapping->EndSpelled LastMapping ? File.SpelledTokens.data() + LastMapping->EndSpelled
Context not available.
TokenBuffer::Expansion TokenBuffer::makeExpansion(const MarkedFile &F, TokenBuffer::Expansion TokenBuffer::makeExpansion(const MarkedFile &F,
const Mapping &M) const { const Mapping &M) const {
Expansion E; Expansion E;
E.Spelled = llvm::makeArrayRef(F.SpelledTokens.data() + M.BeginSpelled, E.Spelled = llvm::ArrayRef(F.SpelledTokens.data() + M.BeginSpelled,
F.SpelledTokens.data() + M.EndSpelled); F.SpelledTokens.data() + M.EndSpelled);
E.Expanded = llvm::makeArrayRef(ExpandedTokens.data() + M.BeginExpanded, E.Expanded = llvm::ArrayRef(ExpandedTokens.data() + M.BeginExpanded,
ExpandedTokens.data() + M.EndExpanded); ExpandedTokens.data() + M.EndExpanded);
return E; return E;
} }
Context not available.
bool AcceptRight = Right != Tokens.end() && Right->location() <= Loc; bool AcceptRight = Right != Tokens.end() && Right->location() <= Loc;
bool AcceptLeft = bool AcceptLeft =
Right != Tokens.begin() && (Right - 1)->endLocation() >= Loc; Right != Tokens.begin() && (Right - 1)->endLocation() >= Loc;
return llvm::makeArrayRef(Right - (AcceptLeft ? 1 : 0), return llvm::ArrayRef(Right - (AcceptLeft ? 1 : 0),
Right + (AcceptRight ? 1 : 0)); Right + (AcceptRight ? 1 : 0));
} }
llvm::ArrayRef<syntax::Token> llvm::ArrayRef<syntax::Token>
Context not available.
OS << "expanded tokens:\n" OS << "expanded tokens:\n"
<< " "; << " ";
// (!) we do not show '<eof>'. // (!) we do not show '<eof>'.
DumpTokens(OS, llvm::makeArrayRef(ExpandedTokens).drop_back()); DumpTokens(OS, llvm::ArrayRef(ExpandedTokens).drop_back());
OS << "\n"; OS << "\n";
std::vector<FileID> Keys; std::vector<FileID> Keys;
Context not available.

clang/lib/Tooling/Tooling.cpp

Context not available.
// We already have a cc1, just create an invocation. // We already have a cc1, just create an invocation.
if (CommandLine.size() >= 2 && CommandLine[1] == "-cc1") { if (CommandLine.size() >= 2 && CommandLine[1] == "-cc1") {
ArrayRef<const char *> CC1Args = makeArrayRef(Argv).drop_front(); ArrayRef<const char *> CC1Args = ArrayRef(Argv).drop_front();
std::unique_ptr<CompilerInvocation> Invocation( std::unique_ptr<CompilerInvocation> Invocation(
newInvocation(&*Diagnostics, CC1Args, BinaryName)); newInvocation(&*Diagnostics, CC1Args, BinaryName));
if (Diagnostics->hasErrorOccurred()) if (Diagnostics->hasErrorOccurred())
Context not available.
if (!Files->getFileSystemOpts().WorkingDir.empty()) if (!Files->getFileSystemOpts().WorkingDir.empty())
Driver->setCheckInputsExist(false); Driver->setCheckInputsExist(false);
const std::unique_ptr<driver::Compilation> Compilation( const std::unique_ptr<driver::Compilation> Compilation(
Driver->BuildCompilation(llvm::makeArrayRef(Argv))); Driver->BuildCompilation(llvm::ArrayRef(Argv)));
if (!Compilation) if (!Compilation)
return false; return false;
const llvm::opt::ArgStringList *const CC1Args = getCC1Arguments( const llvm::opt::ArgStringList *const CC1Args = getCC1Arguments(
Context not available.

clang/tools/diagtool/DiagnosticNames.cpp

Context not available.
}; };
llvm::ArrayRef<DiagnosticRecord> diagtool::getBuiltinDiagnosticsByName() { llvm::ArrayRef<DiagnosticRecord> diagtool::getBuiltinDiagnosticsByName() {
return llvm::makeArrayRef(BuiltinDiagnosticsByName); return llvm::ArrayRef(BuiltinDiagnosticsByName);
} }
Context not available.
} }
llvm::ArrayRef<GroupRecord> diagtool::getDiagnosticGroups() { llvm::ArrayRef<GroupRecord> diagtool::getDiagnosticGroups() {
return llvm::makeArrayRef(OptionTable); return llvm::ArrayRef(OptionTable);
} }
Context not available.

clang/tools/diagtool/FindDiagnosticID.cpp

Context not available.
std::vector<const char *> Args; std::vector<const char *> Args;
Args.push_back("diagtool find-diagnostic-id"); Args.push_back("diagtool find-diagnostic-id");
for (const char *A : llvm::makeArrayRef(argv, argc)) for (const char *A : llvm::ArrayRef(argv, argc))
Args.push_back(A); Args.push_back(A);
llvm::cl::HideUnrelatedOptions(FindDiagnosticIDOptions); llvm::cl::HideUnrelatedOptions(FindDiagnosticIDOptions);
Context not available.

clang/tools/driver/driver.cpp

Context not available.
StringRef Tool = ArgV[1]; StringRef Tool = ArgV[1];
void *GetExecutablePathVP = (void *)(intptr_t)GetExecutablePath; void *GetExecutablePathVP = (void *)(intptr_t)GetExecutablePath;
if (Tool == "-cc1") if (Tool == "-cc1")
return cc1_main(makeArrayRef(ArgV).slice(1), ArgV[0], GetExecutablePathVP); return cc1_main(ArrayRef(ArgV).slice(1), ArgV[0], GetExecutablePathVP);
if (Tool == "-cc1as") if (Tool == "-cc1as")
return cc1as_main(makeArrayRef(ArgV).slice(2), ArgV[0], return cc1as_main(ArrayRef(ArgV).slice(2), ArgV[0], GetExecutablePathVP);
GetExecutablePathVP);
if (Tool == "-cc1gen-reproducer") if (Tool == "-cc1gen-reproducer")
return cc1gen_reproducer_main(makeArrayRef(ArgV).slice(2), ArgV[0], return cc1gen_reproducer_main(ArrayRef(ArgV).slice(2), ArgV[0],
GetExecutablePathVP); GetExecutablePathVP);
// Reject unknown tools. // Reject unknown tools.
llvm::errs() << "error: unknown integrated tool '" << Tool << "'. " llvm::errs() << "error: unknown integrated tool '" << Tool << "'. "
Context not available.
// Finally, our -cc1 tools don't care which tokenization mode we use because // Finally, our -cc1 tools don't care which tokenization mode we use because
// response files written by clang will tokenize the same way in either mode. // response files written by clang will tokenize the same way in either mode.
bool ClangCLMode = bool ClangCLMode =
IsClangCL(getDriverMode(Args[0], llvm::makeArrayRef(Args).slice(1))); IsClangCL(getDriverMode(Args[0], llvm::ArrayRef(Args).slice(1)));
enum { Default, POSIX, Windows } RSPQuoting = Default; enum { Default, POSIX, Windows } RSPQuoting = Default;
for (const char *F : Args) { for (const char *F : Args) {
if (strcmp(F, "--rsp-quoting=posix") == 0) if (strcmp(F, "--rsp-quoting=posix") == 0)
Context not available.

clang/tools/libclang/CIndex.cpp

Context not available.
// Configure the diagnostics. // Configure the diagnostics.
std::unique_ptr<DiagnosticOptions> DiagOpts = CreateAndPopulateDiagOpts( std::unique_ptr<DiagnosticOptions> DiagOpts = CreateAndPopulateDiagOpts(
llvm::makeArrayRef(command_line_args, num_command_line_args)); llvm::ArrayRef(command_line_args, num_command_line_args));
IntrusiveRefCntPtr<DiagnosticsEngine> Diags( IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
CompilerInstance::createDiagnostics(DiagOpts.release())); CompilerInstance::createDiagnostics(DiagOpts.release()));
Context not available.
LibclangInvocationReporter InvocationReporter( LibclangInvocationReporter InvocationReporter(
*CXXIdx, LibclangInvocationReporter::OperationKind::ParseOperation, *CXXIdx, LibclangInvocationReporter::OperationKind::ParseOperation,
options, llvm::makeArrayRef(*Args), /*InvocationArgs=*/std::nullopt, options, llvm::ArrayRef(*Args), /*InvocationArgs=*/std::nullopt,
unsaved_files); unsaved_files);
std::unique_ptr<ASTUnit> Unit(ASTUnit::LoadFromCommandLine( std::unique_ptr<ASTUnit> Unit(ASTUnit::LoadFromCommandLine(
Args->data(), Args->data() + Args->size(), Args->data(), Args->data() + Args->size(),
Context not available.
noteBottomOfStack(); noteBottomOfStack();
result = clang_parseTranslationUnit_Impl( result = clang_parseTranslationUnit_Impl(
CIdx, source_filename, command_line_args, num_command_line_args, CIdx, source_filename, command_line_args, num_command_line_args,
llvm::makeArrayRef(unsaved_files, num_unsaved_files), options, out_TU); llvm::ArrayRef(unsaved_files, num_unsaved_files), options, out_TU);
}; };
llvm::CrashRecoveryContext CRC; llvm::CrashRecoveryContext CRC;
Context not available.
CXErrorCode result; CXErrorCode result;
auto ReparseTranslationUnitImpl = [=, &result]() { auto ReparseTranslationUnitImpl = [=, &result]() {
result = clang_reparseTranslationUnit_Impl( result = clang_reparseTranslationUnit_Impl(
TU, llvm::makeArrayRef(unsaved_files, num_unsaved_files), options); TU, llvm::ArrayRef(unsaved_files, num_unsaved_files), options);
}; };
llvm::CrashRecoveryContext CRC; llvm::CrashRecoveryContext CRC;
Context not available.
getCursorPlatformAvailabilityForDecl(D, always_deprecated, deprecated_message, getCursorPlatformAvailabilityForDecl(D, always_deprecated, deprecated_message,
always_unavailable, unavailable_message, always_unavailable, unavailable_message,
AvailabilityAttrs); AvailabilityAttrs);
for (const auto &Avail : for (const auto &Avail : llvm::enumerate(
llvm::enumerate(llvm::makeArrayRef(AvailabilityAttrs) llvm::ArrayRef(AvailabilityAttrs).take_front(availability_size))) {
.take_front(availability_size))) {
availability[Avail.index()].Platform = availability[Avail.index()].Platform =
cxstring::createDup(Avail.value()->getPlatform()->getName()); cxstring::createDup(Avail.value()->getPlatform()->getName());
availability[Avail.index()].Introduced = availability[Avail.index()].Introduced =
Context not available.

clang/tools/libclang/CIndexCodeCompletion.cpp

Context not available.
auto CodeCompleteAtImpl = [=, &result]() { auto CodeCompleteAtImpl = [=, &result]() {
result = clang_codeCompleteAt_Impl( result = clang_codeCompleteAt_Impl(
TU, complete_filename, complete_line, complete_column, TU, complete_filename, complete_line, complete_column,
llvm::makeArrayRef(unsaved_files, num_unsaved_files), options); llvm::ArrayRef(unsaved_files, num_unsaved_files), options);
}; };
llvm::CrashRecoveryContext CRC; llvm::CrashRecoveryContext CRC;
Context not available.

clang/tools/libclang/Indexing.cpp

Context not available.
result = clang_indexSourceFile_Impl( result = clang_indexSourceFile_Impl(
idxAction, client_data, index_callbacks, index_callbacks_size, idxAction, client_data, index_callbacks, index_callbacks_size,
index_options, source_filename, command_line_args, index_options, source_filename, command_line_args,
num_command_line_args, num_command_line_args, llvm::ArrayRef(unsaved_files, num_unsaved_files),
llvm::makeArrayRef(unsaved_files, num_unsaved_files), out_TU, out_TU, TU_options);
TU_options);
}; };
llvm::CrashRecoveryContext CRC; llvm::CrashRecoveryContext CRC;
Context not available.

clang/unittests/Driver/ToolChainTest.cpp

Context not available.
TEST(GetDriverMode, PrefersLastDriverMode) { TEST(GetDriverMode, PrefersLastDriverMode) {
static constexpr const char *Args[] = {"clang-cl", "--driver-mode=foo", static constexpr const char *Args[] = {"clang-cl", "--driver-mode=foo",
"--driver-mode=bar", "foo.cpp"}; "--driver-mode=bar", "foo.cpp"};
EXPECT_EQ(getDriverMode(Args[0], llvm::makeArrayRef(Args).slice(1)), "bar"); EXPECT_EQ(getDriverMode(Args[0], llvm::ArrayRef(Args).slice(1)), "bar");
} }
struct SimpleDiagnosticConsumer : public DiagnosticConsumer { struct SimpleDiagnosticConsumer : public DiagnosticConsumer {
Context not available.

clang/unittests/Introspection/IntrospectionTest.cpp

Context not available.
// clang-format off // clang-format off
EXPECT_EQ( EXPECT_EQ(
llvm::makeArrayRef(ExpectedRanges), llvm::ArrayRef(ExpectedRanges),
(ArrayRef<std::pair<std::string, SourceRange>>{ (ArrayRef<std::pair<std::string, SourceRange>>{
STRING_LOCATION_STDPAIR(MethodDecl, getExceptionSpecSourceRange()), STRING_LOCATION_STDPAIR(MethodDecl, getExceptionSpecSourceRange()),
STRING_LOCATION_STDPAIR(MethodDecl, getNameInfo().getSourceRange()), STRING_LOCATION_STDPAIR(MethodDecl, getNameInfo().getSourceRange()),
Context not available.
llvm::sort(ExpectedLocations); llvm::sort(ExpectedLocations);
EXPECT_EQ( EXPECT_EQ(
llvm::makeArrayRef(ExpectedLocations), llvm::ArrayRef(ExpectedLocations),
(ArrayRef<std::pair<std::string, SourceLocation>>{ (ArrayRef<std::pair<std::string, SourceLocation>>{
STRING_LOCATION_STDPAIR(NNS, getBeginLoc()), STRING_LOCATION_STDPAIR(NNS, getBeginLoc()),
STRING_LOCATION_STDPAIR(NNS, getEndLoc()), STRING_LOCATION_STDPAIR(NNS, getEndLoc()),
Context not available.
// clang-format off // clang-format off
EXPECT_EQ( EXPECT_EQ(
llvm::makeArrayRef(ExpectedLocations), llvm::ArrayRef(ExpectedLocations),
(ArrayRef<std::pair<std::string, SourceLocation>>{ (ArrayRef<std::pair<std::string, SourceLocation>>{
STRING_LOCATION_STDPAIR(CtorInit, getBaseClassLoc().getAs<clang::ElaboratedTypeLoc>().getNamedTypeLoc().getAs<clang::TemplateSpecializationTypeLoc>().getLAngleLoc()), STRING_LOCATION_STDPAIR(CtorInit, getBaseClassLoc().getAs<clang::ElaboratedTypeLoc>().getNamedTypeLoc().getAs<clang::TemplateSpecializationTypeLoc>().getLAngleLoc()),
STRING_LOCATION_STDPAIR(CtorInit, getBaseClassLoc().getAs<clang::ElaboratedTypeLoc>().getNamedTypeLoc().getAs<clang::TemplateSpecializationTypeLoc>().getRAngleLoc()), STRING_LOCATION_STDPAIR(CtorInit, getBaseClassLoc().getAs<clang::ElaboratedTypeLoc>().getNamedTypeLoc().getAs<clang::TemplateSpecializationTypeLoc>().getRAngleLoc()),
Context not available.
// clang-format off // clang-format off
EXPECT_EQ( EXPECT_EQ(
llvm::makeArrayRef(ExpectedLocations), llvm::ArrayRef(ExpectedLocations),
(ArrayRef<std::pair<std::string, SourceLocation>>{ (ArrayRef<std::pair<std::string, SourceLocation>>{
STRING_LOCATION_STDPAIR(TL, getAs<clang::FunctionTypeLoc>().getLParenLoc()), STRING_LOCATION_STDPAIR(TL, getAs<clang::FunctionTypeLoc>().getLParenLoc()),
STRING_LOCATION_STDPAIR(TL, getAs<clang::FunctionTypeLoc>().getLocalRangeBegin()), STRING_LOCATION_STDPAIR(TL, getAs<clang::FunctionTypeLoc>().getLocalRangeBegin()),
Context not available.
// clang-format off // clang-format off
EXPECT_EQ( EXPECT_EQ(
llvm::makeArrayRef(ExpectedLocations), llvm::ArrayRef(ExpectedLocations),
(ArrayRef<std::pair<std::string, SourceLocation>>{ (ArrayRef<std::pair<std::string, SourceLocation>>{
STRING_LOCATION_STDPAIR(TL, getAs<clang::PointerTypeLoc>().getPointeeLoc().getAs<clang::BuiltinTypeLoc>().getBuiltinLoc()), STRING_LOCATION_STDPAIR(TL, getAs<clang::PointerTypeLoc>().getPointeeLoc().getAs<clang::BuiltinTypeLoc>().getBuiltinLoc()),
STRING_LOCATION_STDPAIR(TL, getAs<clang::PointerTypeLoc>().getPointeeLoc().getAs<clang::BuiltinTypeLoc>().getNameLoc()), STRING_LOCATION_STDPAIR(TL, getAs<clang::PointerTypeLoc>().getPointeeLoc().getAs<clang::BuiltinTypeLoc>().getNameLoc()),
Context not available.
// clang-format off // clang-format off
EXPECT_EQ( EXPECT_EQ(
llvm::makeArrayRef(ExpectedLocations), llvm::ArrayRef(ExpectedLocations),
(ArrayRef<std::pair<std::string, SourceLocation>>{ (ArrayRef<std::pair<std::string, SourceLocation>>{
STRING_LOCATION_STDPAIR((&NI), getBeginLoc()), STRING_LOCATION_STDPAIR((&NI), getBeginLoc()),
STRING_LOCATION_STDPAIR((&NI), getEndLoc()), STRING_LOCATION_STDPAIR((&NI), getEndLoc()),
Context not available.
llvm::sort(ExpectedLocations); llvm::sort(ExpectedLocations);
EXPECT_EQ( EXPECT_EQ(
llvm::makeArrayRef(ExpectedLocations), llvm::ArrayRef(ExpectedLocations),
(ArrayRef<std::pair<std::string, SourceLocation>>{ (ArrayRef<std::pair<std::string, SourceLocation>>{
STRING_LOCATION_STDPAIR(Member, getBeginLoc()), STRING_LOCATION_STDPAIR(Member, getBeginLoc()),
STRING_LOCATION_STDPAIR(Member, getEndLoc()), STRING_LOCATION_STDPAIR(Member, getEndLoc()),
STRING_LOCATION_STDPAIR(Member, getExprLoc()), STRING_LOCATION_STDPAIR(Member, getExprLoc()),
STRING_LOCATION_STDPAIR(Member, getLAngleLoc()), STRING_LOCATION_STDPAIR(Member, getLAngleLoc()),
STRING_LOCATION_STDPAIR(Member, getMemberLoc()), STRING_LOCATION_STDPAIR(Member, getMemberLoc()),
STRING_LOCATION_STDPAIR(Member, getMemberNameInfo().getBeginLoc()), STRING_LOCATION_STDPAIR(Member, getMemberNameInfo().getBeginLoc()),
STRING_LOCATION_STDPAIR(Member, getMemberNameInfo().getEndLoc()), STRING_LOCATION_STDPAIR(Member, getMemberNameInfo().getEndLoc()),
STRING_LOCATION_STDPAIR(Member, getMemberNameInfo().getLoc()), STRING_LOCATION_STDPAIR(Member, getMemberNameInfo().getLoc()),
STRING_LOCATION_STDPAIR(Member, getOperatorLoc()), STRING_LOCATION_STDPAIR(Member, getOperatorLoc()),
STRING_LOCATION_STDPAIR(Member, getRAngleLoc()), STRING_LOCATION_STDPAIR(Member, getRAngleLoc()),
STRING_LOCATION_STDPAIR(Member, getTemplateKeywordLoc()) STRING_LOCATION_STDPAIR(Member, getTemplateKeywordLoc())}));
}));
auto ExpectedRanges = FormatExpected<SourceRange>(Result.RangeAccessors); auto ExpectedRanges = FormatExpected<SourceRange>(Result.RangeAccessors);
Context not available.
llvm::sort(ExpectedLocations); llvm::sort(ExpectedLocations);
EXPECT_EQ(llvm::makeArrayRef(ExpectedLocations), EXPECT_EQ(llvm::ArrayRef(ExpectedLocations),
(ArrayRef<std::pair<std::string, SourceLocation>>{ (ArrayRef<std::pair<std::string, SourceLocation>>{
STRING_LOCATION_STDPAIR((&NI), getBeginLoc()), STRING_LOCATION_STDPAIR((&NI), getBeginLoc()),
STRING_LOCATION_STDPAIR((&NI), getEndLoc()), STRING_LOCATION_STDPAIR((&NI), getEndLoc()),
Context not available.
llvm::sort(ExpectedLocations); llvm::sort(ExpectedLocations);
EXPECT_EQ(llvm::makeArrayRef(ExpectedLocations), EXPECT_EQ(llvm::ArrayRef(ExpectedLocations),
(ArrayRef<std::pair<std::string, SourceLocation>>{ (ArrayRef<std::pair<std::string, SourceLocation>>{
STRING_LOCATION_STDPAIR((&NI), getBeginLoc()), STRING_LOCATION_STDPAIR((&NI), getBeginLoc()),
STRING_LOCATION_STDPAIR((&NI), getCXXLiteralOperatorNameLoc()), STRING_LOCATION_STDPAIR((&NI), getCXXLiteralOperatorNameLoc()),
Context not available.

clang/unittests/Lex/LexerTest.cpp

Context not available.
SrcBuffer.data(), SrcBuffer.data(), SrcBuffer.data(), SrcBuffer.data(),
SrcBuffer.data() + SrcBuffer.size()); SrcBuffer.data() + SrcBuffer.size());
auto ToksView = llvm::makeArrayRef(Toks); auto ToksView = llvm::ArrayRef(Toks);
clang::Token T; clang::Token T;
EXPECT_FALSE(ToksView.empty()); EXPECT_FALSE(ToksView.empty());
while (!L.LexFromRawLexer(T)) { while (!L.LexFromRawLexer(T)) {
Context not available.

clang/unittests/Lex/PPDependencyDirectivesTest.cpp

Context not available.
Input, DepDirectivesObjects.back()->Tokens, Input, DepDirectivesObjects.back()->Tokens,
DepDirectivesObjects.back()->Directives); DepDirectivesObjects.back()->Directives);
EXPECT_FALSE(Err); EXPECT_FALSE(Err);
return llvm::makeArrayRef(DepDirectivesObjects.back()->Directives); return llvm::ArrayRef(DepDirectivesObjects.back()->Directives);
}; };
auto PPOpts = std::make_shared<PreprocessorOptions>(); auto PPOpts = std::make_shared<PreprocessorOptions>();
Context not available.

clang/unittests/Tooling/Syntax/TokensTest.cpp

Context not available.
llvm::ArrayRef<T> Range, Eq F) { llvm::ArrayRef<T> Range, Eq F) {
assert(Subrange.size() >= 1); assert(Subrange.size() >= 1);
if (Range.size() < Subrange.size()) if (Range.size() < Subrange.size())
return llvm::makeArrayRef(Range.end(), Range.end()); return llvm::ArrayRef(Range.end(), Range.end());
for (auto Begin = Range.begin(), Last = Range.end() - Subrange.size(); for (auto Begin = Range.begin(), Last = Range.end() - Subrange.size();
Begin <= Last; ++Begin) { Begin <= Last; ++Begin) {
auto It = Begin; auto It = Begin;
Context not available.
if (!F(*ItSub, *It)) if (!F(*ItSub, *It))
goto continue_outer; goto continue_outer;
} }
return llvm::makeArrayRef(Begin, It); return llvm::ArrayRef(Begin, It);
continue_outer:; continue_outer:;
} }
return llvm::makeArrayRef(Range.end(), Range.end()); return llvm::ArrayRef(Range.end(), Range.end());
} }
/// Finds a subrange in \p Tokens that match the tokens specified in \p Query. /// Finds a subrange in \p Tokens that match the tokens specified in \p Query.
Context not available.
return Q == T.text(*SourceMgr); return Q == T.text(*SourceMgr);
}; };
// Find a match. // Find a match.
auto Found = auto Found = findSubrange(llvm::ArrayRef(QueryTokens), Tokens, TextMatches);
findSubrange(llvm::makeArrayRef(QueryTokens), Tokens, TextMatches);
if (Found.begin() == Tokens.end()) { if (Found.begin() == Tokens.end()) {
ADD_FAILURE() << "could not find the subrange for " << Query; ADD_FAILURE() << "could not find the subrange for " << Query;
std::abort(); std::abort();
} }
// Check that the match is unique. // Check that the match is unique.
if (findSubrange(llvm::makeArrayRef(QueryTokens), if (findSubrange(llvm::ArrayRef(QueryTokens),
llvm::makeArrayRef(Found.end(), Tokens.end()), TextMatches) llvm::ArrayRef(Found.end(), Tokens.end()), TextMatches)
.begin() != Tokens.end()) { .begin() != Tokens.end()) {
ADD_FAILURE() << "match is not unique for " << Query; ADD_FAILURE() << "match is not unique for " << Query;
std::abort(); std::abort();
Context not available.
Buffer.expansionStartingAt(Foo2.data()), Buffer.expansionStartingAt(Foo2.data()),
ValueIs(IsExpansion(SameRange(Foo2.drop_back()), ValueIs(IsExpansion(SameRange(Foo2.drop_back()),
SameRange(findExpanded("3 + 4 2").drop_back())))); SameRange(findExpanded("3 + 4 2").drop_back()))));
EXPECT_THAT(Buffer.expansionsOverlapping( EXPECT_THAT(
llvm::makeArrayRef(Foo1.begin(), Foo2.end())), Buffer.expansionsOverlapping(llvm::ArrayRef(Foo1.begin(), Foo2.end())),
ElementsAre(IsExpansion(SameRange(Foo1.drop_back()), _), ElementsAre(IsExpansion(SameRange(Foo1.drop_back()), _),
IsExpansion(SameRange(Foo2.drop_back()), _))); IsExpansion(SameRange(Foo2.drop_back()), _)));
// Function-like macro expansions. // Function-like macro expansions.
recordTokens(R"cpp( recordTokens(R"cpp(
Context not available.
for (const auto &T : ID2.drop_front()) for (const auto &T : ID2.drop_front())
EXPECT_EQ(Buffer.expansionStartingAt(&T), std::nullopt); EXPECT_EQ(Buffer.expansionStartingAt(&T), std::nullopt);
EXPECT_THAT(Buffer.expansionsOverlapping(llvm::makeArrayRef( EXPECT_THAT(Buffer.expansionsOverlapping(llvm::ArrayRef(
findSpelled("1 + 2").data(), findSpelled("4").data())), findSpelled("1 + 2").data(), findSpelled("4").data())),
ElementsAre(IsExpansion(SameRange(ID1), _), ElementsAre(IsExpansion(SameRange(ID1), _),
IsExpansion(SameRange(ID2), _))); IsExpansion(SameRange(ID2), _)));
Context not available.

clang/unittests/Tooling/Syntax/TreeTestBase.cpp

Context not available.
const TokenBufferTokenManager &STM) { const TokenBufferTokenManager &STM) {
assert(N->isOriginal() && "tokens of modified nodes are not well-defined"); assert(N->isOriginal() && "tokens of modified nodes are not well-defined");
if (auto *L = dyn_cast<syntax::Leaf>(N)) if (auto *L = dyn_cast<syntax::Leaf>(N))
return llvm::makeArrayRef(STM.getToken(L->getTokenKey()), 1); return llvm::ArrayRef(STM.getToken(L->getTokenKey()), 1);
auto *T = cast<syntax::Tree>(N); auto *T = cast<syntax::Tree>(N);
return llvm::makeArrayRef(STM.getToken(T->findFirstLeaf()->getTokenKey()), return llvm::ArrayRef(STM.getToken(T->findFirstLeaf()->getTokenKey()),
STM.getToken(T->findLastLeaf()->getTokenKey()) + 1); STM.getToken(T->findLastLeaf()->getTokenKey()) + 1);
} }
} // namespace } // namespace
Context not available.

clang/unittests/Tooling/ToolingTest.cpp

Context not available.
const llvm::opt::ArgStringList * const llvm::opt::ArgStringList *
extractCC1Arguments(llvm::ArrayRef<const char *> Argv) { extractCC1Arguments(llvm::ArrayRef<const char *> Argv) {
const std::unique_ptr<driver::Compilation> Compilation( const std::unique_ptr<driver::Compilation> Compilation(
Driver.BuildCompilation(llvm::makeArrayRef(Argv))); Driver.BuildCompilation(llvm::ArrayRef(Argv)));
return getCC1Arguments(Diags.get(), Compilation.get()); return getCC1Arguments(Diags.get(), Compilation.get());
} }
Context not available.

flang/lib/Lower/ConvertVariable.cpp

Context not available.
auto commonTy = fir::SequenceType::get(shape, i8Ty); auto commonTy = fir::SequenceType::get(shape, i8Ty);
auto vecTy = mlir::VectorType::get(sz, i8Ty); auto vecTy = mlir::VectorType::get(sz, i8Ty);
mlir::Attribute zero = builder.getIntegerAttr(i8Ty, 0); mlir::Attribute zero = builder.getIntegerAttr(i8Ty, 0);
auto init = mlir::DenseElementsAttr::get(vecTy, llvm::makeArrayRef(zero)); auto init = mlir::DenseElementsAttr::get(vecTy, llvm::ArrayRef(zero));
builder.createGlobal(loc, commonTy, commonName, linkage, init); builder.createGlobal(loc, commonTy, commonName, linkage, init);
// No need to add any initial value later. // No need to add any initial value later.
return std::nullopt; return std::nullopt;
Context not available.

flang/tools/flang-driver/driver.cpp

Context not available.
static int executeFC1Tool(llvm::SmallVectorImpl<const char *> &argV) { static int executeFC1Tool(llvm::SmallVectorImpl<const char *> &argV) {
llvm::StringRef tool = argV[1]; llvm::StringRef tool = argV[1];
if (tool == "-fc1") if (tool == "-fc1")
return fc1_main(makeArrayRef(argV).slice(2), argV[0]); return fc1_main(llvm::ArrayRef(argV).slice(2), argV[0]);
// Reject unknown tools. // Reject unknown tools.
// ATM it only supports fc1. Any fc1[*] is rejected. // ATM it only supports fc1. Any fc1[*] is rejected.
Context not available.

libc/benchmarks/LibcDefaultImplementations.cpp

Context not available.
llvm::ArrayRef<MemcpyConfiguration> getMemcpyConfigurations() { llvm::ArrayRef<MemcpyConfiguration> getMemcpyConfigurations() {
static constexpr MemcpyConfiguration kMemcpyConfigurations[] = { static constexpr MemcpyConfiguration kMemcpyConfigurations[] = {
{__llvm_libc::memcpy, "__llvm_libc::memcpy"}}; {__llvm_libc::memcpy, "__llvm_libc::memcpy"}};
return llvm::makeArrayRef(kMemcpyConfigurations); return llvm::ArrayRef(kMemcpyConfigurations);
} }
llvm::ArrayRef<MemmoveConfiguration> getMemmoveConfigurations() { llvm::ArrayRef<MemmoveConfiguration> getMemmoveConfigurations() {
static constexpr MemmoveConfiguration kMemmoveConfigurations[] = { static constexpr MemmoveConfiguration kMemmoveConfigurations[] = {
{__llvm_libc::memmove, "__llvm_libc::memmove"}}; {__llvm_libc::memmove, "__llvm_libc::memmove"}};
return llvm::makeArrayRef(kMemmoveConfigurations); return llvm::ArrayRef(kMemmoveConfigurations);
} }
llvm::ArrayRef<MemcmpOrBcmpConfiguration> getMemcmpConfigurations() { llvm::ArrayRef<MemcmpOrBcmpConfiguration> getMemcmpConfigurations() {
static constexpr MemcmpOrBcmpConfiguration kMemcmpConfiguration[] = { static constexpr MemcmpOrBcmpConfiguration kMemcmpConfiguration[] = {
{__llvm_libc::memcmp, "__llvm_libc::memcmp"}}; {__llvm_libc::memcmp, "__llvm_libc::memcmp"}};
return llvm::makeArrayRef(kMemcmpConfiguration); return llvm::ArrayRef(kMemcmpConfiguration);
} }
llvm::ArrayRef<MemcmpOrBcmpConfiguration> getBcmpConfigurations() { llvm::ArrayRef<MemcmpOrBcmpConfiguration> getBcmpConfigurations() {
static constexpr MemcmpOrBcmpConfiguration kBcmpConfigurations[] = { static constexpr MemcmpOrBcmpConfiguration kBcmpConfigurations[] = {
{__llvm_libc::bcmp, "__llvm_libc::bcmp"}}; {__llvm_libc::bcmp, "__llvm_libc::bcmp"}};
return llvm::makeArrayRef(kBcmpConfigurations); return llvm::ArrayRef(kBcmpConfigurations);
} }
llvm::ArrayRef<MemsetConfiguration> getMemsetConfigurations() { llvm::ArrayRef<MemsetConfiguration> getMemsetConfigurations() {
static constexpr MemsetConfiguration kMemsetConfigurations[] = { static constexpr MemsetConfiguration kMemsetConfigurations[] = {
{__llvm_libc::memset, "__llvm_libc::memset"}}; {__llvm_libc::memset, "__llvm_libc::memset"}};
return llvm::makeArrayRef(kMemsetConfigurations); return llvm::ArrayRef(kMemsetConfigurations);
} }
llvm::ArrayRef<BzeroConfiguration> getBzeroConfigurations() { llvm::ArrayRef<BzeroConfiguration> getBzeroConfigurations() {
static constexpr BzeroConfiguration kBzeroConfigurations[] = { static constexpr BzeroConfiguration kBzeroConfigurations[] = {
{__llvm_libc::bzero, "__llvm_libc::bzero"}}; {__llvm_libc::bzero, "__llvm_libc::bzero"}};
return llvm::makeArrayRef(kBzeroConfigurations); return llvm::ArrayRef(kBzeroConfigurations);
} }
Context not available.

libc/benchmarks/LibcMemoryBenchmarkMain.cpp

Context not available.
CircularArrayRef<ParameterBatch::ParameterType> CircularArrayRef<ParameterBatch::ParameterType>
generateBatch(size_t Iterations) { generateBatch(size_t Iterations) {
randomize(); randomize();
return cycle(makeArrayRef(Parameters), Iterations); return cycle(ArrayRef(Parameters), Iterations);
} }
protected: protected:
Context not available.

libc/benchmarks/automemcpy/lib/CodeGen.cpp

Context not available.
// {"memcpy_0x8661D80472487AB5",{FunctionType::MEMCPY,Contiguous{{0,1}},std::nullopt,std::nullopt,std::nullopt,Accelerator{{1,kMaxSize}},ElementTypeClass::NATIVE}}, // {"memcpy_0x8661D80472487AB5",{FunctionType::MEMCPY,Contiguous{{0,1}},std::nullopt,std::nullopt,std::nullopt,Accelerator{{1,kMaxSize}},ElementTypeClass::NATIVE}},
// ... // ...
// }; // };
// return makeArrayRef(kDescriptors); // return ArrayRef(kDescriptors);
// } // }
static raw_ostream &operator<<(raw_ostream &Stream, const SizeSpan &SS) { static raw_ostream &operator<<(raw_ostream &Stream, const SizeSpan &SS) {
Context not available.
Stream << kIndent << kIndent << Descriptors[I] << ",\n"; Stream << kIndent << kIndent << Descriptors[I] << ",\n";
} }
Stream << R"( }; Stream << R"( };
return makeArrayRef(kDescriptors); return ArrayRef(kDescriptors);
} }
)"; )";
} }
Context not available.
// {Wrap<memcpy_0x8661D80472487AB5>, "memcpy_0x8661D80472487AB5"}, // {Wrap<memcpy_0x8661D80472487AB5>, "memcpy_0x8661D80472487AB5"},
// ... // ...
// }; // };
// return llvm::makeArrayRef(kConfigurations); // return llvm::ArrayRef(kConfigurations);
// } // }
// The `Wrap` template function is provided in the `Main` function below. // The `Wrap` template function is provided in the `Main` function below.
Context not available.
<< " kConfigurations[] = {\n"; << " kConfigurations[] = {\n";
Stream << C.Descriptors; Stream << C.Descriptors;
Stream << kIndent << "};\n"; Stream << kIndent << "};\n";
Stream << kIndent << "return llvm::makeArrayRef(kConfigurations);\n"; Stream << kIndent << "return llvm::ArrayRef(kConfigurations);\n";
} }
Stream << "}\n"; Stream << "}\n";
return Stream; return Stream;
Context not available.

libc/benchmarks/automemcpy/unittests/CodeGenTest.cpp

Context not available.
{"memset_0x3DF0F44E2ED6A50F",{FunctionType::MEMSET,Contiguous{{0,2}},Overlap{{2,256}},std::nullopt,AlignedLoop{Loop{{256,kMaxSize},32},32,AlignArg::_1},std::nullopt,ElementTypeClass::NATIVE}}, {"memset_0x3DF0F44E2ED6A50F",{FunctionType::MEMSET,Contiguous{{0,2}},Overlap{{2,256}},std::nullopt,AlignedLoop{Loop{{256,kMaxSize},32},32,AlignArg::_1},std::nullopt,ElementTypeClass::NATIVE}},
{"bzero_0x475977492C218AD4",{FunctionType::BZERO,Contiguous{{0,4}},Overlap{{4,128}},std::nullopt,AlignedLoop{Loop{{128,kMaxSize},32},32,AlignArg::_1},std::nullopt,ElementTypeClass::NATIVE}}, {"bzero_0x475977492C218AD4",{FunctionType::BZERO,Contiguous{{0,4}},Overlap{{4,128}},std::nullopt,AlignedLoop{Loop{{128,kMaxSize},32},32,AlignArg::_1},std::nullopt,ElementTypeClass::NATIVE}},
}; };
return makeArrayRef(kDescriptors); return ArrayRef(kDescriptors);
} }
} // namespace automemcpy } // namespace automemcpy
Context not available.
{Wrap<memcpy_0xE00E29EE73994E2B>, "memcpy_0xE00E29EE73994E2B"}, {Wrap<memcpy_0xE00E29EE73994E2B>, "memcpy_0xE00E29EE73994E2B"},
{Wrap<memcpy_0x7381B60C7BE75EF9>, "memcpy_0x7381B60C7BE75EF9"}, {Wrap<memcpy_0x7381B60C7BE75EF9>, "memcpy_0x7381B60C7BE75EF9"},
}; };
return llvm::makeArrayRef(kConfigurations); return llvm::ArrayRef(kConfigurations);
} }
using MemcmpStub = int (*)(const char *, const char *, size_t); using MemcmpStub = int (*)(const char *, const char *, size_t);
Context not available.
static constexpr MemcmpOrBcmpConfiguration kConfigurations[] = { static constexpr MemcmpOrBcmpConfiguration kConfigurations[] = {
{Wrap<memcmp_0x348D7BA6DB0EE033>, "memcmp_0x348D7BA6DB0EE033"}, {Wrap<memcmp_0x348D7BA6DB0EE033>, "memcmp_0x348D7BA6DB0EE033"},
}; };
return llvm::makeArrayRef(kConfigurations); return llvm::ArrayRef(kConfigurations);
} }
llvm::ArrayRef<MemcmpOrBcmpConfiguration> getBcmpConfigurations() { llvm::ArrayRef<MemcmpOrBcmpConfiguration> getBcmpConfigurations() {
return {}; return {};
Context not available.
{Wrap<memset_0x71E761699B999863>, "memset_0x71E761699B999863"}, {Wrap<memset_0x71E761699B999863>, "memset_0x71E761699B999863"},
{Wrap<memset_0x3DF0F44E2ED6A50F>, "memset_0x3DF0F44E2ED6A50F"}, {Wrap<memset_0x3DF0F44E2ED6A50F>, "memset_0x3DF0F44E2ED6A50F"},
}; };
return llvm::makeArrayRef(kConfigurations); return llvm::ArrayRef(kConfigurations);
} }
using BzeroStub = void (*)(char *, size_t); using BzeroStub = void (*)(char *, size_t);
Context not available.
static constexpr BzeroConfiguration kConfigurations[] = { static constexpr BzeroConfiguration kConfigurations[] = {
{Wrap<bzero_0x475977492C218AD4>, "bzero_0x475977492C218AD4"}, {Wrap<bzero_0x475977492C218AD4>, "bzero_0x475977492C218AD4"},
}; };
return llvm::makeArrayRef(kConfigurations); return llvm::ArrayRef(kConfigurations);
} }
llvm::ArrayRef<MemmoveConfiguration> getMemmoveConfigurations() { llvm::ArrayRef<MemmoveConfiguration> getMemmoveConfigurations() {
Context not available.

lld/COFF/Chunks.h

Context not available.
} }
ArrayRef<coff_relocation> getRelocs() const { ArrayRef<coff_relocation> getRelocs() const {
return llvm::makeArrayRef(relocsData, relocsSize); return llvm::ArrayRef(relocsData, relocsSize);
} }
// Reloc setter used by ARM range extension thunk insertion. // Reloc setter used by ARM range extension thunk insertion.
Context not available.

lld/COFF/DebugTypes.cpp

Context not available.
return; return;
GloballyHashedType *hashes = new GloballyHashedType[hashVec.size()]; GloballyHashedType *hashes = new GloballyHashedType[hashVec.size()];
memcpy(hashes, hashVec.data(), hashVec.size() * sizeof(GloballyHashedType)); memcpy(hashes, hashVec.data(), hashVec.size() * sizeof(GloballyHashedType));
ghashes = makeArrayRef(hashes, hashVec.size()); ghashes = ArrayRef(hashes, hashVec.size());
ownedGHashes = true; ownedGHashes = true;
} }
Context not available.
// - source 0, type 1... // - source 0, type 1...
// - source 1, type 0... // - source 1, type 0...
std::vector<GHashCell> entries; std::vector<GHashCell> entries;
for (const GHashCell &cell : for (const GHashCell &cell : ArrayRef(ghashState.table.table, tableSize)) {
makeArrayRef(ghashState.table.table, tableSize)) {
if (!cell.isEmpty()) if (!cell.isEmpty())
entries.push_back(cell); entries.push_back(cell);
} }
Context not available.
ctx.tpiSourceList.insert(ctx.tpiSourceList.end(), objs.begin(), objs.end()); ctx.tpiSourceList.insert(ctx.tpiSourceList.end(), objs.begin(), objs.end());
for (uint32_t i = 0, e = ctx.tpiSourceList.size(); i < e; ++i) for (uint32_t i = 0, e = ctx.tpiSourceList.size(); i < e; ++i)
ctx.tpiSourceList[i]->tpiSrcIdx = i; ctx.tpiSourceList[i]->tpiSrcIdx = i;
dependencySources = makeArrayRef(ctx.tpiSourceList.data(), numDeps); dependencySources = ArrayRef(ctx.tpiSourceList.data(), numDeps);
objectSources = makeArrayRef(ctx.tpiSourceList.data() + numDeps, numObjs); objectSources = ArrayRef(ctx.tpiSourceList.data() + numDeps, numObjs);
} }
/// Given the index into the ghash table for a particular type, return the type /// Given the index into the ghash table for a particular type, return the type
Context not available.

lld/COFF/DriverUtils.cpp

Context not available.
if (!args.hasArg(OPT_lldignoreenv)) if (!args.hasArg(OPT_lldignoreenv))
addLINK(expandedArgv); addLINK(expandedArgv);
cl::ExpandResponseFiles(saver(), getQuotingStyle(args), expandedArgv); cl::ExpandResponseFiles(saver(), getQuotingStyle(args), expandedArgv);
args = optTable.ParseArgs(makeArrayRef(expandedArgv).drop_front(), args = optTable.ParseArgs(ArrayRef(expandedArgv).drop_front(), missingIndex,
missingIndex, missingCount); missingCount);
// Print the real command line if response files are expanded. // Print the real command line if response files are expanded.
if (args.hasArg(OPT_verbose) && argv.size() != expandedArgv.size()) { if (args.hasArg(OPT_verbose) && argv.size() != expandedArgv.size()) {
Context not available.

lld/COFF/PDB.cpp

Context not available.
static void addGlobalSymbol(pdb::GSIStreamBuilder &builder, uint16_t modIndex, static void addGlobalSymbol(pdb::GSIStreamBuilder &builder, uint16_t modIndex,
unsigned symOffset, unsigned symOffset,
std::vector<uint8_t> &symStorage) { std::vector<uint8_t> &symStorage) {
CVSymbol sym(makeArrayRef(symStorage)); CVSymbol sym{ArrayRef(symStorage)};
switch (sym.kind()) { switch (sym.kind()) {
case SymbolKind::S_CONSTANT: case SymbolKind::S_CONSTANT:
case SymbolKind::S_UDT: case SymbolKind::S_UDT:
Context not available.
// to stabilize it. // to stabilize it.
uint8_t *mem = bAlloc().Allocate<uint8_t>(sym.length()); uint8_t *mem = bAlloc().Allocate<uint8_t>(sym.length());
memcpy(mem, sym.data().data(), sym.length()); memcpy(mem, sym.data().data(), sym.length());
builder.addGlobalSymbol(CVSymbol(makeArrayRef(mem, sym.length()))); builder.addGlobalSymbol(CVSymbol(ArrayRef(mem, sym.length())));
break; break;
} }
case SymbolKind::S_GPROC32: case SymbolKind::S_GPROC32:
Context not available.
assert(debugChunk.getOutputSectionIdx() == 0 && assert(debugChunk.getOutputSectionIdx() == 0 &&
"debug sections should not be in output sections"); "debug sections should not be in output sections");
debugChunk.writeTo(buffer); debugChunk.writeTo(buffer);
return makeArrayRef(buffer, debugChunk.getSize()); return ArrayRef(buffer, debugChunk.getSize());
} }
void PDBLinker::addDebugSymbols(TpiSource *source) { void PDBLinker::addDebugSymbols(TpiSource *source) {
Context not available.
ons.Name = "* Linker *"; ons.Name = "* Linker *";
ons.Signature = 0; ons.Signature = 0;
ArrayRef<StringRef> args = makeArrayRef(config->argv).drop_front(); ArrayRef<StringRef> args = ArrayRef(config->argv).drop_front();
std::string argStr = quote(args); std::string argStr = quote(args);
ebs.Fields.push_back("cwd"); ebs.Fields.push_back("cwd");
SmallString<64> cwd; SmallString<64> cwd;
Context not available.

lld/ELF/Arch/AMDGPU.cpp

Context not available.
uint32_t ret = getEFlags(ctx.objectFiles[0]); uint32_t ret = getEFlags(ctx.objectFiles[0]);
// Verify that all input files have the same e_flags. // Verify that all input files have the same e_flags.
for (InputFile *f : makeArrayRef(ctx.objectFiles).slice(1)) { for (InputFile *f : ArrayRef(ctx.objectFiles).slice(1)) {
if (ret == getEFlags(f)) if (ret == getEFlags(f))
continue; continue;
error("incompatible e_flags: " + toString(f)); error("incompatible e_flags: " + toString(f));
Context not available.
// Verify that all input files have compatible e_flags (same mach, all // Verify that all input files have compatible e_flags (same mach, all
// features in the same category are either ANY, ANY and ON, or ANY and OFF). // features in the same category are either ANY, ANY and ON, or ANY and OFF).
for (InputFile *f : makeArrayRef(ctx.objectFiles).slice(1)) { for (InputFile *f : ArrayRef(ctx.objectFiles).slice(1)) {
if (retMach != (getEFlags(f) & EF_AMDGPU_MACH)) { if (retMach != (getEFlags(f) & EF_AMDGPU_MACH)) {
error("incompatible mach: " + toString(f)); error("incompatible mach: " + toString(f));
return 0; return 0;
Context not available.

lld/ELF/Arch/AVR.cpp

Context not available.
uint32_t flags = getEFlags(ctx.objectFiles[0]); uint32_t flags = getEFlags(ctx.objectFiles[0]);
bool hasLinkRelaxFlag = flags & EF_AVR_LINKRELAX_PREPARED; bool hasLinkRelaxFlag = flags & EF_AVR_LINKRELAX_PREPARED;
for (InputFile *f : makeArrayRef(ctx.objectFiles).slice(1)) { for (InputFile *f : ArrayRef(ctx.objectFiles).slice(1)) {
uint32_t objFlags = getEFlags(f); uint32_t objFlags = getEFlags(f);
if ((objFlags & EF_AVR_ARCH_MASK) != (flags & EF_AVR_ARCH_MASK)) if ((objFlags & EF_AVR_ARCH_MASK) != (flags & EF_AVR_ARCH_MASK))
error(toString(f) + error(toString(f) +
Context not available.

lld/ELF/Arch/PPC64.cpp

Context not available.
// instructions and write [first,end). // instructions and write [first,end).
auto *sec = make<InputSection>( auto *sec = make<InputSection>(
nullptr, SHF_ALLOC, SHT_PROGBITS, 4, nullptr, SHF_ALLOC, SHT_PROGBITS, 4,
makeArrayRef(reinterpret_cast<uint8_t *>(buf.data() + first), ArrayRef(reinterpret_cast<uint8_t *>(buf.data() + first),
4 * (buf.size() - first)), 4 * (buf.size() - first)),
".text"); ".text");
ctx.inputSections.push_back(sec); ctx.inputSections.push_back(sec);
for (Defined *sym : defined) { for (Defined *sym : defined) {
Context not available.

lld/ELF/Arch/RISCV.cpp

Context not available.
// Get st_value delta for symbols relative to this section from the previous // Get st_value delta for symbols relative to this section from the previous
// iteration. // iteration.
DenseMap<const Defined *, uint64_t> valueDelta; DenseMap<const Defined *, uint64_t> valueDelta;
ArrayRef<SymbolAnchor> sa = makeArrayRef(aux.anchors); ArrayRef<SymbolAnchor> sa = ArrayRef(aux.anchors);
uint32_t delta = 0; uint32_t delta = 0;
for (auto [i, r] : llvm::enumerate(sec.relocs())) { for (auto [i, r] : llvm::enumerate(sec.relocs())) {
for (; sa.size() && sa[0].offset <= r.offset; sa = sa.slice(1)) for (; sa.size() && sa[0].offset <= r.offset; sa = sa.slice(1))
Context not available.
for (const SymbolAnchor &sa : sa) for (const SymbolAnchor &sa : sa)
if (!sa.end) if (!sa.end)
valueDelta[sa.d] = delta; valueDelta[sa.d] = delta;
sa = makeArrayRef(aux.anchors); sa = ArrayRef(aux.anchors);
delta = 0; delta = 0;
std::fill_n(aux.relocTypes.get(), sec.relocs().size(), R_RISCV_NONE); std::fill_n(aux.relocTypes.get(), sec.relocs().size(), R_RISCV_NONE);
Context not available.

lld/ELF/Config.h

Context not available.
// The first two elements of versionDefinitions represent VER_NDX_LOCAL and // The first two elements of versionDefinitions represent VER_NDX_LOCAL and
// VER_NDX_GLOBAL. This helper returns other elements. // VER_NDX_GLOBAL. This helper returns other elements.
static inline ArrayRef<VersionDefinition> namedVersionDefs() { static inline ArrayRef<VersionDefinition> namedVersionDefs() {
return llvm::makeArrayRef(config->versionDefinitions).slice(2); return llvm::ArrayRef(config->versionDefinitions).slice(2);
} }
void errorOrWarn(const Twine &msg); void errorOrWarn(const Twine &msg);
Context not available.

lld/ELF/Driver.cpp

Context not available.
// compileBitcodeFiles may have produced lto.tmp object files. After this, no // compileBitcodeFiles may have produced lto.tmp object files. After this, no
// more file will be added. // more file will be added.
auto newObjectFiles = makeArrayRef(ctx.objectFiles).slice(numObjsBeforeLTO); auto newObjectFiles = ArrayRef(ctx.objectFiles).slice(numObjsBeforeLTO);
parallelForEach(newObjectFiles, [](ELFFileBase *file) { parallelForEach(newObjectFiles, [](ELFFileBase *file) {
initSectionsAndLocalSyms(file, /*ignoreComdats=*/true); initSectionsAndLocalSyms(file, /*ignoreComdats=*/true);
}); });
Context not available.

lld/ELF/InputFiles.h

Context not available.
ArrayRef<Symbol *> getLocalSymbols() { ArrayRef<Symbol *> getLocalSymbols() {
if (numSymbols == 0) if (numSymbols == 0)
return {}; return {};
return llvm::makeArrayRef(symbols.get() + 1, firstGlobal - 1); return llvm::ArrayRef(symbols.get() + 1, firstGlobal - 1);
} }
ArrayRef<Symbol *> getGlobalSymbols() { ArrayRef<Symbol *> getGlobalSymbols() {
return llvm::makeArrayRef(symbols.get() + firstGlobal, return llvm::ArrayRef(symbols.get() + firstGlobal,
numSymbols - firstGlobal); numSymbols - firstGlobal);
} }
MutableArrayRef<Symbol *> getMutableGlobalSymbols() { MutableArrayRef<Symbol *> getMutableGlobalSymbols() {
return llvm::makeMutableArrayRef(symbols.get() + firstGlobal, return llvm::makeMutableArrayRef(symbols.get() + firstGlobal,
Context not available.

lld/ELF/InputSection.h

Context not available.
template <typename T> llvm::ArrayRef<T> getDataAs() const { template <typename T> llvm::ArrayRef<T> getDataAs() const {
size_t s = content().size(); size_t s = content().size();
assert(s % sizeof(T) == 0); assert(s % sizeof(T) == 0);
return llvm::makeArrayRef<T>((const T *)content().data(), s / sizeof(T)); return llvm::ArrayRef<T>((const T *)content().data(), s / sizeof(T));
} }
protected: protected:
Context not available.

lld/ELF/InputSection.cpp

Context not available.
static ArrayRef<uint8_t> getSectionContents(ObjFile<ELFT> &file, static ArrayRef<uint8_t> getSectionContents(ObjFile<ELFT> &file,
const typename ELFT::Shdr &hdr) { const typename ELFT::Shdr &hdr) {
if (hdr.sh_type == SHT_NOBITS) if (hdr.sh_type == SHT_NOBITS)
return makeArrayRef<uint8_t>(nullptr, hdr.sh_size); return ArrayRef<uint8_t>(nullptr, hdr.sh_size);
return check(file.getObj().getSectionContents(hdr)); return check(file.getObj().getSectionContents(hdr));
} }
Context not available.
typename ELFT::Shdr shdr = typename ELFT::Shdr shdr =
cast<ELFFileBase>(file)->getELFShdrs<ELFT>()[relSecIdx]; cast<ELFFileBase>(file)->getELFShdrs<ELFT>()[relSecIdx];
if (shdr.sh_type == SHT_REL) { if (shdr.sh_type == SHT_REL) {
ret.rels = makeArrayRef(reinterpret_cast<const typename ELFT::Rel *>( ret.rels = ArrayRef(reinterpret_cast<const typename ELFT::Rel *>(
file->mb.getBufferStart() + shdr.sh_offset), file->mb.getBufferStart() + shdr.sh_offset),
shdr.sh_size / sizeof(typename ELFT::Rel)); shdr.sh_size / sizeof(typename ELFT::Rel));
} else { } else {
assert(shdr.sh_type == SHT_RELA); assert(shdr.sh_type == SHT_RELA);
ret.relas = makeArrayRef(reinterpret_cast<const typename ELFT::Rela *>( ret.relas = ArrayRef(reinterpret_cast<const typename ELFT::Rela *>(
file->mb.getBufferStart() + shdr.sh_offset), file->mb.getBufferStart() + shdr.sh_offset),
shdr.sh_size / sizeof(typename ELFT::Rela)); shdr.sh_size / sizeof(typename ELFT::Rela));
} }
return ret; return ret;
} }
Context not available.

lld/ELF/OutputSections.cpp

Context not available.
// Split input into 1-MiB shards. // Split input into 1-MiB shards.
constexpr size_t shardSize = 1 << 20; constexpr size_t shardSize = 1 << 20;
auto shardsIn = split(makeArrayRef<uint8_t>(buf.get(), size), shardSize); auto shardsIn = split(ArrayRef<uint8_t>(buf.get(), size), shardSize);
const size_t numShards = shardsIn.size(); const size_t numShards = shardsIn.size();
// Compress shards and compute Alder-32 checksums. Use Z_SYNC_FLUSH for all // Compress shards and compute Alder-32 checksums. Use Z_SYNC_FLUSH for all
Context not available.
storage.insert(storage.end(), isd->sections.begin(), isd->sections.end()); storage.insert(storage.end(), isd->sections.begin(), isd->sections.end());
} }
} }
return storage.empty() ? ret : makeArrayRef(storage); return storage.empty() ? ret : ArrayRef(storage);
} }
// Sorts input sections by section name suffixes, so that .foo.N comes // Sorts input sections by section name suffixes, so that .foo.N comes
Context not available.

lld/ELF/SyntheticSections.cpp

Context not available.
}); });
size_t numSymbols = 0; size_t numSymbols = 0;
for (ArrayRef<GdbSymbol> v : makeArrayRef(symbols.get(), numShards)) for (ArrayRef<GdbSymbol> v : ArrayRef(symbols.get(), numShards))
numSymbols += v.size(); numSymbols += v.size();
// The return type is a flattened vector, so we'll copy each vector // The return type is a flattened vector, so we'll copy each vector
Context not available.
if (config->emachine == EM_AMDGPU && !ctx.objectFiles.empty()) { if (config->emachine == EM_AMDGPU && !ctx.objectFiles.empty()) {
uint8_t ver = ctx.objectFiles[0]->abiVersion; uint8_t ver = ctx.objectFiles[0]->abiVersion;
for (InputFile *file : makeArrayRef(ctx.objectFiles).slice(1)) for (InputFile *file : ArrayRef(ctx.objectFiles).slice(1))
if (file->abiVersion != ver) if (file->abiVersion != ver)
error("incompatible ABI version: " + toString(file)); error("incompatible ABI version: " + toString(file));
return ver; return ver;
Context not available.

lld/ELF/Writer.cpp

Context not available.
} }
isd->sections.clear(); isd->sections.clear();
for (InputSection *isec : makeArrayRef(unorderedSections).slice(0, insPt)) for (InputSection *isec : ArrayRef(unorderedSections).slice(0, insPt))
isd->sections.push_back(isec); isd->sections.push_back(isec);
for (std::pair<InputSection *, int> p : orderedSections) for (std::pair<InputSection *, int> p : orderedSections)
isd->sections.push_back(p.first); isd->sections.push_back(p.first);
for (InputSection *isec : makeArrayRef(unorderedSections).slice(insPt)) for (InputSection *isec : ArrayRef(unorderedSections).slice(insPt))
isd->sections.push_back(isec); isd->sections.push_back(isec);
} }
Context not available.
}); });
// Write to the final output buffer. // Write to the final output buffer.
hashFn(hashBuf.data(), makeArrayRef(hashes.get(), hashesSize)); hashFn(hashBuf.data(), ArrayRef(hashes.get(), hashesSize));
} }
template <class ELFT> void Writer<ELFT>::writeBuildId() { template <class ELFT> void Writer<ELFT>::writeBuildId() {
Context not available.

lldb/include/lldb/Utility/AnsiTerminal.h

Context not available.
#undef _TO_STR2 #undef _TO_STR2
}; };
// clang-format on // clang-format on
auto codes = llvm::makeArrayRef(g_color_tokens); auto codes = llvm::ArrayRef(g_color_tokens);
static const char tok_hdr[] = "${ansi."; static const char tok_hdr[] = "${ansi.";
Context not available.

lldb/include/lldb/Utility/Args.h

Context not available.
/// have a nullptr const char * at the end, as the size of the list is /// have a nullptr const char * at the end, as the size of the list is
/// embedded in the ArrayRef object. /// embedded in the ArrayRef object.
llvm::ArrayRef<const char *> GetArgumentArrayRef() const { llvm::ArrayRef<const char *> GetArgumentArrayRef() const {
return llvm::makeArrayRef(m_argv).drop_back(); return llvm::ArrayRef(m_argv).drop_back();
} }
/// Appends a new argument to the end of the list argument list. /// Appends a new argument to the end of the list argument list.
Context not available.

lldb/source/API/SBDebugger.cpp

Context not available.
size_t len = 0; size_t len = 0;
while (categories[len] != nullptr) while (categories[len] != nullptr)
++len; ++len;
return llvm::makeArrayRef(categories, len); return llvm::ArrayRef(categories, len);
} }
bool SBDebugger::EnableLog(const char *channel, const char **categories) { bool SBDebugger::EnableLog(const char *channel, const char **categories) {
Context not available.

lldb/source/Breakpoint/BreakpointID.cpp

Context not available.
} }
llvm::ArrayRef<llvm::StringRef> BreakpointID::GetRangeSpecifiers() { llvm::ArrayRef<llvm::StringRef> BreakpointID::GetRangeSpecifiers() {
return llvm::makeArrayRef(g_range_specifiers); return llvm::ArrayRef(g_range_specifiers);
} }
void BreakpointID::GetDescription(Stream *s, lldb::DescriptionLevel level) { void BreakpointID::GetDescription(Stream *s, lldb::DescriptionLevel level) {
Context not available.

lldb/source/Commands/CommandObjectBreakpoint.cpp

Context not available.
~BreakpointOptionGroup() override = default; ~BreakpointOptionGroup() override = default;
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_breakpoint_modify_options); return llvm::ArrayRef(g_breakpoint_modify_options);
} }
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
Context not available.
~BreakpointDummyOptionGroup() override = default; ~BreakpointDummyOptionGroup() override = default;
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_breakpoint_dummy_options); return llvm::ArrayRef(g_breakpoint_dummy_options);
} }
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_breakpoint_set_options); return llvm::ArrayRef(g_breakpoint_set_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_breakpoint_list_options); return llvm::ArrayRef(g_breakpoint_list_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_breakpoint_clear_options); return llvm::ArrayRef(g_breakpoint_clear_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_breakpoint_delete_options); return llvm::ArrayRef(g_breakpoint_delete_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.
~BreakpointNameOptionGroup() override = default; ~BreakpointNameOptionGroup() override = default;
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_breakpoint_name_options); return llvm::ArrayRef(g_breakpoint_name_options);
} }
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
Context not available.
~BreakpointAccessOptionGroup() override = default; ~BreakpointAccessOptionGroup() override = default;
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_breakpoint_access_options); return llvm::ArrayRef(g_breakpoint_access_options);
} }
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
ExecutionContext *execution_context) override { ExecutionContext *execution_context) override {
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_breakpoint_read_options); return llvm::ArrayRef(g_breakpoint_read_options);
} }
void HandleOptionArgumentCompletion( void HandleOptionArgumentCompletion(
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_breakpoint_write_options); return llvm::ArrayRef(g_breakpoint_write_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.

lldb/source/Commands/CommandObjectBreakpointCommand.cpp

Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_breakpoint_command_add_options); return llvm::ArrayRef(g_breakpoint_command_add_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_breakpoint_command_delete_options); return llvm::ArrayRef(g_breakpoint_command_delete_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.

lldb/source/Commands/CommandObjectCommands.cpp

Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_source_options); return llvm::ArrayRef(g_source_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.
~CommandOptions() override = default; ~CommandOptions() override = default;
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_alias_options); return llvm::ArrayRef(g_alias_options);
} }
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value, Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_regex_options); return llvm::ArrayRef(g_regex_options);
} }
llvm::StringRef GetHelp() { return m_help; } llvm::StringRef GetHelp() { return m_help; }
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_script_import_options); return llvm::ArrayRef(g_script_import_options);
} }
bool relative_to_command_file = false; bool relative_to_command_file = false;
bool silent = false; bool silent = false;
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_script_add_options); return llvm::ArrayRef(g_script_add_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_container_add_options); return llvm::ArrayRef(g_container_add_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.

lldb/source/Commands/CommandObjectDiagnostics.cpp

Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_diagnostics_dump_options); return llvm::ArrayRef(g_diagnostics_dump_options);
} }
FileSpec directory; FileSpec directory;
Context not available.

lldb/source/Commands/CommandObjectDisassemble.cpp

Context not available.
llvm::ArrayRef<OptionDefinition> llvm::ArrayRef<OptionDefinition>
CommandObjectDisassemble::CommandOptions::GetDefinitions() { CommandObjectDisassemble::CommandOptions::GetDefinitions() {
return llvm::makeArrayRef(g_disassemble_options); return llvm::ArrayRef(g_disassemble_options);
} }
// CommandObjectDisassemble // CommandObjectDisassemble
Context not available.

lldb/source/Commands/CommandObjectExpression.cpp

Context not available.
llvm::ArrayRef<OptionDefinition> llvm::ArrayRef<OptionDefinition>
CommandObjectExpression::CommandOptions::GetDefinitions() { CommandObjectExpression::CommandOptions::GetDefinitions() {
return llvm::makeArrayRef(g_expression_options); return llvm::ArrayRef(g_expression_options);
} }
CommandObjectExpression::CommandObjectExpression( CommandObjectExpression::CommandObjectExpression(
Context not available.

lldb/source/Commands/CommandObjectFrame.cpp

Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_frame_diag_options); return llvm::ArrayRef(g_frame_diag_options);
} }
// Options. // Options.
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_frame_select_options); return llvm::ArrayRef(g_frame_select_options);
} }
llvm::Optional<int32_t> relative_frame_offset; llvm::Optional<int32_t> relative_frame_offset;
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_frame_recognizer_add_options); return llvm::ArrayRef(g_frame_recognizer_add_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.

lldb/source/Commands/CommandObjectHelp.cpp

Context not available.
llvm::ArrayRef<OptionDefinition> llvm::ArrayRef<OptionDefinition>
CommandObjectHelp::CommandOptions::GetDefinitions() { CommandObjectHelp::CommandOptions::GetDefinitions() {
return llvm::makeArrayRef(g_help_options); return llvm::ArrayRef(g_help_options);
} }
bool CommandObjectHelp::DoExecute(Args &command, CommandReturnObject &result) { bool CommandObjectHelp::DoExecute(Args &command, CommandReturnObject &result) {
Context not available.

lldb/source/Commands/CommandObjectLog.cpp

Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_log_enable_options); return llvm::ArrayRef(g_log_enable_options);
} }
FileSpec log_file; FileSpec log_file;
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_log_dump_options); return llvm::ArrayRef(g_log_dump_options);
} }
FileSpec log_file; FileSpec log_file;
Context not available.

lldb/source/Commands/CommandObjectMemory.cpp

Context not available.
~OptionGroupReadMemory() override = default; ~OptionGroupReadMemory() override = default;
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_memory_read_options); return llvm::ArrayRef(g_memory_read_options);
} }
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value, Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
Context not available.
~OptionGroupFindMemory() override = default; ~OptionGroupFindMemory() override = default;
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_memory_find_options); return llvm::ArrayRef(g_memory_find_options);
} }
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value, Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
Context not available.
~OptionGroupWriteMemory() override = default; ~OptionGroupWriteMemory() override = default;
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_memory_write_options); return llvm::ArrayRef(g_memory_write_options);
} }
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value, Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
Context not available.
~OptionGroupMemoryRegion() override = default; ~OptionGroupMemoryRegion() override = default;
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_memory_region_options); return llvm::ArrayRef(g_memory_region_options);
} }
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value, Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
Context not available.

lldb/source/Commands/CommandObjectMemoryTag.cpp

Context not available.
~OptionGroupTagWrite() override = default; ~OptionGroupTagWrite() override = default;
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_memory_tag_write_options); return llvm::ArrayRef(g_memory_tag_write_options);
} }
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value, Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
Context not available.

lldb/source/Commands/CommandObjectPlatform.cpp

Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_permissions_options); return llvm::ArrayRef(g_permissions_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_platform_fread_options); return llvm::ArrayRef(g_platform_fread_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_platform_fwrite_options); return llvm::ArrayRef(g_platform_fwrite_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_platform_process_list_options); return llvm::ArrayRef(g_platform_process_list_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_platform_process_attach_options); return llvm::ArrayRef(g_platform_process_attach_options);
} }
// Options table: Required for subclasses of Options. // Options table: Required for subclasses of Options.
Context not available.
~CommandOptions() override = default; ~CommandOptions() override = default;
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_platform_shell_options); return llvm::ArrayRef(g_platform_shell_options);
} }
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
Context not available.

lldb/source/Commands/CommandObjectProcess.cpp

Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_process_attach_options); return llvm::ArrayRef(g_process_attach_options);
} }
ProcessAttachInfo attach_info; ProcessAttachInfo attach_info;
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_process_continue_options); return llvm::ArrayRef(g_process_continue_options);
} }
uint32_t m_ignore = 0; uint32_t m_ignore = 0;
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_process_detach_options); return llvm::ArrayRef(g_process_detach_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_process_connect_options); return llvm::ArrayRef(g_process_connect_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_process_load_options); return llvm::ArrayRef(g_process_load_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.
~CommandOptions() override = default; ~CommandOptions() override = default;
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_process_save_core_options); return llvm::ArrayRef(g_process_save_core_options);
} }
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_process_status_options); return llvm::ArrayRef(g_process_status_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_process_handle_options); return llvm::ArrayRef(g_process_handle_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.

lldb/source/Commands/CommandObjectRegister.cpp

Context not available.
~CommandOptions() override = default; ~CommandOptions() override = default;
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_register_read_options); return llvm::ArrayRef(g_register_read_options);
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
Context not available.

lldb/source/Commands/CommandObjectScript.cpp

Context not available.
llvm::ArrayRef<OptionDefinition> llvm::ArrayRef<OptionDefinition>
CommandObjectScript::CommandOptions::GetDefinitions() { CommandObjectScript::CommandOptions::GetDefinitions() {
return llvm::makeArrayRef(g_script_options); return llvm::ArrayRef(g_script_options);
} }
CommandObjectScript::CommandObjectScript(CommandInterpreter &interpreter) CommandObjectScript::CommandObjectScript(CommandInterpreter &interpreter)
Context not available.

lldb/source/Commands/CommandObjectSession.cpp

Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_history_options); return llvm::ArrayRef(g_history_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.

lldb/source/Commands/CommandObjectSettings.cpp

Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_settings_set_options); return llvm::ArrayRef(g_settings_set_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_settings_write_options); return llvm::ArrayRef(g_settings_write_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_settings_read_options); return llvm::ArrayRef(g_settings_read_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_settings_clear_options); return llvm::ArrayRef(g_settings_clear_options);
} }
bool m_clear_all = false; bool m_clear_all = false;
Context not available.

lldb/source/Commands/CommandObjectSource.cpp

Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_source_info_options); return llvm::ArrayRef(g_source_info_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_source_list_options); return llvm::ArrayRef(g_source_list_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.

lldb/source/Commands/CommandObjectStats.cpp

Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_statistics_dump_options); return llvm::ArrayRef(g_statistics_dump_options);
} }
bool m_all_targets = false; bool m_all_targets = false;
Context not available.

lldb/source/Commands/CommandObjectTarget.cpp

Context not available.
~OptionGroupDependents() override = default; ~OptionGroupDependents() override = default;
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_target_dependents_options); return llvm::ArrayRef(g_target_dependents_options);
} }
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value, Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_target_modules_dump_symtab_options); return llvm::ArrayRef(g_target_modules_dump_symtab_options);
} }
SortOrder m_sort_order = eSortOrderNone; SortOrder m_sort_order = eSortOrderNone;
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_target_modules_dump_options); return llvm::ArrayRef(g_target_modules_dump_options);
} }
bool m_verbose; bool m_verbose;
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_target_modules_list_options); return llvm::ArrayRef(g_target_modules_list_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_target_modules_show_unwind_options); return llvm::ArrayRef(g_target_modules_show_unwind_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_target_modules_lookup_options); return llvm::ArrayRef(g_target_modules_lookup_options);
} }
int m_type; // Should be a eLookupTypeXXX enum after parsing options int m_type; // Should be a eLookupTypeXXX enum after parsing options
Context not available.
~CommandOptions() override = default; ~CommandOptions() override = default;
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_target_stop_hook_add_options); return llvm::ArrayRef(g_target_stop_hook_add_options);
} }
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
Context not available.

lldb/source/Commands/CommandObjectThread.cpp

Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_thread_backtrace_options); return llvm::ArrayRef(g_thread_backtrace_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.
~ThreadStepScopeOptionGroup() override = default; ~ThreadStepScopeOptionGroup() override = default;
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_thread_step_scope_options); return llvm::ArrayRef(g_thread_step_scope_options);
} }
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_thread_until_options); return llvm::ArrayRef(g_thread_until_options);
} }
uint32_t m_step_thread_idx = LLDB_INVALID_THREAD_ID; uint32_t m_step_thread_idx = LLDB_INVALID_THREAD_ID;
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_thread_info_options); return llvm::ArrayRef(g_thread_info_options);
} }
bool m_json_thread; bool m_json_thread;
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_thread_return_options); return llvm::ArrayRef(g_thread_return_options);
} }
bool m_from_expression = false; bool m_from_expression = false;
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_thread_jump_options); return llvm::ArrayRef(g_thread_jump_options);
} }
FileSpecList m_filenames; FileSpecList m_filenames;
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_thread_plan_list_options); return llvm::ArrayRef(g_thread_plan_list_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_thread_trace_dump_function_calls_options); return llvm::ArrayRef(g_thread_trace_dump_function_calls_options);
} }
static const size_t kDefaultCount = 20; static const size_t kDefaultCount = 20;
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_thread_trace_dump_instructions_options); return llvm::ArrayRef(g_thread_trace_dump_instructions_options);
} }
static const size_t kDefaultCount = 20; static const size_t kDefaultCount = 20;
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_thread_trace_dump_info_options); return llvm::ArrayRef(g_thread_trace_dump_info_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.

lldb/source/Commands/CommandObjectTrace.cpp

Context not available.
}; };
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_trace_save_options); return llvm::ArrayRef(g_trace_save_options);
}; };
bool m_compact; bool m_compact;
Context not available.
} }
ArrayRef<OptionDefinition> GetDefinitions() override { ArrayRef<OptionDefinition> GetDefinitions() override {
return makeArrayRef(g_trace_load_options); return ArrayRef(g_trace_load_options);
} }
bool m_verbose; // Enable verbose logging for debugging purposes. bool m_verbose; // Enable verbose logging for debugging purposes.
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_trace_dump_options); return llvm::ArrayRef(g_trace_dump_options);
} }
bool m_verbose; // Enable verbose logging for debugging purposes. bool m_verbose; // Enable verbose logging for debugging purposes.
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_trace_schema_options); return llvm::ArrayRef(g_trace_schema_options);
} }
bool m_verbose; // Enable verbose logging for debugging purposes. bool m_verbose; // Enable verbose logging for debugging purposes.
Context not available.

lldb/source/Commands/CommandObjectType.cpp

Context not available.
void OptionParsingStarting(ExecutionContext *execution_context) override; void OptionParsingStarting(ExecutionContext *execution_context) override;
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_type_summary_add_options); return llvm::ArrayRef(g_type_summary_add_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_type_synth_add_options); return llvm::ArrayRef(g_type_synth_add_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.
~CommandOptions() override = default; ~CommandOptions() override = default;
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_type_format_add_options); return llvm::ArrayRef(g_type_format_add_options);
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_type_formatter_delete_options); return llvm::ArrayRef(g_type_formatter_delete_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_type_formatter_clear_options); return llvm::ArrayRef(g_type_formatter_clear_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_type_formatter_list_options); return llvm::ArrayRef(g_type_formatter_list_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_type_category_define_options); return llvm::ArrayRef(g_type_category_define_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_type_category_enable_options); return llvm::ArrayRef(g_type_category_enable_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_type_category_disable_options); return llvm::ArrayRef(g_type_category_disable_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_type_filter_add_options); return llvm::ArrayRef(g_type_filter_add_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.
~CommandOptions() override = default; ~CommandOptions() override = default;
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_type_lookup_options); return llvm::ArrayRef(g_type_lookup_options);
} }
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value, Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
Context not available.

lldb/source/Commands/CommandObjectWatchpoint.cpp

Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_watchpoint_list_options); return llvm::ArrayRef(g_watchpoint_list_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_watchpoint_delete_options); return llvm::ArrayRef(g_watchpoint_delete_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_watchpoint_ignore_options); return llvm::ArrayRef(g_watchpoint_ignore_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_watchpoint_modify_options); return llvm::ArrayRef(g_watchpoint_modify_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.

lldb/source/Commands/CommandObjectWatchpointCommand.cpp

Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_watchpoint_command_add_options); return llvm::ArrayRef(g_watchpoint_command_add_options);
} }
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
Context not available.

lldb/source/Commands/CommandOptionsProcessLaunch.cpp

Context not available.
} }
llvm::ArrayRef<OptionDefinition> CommandOptionsProcessLaunch::GetDefinitions() { llvm::ArrayRef<OptionDefinition> CommandOptionsProcessLaunch::GetDefinitions() {
return llvm::makeArrayRef(g_process_launch_options); return llvm::ArrayRef(g_process_launch_options);
} }
Context not available.

lldb/source/Host/common/NativeProcessProtocol.cpp

Context not available.
} }
const auto &saved = it->second.saved_opcodes; const auto &saved = it->second.saved_opcodes;
// Make sure the breakpoint opcode exists at this address // Make sure the breakpoint opcode exists at this address
if (makeArrayRef(curr_break_op) != it->second.breakpoint_opcodes) { if (llvm::ArrayRef(curr_break_op) != it->second.breakpoint_opcodes) {
if (curr_break_op != it->second.saved_opcodes) if (curr_break_op != it->second.saved_opcodes)
return Status("Original breakpoint trap is no longer in memory."); return Status("Original breakpoint trap is no longer in memory.");
LLDB_LOG(log, LLDB_LOG(log,
Context not available.
verify_bp_opcode_bytes.size(), verify_bytes_read); verify_bp_opcode_bytes.size(), verify_bytes_read);
} }
if (llvm::makeArrayRef(verify_bp_opcode_bytes.data(), verify_bytes_read) != if (llvm::ArrayRef(verify_bp_opcode_bytes.data(), verify_bytes_read) !=
*expected_trap) { *expected_trap) {
return llvm::createStringError( return llvm::createStringError(
llvm::inconvertibleErrorCode(), llvm::inconvertibleErrorCode(),
Context not available.
switch (GetArchitecture().GetMachine()) { switch (GetArchitecture().GetMachine()) {
case llvm::Triple::aarch64: case llvm::Triple::aarch64:
case llvm::Triple::aarch64_32: case llvm::Triple::aarch64_32:
return llvm::makeArrayRef(g_aarch64_opcode); return llvm::ArrayRef(g_aarch64_opcode);
case llvm::Triple::x86: case llvm::Triple::x86:
case llvm::Triple::x86_64: case llvm::Triple::x86_64:
return llvm::makeArrayRef(g_i386_opcode); return llvm::ArrayRef(g_i386_opcode);
case llvm::Triple::mips: case llvm::Triple::mips:
case llvm::Triple::mips64: case llvm::Triple::mips64:
return llvm::makeArrayRef(g_mips64_opcode); return llvm::ArrayRef(g_mips64_opcode);
case llvm::Triple::mipsel: case llvm::Triple::mipsel:
case llvm::Triple::mips64el: case llvm::Triple::mips64el:
return llvm::makeArrayRef(g_mips64el_opcode); return llvm::ArrayRef(g_mips64el_opcode);
case llvm::Triple::systemz: case llvm::Triple::systemz:
return llvm::makeArrayRef(g_s390x_opcode); return llvm::ArrayRef(g_s390x_opcode);
case llvm::Triple::ppc: case llvm::Triple::ppc:
case llvm::Triple::ppc64: case llvm::Triple::ppc64:
return llvm::makeArrayRef(g_ppc_opcode); return llvm::ArrayRef(g_ppc_opcode);
case llvm::Triple::ppc64le: case llvm::Triple::ppc64le:
return llvm::makeArrayRef(g_ppcle_opcode); return llvm::ArrayRef(g_ppcle_opcode);
case llvm::Triple::riscv32: case llvm::Triple::riscv32:
case llvm::Triple::riscv64: { case llvm::Triple::riscv64: {
return size_hint == 2 ? llvm::makeArrayRef(g_riscv_opcode_c) return size_hint == 2 ? llvm::ArrayRef(g_riscv_opcode_c)
: llvm::makeArrayRef(g_riscv_opcode); : llvm::ArrayRef(g_riscv_opcode);
} }
case llvm::Triple::loongarch32: case llvm::Triple::loongarch32:
case llvm::Triple::loongarch64: case llvm::Triple::loongarch64:
return llvm::makeArrayRef(g_loongarch_opcode); return llvm::ArrayRef(g_loongarch_opcode);
default: default:
return llvm::createStringError(llvm::inconvertibleErrorCode(), return llvm::createStringError(llvm::inconvertibleErrorCode(),
Context not available.
llvm::makeMutableArrayRef(static_cast<uint8_t *>(buf), bytes_read); llvm::makeMutableArrayRef(static_cast<uint8_t *>(buf), bytes_read);
for (const auto &pair : m_software_breakpoints) { for (const auto &pair : m_software_breakpoints) {
lldb::addr_t bp_addr = pair.first; lldb::addr_t bp_addr = pair.first;
auto saved_opcodes = makeArrayRef(pair.second.saved_opcodes); auto saved_opcodes = llvm::ArrayRef(pair.second.saved_opcodes);
if (bp_addr + saved_opcodes.size() < addr || addr + bytes_read <= bp_addr) if (bp_addr + saved_opcodes.size() < addr || addr + bytes_read <= bp_addr)
continue; // Breakpoint not in range, ignore continue; // Breakpoint not in range, ignore
Context not available.

lldb/source/Interpreter/OptionGroupArchitecture.cpp

Context not available.
}; };
llvm::ArrayRef<OptionDefinition> OptionGroupArchitecture::GetDefinitions() { llvm::ArrayRef<OptionDefinition> OptionGroupArchitecture::GetDefinitions() {
return llvm::makeArrayRef(g_option_table); return llvm::ArrayRef(g_option_table);
} }
bool OptionGroupArchitecture::GetArchitecture(Platform *platform, bool OptionGroupArchitecture::GetArchitecture(Platform *platform,
Context not available.

lldb/source/Interpreter/OptionGroupFormat.cpp

Context not available.
} }
llvm::ArrayRef<OptionDefinition> OptionGroupFormat::GetDefinitions() { llvm::ArrayRef<OptionDefinition> OptionGroupFormat::GetDefinitions() {
auto result = llvm::makeArrayRef(m_option_definitions); auto result = llvm::ArrayRef(m_option_definitions);
if (m_byte_size.GetDefaultValue() < UINT64_MAX) { if (m_byte_size.GetDefaultValue() < UINT64_MAX) {
if (m_count.GetDefaultValue() < UINT64_MAX) if (m_count.GetDefaultValue() < UINT64_MAX)
return result; return result;
Context not available.

lldb/source/Interpreter/OptionGroupMemoryTag.cpp

Context not available.
: "Include memory tags in output."} {} : "Include memory tags in output."} {}
llvm::ArrayRef<OptionDefinition> OptionGroupMemoryTag::GetDefinitions() { llvm::ArrayRef<OptionDefinition> OptionGroupMemoryTag::GetDefinitions() {
return llvm::makeArrayRef(m_option_definition); return llvm::ArrayRef(m_option_definition);
} }
Status Status
Context not available.

lldb/source/Interpreter/OptionGroupOutputFile.cpp

Context not available.
}; };
llvm::ArrayRef<OptionDefinition> OptionGroupOutputFile::GetDefinitions() { llvm::ArrayRef<OptionDefinition> OptionGroupOutputFile::GetDefinitions() {
return llvm::makeArrayRef(g_option_table); return llvm::ArrayRef(g_option_table);
} }
Status Status
Context not available.

lldb/source/Interpreter/OptionGroupUUID.cpp

Context not available.
}; };
llvm::ArrayRef<OptionDefinition> OptionGroupUUID::GetDefinitions() { llvm::ArrayRef<OptionDefinition> OptionGroupUUID::GetDefinitions() {
return llvm::makeArrayRef(g_option_table); return llvm::ArrayRef(g_option_table);
} }
Status OptionGroupUUID::SetOptionValue(uint32_t option_idx, Status OptionGroupUUID::SetOptionValue(uint32_t option_idx,
Context not available.

lldb/source/Interpreter/OptionGroupValueObjectDisplay.cpp

Context not available.
llvm::ArrayRef<OptionDefinition> llvm::ArrayRef<OptionDefinition>
OptionGroupValueObjectDisplay::GetDefinitions() { OptionGroupValueObjectDisplay::GetDefinitions() {
return llvm::makeArrayRef(g_option_table); return llvm::ArrayRef(g_option_table);
} }
Status OptionGroupValueObjectDisplay::SetOptionValue( Status OptionGroupValueObjectDisplay::SetOptionValue(
Context not available.

lldb/source/Interpreter/OptionGroupVariable.cpp

Context not available.
#define NUM_FRAME_OPTS 3 #define NUM_FRAME_OPTS 3
llvm::ArrayRef<OptionDefinition> OptionGroupVariable::GetDefinitions() { llvm::ArrayRef<OptionDefinition> OptionGroupVariable::GetDefinitions() {
auto result = llvm::makeArrayRef(g_variable_options); auto result = llvm::ArrayRef(g_variable_options);
// Show the "--no-args", "--no-locals" and "--show-globals" options if we are // Show the "--no-args", "--no-locals" and "--show-globals" options if we are
// showing frame specific options // showing frame specific options
if (include_frame_options) if (include_frame_options)
Context not available.

lldb/source/Interpreter/OptionGroupWatchpoint.cpp

Context not available.
} }
llvm::ArrayRef<OptionDefinition> OptionGroupWatchpoint::GetDefinitions() { llvm::ArrayRef<OptionDefinition> OptionGroupWatchpoint::GetDefinitions() {
return llvm::makeArrayRef(g_option_table); return llvm::ArrayRef(g_option_table);
} }
Context not available.

lldb/source/Interpreter/OptionValueBoolean.cpp

Context not available.
llvm::StringRef autocomplete_entries[] = {"true", "false", "on", "off", llvm::StringRef autocomplete_entries[] = {"true", "false", "on", "off",
"yes", "no", "1", "0"}; "yes", "no", "1", "0"};
auto entries = llvm::makeArrayRef(autocomplete_entries); auto entries = llvm::ArrayRef(autocomplete_entries);
// only suggest "true" or "false" by default // only suggest "true" or "false" by default
if (request.GetCursorArgumentPrefix().empty()) if (request.GetCursorArgumentPrefix().empty())
Context not available.

lldb/source/Plugins/ABI/ARC/ABISysV_arc.cpp

Context not available.
reg_value[byte_index++] = 0; reg_value[byte_index++] = 0;
} }
RegisterValue reg_val_obj(llvm::makeArrayRef(reg_value, reg_size), RegisterValue reg_val_obj(llvm::ArrayRef(reg_value, reg_size),
eByteOrderLittle); eByteOrderLittle);
if (!reg_ctx->WriteRegister( if (!reg_ctx->WriteRegister(
reg_ctx->GetRegisterInfo(eRegisterKindGeneric, reg_index), reg_ctx->GetRegisterInfo(eRegisterKindGeneric, reg_index),
Context not available.

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_objc_classtable_dump_options); return llvm::ArrayRef(g_objc_classtable_dump_options);
} }
OptionValueBoolean m_verbose; OptionValueBoolean m_verbose;
Context not available.

lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_renderscript_reduction_bp_set_options); return llvm::ArrayRef(g_renderscript_reduction_bp_set_options);
} }
bool ParseReductionTypes(llvm::StringRef option_val, bool ParseReductionTypes(llvm::StringRef option_val,
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_renderscript_kernel_bp_set_options); return llvm::ArrayRef(g_renderscript_kernel_bp_set_options);
} }
RSCoordinate m_coord; RSCoordinate m_coord;
Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_renderscript_runtime_alloc_dump_options); return llvm::ArrayRef(g_renderscript_runtime_alloc_dump_options);
} }
FileSpec m_outfile; FileSpec m_outfile;
Context not available.
void OptionParsingStarting(ExecutionContext *exe_ctx) override { m_id = 0; } void OptionParsingStarting(ExecutionContext *exe_ctx) override { m_id = 0; }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_renderscript_runtime_alloc_list_options); return llvm::ArrayRef(g_renderscript_runtime_alloc_list_options);
} }
uint32_t m_id = 0; uint32_t m_id = 0;
Context not available.

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

Context not available.
} }
static uint32_t calc_crc32(uint32_t init, const DataExtractor &data) { static uint32_t calc_crc32(uint32_t init, const DataExtractor &data) {
return llvm::crc32( return llvm::crc32(init,
init, llvm::makeArrayRef(data.GetDataStart(), data.GetByteSize())); llvm::ArrayRef(data.GetDataStart(), data.GetByteSize()));
} }
uint32_t ObjectFileELF::CalculateELFNotesSegmentsCRC32( uint32_t ObjectFileELF::CalculateELFNotesSegmentsCRC32(
Context not available.

lldb/source/Plugins/ObjectFile/wasm/ObjectFileWasm.cpp

Context not available.
return std::nullopt; return std::nullopt;
} }
llvm::StringRef str = toStringRef(makeArrayRef(str_storage)); llvm::StringRef str = toStringRef(llvm::ArrayRef(str_storage));
return ConstString(str); return ConstString(str);
} }
Context not available.

lldb/source/Plugins/Process/FreeBSD/NativeProcessFreeBSD.cpp

Context not available.
case llvm::Triple::arm: case llvm::Triple::arm:
switch (size_hint) { switch (size_hint) {
case 2: case 2:
return llvm::makeArrayRef(g_thumb_opcode); return llvm::ArrayRef(g_thumb_opcode);
case 4: case 4:
return llvm::makeArrayRef(g_arm_opcode); return llvm::ArrayRef(g_arm_opcode);
default: default:
return llvm::createStringError(llvm::inconvertibleErrorCode(), return llvm::createStringError(llvm::inconvertibleErrorCode(),
"Unrecognised trap opcode size hint!"); "Unrecognised trap opcode size hint!");
Context not available.

lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp

Context not available.
case llvm::Triple::arm: case llvm::Triple::arm:
switch (size_hint) { switch (size_hint) {
case 2: case 2:
return llvm::makeArrayRef(g_thumb_opcode); return llvm::ArrayRef(g_thumb_opcode);
case 4: case 4:
return llvm::makeArrayRef(g_arm_opcode); return llvm::ArrayRef(g_arm_opcode);
default: default:
return llvm::createStringError(llvm::inconvertibleErrorCode(), return llvm::createStringError(llvm::inconvertibleErrorCode(),
"Unrecognised trap opcode size hint!"); "Unrecognised trap opcode size hint!");
Context not available.

lldb/source/Plugins/Process/Utility/RegisterInfoPOSIX_arm64.cpp

Context not available.
if (m_opt_regsets.AnySet(eRegsetMaskDynamic)) { if (m_opt_regsets.AnySet(eRegsetMaskDynamic)) {
llvm::ArrayRef<lldb_private::RegisterInfo> reg_infos_ref = llvm::ArrayRef<lldb_private::RegisterInfo> reg_infos_ref =
llvm::makeArrayRef(m_register_info_p, m_register_info_count); llvm::ArrayRef(m_register_info_p, m_register_info_count);
llvm::ArrayRef<lldb_private::RegisterSet> reg_sets_ref = llvm::ArrayRef<lldb_private::RegisterSet> reg_sets_ref =
llvm::makeArrayRef(m_register_set_p, m_register_set_count); llvm::ArrayRef(m_register_set_p, m_register_set_count);
llvm::copy(reg_infos_ref, std::back_inserter(m_dynamic_reg_infos)); llvm::copy(reg_infos_ref, std::back_inserter(m_dynamic_reg_infos));
llvm::copy(reg_sets_ref, std::back_inserter(m_dynamic_reg_sets)); llvm::copy(reg_sets_ref, std::back_inserter(m_dynamic_reg_sets));
Context not available.
m_per_vq_reg_infos[sve_vq]; m_per_vq_reg_infos[sve_vq];
if (reg_info_ref.empty()) { if (reg_info_ref.empty()) {
reg_info_ref = llvm::makeArrayRef(m_register_info_p, m_register_info_count); reg_info_ref = llvm::ArrayRef(m_register_info_p, m_register_info_count);
uint32_t offset = SVE_REGS_DEFAULT_OFFSET_LINUX; uint32_t offset = SVE_REGS_DEFAULT_OFFSET_LINUX;
reg_info_ref[fpu_fpsr].byte_offset = offset; reg_info_ref[fpu_fpsr].byte_offset = offset;
Context not available.

lldb/source/Plugins/Process/Windows/Common/NativeProcessWindows.cpp

Context not available.
switch (GetArchitecture().GetMachine()) { switch (GetArchitecture().GetMachine()) {
case llvm::Triple::aarch64: case llvm::Triple::aarch64:
return llvm::makeArrayRef(g_aarch64_opcode); return llvm::ArrayRef(g_aarch64_opcode);
case llvm::Triple::arm: case llvm::Triple::arm:
case llvm::Triple::thumb: case llvm::Triple::thumb:
return llvm::makeArrayRef(g_thumb_opcode); return llvm::ArrayRef(g_thumb_opcode);
default: default:
return NativeProcessProtocol::GetSoftwareBreakpointTrapOpcode(size_hint); return NativeProcessProtocol::GetSoftwareBreakpointTrapOpcode(size_hint);
Context not available.

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

Context not available.
// Build the reginfos response. // Build the reginfos response.
StreamGDBRemote response; StreamGDBRemote response;
RegisterValue reg_value(makeArrayRef(reg_bytes, reg_size), RegisterValue reg_value(ArrayRef(reg_bytes, reg_size),
m_current_process->GetArchitecture().GetByteOrder()); m_current_process->GetArchitecture().GetByteOrder());
Status error = reg_context.WriteRegister(reg_info, reg_value); Status error = reg_context.WriteRegister(reg_info, reg_value);
if (error.Fail()) { if (error.Fail()) {
Context not available.

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

Context not available.
return {}; return {};
return std::make_pair( return std::make_pair(
llvm::makeArrayRef( llvm::ArrayRef(
reinterpret_cast<const MinidumpMemoryDescriptor64 *>(data.data()), reinterpret_cast<const MinidumpMemoryDescriptor64 *>(data.data()),
*mem_ranges_count), *mem_ranges_count),
*base_rva); *base_rva);
Context not available.

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

Context not available.
bool ScriptedProcess::IsScriptLanguageSupported(lldb::ScriptLanguage language) { bool ScriptedProcess::IsScriptLanguageSupported(lldb::ScriptLanguage language) {
llvm::ArrayRef<lldb::ScriptLanguage> supported_languages = llvm::ArrayRef<lldb::ScriptLanguage> supported_languages =
llvm::makeArrayRef(g_supported_script_languages); llvm::ArrayRef(g_supported_script_languages);
return llvm::is_contained(supported_languages, language); return llvm::is_contained(supported_languages, language);
} }
Context not available.

lldb/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.cpp

Context not available.
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_enable_option_table); return llvm::ArrayRef(g_enable_option_table);
} }
StructuredData::DictionarySP BuildConfigurationData(bool enabled) { StructuredData::DictionarySP BuildConfigurationData(bool enabled) {
Context not available.

lldb/source/Plugins/SymbolFile/DWARF/DWARFDataExtractor.cpp

Context not available.
} }
llvm::DWARFDataExtractor DWARFDataExtractor::GetAsLLVM() const { llvm::DWARFDataExtractor DWARFDataExtractor::GetAsLLVM() const {
return llvm::DWARFDataExtractor( return llvm::DWARFDataExtractor(llvm::ArrayRef(GetDataStart(), GetByteSize()),
llvm::makeArrayRef(GetDataStart(), GetByteSize()), GetByteOrder() == lldb::eByteOrderLittle,
GetByteOrder() == lldb::eByteOrderLittle, GetAddressByteSize()); GetAddressByteSize());
} }
} // namespace lldb_private } // namespace lldb_private
Context not available.

lldb/source/Plugins/SymbolFile/NativePDB/DWARFLocationExpression.cpp

Context not available.
Value.U = constant.getZExtValue(); Value.U = constant.getZExtValue();
} }
bytes = llvm::makeArrayRef(reinterpret_cast<const uint8_t *>(&Value), 8) bytes = llvm::ArrayRef(reinterpret_cast<const uint8_t *>(&Value), 8)
.take_front(size); .take_front(size);
buffer->CopyData(bytes.data(), size); buffer->CopyData(bytes.data(), size);
DataExtractor extractor(buffer, lldb::eByteOrderLittle, address_size); DataExtractor extractor(buffer, lldb::eByteOrderLittle, address_size);
Context not available.

lldb/source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.cpp

Context not available.
llvm::cantFail( llvm::cantFail(
TypeDeserializer::deserializeAs<ArgListRecord>(args_cvt, args)); TypeDeserializer::deserializeAs<ArgListRecord>(args_cvt, args));
llvm::ArrayRef<TypeIndex> arg_indices = llvm::makeArrayRef(args.ArgIndices); llvm::ArrayRef<TypeIndex> arg_indices = llvm::ArrayRef(args.ArgIndices);
bool is_variadic = IsCVarArgsFunction(arg_indices); bool is_variadic = IsCVarArgsFunction(arg_indices);
if (is_variadic) if (is_variadic)
arg_indices = arg_indices.drop_back(); arg_indices = arg_indices.drop_back();
Context not available.

lldb/source/Plugins/Trace/intel-pt/CommandObjectTraceStartIntelPT.cpp

Context not available.
llvm::ArrayRef<OptionDefinition> llvm::ArrayRef<OptionDefinition>
CommandObjectThreadTraceStartIntelPT::CommandOptions::GetDefinitions() { CommandObjectThreadTraceStartIntelPT::CommandOptions::GetDefinitions() {
return llvm::makeArrayRef(g_thread_trace_start_intel_pt_options); return llvm::ArrayRef(g_thread_trace_start_intel_pt_options);
} }
bool CommandObjectThreadTraceStartIntelPT::DoExecuteOnThreads( bool CommandObjectThreadTraceStartIntelPT::DoExecuteOnThreads(
Context not available.
llvm::ArrayRef<OptionDefinition> llvm::ArrayRef<OptionDefinition>
CommandObjectProcessTraceStartIntelPT::CommandOptions::GetDefinitions() { CommandObjectProcessTraceStartIntelPT::CommandOptions::GetDefinitions() {
return llvm::makeArrayRef(g_process_trace_start_intel_pt_options); return llvm::ArrayRef(g_process_trace_start_intel_pt_options);
} }
bool CommandObjectProcessTraceStartIntelPT::DoExecute( bool CommandObjectProcessTraceStartIntelPT::DoExecute(
Context not available.

lldb/source/Plugins/TraceExporter/ctf/CommandObjectThreadTraceExportCTF.cpp

Context not available.
llvm::ArrayRef<OptionDefinition> llvm::ArrayRef<OptionDefinition>
CommandObjectThreadTraceExportCTF::CommandOptions::GetDefinitions() { CommandObjectThreadTraceExportCTF::CommandOptions::GetDefinitions() {
return llvm::makeArrayRef(g_thread_trace_export_ctf_options); return llvm::ArrayRef(g_thread_trace_export_ctf_options);
} }
bool CommandObjectThreadTraceExportCTF::DoExecute(Args &command, bool CommandObjectThreadTraceExportCTF::DoExecute(Args &command,
Context not available.

lldb/source/Symbol/UnwindPlan.cpp

Context not available.
if (m_type == atDWARFExpression) if (m_type == atDWARFExpression)
s.PutChar('['); s.PutChar('[');
DumpDWARFExpr( DumpDWARFExpr(
s, llvm::makeArrayRef(m_location.expr.opcodes, m_location.expr.length), s, llvm::ArrayRef(m_location.expr.opcodes, m_location.expr.length),
thread); thread);
if (m_type == atDWARFExpression) if (m_type == atDWARFExpression)
s.PutChar(']'); s.PutChar(']');
Context not available.
s.PutChar(']'); s.PutChar(']');
break; break;
case isDWARFExpression: case isDWARFExpression:
DumpDWARFExpr(s, DumpDWARFExpr(s, llvm::ArrayRef(m_value.expr.opcodes, m_value.expr.length),
llvm::makeArrayRef(m_value.expr.opcodes, m_value.expr.length),
thread); thread);
break; break;
case unspecified: case unspecified:
Context not available.

lldb/source/Target/Platform.cpp

Context not available.
}; };
llvm::ArrayRef<OptionDefinition> OptionGroupPlatformRSync::GetDefinitions() { llvm::ArrayRef<OptionDefinition> OptionGroupPlatformRSync::GetDefinitions() {
return llvm::makeArrayRef(g_rsync_option_table); return llvm::ArrayRef(g_rsync_option_table);
} }
void OptionGroupPlatformRSync::OptionParsingStarting( void OptionGroupPlatformRSync::OptionParsingStarting(
Context not available.
} }
llvm::ArrayRef<OptionDefinition> OptionGroupPlatformSSH::GetDefinitions() { llvm::ArrayRef<OptionDefinition> OptionGroupPlatformSSH::GetDefinitions() {
return llvm::makeArrayRef(g_ssh_option_table); return llvm::ArrayRef(g_ssh_option_table);
} }
void OptionGroupPlatformSSH::OptionParsingStarting( void OptionGroupPlatformSSH::OptionParsingStarting(
Context not available.
} }
llvm::ArrayRef<OptionDefinition> OptionGroupPlatformCaching::GetDefinitions() { llvm::ArrayRef<OptionDefinition> OptionGroupPlatformCaching::GetDefinitions() {
return llvm::makeArrayRef(g_caching_option_table); return llvm::ArrayRef(g_caching_option_table);
} }
void OptionGroupPlatformCaching::OptionParsingStarting( void OptionGroupPlatformCaching::OptionParsingStarting(
Context not available.

lldb/source/Target/StackFrameRecognizer.cpp

Context not available.
symbol_name = entry.symbol_regexp->GetText().str(); symbol_name = entry.symbol_regexp->GetText().str();
callback(entry.recognizer_id, entry.recognizer->GetName(), module_name, callback(entry.recognizer_id, entry.recognizer->GetName(), module_name,
llvm::makeArrayRef(ConstString(symbol_name)), true); llvm::ArrayRef(ConstString(symbol_name)), true);
} else { } else {
callback(entry.recognizer_id, entry.recognizer->GetName(), callback(entry.recognizer_id, entry.recognizer->GetName(),
Context not available.

lldb/source/Utility/Args.cpp

Context not available.
assert(m_argv.size() == m_entries.size() + 1); assert(m_argv.size() == m_entries.size() + 1);
assert(m_argv.back() == nullptr); assert(m_argv.back() == nullptr);
m_argv.pop_back(); m_argv.pop_back();
for (auto arg : llvm::makeArrayRef(argv, argc)) { for (auto arg : llvm::ArrayRef(argv, argc)) {
m_entries.emplace_back(arg, '\0'); m_entries.emplace_back(arg, '\0');
m_argv.push_back(m_entries.back().data()); m_argv.push_back(m_entries.back().data());
} }
Context not available.
void Args::SetArguments(size_t argc, const char **argv) { void Args::SetArguments(size_t argc, const char **argv) {
Clear(); Clear();
auto args = llvm::makeArrayRef(argv, argc); auto args = llvm::ArrayRef(argv, argc);
m_entries.resize(argc); m_entries.resize(argc);
m_argv.resize(argc + 1); m_argv.resize(argc + 1);
for (size_t i = 0; i < args.size(); ++i) { for (size_t i = 0; i < args.size(); ++i) {
Context not available.

lldb/source/Utility/StringList.cpp

Context not available.
if (m_strings.empty()) if (m_strings.empty())
return {}; return {};
auto args = llvm::makeArrayRef(m_strings); auto args = llvm::ArrayRef(m_strings);
llvm::StringRef prefix = args.front(); llvm::StringRef prefix = args.front();
for (auto arg : args.drop_front()) { for (auto arg : args.drop_front()) {
size_t count = 0; size_t count = 0;
Context not available.

lldb/tools/driver/Driver.cpp

Context not available.
LLDBOptTable T; LLDBOptTable T;
unsigned MissingArgIndex; unsigned MissingArgIndex;
unsigned MissingArgCount; unsigned MissingArgCount;
ArrayRef<const char *> arg_arr = makeArrayRef(argv + 1, argc - 1); ArrayRef<const char *> arg_arr = ArrayRef(argv + 1, argc - 1);
opt::InputArgList input_args = opt::InputArgList input_args =
T.ParseArgs(arg_arr, MissingArgIndex, MissingArgCount); T.ParseArgs(arg_arr, MissingArgIndex, MissingArgCount);
llvm::StringRef argv0 = llvm::sys::path::filename(argv[0]); llvm::StringRef argv0 = llvm::sys::path::filename(argv[0]);
Context not available.

lldb/tools/lldb-vscode/lldb-vscode.cpp

Context not available.
LLDBVSCodeOptTable T; LLDBVSCodeOptTable T;
unsigned MAI, MAC; unsigned MAI, MAC;
llvm::ArrayRef<const char *> ArgsArr = llvm::makeArrayRef(argv + 1, argc); llvm::ArrayRef<const char *> ArgsArr = llvm::ArrayRef(argv + 1, argc);
llvm::opt::InputArgList input_args = T.ParseArgs(ArgsArr, MAI, MAC); llvm::opt::InputArgList input_args = T.ParseArgs(ArgsArr, MAI, MAC);
if (input_args.hasArg(OPT_help)) { if (input_args.hasArg(OPT_help)) {
Context not available.

lldb/unittests/TestingSupport/Host/NativeProcessTestUtils.h

Context not available.
Status WriteMemory(addr_t Addr, const void *Buf, size_t Size, Status WriteMemory(addr_t Addr, const void *Buf, size_t Size,
size_t &BytesWritten) /*override*/ { size_t &BytesWritten) /*override*/ {
auto ExpectedBytes = this->WriteMemory( auto ExpectedBytes = this->WriteMemory(
Addr, llvm::makeArrayRef(static_cast<const uint8_t *>(Buf), Size)); Addr, llvm::ArrayRef(static_cast<const uint8_t *>(Buf), Size));
if (!ExpectedBytes) { if (!ExpectedBytes) {
BytesWritten = 0; BytesWritten = 0;
return Status(ExpectedBytes.takeError()); return Status(ExpectedBytes.takeError());
Context not available.

llvm/docs/TableGen/BackEnds.rst

Context not available.
uint16_t Val2; uint16_t Val2;
}; };
KeyType Key = { Val1, Val2 }; KeyType Key = { Val1, Val2 };
auto Table = makeArrayRef(ATable); auto Table = ArrayRef(ATable);
auto Idx = std::lower_bound(Table.begin(), Table.end(), Key, auto Idx = std::lower_bound(Table.begin(), Table.end(), Key,
[](const AEntry &LHS, const KeyType &RHS) { [](const AEntry &LHS, const KeyType &RHS) {
if (LHS.Val1 < RHS.Val1) if (LHS.Val1 < RHS.Val1)
Context not available.
uint16_t Encoding; uint16_t Encoding;
}; };
KeyType Key = { Encoding }; KeyType Key = { Encoding };
auto Table = makeArrayRef(CTable); auto Table = ArrayRef(CTable);
auto Idx = std::lower_bound(Table.begin(), Table.end(), Key, auto Idx = std::lower_bound(Table.begin(), Table.end(), Key,
[](const CEntry &LHS, const KeyType &RHS) { [](const CEntry &LHS, const KeyType &RHS) {
if (LHS.Encoding < RHS.Encoding) if (LHS.Encoding < RHS.Encoding)
Context not available.
unsigned Kind; unsigned Kind;
}; };
KeyType Key = { Name.upper(), Kind }; KeyType Key = { Name.upper(), Kind };
auto Table = makeArrayRef(Index); auto Table = ArrayRef(Index);
auto Idx = std::lower_bound(Table.begin(), Table.end(), Key, auto Idx = std::lower_bound(Table.begin(), Table.end(), Key,
[](const IndexType &LHS, const KeyType &RHS) { [](const IndexType &LHS, const KeyType &RHS) {
int CmpName = StringRef(LHS.Name).compare(RHS.Name); int CmpName = StringRef(LHS.Name).compare(RHS.Name);
Context not available.

llvm/include/llvm/ADT/ArrayRef.h

Context not available.
~OwningArrayRef() { delete[] this->data(); } ~OwningArrayRef() { delete[] this->data(); }
}; };
/// @name ArrayRef Convenience constructors /// @name ArrayRef Deduction guides
/// @{ /// @{
/// Deduction guide to construct an ArrayRef from a single element.
template <typename T> ArrayRef(const T &OneElt) -> ArrayRef<T>;
/// Deduction guide to construct an ArrayRef from a pointer and length
template <typename T> ArrayRef(const T *data, size_t length) -> ArrayRef<T>;
/// Deduction guide to construct an ArrayRef from a range
template <typename T> ArrayRef(const T *data, const T *end) -> ArrayRef<T>;
/// Deduction guide to construct an ArrayRef from a SmallVector
template <typename T> ArrayRef(const SmallVectorImpl<T> &Vec) -> ArrayRef<T>;
/// Deduction guide to construct an ArrayRef from a SmallVector
template <typename T, unsigned N>
ArrayRef(const SmallVector<T, N> &Vec) -> ArrayRef<T>;
/// Deduction guide to construct an ArrayRef from a std::vector
template <typename T> ArrayRef(const std::vector<T> &Vec) -> ArrayRef<T>;
/// Deduction guide to construct an ArrayRef from a std::array
template <typename T, std::size_t N>
ArrayRef(const std::array<T, N> &Vec) -> ArrayRef<T>;
/// Deduction guide to construct an ArrayRef from an ArrayRef (no-op) (const)
template <typename T> ArrayRef(const ArrayRef<T> &Vec) -> ArrayRef<T>;
/// Deduction guide to construct an ArrayRef from an ArrayRef (no-op)
template <typename T> ArrayRef(ArrayRef<T> &Vec) -> ArrayRef<T>;
/// Deduction guide to construct an ArrayRef from a C array.
template <typename T, size_t N> ArrayRef(const T (&Arr)[N]) -> ArrayRef<T>;
mehdi_aminiUnsubmitted
Not Done
ReplyInline Actions

Can we keep the makeArrayRef functions for now and mark them deprecated?

mehdi_amini: Can we keep the makeArrayRef functions for now and mark them deprecated?
jpienaarUnsubmitted
Not Done
ReplyInline Actions

+1 that would also allow for this change to broken up so that the deduction guides land first and then the updates (potentially even 3 hops, 1) add guides, 2) update, 3) mark deprecated - 1 & 2 could be combined but it'll greatly simplify review/enable sharding it)

jpienaar: +1 that would also allow for this change to broken up so that the deduction guides land first…
/// @}
/// @name ArrayRef Convenience constructors
/// @{
/// Construct an ArrayRef from a single element. /// Construct an ArrayRef from a single element.
template<typename T> template <typename T>
LLVM_DEPRECATED("Use deduction guide instead", "ArrayRef")
ArrayRef<T> makeArrayRef(const T &OneElt) { ArrayRef<T> makeArrayRef(const T &OneElt) {
return OneElt; return OneElt;
} }
/// Construct an ArrayRef from a pointer and length. /// Construct an ArrayRef from a pointer and length.
template<typename T> template <typename T>
LLVM_DEPRECATED("Use deduction guide instead", "ArrayRef")
ArrayRef<T> makeArrayRef(const T *data, size_t length) { ArrayRef<T> makeArrayRef(const T *data, size_t length) {
return ArrayRef<T>(data, length); return ArrayRef<T>(data, length);
} }
/// Construct an ArrayRef from a range. /// Construct an ArrayRef from a range.
template<typename T> template <typename T>
LLVM_DEPRECATED("Use deduction guide instead", "ArrayRef")
ArrayRef<T> makeArrayRef(const T *begin, const T *end) { ArrayRef<T> makeArrayRef(const T *begin, const T *end) {
return ArrayRef<T>(begin, end); return ArrayRef<T>(begin, end);
} }
/// Construct an ArrayRef from a SmallVector. /// Construct an ArrayRef from a SmallVector.
template <typename T> template <typename T>
LLVM_DEPRECATED("Use deduction guide instead", "ArrayRef")
ArrayRef<T> makeArrayRef(const SmallVectorImpl<T> &Vec) { ArrayRef<T> makeArrayRef(const SmallVectorImpl<T> &Vec) {
return Vec; return Vec;
} }
/// Construct an ArrayRef from a SmallVector. /// Construct an ArrayRef from a SmallVector.
template <typename T, unsigned N> template <typename T, unsigned N>
LLVM_DEPRECATED("Use deduction guide instead", "ArrayRef")
ArrayRef<T> makeArrayRef(const SmallVector<T, N> &Vec) { ArrayRef<T> makeArrayRef(const SmallVector<T, N> &Vec) {
return Vec; return Vec;
} }
/// Construct an ArrayRef from a std::vector. /// Construct an ArrayRef from a std::vector.
template<typename T> template <typename T>
LLVM_DEPRECATED("Use deduction guide instead", "ArrayRef")
ArrayRef<T> makeArrayRef(const std::vector<T> &Vec) { ArrayRef<T> makeArrayRef(const std::vector<T> &Vec) {
return Vec; return Vec;
} }
/// Construct an ArrayRef from a std::array. /// Construct an ArrayRef from a std::array.
template <typename T, std::size_t N> template <typename T, std::size_t N>
LLVM_DEPRECATED("Use deduction guide instead", "ArrayRef")
ArrayRef<T> makeArrayRef(const std::array<T, N> &Arr) { ArrayRef<T> makeArrayRef(const std::array<T, N> &Arr) {
return Arr; return Arr;
} }
/// Construct an ArrayRef from an ArrayRef (no-op) (const) /// Construct an ArrayRef from an ArrayRef (no-op) (const)
template <typename T> ArrayRef<T> makeArrayRef(const ArrayRef<T> &Vec) { template <typename T>
LLVM_DEPRECATED("Use deduction guide instead", "ArrayRef")
ArrayRef<T> makeArrayRef(const ArrayRef<T> &Vec) {
return Vec; return Vec;
} }
/// Construct an ArrayRef from an ArrayRef (no-op) /// Construct an ArrayRef from an ArrayRef (no-op)
template <typename T> ArrayRef<T> &makeArrayRef(ArrayRef<T> &Vec) { template <typename T>
LLVM_DEPRECATED("Use deduction guide instead", "ArrayRef")
ArrayRef<T> &makeArrayRef(ArrayRef<T> &Vec) {
return Vec; return Vec;
} }
/// Construct an ArrayRef from a C array. /// Construct an ArrayRef from a C array.
template<typename T, size_t N> template <typename T, size_t N>
ArrayRef<T> makeArrayRef(const T (&Arr)[N]) { ArrayRef<T> LLVM_DEPRECATED("Use deduction guide instead", "ArrayRef")
makeArrayRef(const T (&Arr)[N]) {
return ArrayRef<T>(Arr); return ArrayRef<T>(Arr);
} }
Context not available.

llvm/include/llvm/ADT/SmallBitVector.h

Context not available.
if (!isSmall()) if (!isSmall())
return getPointer()->getData(); return getPointer()->getData();
Store = getSmallBits(); Store = getSmallBits();
return makeArrayRef(Store); return ArrayRef(Store);
} }
private: private:
Context not available.

llvm/include/llvm/Analysis/ConstraintSystem.h

Context not available.
assert(Constraints.empty() || R.size() == Constraints.back().size()); assert(Constraints.empty() || R.size() == Constraints.back().size());
// If all variable coefficients are 0, the constraint does not provide any // If all variable coefficients are 0, the constraint does not provide any
// usable information. // usable information.
if (all_of(makeArrayRef(R).drop_front(1), [](int64_t C) { return C == 0; })) if (all_of(ArrayRef(R).drop_front(1), [](int64_t C) { return C == 0; }))
return false; return false;
for (const auto &C : R) { for (const auto &C : R) {
Context not available.
bool addVariableRowFill(ArrayRef<int64_t> R) { bool addVariableRowFill(ArrayRef<int64_t> R) {
// If all variable coefficients are 0, the constraint does not provide any // If all variable coefficients are 0, the constraint does not provide any
// usable information. // usable information.
if (all_of(makeArrayRef(R).drop_front(1), [](int64_t C) { return C == 0; })) if (all_of(ArrayRef(R).drop_front(1), [](int64_t C) { return C == 0; }))
return false; return false;
for (auto &CR : Constraints) { for (auto &CR : Constraints) {
Context not available.

llvm/include/llvm/Analysis/ScalarEvolutionExpressions.h

Context not available.
SCEVNAryExpr(const FoldingSetNodeIDRef ID, enum SCEVTypes T, SCEVNAryExpr(const FoldingSetNodeIDRef ID, enum SCEVTypes T,
const SCEV *const *O, size_t N) const SCEV *const *O, size_t N)
: SCEV(ID, T, computeExpressionSize(makeArrayRef(O, N))), Operands(O), : SCEV(ID, T, computeExpressionSize(ArrayRef(O, N))), Operands(O),
NumOperands(N) {} NumOperands(N) {}
public: public:
Context not available.
} }
ArrayRef<const SCEV *> operands() const { ArrayRef<const SCEV *> operands() const {
return makeArrayRef(Operands, NumOperands); return ArrayRef(Operands, NumOperands);
} }
NoWrapFlags getNoWrapFlags(NoWrapFlags Mask = NoWrapMask) const { NoWrapFlags getNoWrapFlags(NoWrapFlags Mask = NoWrapMask) const {
Context not available.

llvm/include/llvm/Bitcode/BitcodeConvenience.h

Context not available.
/// in the buffer and should be handled separately by the caller. /// in the buffer and should be handled separately by the caller.
template <typename BufferTy, typename... Data> template <typename BufferTy, typename... Data>
static void readRecord(BufferTy &buffer, Data &&...data) { static void readRecord(BufferTy &buffer, Data &&...data) {
return readRecord(llvm::makeArrayRef(buffer), std::forward<Data>(data)...); return readRecord(llvm::ArrayRef(buffer), std::forward<Data>(data)...);
} }
}; };
Context not available.

llvm/include/llvm/Bitstream/BitstreamWriter.h

Context not available.
Out.push_back(0); Out.push_back(0);
} }
void emitBlob(StringRef Bytes, bool ShouldEmitSize = true) { void emitBlob(StringRef Bytes, bool ShouldEmitSize = true) {
emitBlob(makeArrayRef((const uint8_t *)Bytes.data(), Bytes.size()), emitBlob(ArrayRef((const uint8_t *)Bytes.data(), Bytes.size()),
ShouldEmitSize); ShouldEmitSize);
} }
Context not available.
if (!Abbrev) { if (!Abbrev) {
// If we don't have an abbrev to use, emit this in its fully unabbreviated // If we don't have an abbrev to use, emit this in its fully unabbreviated
// form. // form.
auto Count = static_cast<uint32_t>(makeArrayRef(Vals).size()); auto Count = static_cast<uint32_t>(ArrayRef(Vals).size());
EmitCode(bitc::UNABBREV_RECORD); EmitCode(bitc::UNABBREV_RECORD);
EmitVBR(Code, 6); EmitVBR(Code, 6);
EmitVBR(Count, 6); EmitVBR(Count, 6);
Context not available.
return; return;
} }
EmitRecordWithAbbrevImpl(Abbrev, makeArrayRef(Vals), StringRef(), Code); EmitRecordWithAbbrevImpl(Abbrev, ArrayRef(Vals), StringRef(), Code);
} }
/// EmitRecordWithAbbrev - Emit a record with the specified abbreviation. /// EmitRecordWithAbbrev - Emit a record with the specified abbreviation.
Context not available.
/// the first entry. /// the first entry.
template <typename Container> template <typename Container>
void EmitRecordWithAbbrev(unsigned Abbrev, const Container &Vals) { void EmitRecordWithAbbrev(unsigned Abbrev, const Container &Vals) {
EmitRecordWithAbbrevImpl(Abbrev, makeArrayRef(Vals), StringRef(), EmitRecordWithAbbrevImpl(Abbrev, ArrayRef(Vals), StringRef(), std::nullopt);
std::nullopt);
} }
/// EmitRecordWithBlob - Emit the specified record to the stream, using an /// EmitRecordWithBlob - Emit the specified record to the stream, using an
Context not available.
template <typename Container> template <typename Container>
void EmitRecordWithBlob(unsigned Abbrev, const Container &Vals, void EmitRecordWithBlob(unsigned Abbrev, const Container &Vals,
StringRef Blob) { StringRef Blob) {
EmitRecordWithAbbrevImpl(Abbrev, makeArrayRef(Vals), Blob, std::nullopt); EmitRecordWithAbbrevImpl(Abbrev, ArrayRef(Vals), Blob, std::nullopt);
} }
template <typename Container> template <typename Container>
void EmitRecordWithBlob(unsigned Abbrev, const Container &Vals, void EmitRecordWithBlob(unsigned Abbrev, const Container &Vals,
const char *BlobData, unsigned BlobLen) { const char *BlobData, unsigned BlobLen) {
return EmitRecordWithAbbrevImpl(Abbrev, makeArrayRef(Vals), return EmitRecordWithAbbrevImpl(Abbrev, ArrayRef(Vals),
StringRef(BlobData, BlobLen), std::nullopt); StringRef(BlobData, BlobLen), std::nullopt);
} }
Context not available.
template <typename Container> template <typename Container>
void EmitRecordWithArray(unsigned Abbrev, const Container &Vals, void EmitRecordWithArray(unsigned Abbrev, const Container &Vals,
StringRef Array) { StringRef Array) {
EmitRecordWithAbbrevImpl(Abbrev, makeArrayRef(Vals), Array, std::nullopt); EmitRecordWithAbbrevImpl(Abbrev, ArrayRef(Vals), Array, std::nullopt);
} }
template <typename Container> template <typename Container>
void EmitRecordWithArray(unsigned Abbrev, const Container &Vals, void EmitRecordWithArray(unsigned Abbrev, const Container &Vals,
const char *ArrayData, unsigned ArrayLen) { const char *ArrayData, unsigned ArrayLen) {
return EmitRecordWithAbbrevImpl(Abbrev, makeArrayRef(Vals), return EmitRecordWithAbbrevImpl(
StringRef(ArrayData, ArrayLen), Abbrev, ArrayRef(Vals), StringRef(ArrayData, ArrayLen), std::nullopt);
std::nullopt);
} }
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
Context not available.

llvm/include/llvm/CodeGen/CostTable.h

Context not available.
inline const CostTblEntryT<CostType> * inline const CostTblEntryT<CostType> *
CostTableLookup(const CostTblEntryT<CostType> (&Table)[N], int ISD, MVT Ty) { CostTableLookup(const CostTblEntryT<CostType> (&Table)[N], int ISD, MVT Ty) {
// Wrapper to fix template argument deduction failures. // Wrapper to fix template argument deduction failures.
return CostTableLookup<CostType>(makeArrayRef(Table), ISD, Ty); return CostTableLookup<CostType>(ArrayRef(Table), ISD, Ty);
} }
/// Type Conversion Cost Table /// Type Conversion Cost Table
Context not available.
ConvertCostTableLookup(const TypeConversionCostTblEntryT<CostType> (&Table)[N], ConvertCostTableLookup(const TypeConversionCostTblEntryT<CostType> (&Table)[N],
int ISD, MVT Dst, MVT Src) { int ISD, MVT Dst, MVT Src) {
// Wrapper to fix template argument deduction failures. // Wrapper to fix template argument deduction failures.
return ConvertCostTableLookup<CostType>(makeArrayRef(Table), ISD, Dst, Src); return ConvertCostTableLookup<CostType>(ArrayRef(Table), ISD, Dst, Src);
} }
} // namespace llvm } // namespace llvm
Context not available.

llvm/include/llvm/CodeGen/LiveRangeEdit.h

Context not available.
/// we want to drop it from the NewRegs set. /// we want to drop it from the NewRegs set.
void pop_back() { NewRegs.pop_back(); } void pop_back() { NewRegs.pop_back(); }
ArrayRef<Register> regs() const { ArrayRef<Register> regs() const { return ArrayRef(NewRegs).slice(FirstNew); }
return makeArrayRef(NewRegs).slice(FirstNew);
}
/// createFrom - Create a new virtual register based on OldReg. /// createFrom - Create a new virtual register based on OldReg.
Register createFrom(Register OldReg); Register createFrom(Register OldReg);
Context not available.

llvm/include/llvm/CodeGen/MachineInstr.h

Context not available.
} }
ArrayRef<MachineMemOperand *> getMMOs() const { ArrayRef<MachineMemOperand *> getMMOs() const {
return makeArrayRef(getTrailingObjects<MachineMemOperand *>(), NumMMOs); return ArrayRef(getTrailingObjects<MachineMemOperand *>(), NumMMOs);
} }
MCSymbol *getPreInstrSymbol() const { MCSymbol *getPreInstrSymbol() const {
Context not available.
return {}; return {};
if (Info.is<EIIK_MMO>()) if (Info.is<EIIK_MMO>())
return makeArrayRef(Info.getAddrOfZeroTagPointer(), 1); return ArrayRef(Info.getAddrOfZeroTagPointer(), 1);
if (ExtraInfo *EI = Info.get<EIIK_OutOfLine>()) if (ExtraInfo *EI = Info.get<EIIK_OutOfLine>())
return EI->getMMOs(); return EI->getMMOs();
Context not available.

llvm/include/llvm/CodeGen/RegisterClassInfo.h

Context not available.
RCInfo() = default; RCInfo() = default;
operator ArrayRef<MCPhysReg>() const { operator ArrayRef<MCPhysReg>() const {
return makeArrayRef(Order.get(), NumRegs); return ArrayRef(Order.get(), NumRegs);
} }
}; };
Context not available.

llvm/include/llvm/CodeGen/SelectionDAG.h

Context not available.
SDVTList VTs = getVTList(MVT::Other, MVT::Glue); SDVTList VTs = getVTList(MVT::Other, MVT::Glue);
SDValue Ops[] = { Chain, getRegister(Reg, N.getValueType()), N, Glue }; SDValue Ops[] = { Chain, getRegister(Reg, N.getValueType()), N, Glue };
return getNode(ISD::CopyToReg, dl, VTs, return getNode(ISD::CopyToReg, dl, VTs,
makeArrayRef(Ops, Glue.getNode() ? 4 : 3)); ArrayRef(Ops, Glue.getNode() ? 4 : 3));
} }
// Similar to last getCopyToReg() except parameter Reg is a SDValue // Similar to last getCopyToReg() except parameter Reg is a SDValue
Context not available.
SDVTList VTs = getVTList(MVT::Other, MVT::Glue); SDVTList VTs = getVTList(MVT::Other, MVT::Glue);
SDValue Ops[] = { Chain, Reg, N, Glue }; SDValue Ops[] = { Chain, Reg, N, Glue };
return getNode(ISD::CopyToReg, dl, VTs, return getNode(ISD::CopyToReg, dl, VTs,
makeArrayRef(Ops, Glue.getNode() ? 4 : 3)); ArrayRef(Ops, Glue.getNode() ? 4 : 3));
} }
SDValue getCopyFromReg(SDValue Chain, const SDLoc &dl, unsigned Reg, EVT VT) { SDValue getCopyFromReg(SDValue Chain, const SDLoc &dl, unsigned Reg, EVT VT) {
Context not available.
SDVTList VTs = getVTList(VT, MVT::Other, MVT::Glue); SDVTList VTs = getVTList(VT, MVT::Other, MVT::Glue);
SDValue Ops[] = { Chain, getRegister(Reg, VT), Glue }; SDValue Ops[] = { Chain, getRegister(Reg, VT), Glue };
return getNode(ISD::CopyFromReg, dl, VTs, return getNode(ISD::CopyFromReg, dl, VTs,
makeArrayRef(Ops, Glue.getNode() ? 3 : 2)); ArrayRef(Ops, Glue.getNode() ? 3 : 2));
} }
SDValue getCondCode(ISD::CondCode Cond); SDValue getCondCode(ISD::CondCode Cond);
Context not available.

llvm/include/llvm/CodeGen/SelectionDAGNodes.h

Context not available.
op_iterator op_begin() const { return OperandList; } op_iterator op_begin() const { return OperandList; }
op_iterator op_end() const { return OperandList+NumOperands; } op_iterator op_end() const { return OperandList+NumOperands; }
ArrayRef<SDUse> ops() const { return makeArrayRef(op_begin(), op_end()); } ArrayRef<SDUse> ops() const { return ArrayRef(op_begin(), op_end()); }
/// Iterator for directly iterating over the operand SDValue's. /// Iterator for directly iterating over the operand SDValue's.
struct value_op_iterator struct value_op_iterator
Context not available.
public: public:
ArrayRef<int> getMask() const { ArrayRef<int> getMask() const {
EVT VT = getValueType(0); EVT VT = getValueType(0);
return makeArrayRef(Mask, VT.getVectorNumElements()); return ArrayRef(Mask, VT.getVectorNumElements());
} }
int getMaskElt(unsigned Idx) const { int getMaskElt(unsigned Idx) const {
Context not available.
if (NumMemRefs == 0) if (NumMemRefs == 0)
return {}; return {};
if (NumMemRefs == 1) if (NumMemRefs == 1)
return makeArrayRef(MemRefs.getAddrOfPtr1(), 1); return ArrayRef(MemRefs.getAddrOfPtr1(), 1);
// Otherwise we have an actual array. // Otherwise we have an actual array.
return makeArrayRef(MemRefs.get<MachineMemOperand **>(), NumMemRefs); return ArrayRef(MemRefs.get<MachineMemOperand **>(), NumMemRefs);
} }
mmo_iterator memoperands_begin() const { return memoperands().begin(); } mmo_iterator memoperands_begin() const { return memoperands().begin(); }
mmo_iterator memoperands_end() const { return memoperands().end(); } mmo_iterator memoperands_end() const { return memoperands().end(); }
Context not available.

llvm/include/llvm/CodeGen/TargetRegisterInfo.h

Context not available.
/// ///
/// By default, this method returns all registers in the class. /// By default, this method returns all registers in the class.
ArrayRef<MCPhysReg> getRawAllocationOrder(const MachineFunction &MF) const { ArrayRef<MCPhysReg> getRawAllocationOrder(const MachineFunction &MF) const {
return OrderFunc ? OrderFunc(MF) : makeArrayRef(begin(), getNumRegs()); return OrderFunc ? OrderFunc(MF) : ArrayRef(begin(), getNumRegs());
} }
/// Returns the combination of all lane masks of register in this class. /// Returns the combination of all lane masks of register in this class.
Context not available.
unsigned NumRegs = getNumRegs(); unsigned NumRegs = getNumRegs();
assert(Idx < InfoDesc->NumCosts && "CostPerUse index out of bounds"); assert(Idx < InfoDesc->NumCosts && "CostPerUse index out of bounds");
return makeArrayRef(&InfoDesc->CostPerUse[Idx * NumRegs], NumRegs); return ArrayRef(&InfoDesc->CostPerUse[Idx * NumRegs], NumRegs);
} }
/// Return true if the register is in the allocation of any register class. /// Return true if the register is in the allocation of any register class.
Context not available.

llvm/include/llvm/DebugInfo/CodeView/TypeRecord.h

Context not available.
TypeIndex getCompleteClass() const { return CompleteClass; } TypeIndex getCompleteClass() const { return CompleteClass; }
TypeIndex getOverriddenVTable() const { return OverriddenVFTable; } TypeIndex getOverriddenVTable() const { return OverriddenVFTable; }
uint32_t getVFPtrOffset() const { return VFPtrOffset; } uint32_t getVFPtrOffset() const { return VFPtrOffset; }
StringRef getName() const { return makeArrayRef(MethodNames).front(); } StringRef getName() const { return ArrayRef(MethodNames).front(); }
ArrayRef<StringRef> getMethodNames() const { ArrayRef<StringRef> getMethodNames() const {
return makeArrayRef(MethodNames).drop_front(); return ArrayRef(MethodNames).drop_front();
} }
TypeIndex CompleteClass; TypeIndex CompleteClass;
Context not available.

llvm/include/llvm/DebugInfo/DWARF/DWARFUnitIndex.h

Context not available.
const Entry *getFromHash(uint64_t Offset) const; const Entry *getFromHash(uint64_t Offset) const;
ArrayRef<DWARFSectionKind> getColumnKinds() const { ArrayRef<DWARFSectionKind> getColumnKinds() const {
return makeArrayRef(ColumnKinds.get(), Header.NumColumns); return ArrayRef(ColumnKinds.get(), Header.NumColumns);
} }
ArrayRef<Entry> getRows() const { ArrayRef<Entry> getRows() const {
return makeArrayRef(Rows.get(), Header.NumBuckets); return ArrayRef(Rows.get(), Header.NumBuckets);
} }
}; };
Context not available.

llvm/include/llvm/DebugInfo/PDB/Native/DbiModuleDescriptorBuilder.h

Context not available.
unsigned getModuleIndex() const { return Layout.Mod; } unsigned getModuleIndex() const { return Layout.Mod; }
ArrayRef<std::string> source_files() const { ArrayRef<std::string> source_files() const { return ArrayRef(SourceFiles); }
return makeArrayRef(SourceFiles);
}
uint32_t calculateSerializedLength() const; uint32_t calculateSerializedLength() const;
Context not available.

llvm/include/llvm/IR/Constants.h

Context not available.
/// ArrayRef<ElementTy>. Calls get(LLVMContext, ArrayRef<ElementTy>). /// ArrayRef<ElementTy>. Calls get(LLVMContext, ArrayRef<ElementTy>).
template <typename ArrayTy> template <typename ArrayTy>
static Constant *get(LLVMContext &Context, ArrayTy &Elts) { static Constant *get(LLVMContext &Context, ArrayTy &Elts) {
return ConstantDataArray::get(Context, makeArrayRef(Elts)); return ConstantDataArray::get(Context, ArrayRef(Elts));
} }
/// getRaw() constructor - Return a constant with array type with an element /// getRaw() constructor - Return a constant with array type with an element
Context not available.
std::optional<unsigned> InRangeIndex = std::nullopt, std::optional<unsigned> InRangeIndex = std::nullopt,
Type *OnlyIfReducedTy = nullptr) { Type *OnlyIfReducedTy = nullptr) {
return getGetElementPtr( return getGetElementPtr(
Ty, C, makeArrayRef((Value *const *)IdxList.data(), IdxList.size()), Ty, C, ArrayRef((Value *const *)IdxList.data(), IdxList.size()),
InBounds, InRangeIndex, OnlyIfReducedTy); InBounds, InRangeIndex, OnlyIfReducedTy);
} }
static Constant * static Constant *
Context not available.

llvm/include/llvm/IR/DataLayout.h

Context not available.
} }
ArrayRef<uint64_t> getMemberOffsets() const { ArrayRef<uint64_t> getMemberOffsets() const {
return llvm::makeArrayRef(getTrailingObjects<uint64_t>(), NumElements); return llvm::ArrayRef(getTrailingObjects<uint64_t>(), NumElements);
} }
uint64_t getElementOffset(unsigned Idx) const { uint64_t getElementOffset(unsigned Idx) const {
Context not available.

llvm/include/llvm/IR/DerivedTypes.h

Context not available.
param_iterator param_begin() const { return ContainedTys + 1; } param_iterator param_begin() const { return ContainedTys + 1; }
param_iterator param_end() const { return &ContainedTys[NumContainedTys]; } param_iterator param_end() const { return &ContainedTys[NumContainedTys]; }
ArrayRef<Type *> params() const { ArrayRef<Type *> params() const {
return makeArrayRef(param_begin(), param_end()); return ArrayRef(param_begin(), param_end());
} }
/// Parameter type accessors. /// Parameter type accessors.
Context not available.
element_iterator element_begin() const { return ContainedTys; } element_iterator element_begin() const { return ContainedTys; }
element_iterator element_end() const { return &ContainedTys[NumContainedTys];} element_iterator element_end() const { return &ContainedTys[NumContainedTys];}
ArrayRef<Type *> elements() const { ArrayRef<Type *> elements() const {
return makeArrayRef(element_begin(), element_end()); return ArrayRef(element_begin(), element_end());
} }
/// Return true if this is layout identical to the specified struct. /// Return true if this is layout identical to the specified struct.
Context not available.
/// Return the type parameters for this particular target extension type. If /// Return the type parameters for this particular target extension type. If
/// there are no parameters, an empty array is returned. /// there are no parameters, an empty array is returned.
ArrayRef<Type *> type_params() const { ArrayRef<Type *> type_params() const {
return makeArrayRef(type_param_begin(), type_param_end()); return ArrayRef(type_param_begin(), type_param_end());
} }
using type_param_iterator = Type::subtype_iterator; using type_param_iterator = Type::subtype_iterator;
Context not available.
/// Return the integer parameters for this particular target extension type. /// Return the integer parameters for this particular target extension type.
/// If there are no parameters, an empty array is returned. /// If there are no parameters, an empty array is returned.
ArrayRef<unsigned> int_params() const { ArrayRef<unsigned> int_params() const {
return makeArrayRef(IntParams, getNumIntParameters()); return ArrayRef(IntParams, getNumIntParameters());
} }
unsigned getIntParameter(unsigned i) const { return IntParams[i]; } unsigned getIntParameter(unsigned i) const { return IntParams[i]; }
Context not available.

llvm/include/llvm/IR/IRBuilder.h

Context not available.
const Twine &Name = ""); const Twine &Name = "");
/// Conveninence function for the common case when CallArgs are filled /// Conveninence function for the common case when CallArgs are filled
/// in using makeArrayRef(CS.arg_begin(), CS.arg_end()); Use needs to be /// in using ArrayRef(CS.arg_begin(), CS.arg_end()); Use needs to be
/// .get()'ed to get the Value pointer. /// .get()'ed to get the Value pointer.
CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes, CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes,
FunctionCallee ActualCallee, FunctionCallee ActualCallee,
Context not available.
const Twine &Name = ""); const Twine &Name = "");
// Convenience function for the common case when CallArgs are filled in using // Convenience function for the common case when CallArgs are filled in using
// makeArrayRef(CS.arg_begin(), CS.arg_end()); Use needs to be .get()'ed to // ArrayRef(CS.arg_begin(), CS.arg_end()); Use needs to be .get()'ed to
// get the Value *. // get the Value *.
InvokeInst * InvokeInst *
CreateGCStatepointInvoke(uint64_t ID, uint32_t NumPatchBytes, CreateGCStatepointInvoke(uint64_t ID, uint32_t NumPatchBytes,
Context not available.
if (MDSrc) { if (MDSrc) {
unsigned WL[4] = {LLVMContext::MD_prof, LLVMContext::MD_unpredictable, unsigned WL[4] = {LLVMContext::MD_prof, LLVMContext::MD_unpredictable,
LLVMContext::MD_make_implicit, LLVMContext::MD_dbg}; LLVMContext::MD_make_implicit, LLVMContext::MD_dbg};
Br->copyMetadata(*MDSrc, makeArrayRef(&WL[0], 4)); Br->copyMetadata(*MDSrc, ArrayRef(&WL[0], 4));
} }
return Insert(Br); return Insert(Br);
} }
Context not available.

llvm/include/llvm/IR/Instruction.h

Context not available.
return dropUnknownNonDebugMetadata(std::nullopt); return dropUnknownNonDebugMetadata(std::nullopt);
} }
void dropUnknownNonDebugMetadata(unsigned ID1) { void dropUnknownNonDebugMetadata(unsigned ID1) {
return dropUnknownNonDebugMetadata(makeArrayRef(ID1)); return dropUnknownNonDebugMetadata(ArrayRef(ID1));
} }
void dropUnknownNonDebugMetadata(unsigned ID1, unsigned ID2) { void dropUnknownNonDebugMetadata(unsigned ID1, unsigned ID2) {
unsigned IDs[] = {ID1, ID2}; unsigned IDs[] = {ID1, ID2};
Context not available.

llvm/include/llvm/IR/Metadata.h

Context not available.
ArrayRef<MDOperand> operands() const { ArrayRef<MDOperand> operands() const {
if (IsLarge) if (IsLarge)
return getLarge(); return getLarge();
return makeArrayRef(reinterpret_cast<const MDOperand *>(this) - SmallSize, return ArrayRef(reinterpret_cast<const MDOperand *>(this) - SmallSize,
SmallNumOps); SmallNumOps);
} }
unsigned getNumOperands() const { unsigned getNumOperands() const {
Context not available.

llvm/include/llvm/IR/PredIteratorCache.h

Context not available.
public: public:
size_t size(BasicBlock *BB) const { return GetNumPreds(BB); } size_t size(BasicBlock *BB) const { return GetNumPreds(BB); }
ArrayRef<BasicBlock *> get(BasicBlock *BB) { ArrayRef<BasicBlock *> get(BasicBlock *BB) {
return makeArrayRef(GetPreds(BB), GetNumPreds(BB)); return ArrayRef(GetPreds(BB), GetNumPreds(BB));
} }
/// clear - Remove all information. /// clear - Remove all information.
Context not available.

llvm/include/llvm/IR/Type.h

Context not available.
subtype_iterator subtype_begin() const { return ContainedTys; } subtype_iterator subtype_begin() const { return ContainedTys; }
subtype_iterator subtype_end() const { return &ContainedTys[NumContainedTys];} subtype_iterator subtype_end() const { return &ContainedTys[NumContainedTys];}
ArrayRef<Type*> subtypes() const { ArrayRef<Type*> subtypes() const {
return makeArrayRef(subtype_begin(), subtype_end()); return ArrayRef(subtype_begin(), subtype_end());
} }
using subtype_reverse_iterator = std::reverse_iterator<subtype_iterator>; using subtype_reverse_iterator = std::reverse_iterator<subtype_iterator>;
Context not available.

llvm/include/llvm/Object/ELF.h

Context not available.
Expected<Elf_Sym_Range> symbols(const Elf_Shdr *Sec) const { Expected<Elf_Sym_Range> symbols(const Elf_Shdr *Sec) const {
if (!Sec) if (!Sec)
return makeArrayRef<Elf_Sym>(nullptr, nullptr); return ArrayRef<Elf_Sym>(nullptr, nullptr);
return getSectionContentsAsArray<Elf_Sym>(*Sec); return getSectionContentsAsArray<Elf_Sym>(*Sec);
} }
Context not available.
", e_phentsize = " + Twine(getHeader().e_phentsize)); ", e_phentsize = " + Twine(getHeader().e_phentsize));
auto *Begin = reinterpret_cast<const Elf_Phdr *>(base() + PhOff); auto *Begin = reinterpret_cast<const Elf_Phdr *>(base() + PhOff);
return makeArrayRef(Begin, Begin + getHeader().e_phnum); return ArrayRef(Begin, Begin + getHeader().e_phnum);
} }
/// Get an iterator over notes in a program header. /// Get an iterator over notes in a program header.
Context not available.
return createError("unaligned data"); return createError("unaligned data");
const T *Start = reinterpret_cast<const T *>(base() + Offset); const T *Start = reinterpret_cast<const T *>(base() + Offset);
return makeArrayRef(Start, Size / sizeof(T)); return ArrayRef(Start, Size / sizeof(T));
} }
template <class ELFT> template <class ELFT>
Context not available.
") + p_filesz (0x" + Twine::utohexstr(Size) + ") + p_filesz (0x" + Twine::utohexstr(Size) +
") that is greater than the file size (0x" + ") that is greater than the file size (0x" +
Twine::utohexstr(Buf.size()) + ")"); Twine::utohexstr(Buf.size()) + ")");
return makeArrayRef(base() + Offset, Size); return ArrayRef(base() + Offset, Size);
} }
template <class ELFT> template <class ELFT>
Context not available.
const uintX_t SectionTableOffset = getHeader().e_shoff; const uintX_t SectionTableOffset = getHeader().e_shoff;
if (SectionTableOffset == 0) { if (SectionTableOffset == 0) {
if (!FakeSections.empty()) if (!FakeSections.empty())
return makeArrayRef(FakeSections.data(), FakeSections.size()); return ArrayRef(FakeSections.data(), FakeSections.size());
return ArrayRef<Elf_Shdr>(); return ArrayRef<Elf_Shdr>();
} }
Context not available.
// Section table goes past end of file! // Section table goes past end of file!
if (SectionTableOffset + SectionTableSize > FileSize) if (SectionTableOffset + SectionTableSize > FileSize)
return createError("section table goes past the end of file"); return createError("section table goes past the end of file");
return makeArrayRef(First, NumSections); return ArrayRef(First, NumSections);
} }
template <class ELFT> template <class ELFT>
Context not available.

llvm/include/llvm/Object/ELFObjectFile.h

Context not available.
ELFObjectFile<ELFT>::getSectionContents(DataRefImpl Sec) const { ELFObjectFile<ELFT>::getSectionContents(DataRefImpl Sec) const {
const Elf_Shdr *EShdr = getSection(Sec); const Elf_Shdr *EShdr = getSection(Sec);
if (EShdr->sh_type == ELF::SHT_NOBITS) if (EShdr->sh_type == ELF::SHT_NOBITS)
return makeArrayRef((const uint8_t *)base(), 0); return ArrayRef((const uint8_t *)base(), (size_t)0);
if (Error E = if (Error E =
checkOffset(getMemoryBufferRef(), checkOffset(getMemoryBufferRef(),
(uintptr_t)base() + EShdr->sh_offset, EShdr->sh_size)) (uintptr_t)base() + EShdr->sh_offset, EShdr->sh_size))
return std::move(E); return std::move(E);
return makeArrayRef((const uint8_t *)base() + EShdr->sh_offset, return ArrayRef((const uint8_t *)base() + EShdr->sh_offset, EShdr->sh_size);
EShdr->sh_size);
} }
template <class ELFT> template <class ELFT>
Context not available.

llvm/include/llvm/Support/ARMWinEH.h

Context not available.
ArrayRef<support::ulittle32_t> EpilogueScopes() const { ArrayRef<support::ulittle32_t> EpilogueScopes() const {
assert(E() == 0 && "epilogue scopes are only present when the E bit is 0"); assert(E() == 0 && "epilogue scopes are only present when the E bit is 0");
size_t Offset = HeaderWords(*this); size_t Offset = HeaderWords(*this);
return makeArrayRef(&Data[Offset], EpilogueCount()); return ArrayRef(&Data[Offset], EpilogueCount());
} }
ArrayRef<uint8_t> UnwindByteCode() const { ArrayRef<uint8_t> UnwindByteCode() const {
Context not available.
+ (E() ? 0 : EpilogueCount()); + (E() ? 0 : EpilogueCount());
const uint8_t *ByteCode = const uint8_t *ByteCode =
reinterpret_cast<const uint8_t *>(&Data[Offset]); reinterpret_cast<const uint8_t *>(&Data[Offset]);
return makeArrayRef(ByteCode, CodeWords() * sizeof(uint32_t)); return ArrayRef(ByteCode, CodeWords() * sizeof(uint32_t));
} }
uint32_t ExceptionHandlerRVA() const { uint32_t ExceptionHandlerRVA() const {
Context not available.

llvm/include/llvm/Support/BinaryByteStream.h

Context not available.
if (auto EC = checkOffsetForWrite(Offset, Buffer.size())) if (auto EC = checkOffsetForWrite(Offset, Buffer.size()))
return EC; return EC;
Buffer = makeArrayRef(Data).slice(Offset, Size); Buffer = ArrayRef(Data).slice(Offset, Size);
return Error::success(); return Error::success();
} }
Context not available.
if (auto EC = checkOffsetForWrite(Offset, 1)) if (auto EC = checkOffsetForWrite(Offset, 1))
return EC; return EC;
Buffer = makeArrayRef(Data).slice(Offset); Buffer = ArrayRef(Data).slice(Offset);
return Error::success(); return Error::success();
} }
Context not available.

llvm/include/llvm/Support/HashBuilder.h

Context not available.
/// Users of this function should pay attention to respect endianness /// Users of this function should pay attention to respect endianness
/// contraints. /// contraints.
void update(StringRef Data) { void update(StringRef Data) {
update(makeArrayRef(reinterpret_cast<const uint8_t *>(Data.data()), update(
Data.size())); ArrayRef(reinterpret_cast<const uint8_t *>(Data.data()), Data.size()));
} }
/// Forward to `HasherT::final()` if available. /// Forward to `HasherT::final()` if available.
Context not available.
add(Value.size()); add(Value.size());
if (hashbuilder_detail::IsHashableData<T>::value && if (hashbuilder_detail::IsHashableData<T>::value &&
Endianness == support::endian::system_endianness()) { Endianness == support::endian::system_endianness()) {
this->update( this->update(ArrayRef(reinterpret_cast<const uint8_t *>(Value.begin()),
makeArrayRef(reinterpret_cast<const uint8_t *>(Value.begin()), Value.size() * sizeof(T)));
Value.size() * sizeof(T)));
} else { } else {
for (auto &V : Value) for (auto &V : Value)
add(V); add(V);
Context not available.
// `StringRef::begin()` and `StringRef::end()`. Explicitly call `update` to // `StringRef::begin()` and `StringRef::end()`. Explicitly call `update` to
// guarantee the fast path. // guarantee the fast path.
add(Value.size()); add(Value.size());
this->update(makeArrayRef(reinterpret_cast<const uint8_t *>(Value.begin()), this->update(ArrayRef(reinterpret_cast<const uint8_t *>(Value.begin()),
Value.size())); Value.size()));
return *this; return *this;
} }
Context not available.
/// friend void addHash(HashBuilderImpl<HasherT, Endianness> &HBuilder, /// friend void addHash(HashBuilderImpl<HasherT, Endianness> &HBuilder,
/// const StructWithFastHash &Value) { /// const StructWithFastHash &Value) {
/// if (Endianness == support::endian::system_endianness()) { /// if (Endianness == support::endian::system_endianness()) {
/// HBuilder.update(makeArrayRef( /// HBuilder.update(ArrayRef(
/// reinterpret_cast<const uint8_t *>(&Value), sizeof(Value))); /// reinterpret_cast<const uint8_t *>(&Value), sizeof(Value)));
/// } else { /// } else {
/// // Rely on existing `add` methods to handle endianness. /// // Rely on existing `add` methods to handle endianness.
Context not available.
/// friend void addHash(HashBuilderImpl<HasherT, Endianness> &HBuilder, /// friend void addHash(HashBuilderImpl<HasherT, Endianness> &HBuilder,
/// const CustomContainer &Value) { /// const CustomContainer &Value) {
/// if (Endianness == support::endian::system_endianness()) { /// if (Endianness == support::endian::system_endianness()) {
/// HBuilder.update(makeArrayRef( /// HBuilder.update(ArrayRef(
/// reinterpret_cast<const uint8_t *>(&Value.Size), /// reinterpret_cast<const uint8_t *>(&Value.Size),
/// sizeof(Value.Size) + Value.Size * sizeof(Value.Elements[0]))); /// sizeof(Value.Size) + Value.Size * sizeof(Value.Elements[0])));
/// } else { /// } else {
Context not available.
std::enable_if_t<is_detected<HasByteSwapT, T>::value, HashBuilderImpl &> std::enable_if_t<is_detected<HasByteSwapT, T>::value, HashBuilderImpl &>
adjustForEndiannessAndAdd(const T &Value) { adjustForEndiannessAndAdd(const T &Value) {
T SwappedValue = support::endian::byte_swap(Value, Endianness); T SwappedValue = support::endian::byte_swap(Value, Endianness);
this->update(makeArrayRef(reinterpret_cast<const uint8_t *>(&SwappedValue), this->update(ArrayRef(reinterpret_cast<const uint8_t *>(&SwappedValue),
sizeof(SwappedValue))); sizeof(SwappedValue)));
return *this; return *this;
} }
Context not available.
Endianness == support::endian::system_endianness(), Endianness == support::endian::system_endianness(),
HashBuilderImpl &> HashBuilderImpl &>
addRangeElementsImpl(T *First, T *Last, std::forward_iterator_tag) { addRangeElementsImpl(T *First, T *Last, std::forward_iterator_tag) {
this->update(makeArrayRef(reinterpret_cast<const uint8_t *>(First), this->update(ArrayRef(reinterpret_cast<const uint8_t *>(First),
(Last - First) * sizeof(T))); (Last - First) * sizeof(T)));
return *this; return *this;
} }
}; };
Context not available.

llvm/include/llvm/Support/ScopedPrinter.h

Context not available.
} }
void printBinary(StringRef Label, StringRef Str, ArrayRef<char> Value) { void printBinary(StringRef Label, StringRef Str, ArrayRef<char> Value) {
auto V = makeArrayRef(reinterpret_cast<const uint8_t *>(Value.data()), auto V =
Value.size()); ArrayRef(reinterpret_cast<const uint8_t *>(Value.data()), Value.size());
printBinaryImpl(Label, Str, V, false); printBinaryImpl(Label, Str, V, false);
} }
Context not available.
} }
void printBinary(StringRef Label, ArrayRef<char> Value) { void printBinary(StringRef Label, ArrayRef<char> Value) {
auto V = makeArrayRef(reinterpret_cast<const uint8_t *>(Value.data()), auto V =
Value.size()); ArrayRef(reinterpret_cast<const uint8_t *>(Value.data()), Value.size());
printBinaryImpl(Label, StringRef(), V, false); printBinaryImpl(Label, StringRef(), V, false);
} }
void printBinary(StringRef Label, StringRef Value) { void printBinary(StringRef Label, StringRef Value) {
auto V = makeArrayRef(reinterpret_cast<const uint8_t *>(Value.data()), auto V =
Value.size()); ArrayRef(reinterpret_cast<const uint8_t *>(Value.data()), Value.size());
printBinaryImpl(Label, StringRef(), V, false); printBinaryImpl(Label, StringRef(), V, false);
} }
Context not available.
} }
void printBinaryBlock(StringRef Label, StringRef Value) { void printBinaryBlock(StringRef Label, StringRef Value) {
auto V = makeArrayRef(reinterpret_cast<const uint8_t *>(Value.data()), auto V =
Value.size()); ArrayRef(reinterpret_cast<const uint8_t *>(Value.data()), Value.size());
printBinaryImpl(Label, StringRef(), V, true); printBinaryImpl(Label, StringRef(), V, true);
} }
Context not available.

llvm/include/llvm/TableGen/Record.h

Context not available.
void Profile(FoldingSetNodeID &ID) const; void Profile(FoldingSetNodeID &ID) const;
ArrayRef<Record *> getClasses() const { ArrayRef<Record *> getClasses() const {
return makeArrayRef(getTrailingObjects<Record *>(), NumClasses); return ArrayRef(getTrailingObjects<Record *>(), NumClasses);
} }
using const_record_iterator = Record * const *; using const_record_iterator = Record * const *;
Context not available.
std::string getAsString() const override; std::string getAsString() const override;
ArrayRef<Init*> getValues() const { ArrayRef<Init*> getValues() const {
return makeArrayRef(getTrailingObjects<Init *>(), NumValues); return ArrayRef(getTrailingObjects<Init *>(), NumValues);
} }
const_iterator begin() const { return getTrailingObjects<Init *>(); } const_iterator begin() const { return getTrailingObjects<Init *>(); }
Context not available.
} }
ArrayRef<Init *> getConds() const { ArrayRef<Init *> getConds() const {
return makeArrayRef(getTrailingObjects<Init *>(), NumConds); return ArrayRef(getTrailingObjects<Init *>(), NumConds);
} }
ArrayRef<Init *> getVals() const { ArrayRef<Init *> getVals() const {
return makeArrayRef(getTrailingObjects<Init *>()+NumConds, NumConds); return ArrayRef(getTrailingObjects<Init *>() + NumConds, NumConds);
} }
Init *Fold(Record *CurRec) const; Init *Fold(Record *CurRec) const;
Context not available.
size_t args_size () const { return NumArgs; } size_t args_size () const { return NumArgs; }
bool args_empty() const { return NumArgs == 0; } bool args_empty() const { return NumArgs == 0; }
ArrayRef<Init *> args() const { return makeArrayRef(args_begin(), NumArgs); } ArrayRef<Init *> args() const { return ArrayRef(args_begin(), NumArgs); }
Init *getBit(unsigned Bit) const override { Init *getBit(unsigned Bit) const override {
llvm_unreachable("Illegal bit reference off anonymous def"); llvm_unreachable("Illegal bit reference off anonymous def");
Context not available.
} }
ArrayRef<Init *> getArgs() const { ArrayRef<Init *> getArgs() const {
return makeArrayRef(getTrailingObjects<Init *>(), NumArgs); return ArrayRef(getTrailingObjects<Init *>(), NumArgs);
} }
ArrayRef<StringInit *> getArgNames() const { ArrayRef<StringInit *> getArgNames() const {
return makeArrayRef(getTrailingObjects<StringInit *>(), NumArgNames); return ArrayRef(getTrailingObjects<StringInit *>(), NumArgNames);
} }
Init *resolveReferences(Resolver &R) const override; Init *resolveReferences(Resolver &R) const override;
Context not available.

llvm/lib/Analysis/ConstantFolding.cpp

Context not available.
return nullptr; return nullptr;
unsigned BitWidth = DL.getTypeSizeInBits(IntIdxTy); unsigned BitWidth = DL.getTypeSizeInBits(IntIdxTy);
APInt Offset = APInt Offset = APInt(
APInt(BitWidth, BitWidth,
DL.getIndexedOffsetInType( DL.getIndexedOffsetInType(
SrcElemTy, SrcElemTy, ArrayRef((Value *const *)Ops.data() + 1, Ops.size() - 1)));
makeArrayRef((Value * const *)Ops.data() + 1, Ops.size() - 1)));
Ptr = StripPtrCastKeepAS(Ptr); Ptr = StripPtrCastKeepAS(Ptr);
// If this is a GEP of a GEP, fold it all into a single GEP. // If this is a GEP of a GEP, fold it all into a single GEP.
Context not available.

llvm/lib/Analysis/ConstraintSystem.cpp

Context not available.
bool ConstraintSystem::isConditionImplied(SmallVector<int64_t, 8> R) const { bool ConstraintSystem::isConditionImplied(SmallVector<int64_t, 8> R) const {
// If all variable coefficients are 0, we have 'C >= 0'. If the constant is >= // If all variable coefficients are 0, we have 'C >= 0'. If the constant is >=
// 0, R is always true, regardless of the system. // 0, R is always true, regardless of the system.
if (all_of(makeArrayRef(R).drop_front(1), [](int64_t C) { return C == 0; })) if (all_of(ArrayRef(R).drop_front(1), [](int64_t C) { return C == 0; }))
return R[0] >= 0; return R[0] >= 0;
// If there is no solution with the negation of R added to the system, the // If there is no solution with the negation of R added to the system, the
Context not available.

llvm/lib/Analysis/InstructionSimplify.cpp

Context not available.
if (auto *GEP = dyn_cast<GetElementPtrInst>(I)) if (auto *GEP = dyn_cast<GetElementPtrInst>(I))
return PreventSelfSimplify(simplifyGEPInst( return PreventSelfSimplify(simplifyGEPInst(
GEP->getSourceElementType(), NewOps[0], makeArrayRef(NewOps).slice(1), GEP->getSourceElementType(), NewOps[0], ArrayRef(NewOps).slice(1),
GEP->isInBounds(), Q, MaxRecurse - 1)); GEP->isInBounds(), Q, MaxRecurse - 1));
if (isa<SelectInst>(I)) if (isa<SelectInst>(I))
Context not available.
case Instruction::GetElementPtr: { case Instruction::GetElementPtr: {
auto *GEPI = cast<GetElementPtrInst>(I); auto *GEPI = cast<GetElementPtrInst>(I);
return simplifyGEPInst(GEPI->getSourceElementType(), NewOps[0], return simplifyGEPInst(GEPI->getSourceElementType(), NewOps[0],
makeArrayRef(NewOps).slice(1), GEPI->isInBounds(), ArrayRef(NewOps).slice(1), GEPI->isInBounds(), Q);
Q);
} }
case Instruction::InsertValue: { case Instruction::InsertValue: {
InsertValueInst *IV = cast<InsertValueInst>(I); InsertValueInst *IV = cast<InsertValueInst>(I);
Context not available.

llvm/lib/Analysis/LazyCallGraph.cpp

Context not available.
// Run the user's callback on the merged SCCs before we actually merge them. // Run the user's callback on the merged SCCs before we actually merge them.
if (MergeCB) if (MergeCB)
MergeCB(makeArrayRef(MergeRange.begin(), MergeRange.end())); MergeCB(ArrayRef(MergeRange.begin(), MergeRange.end()));
// If the merge range is empty, then adding the edge didn't actually form any // If the merge range is empty, then adding the edge didn't actually form any
// new cycles. We're done. // new cycles. We're done.
Context not available.

llvm/lib/Analysis/PHITransAddr.cpp

Context not available.
} }
GetElementPtrInst *Result = GetElementPtrInst::Create( GetElementPtrInst *Result = GetElementPtrInst::Create(
GEP->getSourceElementType(), GEPOps[0], makeArrayRef(GEPOps).slice(1), GEP->getSourceElementType(), GEPOps[0], ArrayRef(GEPOps).slice(1),
InVal->getName() + ".phi.trans.insert", PredBB->getTerminator()); InVal->getName() + ".phi.trans.insert", PredBB->getTerminator());
Result->setDebugLoc(Inst->getDebugLoc()); Result->setDebugLoc(Inst->getDebugLoc());
Result->setIsInBounds(GEP->isInBounds()); Result->setIsInBounds(GEP->isInBounds());
Context not available.

llvm/lib/Analysis/ValueTracking.cpp

Context not available.
return nullptr; return nullptr;
// Insert the value in the new (sub) aggregate // Insert the value in the new (sub) aggregate
return InsertValueInst::Create(To, V, makeArrayRef(Idxs).slice(IdxSkip), return InsertValueInst::Create(To, V, ArrayRef(Idxs).slice(IdxSkip), "tmp",
"tmp", InsertBefore); InsertBefore);
} }
// This helper takes a nested struct and extracts a part of it (which is again a // This helper takes a nested struct and extracts a part of it (which is again a
Context not available.
// %C = insertvalue {i32, i32 } %A, i32 11, 1 // %C = insertvalue {i32, i32 } %A, i32 11, 1
// which allows the unused 0,0 element from the nested struct to be // which allows the unused 0,0 element from the nested struct to be
// removed. // removed.
return BuildSubAggregate(V, makeArrayRef(idx_range.begin(), req_idx), return BuildSubAggregate(V, ArrayRef(idx_range.begin(), req_idx),
InsertBefore); InsertBefore);
} }
Context not available.
// requested (though possibly only partially). Now we recursively look at // requested (though possibly only partially). Now we recursively look at
// the inserted value, passing any remaining indices. // the inserted value, passing any remaining indices.
return FindInsertedValue(I->getInsertedValueOperand(), return FindInsertedValue(I->getInsertedValueOperand(),
makeArrayRef(req_idx, idx_range.end()), ArrayRef(req_idx, idx_range.end()), InsertBefore);
InsertBefore);
} }
if (ExtractValueInst *I = dyn_cast<ExtractValueInst>(V)) { if (ExtractValueInst *I = dyn_cast<ExtractValueInst>(V)) {
Context not available.

llvm/lib/AsmParser/LLParser.cpp

Context not available.
" of struct initializer doesn't match struct element type"); " of struct initializer doesn't match struct element type");
V = ConstantStruct::get( V = ConstantStruct::get(
ST, makeArrayRef(ID.ConstantStructElts.get(), ID.UIntVal)); ST, ArrayRef(ID.ConstantStructElts.get(), ID.UIntVal));
} else } else
return error(ID.Loc, "constant expression type mismatch"); return error(ID.Loc, "constant expression type mismatch");
return false; return false;
Context not available.

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

Context not available.
static bool classof(const Value *V) { return V->getValueID() == SubclassID; } static bool classof(const Value *V) { return V->getValueID() == SubclassID; }
ArrayRef<unsigned> getOperandIDs() const { ArrayRef<unsigned> getOperandIDs() const {
return makeArrayRef(getTrailingObjects<unsigned>(), NumOperands); return ArrayRef(getTrailingObjects<unsigned>(), NumOperands);
} }
std::optional<unsigned> getInRangeIndex() const { std::optional<unsigned> getInRangeIndex() const {
Context not available.
C = ConstantExpr::getCompare(BC->Flags, ConstOps[0], ConstOps[1]); C = ConstantExpr::getCompare(BC->Flags, ConstOps[0], ConstOps[1]);
break; break;
case Instruction::GetElementPtr: case Instruction::GetElementPtr:
C = ConstantExpr::getGetElementPtr( C = ConstantExpr::getGetElementPtr(BC->SrcElemTy, ConstOps[0],
BC->SrcElemTy, ConstOps[0], makeArrayRef(ConstOps).drop_front(), ArrayRef(ConstOps).drop_front(),
BC->Flags, BC->getInRangeIndex()); BC->Flags, BC->getInRangeIndex());
break; break;
case Instruction::Select: case Instruction::Select:
C = ConstantExpr::getSelect(ConstOps[0], ConstOps[1], ConstOps[2]); C = ConstantExpr::getSelect(ConstOps[0], ConstOps[1], ConstOps[2]);
Context not available.
break; break;
case Instruction::GetElementPtr: case Instruction::GetElementPtr:
I = GetElementPtrInst::Create(BC->SrcElemTy, Ops[0], I = GetElementPtrInst::Create(BC->SrcElemTy, Ops[0],
makeArrayRef(Ops).drop_front(), ArrayRef(Ops).drop_front(), "constexpr",
"constexpr", InsertBB); InsertBB);
if (BC->Flags) if (BC->Flags)
cast<GetElementPtrInst>(I)->setIsInBounds(); cast<GetElementPtrInst>(I)->setIsInBounds();
break; break;
Context not available.
unsigned ActiveWords = 1; unsigned ActiveWords = 1;
if (ValueBitWidth > 64) if (ValueBitWidth > 64)
ActiveWords = Record[CurIdx++]; ActiveWords = Record[CurIdx++];
Low = readWideAPInt(makeArrayRef(&Record[CurIdx], ActiveWords), Low = readWideAPInt(ArrayRef(&Record[CurIdx], ActiveWords),
ValueBitWidth); ValueBitWidth);
CurIdx += ActiveWords; CurIdx += ActiveWords;
Context not available.
ActiveWords = 1; ActiveWords = 1;
if (ValueBitWidth > 64) if (ValueBitWidth > 64)
ActiveWords = Record[CurIdx++]; ActiveWords = Record[CurIdx++];
APInt High = readWideAPInt( APInt High = readWideAPInt(ArrayRef(&Record[CurIdx], ActiveWords),
makeArrayRef(&Record[CurIdx], ActiveWords), ValueBitWidth); ValueBitWidth);
CurIdx += ActiveWords; CurIdx += ActiveWords;
// FIXME: It is not clear whether values in the range should be // FIXME: It is not clear whether values in the range should be
Context not available.

llvm/lib/Bitcode/Reader/MetadataLoader.cpp

Context not available.
if (IsBigInt) { if (IsBigInt) {
const uint64_t BitWidth = Record[1]; const uint64_t BitWidth = Record[1];
const size_t NumWords = Record.size() - 3; const size_t NumWords = Record.size() - 3;
Value = readWideAPInt(makeArrayRef(&Record[3], NumWords), BitWidth); Value = readWideAPInt(ArrayRef(&Record[3], NumWords), BitWidth);
} else } else
Value = APInt(64, unrotateSign(Record[1]), !IsUnsigned); Value = APInt(64, unrotateSign(Record[1]), !IsUnsigned);
Context not available.

llvm/lib/Bitcode/Writer/ValueEnumerator.h

Context not available.
/// Get the MDString metadata for this block. /// Get the MDString metadata for this block.
ArrayRef<const Metadata *> getMDStrings() const { ArrayRef<const Metadata *> getMDStrings() const {
return makeArrayRef(MDs).slice(NumModuleMDs, NumMDStrings); return ArrayRef(MDs).slice(NumModuleMDs, NumMDStrings);
} }
/// Get the non-MDString metadata for this block. /// Get the non-MDString metadata for this block.
ArrayRef<const Metadata *> getNonMDStrings() const { ArrayRef<const Metadata *> getNonMDStrings() const {
return makeArrayRef(MDs).slice(NumModuleMDs).slice(NumMDStrings); return ArrayRef(MDs).slice(NumModuleMDs).slice(NumMDStrings);
} }
const TypeList &getTypes() const { return Types; } const TypeList &getTypes() const { return Types; }
Context not available.

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

Context not available.
TypeIndex ReturnTypeIndex = TypeIndex::Void(); TypeIndex ReturnTypeIndex = TypeIndex::Void();
ArrayRef<TypeIndex> ArgTypeIndices = std::nullopt; ArrayRef<TypeIndex> ArgTypeIndices = std::nullopt;
if (!ReturnAndArgTypeIndices.empty()) { if (!ReturnAndArgTypeIndices.empty()) {
auto ReturnAndArgTypesRef = makeArrayRef(ReturnAndArgTypeIndices); auto ReturnAndArgTypesRef = ArrayRef(ReturnAndArgTypeIndices);
ReturnTypeIndex = ReturnAndArgTypesRef.front(); ReturnTypeIndex = ReturnAndArgTypesRef.front();
ArgTypeIndices = ReturnAndArgTypesRef.drop_front(); ArgTypeIndices = ReturnAndArgTypesRef.drop_front();
} }
Context not available.

llvm/lib/CodeGen/AsmPrinter/DIEHash.cpp

Context not available.
void DIEHash::addString(StringRef Str) { void DIEHash::addString(StringRef Str) {
LLVM_DEBUG(dbgs() << "Adding string " << Str << " to hash.\n"); LLVM_DEBUG(dbgs() << "Adding string " << Str << " to hash.\n");
Hash.update(Str); Hash.update(Str);
Hash.update(makeArrayRef((uint8_t)'\0')); Hash.update(ArrayRef((uint8_t)'\0'));
} }
// FIXME: The LEB128 routines are copied and only slightly modified out of // FIXME: The LEB128 routines are copied and only slightly modified out of
Context not available.
} }
// Following the last (or if there are no children), append a zero byte. // Following the last (or if there are no children), append a zero byte.
Hash.update(makeArrayRef((uint8_t)'\0')); Hash.update(ArrayRef((uint8_t)'\0'));
} }
/// This is based on the type signature computation given in section 7.27 of the /// This is based on the type signature computation given in section 7.27 of the
Context not available.

llvm/lib/CodeGen/AsmPrinter/DebugLocStream.h

Context not available.
ArrayRef<Entry> getEntries(const List &L) const { ArrayRef<Entry> getEntries(const List &L) const {
size_t LI = getIndex(L); size_t LI = getIndex(L);
return makeArrayRef(Entries) return ArrayRef(Entries).slice(Lists[LI].EntryOffset, getNumEntries(LI));
.slice(Lists[LI].EntryOffset, getNumEntries(LI));
} }
ArrayRef<char> getBytes(const Entry &E) const { ArrayRef<char> getBytes(const Entry &E) const {
size_t EI = getIndex(E); size_t EI = getIndex(E);
return makeArrayRef(DWARFBytes.begin(), DWARFBytes.end()) return ArrayRef(DWARFBytes.begin(), DWARFBytes.end())
.slice(Entries[EI].ByteOffset, getNumBytes(EI)); .slice(Entries[EI].ByteOffset, getNumBytes(EI));
} }
ArrayRef<std::string> getComments(const Entry &E) const { ArrayRef<std::string> getComments(const Entry &E) const {
size_t EI = getIndex(E); size_t EI = getIndex(E);
return makeArrayRef(Comments) return ArrayRef(Comments).slice(Entries[EI].CommentOffset,
.slice(Entries[EI].CommentOffset, getNumComments(EI)); getNumComments(EI));
} }
private: private:
Context not available.

llvm/lib/CodeGen/AtomicExpandPass.cpp

Context not available.
case AtomicRMWInst::BAD_BINOP: case AtomicRMWInst::BAD_BINOP:
llvm_unreachable("Should not have BAD_BINOP."); llvm_unreachable("Should not have BAD_BINOP.");
case AtomicRMWInst::Xchg: case AtomicRMWInst::Xchg:
return makeArrayRef(LibcallsXchg); return ArrayRef(LibcallsXchg);
case AtomicRMWInst::Add: case AtomicRMWInst::Add:
return makeArrayRef(LibcallsAdd); return ArrayRef(LibcallsAdd);
case AtomicRMWInst::Sub: case AtomicRMWInst::Sub:
return makeArrayRef(LibcallsSub); return ArrayRef(LibcallsSub);
case AtomicRMWInst::And: case AtomicRMWInst::And:
return makeArrayRef(LibcallsAnd); return ArrayRef(LibcallsAnd);
case AtomicRMWInst::Or: case AtomicRMWInst::Or:
return makeArrayRef(LibcallsOr); return ArrayRef(LibcallsOr);
case AtomicRMWInst::Xor: case AtomicRMWInst::Xor:
return makeArrayRef(LibcallsXor); return ArrayRef(LibcallsXor);
case AtomicRMWInst::Nand: case AtomicRMWInst::Nand:
return makeArrayRef(LibcallsNand); return ArrayRef(LibcallsNand);
case AtomicRMWInst::Max: case AtomicRMWInst::Max:
case AtomicRMWInst::Min: case AtomicRMWInst::Min:
case AtomicRMWInst::UMax: case AtomicRMWInst::UMax:
Context not available.

llvm/lib/CodeGen/CodeGenPrepare.cpp

Context not available.
} }
Value *Replacement = Value *Replacement =
Builder.CreateGEP(Derived->getSourceElementType(), ActualRelocatedBase, Builder.CreateGEP(Derived->getSourceElementType(), ActualRelocatedBase,
makeArrayRef(OffsetV)); ArrayRef(OffsetV));
Replacement->takeName(ToReplace); Replacement->takeName(ToReplace);
// If the newly generated derived pointer's type does not match the original // If the newly generated derived pointer's type does not match the original
// derived pointer's type, cast the new derived pointer to match it. Same // derived pointer's type, cast the new derived pointer to match it. Same
Context not available.
// If the final index isn't a vector, emit a scalar GEP containing all ops // If the final index isn't a vector, emit a scalar GEP containing all ops
// and a vector GEP with all zeroes final index. // and a vector GEP with all zeroes final index.
if (!Ops[FinalIndex]->getType()->isVectorTy()) { if (!Ops[FinalIndex]->getType()->isVectorTy()) {
NewAddr = NewAddr = Builder.CreateGEP(SourceTy, Ops[0], ArrayRef(Ops).drop_front());
Builder.CreateGEP(SourceTy, Ops[0], makeArrayRef(Ops).drop_front());
auto *IndexTy = VectorType::get(ScalarIndexTy, NumElts); auto *IndexTy = VectorType::get(ScalarIndexTy, NumElts);
auto *SecondTy = GetElementPtrInst::getIndexedType( auto *SecondTy = GetElementPtrInst::getIndexedType(
SourceTy, makeArrayRef(Ops).drop_front()); SourceTy, ArrayRef(Ops).drop_front());
NewAddr = NewAddr =
Builder.CreateGEP(SecondTy, NewAddr, Constant::getNullValue(IndexTy)); Builder.CreateGEP(SecondTy, NewAddr, Constant::getNullValue(IndexTy));
} else { } else {
Context not available.
if (Ops.size() != 2) { if (Ops.size() != 2) {
// Replace the last index with 0. // Replace the last index with 0.
Ops[FinalIndex] = Constant::getNullValue(ScalarIndexTy); Ops[FinalIndex] = Constant::getNullValue(ScalarIndexTy);
Base = Base = Builder.CreateGEP(SourceTy, Base, ArrayRef(Ops).drop_front());
Builder.CreateGEP(SourceTy, Base, makeArrayRef(Ops).drop_front());
SourceTy = GetElementPtrInst::getIndexedType( SourceTy = GetElementPtrInst::getIndexedType(
SourceTy, makeArrayRef(Ops).drop_front()); SourceTy, ArrayRef(Ops).drop_front());
} }
// Now create the GEP with scalar pointer and vector index. // Now create the GEP with scalar pointer and vector index.
Context not available.

llvm/lib/CodeGen/GlobalISel/CallLowering.cpp

Context not available.
if (VA.needsCustom()) { if (VA.needsCustom()) {
std::function<void()> Thunk; std::function<void()> Thunk;
unsigned NumArgRegs = Handler.assignCustomValue( unsigned NumArgRegs = Handler.assignCustomValue(
Args[i], makeArrayRef(ArgLocs).slice(j), &Thunk); Args[i], ArrayRef(ArgLocs).slice(j), &Thunk);
if (Thunk) if (Thunk)
DelayedOutgoingRegAssignments.emplace_back(Thunk); DelayedOutgoingRegAssignments.emplace_back(Thunk);
if (!NumArgRegs) if (!NumArgRegs)
Context not available.

llvm/lib/CodeGen/GlobalISel/IRTranslator.cpp

Context not available.
SwiftInVReg = MRI->createGenericVirtualRegister(Ty); SwiftInVReg = MRI->createGenericVirtualRegister(Ty);
MIRBuilder.buildCopy(SwiftInVReg, SwiftError.getOrCreateVRegUseAt( MIRBuilder.buildCopy(SwiftInVReg, SwiftError.getOrCreateVRegUseAt(
&CB, &MIRBuilder.getMBB(), Arg)); &CB, &MIRBuilder.getMBB(), Arg));
Args.emplace_back(makeArrayRef(SwiftInVReg)); Args.emplace_back(ArrayRef(SwiftInVReg));
SwiftErrorVReg = SwiftErrorVReg =
SwiftError.getOrCreateVRegDefAt(&CB, &MIRBuilder.getMBB(), Arg); SwiftError.getOrCreateVRegDefAt(&CB, &MIRBuilder.getMBB(), Arg);
continue; continue;
Context not available.

llvm/lib/CodeGen/GlobalISel/LegalizerHelper.cpp

Context not available.
CarryIn = CarryOut; CarryIn = CarryOut;
} }
insertParts(MI.getOperand(0).getReg(), RegTy, NarrowTy, insertParts(MI.getOperand(0).getReg(), RegTy, NarrowTy,
makeArrayRef(DstRegs).take_front(NarrowParts), LeftoverTy, ArrayRef(DstRegs).take_front(NarrowParts), LeftoverTy,
makeArrayRef(DstRegs).drop_front(NarrowParts)); ArrayRef(DstRegs).drop_front(NarrowParts));
MI.eraseFromParent(); MI.eraseFromParent();
return Legalized; return Legalized;
Context not available.

llvm/lib/CodeGen/InterleavedLoadCombinePass.cpp

Context not available.
ConstantInt::get(Type::getInt32Ty(LI->getContext()), 0), ConstantInt::get(Type::getInt32Ty(LI->getContext()), 0),
ConstantInt::get(Type::getInt32Ty(LI->getContext()), i), ConstantInt::get(Type::getInt32Ty(LI->getContext()), i),
}; };
int64_t Ofs = DL.getIndexedOffsetInType(Result.VTy, makeArrayRef(Idx, 2)); int64_t Ofs = DL.getIndexedOffsetInType(Result.VTy, ArrayRef(Idx, 2));
Result.EI[i] = ElementInfo(Offset + Ofs, i == 0 ? LI : nullptr); Result.EI[i] = ElementInfo(Offset + Ofs, i == 0 ? LI : nullptr);
} }
Context not available.

llvm/lib/CodeGen/MachineCombiner.cpp

Context not available.
instr2instrSC(InsInstrs, InsInstrsSC); instr2instrSC(InsInstrs, InsInstrsSC);
instr2instrSC(DelInstrs, DelInstrsSC); instr2instrSC(DelInstrs, DelInstrsSC);
ArrayRef<const MCSchedClassDesc *> MSCInsArr = makeArrayRef(InsInstrsSC); ArrayRef<const MCSchedClassDesc *> MSCInsArr = ArrayRef(InsInstrsSC);
ArrayRef<const MCSchedClassDesc *> MSCDelArr = makeArrayRef(DelInstrsSC); ArrayRef<const MCSchedClassDesc *> MSCDelArr = ArrayRef(DelInstrsSC);
// Compute new resource length. // Compute new resource length.
unsigned ResLenAfterCombine = unsigned ResLenAfterCombine =
Context not available.

llvm/lib/CodeGen/MachineTraceMetrics.cpp

Context not available.
"getResources() must be called before getProcResourceCycles()"); "getResources() must be called before getProcResourceCycles()");
unsigned PRKinds = SchedModel.getNumProcResourceKinds(); unsigned PRKinds = SchedModel.getNumProcResourceKinds();
assert((MBBNum+1) * PRKinds <= ProcResourceCycles.size()); assert((MBBNum+1) * PRKinds <= ProcResourceCycles.size());
return makeArrayRef(ProcResourceCycles.data() + MBBNum * PRKinds, PRKinds); return ArrayRef(ProcResourceCycles.data() + MBBNum * PRKinds, PRKinds);
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
Context not available.
getProcResourceDepths(unsigned MBBNum) const { getProcResourceDepths(unsigned MBBNum) const {
unsigned PRKinds = MTM.SchedModel.getNumProcResourceKinds(); unsigned PRKinds = MTM.SchedModel.getNumProcResourceKinds();
assert((MBBNum+1) * PRKinds <= ProcResourceDepths.size()); assert((MBBNum+1) * PRKinds <= ProcResourceDepths.size());
return makeArrayRef(ProcResourceDepths.data() + MBBNum * PRKinds, PRKinds); return ArrayRef(ProcResourceDepths.data() + MBBNum * PRKinds, PRKinds);
} }
/// Get an array of processor resource heights for MBB. Indexed by processor /// Get an array of processor resource heights for MBB. Indexed by processor
Context not available.
getProcResourceHeights(unsigned MBBNum) const { getProcResourceHeights(unsigned MBBNum) const {
unsigned PRKinds = MTM.SchedModel.getNumProcResourceKinds(); unsigned PRKinds = MTM.SchedModel.getNumProcResourceKinds();
assert((MBBNum+1) * PRKinds <= ProcResourceHeights.size()); assert((MBBNum+1) * PRKinds <= ProcResourceHeights.size());
return makeArrayRef(ProcResourceHeights.data() + MBBNum * PRKinds, PRKinds); return ArrayRef(ProcResourceHeights.data() + MBBNum * PRKinds, PRKinds);
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
Context not available.

llvm/lib/CodeGen/RegAllocGreedy.cpp

Context not available.
assert(T < GroupSize && "Array overflow"); assert(T < GroupSize && "Array overflow");
TBS[T] = Number; TBS[T] = Number;
if (++T == GroupSize) { if (++T == GroupSize) {
SpillPlacer->addLinks(makeArrayRef(TBS, T)); SpillPlacer->addLinks(ArrayRef(TBS, T));
T = 0; T = 0;
} }
continue; continue;
Context not available.
BCS[B].Exit = SpillPlacement::PrefSpill; BCS[B].Exit = SpillPlacement::PrefSpill;
if (++B == GroupSize) { if (++B == GroupSize) {
SpillPlacer->addConstraints(makeArrayRef(BCS, B)); SpillPlacer->addConstraints(ArrayRef(BCS, B));
B = 0; B = 0;
} }
} }
SpillPlacer->addConstraints(makeArrayRef(BCS, B)); SpillPlacer->addConstraints(ArrayRef(BCS, B));
SpillPlacer->addLinks(makeArrayRef(TBS, T)); SpillPlacer->addLinks(ArrayRef(TBS, T));
return true; return true;
} }
Context not available.
// Compute through constraints from the interference, or assume that all // Compute through constraints from the interference, or assume that all
// through blocks prefer spilling when forming compact regions. // through blocks prefer spilling when forming compact regions.
auto NewBlocks = makeArrayRef(ActiveBlocks).slice(AddedTo); auto NewBlocks = ArrayRef(ActiveBlocks).slice(AddedTo);
if (Cand.PhysReg) { if (Cand.PhysReg) {
if (!addThroughConstraints(Cand.Intf, NewBlocks)) if (!addThroughConstraints(Cand.Intf, NewBlocks))
return false; return false;
Context not available.

llvm/lib/CodeGen/RegisterUsageInfo.cpp

Context not available.
PhysicalRegisterUsageInfo::getRegUsageInfo(const Function &FP) { PhysicalRegisterUsageInfo::getRegUsageInfo(const Function &FP) {
auto It = RegMasks.find(&FP); auto It = RegMasks.find(&FP);
if (It != RegMasks.end()) if (It != RegMasks.end())
return makeArrayRef<uint32_t>(It->second); return ArrayRef<uint32_t>(It->second);
return ArrayRef<uint32_t>(); return ArrayRef<uint32_t>();
} }
Context not available.

llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp

Context not available.
// Check if the bytes of the OR we are looking at match with either big or // Check if the bytes of the OR we are looking at match with either big or
// little endian value load // little endian value load
std::optional<bool> IsBigEndian = isBigEndian( std::optional<bool> IsBigEndian = isBigEndian(
makeArrayRef(ByteOffsets).drop_back(ZeroExtendedBytes), FirstOffset); ArrayRef(ByteOffsets).drop_back(ZeroExtendedBytes), FirstOffset);
if (!IsBigEndian) if (!IsBigEndian)
return SDValue(); return SDValue();
Context not available.

llvm/lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp

Context not available.
SDLoc dl(N); SDLoc dl(N);
SDValue Res = DAG.getNode(N->getOpcode(), dl, DAG.getVTList(VT, SVT), SDValue Res = DAG.getNode(N->getOpcode(), dl, DAG.getVTList(VT, SVT),
makeArrayRef(Ops, NumOps)); ArrayRef(Ops, NumOps));
// Modified the sum result - switch anything that used the old sum to use // Modified the sum result - switch anything that used the old sum to use
// the new one. // the new one.
Context not available.
Lo = DAG.getNode(ISD::UADDO, dl, VTList, LoOps); Lo = DAG.getNode(ISD::UADDO, dl, VTList, LoOps);
HiOps[2] = Lo.getValue(1); HiOps[2] = Lo.getValue(1);
Hi = DAG.computeKnownBits(HiOps[2]).isZero() Hi = DAG.computeKnownBits(HiOps[2]).isZero()
? DAG.getNode(ISD::UADDO, dl, VTList, makeArrayRef(HiOps, 2)) ? DAG.getNode(ISD::UADDO, dl, VTList, ArrayRef(HiOps, 2))
: DAG.getNode(ISD::ADDCARRY, dl, VTList, HiOps); : DAG.getNode(ISD::ADDCARRY, dl, VTList, HiOps);
} else { } else {
Lo = DAG.getNode(ISD::USUBO, dl, VTList, LoOps); Lo = DAG.getNode(ISD::USUBO, dl, VTList, LoOps);
HiOps[2] = Lo.getValue(1); HiOps[2] = Lo.getValue(1);
Hi = DAG.computeKnownBits(HiOps[2]).isZero() Hi = DAG.computeKnownBits(HiOps[2]).isZero()
? DAG.getNode(ISD::USUBO, dl, VTList, makeArrayRef(HiOps, 2)) ? DAG.getNode(ISD::USUBO, dl, VTList, ArrayRef(HiOps, 2))
: DAG.getNode(ISD::SUBCARRY, dl, VTList, HiOps); : DAG.getNode(ISD::SUBCARRY, dl, VTList, HiOps);
} }
return; return;
Context not available.
if (N->getOpcode() == ISD::ADD) { if (N->getOpcode() == ISD::ADD) {
RevOpc = ISD::SUB; RevOpc = ISD::SUB;
Lo = DAG.getNode(ISD::UADDO, dl, VTList, LoOps); Lo = DAG.getNode(ISD::UADDO, dl, VTList, LoOps);
Hi = DAG.getNode(ISD::ADD, dl, NVT, makeArrayRef(HiOps, 2)); Hi = DAG.getNode(ISD::ADD, dl, NVT, ArrayRef(HiOps, 2));
} else { } else {
RevOpc = ISD::ADD; RevOpc = ISD::ADD;
Lo = DAG.getNode(ISD::USUBO, dl, VTList, LoOps); Lo = DAG.getNode(ISD::USUBO, dl, VTList, LoOps);
Hi = DAG.getNode(ISD::SUB, dl, NVT, makeArrayRef(HiOps, 2)); Hi = DAG.getNode(ISD::SUB, dl, NVT, ArrayRef(HiOps, 2));
} }
SDValue OVF = Lo.getValue(1); SDValue OVF = Lo.getValue(1);
Context not available.
if (N->getOpcode() == ISD::ADD) { if (N->getOpcode() == ISD::ADD) {
Lo = DAG.getNode(ISD::ADD, dl, NVT, LoOps); Lo = DAG.getNode(ISD::ADD, dl, NVT, LoOps);
Hi = DAG.getNode(ISD::ADD, dl, NVT, makeArrayRef(HiOps, 2)); Hi = DAG.getNode(ISD::ADD, dl, NVT, ArrayRef(HiOps, 2));
SDValue Cmp = DAG.getSetCC(dl, getSetCCResultType(NVT), Lo, LoOps[0], SDValue Cmp = DAG.getSetCC(dl, getSetCCResultType(NVT), Lo, LoOps[0],
ISD::SETULT); ISD::SETULT);
Context not available.
Hi = DAG.getNode(ISD::ADD, dl, NVT, Hi, Carry); Hi = DAG.getNode(ISD::ADD, dl, NVT, Hi, Carry);
} else { } else {
Lo = DAG.getNode(ISD::SUB, dl, NVT, LoOps); Lo = DAG.getNode(ISD::SUB, dl, NVT, LoOps);
Hi = DAG.getNode(ISD::SUB, dl, NVT, makeArrayRef(HiOps, 2)); Hi = DAG.getNode(ISD::SUB, dl, NVT, ArrayRef(HiOps, 2));
SDValue Cmp = SDValue Cmp =
DAG.getSetCC(dl, getSetCCResultType(LoOps[0].getValueType()), DAG.getSetCC(dl, getSetCCResultType(LoOps[0].getValueType()),
LoOps[0], LoOps[1], ISD::SETULT); LoOps[0], LoOps[1], ISD::SETULT);
Context not available.

llvm/lib/CodeGen/SelectionDAG/LegalizeTypesGeneric.cpp

Context not available.
SmallVector<SDValue, 8> Ops; SmallVector<SDValue, 8> Ops;
IntegerToVector(N->getOperand(0), NumElts, Ops, NVT.getVectorElementType()); IntegerToVector(N->getOperand(0), NumElts, Ops, NVT.getVectorElementType());
SDValue Vec = SDValue Vec = DAG.getBuildVector(NVT, dl, ArrayRef(Ops.data(), NumElts));
DAG.getBuildVector(NVT, dl, makeArrayRef(Ops.data(), NumElts));
return DAG.getNode(ISD::BITCAST, dl, N->getValueType(0), Vec); return DAG.getNode(ISD::BITCAST, dl, N->getValueType(0), Vec);
} }
Context not available.

llvm/lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp

Context not available.
// input vectors to use as shuffle operands. // input vectors to use as shuffle operands.
unsigned FirstMaskIdx = High * NewElts; unsigned FirstMaskIdx = High * NewElts;
SmallVector<int> Mask(NewElts * std::size(Inputs), UndefMaskElem); SmallVector<int> Mask(NewElts * std::size(Inputs), UndefMaskElem);
copy(makeArrayRef(OrigMask).slice(FirstMaskIdx, NewElts), Mask.begin()); copy(ArrayRef(OrigMask).slice(FirstMaskIdx, NewElts), Mask.begin());
assert(!Output && "Expected default initialized initial value."); assert(!Output && "Expected default initialized initial value.");
TryPeekThroughShufflesInputs(Mask); TryPeekThroughShufflesInputs(Mask);
MakeUniqueInputs(Mask); MakeUniqueInputs(Mask);
Context not available.
ConcatOps[j] = UndefVal; ConcatOps[j] = UndefVal;
} }
return DAG.getNode(ISD::CONCAT_VECTORS, dl, WidenVT, return DAG.getNode(ISD::CONCAT_VECTORS, dl, WidenVT,
makeArrayRef(ConcatOps.data(), NumOps)); ArrayRef(ConcatOps.data(), NumOps));
} }
SDValue DAGTypeLegalizer::WidenVecRes_BinaryCanTrap(SDNode *N) { SDValue DAGTypeLegalizer::WidenVecRes_BinaryCanTrap(SDNode *N) {
Context not available.
if (WidenWidth == LdTy.getSizeInBits() * (End - Idx)) if (WidenWidth == LdTy.getSizeInBits() * (End - Idx))
return DAG.getNode(ISD::CONCAT_VECTORS, dl, WidenVT, return DAG.getNode(ISD::CONCAT_VECTORS, dl, WidenVT,
makeArrayRef(&ConcatOps[Idx], End - Idx)); ArrayRef(&ConcatOps[Idx], End - Idx));
// We need to fill the rest with undefs to build the vector. // We need to fill the rest with undefs to build the vector.
unsigned NumOps = unsigned NumOps =
Context not available.

llvm/lib/CodeGen/SelectionDAG/ScheduleDAGRRList.cpp

Context not available.
} }
if (const uint32_t *RegMask = getNodeRegMask(Node)) if (const uint32_t *RegMask = getNodeRegMask(Node))
CheckForLiveRegDefMasked(SU, RegMask, CheckForLiveRegDefMasked(SU, RegMask,
makeArrayRef(LiveRegDefs.get(), TRI->getNumRegs()), ArrayRef(LiveRegDefs.get(), TRI->getNumRegs()),
RegAdded, LRegs); RegAdded, LRegs);
const MCInstrDesc &MCID = TII->get(Node->getMachineOpcode()); const MCInstrDesc &MCID = TII->get(Node->getMachineOpcode());
Context not available.

llvm/lib/CodeGen/SelectionDAG/ScheduleDAGSDNodes.cpp

Context not available.
"expected an unused glue value"); "expected an unused glue value");
CloneNodeWithValues(N, DAG, CloneNodeWithValues(N, DAG,
makeArrayRef(N->value_begin(), N->getNumValues() - 1)); ArrayRef(N->value_begin(), N->getNumValues() - 1));
} }
/// ClusterNeighboringLoads - Force nearby loads together by "gluing" them. /// ClusterNeighboringLoads - Force nearby loads together by "gluing" them.
Context not available.

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

Context not available.
if (ChainI == MaxParallelChains) { if (ChainI == MaxParallelChains) {
assert(PendingLoads.empty() && "PendingLoads must be serialized first"); assert(PendingLoads.empty() && "PendingLoads must be serialized first");
SDValue Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, SDValue Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
makeArrayRef(Chains.data(), ChainI)); ArrayRef(Chains.data(), ChainI));
Root = Chain; Root = Chain;
ChainI = 0; ChainI = 0;
} }
Context not available.
if (!ConstantMemory) { if (!ConstantMemory) {
SDValue Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, SDValue Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
makeArrayRef(Chains.data(), ChainI)); ArrayRef(Chains.data(), ChainI));
if (isVolatile) if (isVolatile)
DAG.setRoot(Chain); DAG.setRoot(Chain);
else else
Context not available.
// See visitLoad comments. // See visitLoad comments.
if (ChainI == MaxParallelChains) { if (ChainI == MaxParallelChains) {
SDValue Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, SDValue Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
makeArrayRef(Chains.data(), ChainI)); ArrayRef(Chains.data(), ChainI));
Root = Chain; Root = Chain;
ChainI = 0; ChainI = 0;
} }
Context not available.
} }
SDValue StoreNode = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, SDValue StoreNode = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
makeArrayRef(Chains.data(), ChainI)); ArrayRef(Chains.data(), ChainI));
setValue(&I, StoreNode); setValue(&I, StoreNode);
DAG.setRoot(StoreNode); DAG.setRoot(StoreNode);
} }
Context not available.
if (StructType *StructResult = dyn_cast<StructType>(CallResultType)) if (StructType *StructResult = dyn_cast<StructType>(CallResultType))
ResultTypes = StructResult->elements(); ResultTypes = StructResult->elements();
else if (!CallResultType->isVoidTy()) else if (!CallResultType->isVoidTy())
ResultTypes = makeArrayRef(CallResultType); ResultTypes = ArrayRef(CallResultType);
auto CurResultType = ResultTypes.begin(); auto CurResultType = ResultTypes.begin();
auto handleRegAssign = [&](SDValue V) { auto handleRegAssign = [&](SDValue V) {
Context not available.
dyn_cast<FrameIndexSDNode>(ArgValues[0].getNode())) dyn_cast<FrameIndexSDNode>(ArgValues[0].getNode()))
FuncInfo->setArgumentFrameIndex(&Arg, FI->getIndex()); FuncInfo->setArgumentFrameIndex(&Arg, FI->getIndex());
SDValue Res = DAG.getMergeValues(makeArrayRef(ArgValues.data(), NumValues), SDValue Res = DAG.getMergeValues(ArrayRef(ArgValues.data(), NumValues),
SDB->getCurSDLoc()); SDB->getCurSDLoc());
SDB->setValue(&Arg, Res); SDB->setValue(&Arg, Res);
Context not available.

llvm/lib/CodeGen/SjLjEHPrepare.cpp

Context not available.
lowerAcrossUnwindEdges(F, Invokes); lowerAcrossUnwindEdges(F, Invokes);
Value *FuncCtx = Value *FuncCtx =
setupFunctionContext(F, makeArrayRef(LPads.begin(), LPads.end())); setupFunctionContext(F, ArrayRef(LPads.begin(), LPads.end()));
BasicBlock *EntryBB = &F.front(); BasicBlock *EntryBB = &F.front();
IRBuilder<> Builder(EntryBB->getTerminator()); IRBuilder<> Builder(EntryBB->getTerminator());
Context not available.

llvm/lib/CodeGen/VirtRegMap.cpp

Context not available.
// clobbering. // clobbering.
for (int E = MIs.size(), PrevE = E; E > 1; PrevE = E) { for (int E = MIs.size(), PrevE = E; E > 1; PrevE = E) {
for (int I = E; I--; ) for (int I = E; I--; )
if (!anyRegsAlias(MIs[I], makeArrayRef(MIs).take_front(E), TRI)) { if (!anyRegsAlias(MIs[I], ArrayRef(MIs).take_front(E), TRI)) {
if (I + 1 != E) if (I + 1 != E)
std::swap(MIs[I], MIs[E - 1]); std::swap(MIs[I], MIs[E - 1]);
--E; --E;
Context not available.

llvm/lib/DebugInfo/CodeView/CodeViewRecordIO.cpp

Context not available.
// the general case. // the general case.
uint32_t Offset = getCurrentOffset(); uint32_t Offset = getCurrentOffset();
std::optional<uint32_t> Min = Limits.front().bytesRemaining(Offset); std::optional<uint32_t> Min = Limits.front().bytesRemaining(Offset);
for (auto X : makeArrayRef(Limits).drop_front()) { for (auto X : ArrayRef(Limits).drop_front()) {
std::optional<uint32_t> ThisMin = X.bytesRemaining(Offset); std::optional<uint32_t> ThisMin = X.bytesRemaining(Offset);
if (ThisMin) if (ThisMin)
Min = Min ? std::min(*Min, *ThisMin) : *ThisMin; Min = Min ? std::min(*Min, *ThisMin) : *ThisMin;
Context not available.

llvm/lib/DebugInfo/CodeView/ContinuationRecordBuilder.cpp

Context not available.
std::vector<CVType> Types; std::vector<CVType> Types;
Types.reserve(SegmentOffsets.size()); Types.reserve(SegmentOffsets.size());
auto SO = makeArrayRef(SegmentOffsets); auto SO = ArrayRef(SegmentOffsets);
uint32_t End = SegmentWriter.getOffset(); uint32_t End = SegmentWriter.getOffset();
Context not available.

llvm/lib/DebugInfo/CodeView/DebugChecksumsSubsection.cpp

Context not available.
if (!Bytes.empty()) { if (!Bytes.empty()) {
uint8_t *Copy = Storage.Allocate<uint8_t>(Bytes.size()); uint8_t *Copy = Storage.Allocate<uint8_t>(Bytes.size());
::memcpy(Copy, Bytes.data(), Bytes.size()); ::memcpy(Copy, Bytes.data(), Bytes.size());
Entry.Checksum = makeArrayRef(Copy, Bytes.size()); Entry.Checksum = ArrayRef(Copy, Bytes.size());
} }
Entry.FileNameOffset = Strings.insert(FileName); Entry.FileNameOffset = Strings.insert(FileName);
Context not available.
Header.FileNameOffset = FC.FileNameOffset; Header.FileNameOffset = FC.FileNameOffset;
if (auto EC = Writer.writeObject(Header)) if (auto EC = Writer.writeObject(Header))
return EC; return EC;
if (auto EC = Writer.writeArray(makeArrayRef(FC.Checksum))) if (auto EC = Writer.writeArray(ArrayRef(FC.Checksum)))
return EC; return EC;
if (auto EC = Writer.padToAlignment(4)) if (auto EC = Writer.padToAlignment(4))
return EC; return EC;
Context not available.

llvm/lib/DebugInfo/CodeView/DebugCrossImpSubsection.cpp

Context not available.
Imp.Count = Item->getValue().size(); Imp.Count = Item->getValue().size();
if (auto EC = Writer.writeObject(Imp)) if (auto EC = Writer.writeObject(Imp))
return EC; return EC;
if (auto EC = Writer.writeArray(makeArrayRef(Item->getValue()))) if (auto EC = Writer.writeArray(ArrayRef(Item->getValue())))
return EC; return EC;
} }
return Error::success(); return Error::success();
Context not available.

llvm/lib/DebugInfo/CodeView/DebugFrameDataSubsection.cpp

Context not available.
llvm::sort(SortedFrames, [](const FrameData &LHS, const FrameData &RHS) { llvm::sort(SortedFrames, [](const FrameData &LHS, const FrameData &RHS) {
return LHS.RvaStart < RHS.RvaStart; return LHS.RvaStart < RHS.RvaStart;
}); });
if (auto EC = Writer.writeArray(makeArrayRef(SortedFrames))) if (auto EC = Writer.writeArray(ArrayRef(SortedFrames)))
return EC; return EC;
return Error::success(); return Error::success();
} }
Context not available.

llvm/lib/DebugInfo/CodeView/DebugInlineeLinesSubsection.cpp

Context not available.
if (auto EC = Writer.writeInteger<uint32_t>(E.ExtraFiles.size())) if (auto EC = Writer.writeInteger<uint32_t>(E.ExtraFiles.size()))
return EC; return EC;
if (auto EC = Writer.writeArray(makeArrayRef(E.ExtraFiles))) if (auto EC = Writer.writeArray(ArrayRef(E.ExtraFiles)))
return EC; return EC;
} }
Context not available.

llvm/lib/DebugInfo/CodeView/DebugLinesSubsection.cpp

Context not available.
if (auto EC = Writer.writeObject(BlockHeader)) if (auto EC = Writer.writeObject(BlockHeader))
return EC; return EC;
if (auto EC = Writer.writeArray(makeArrayRef(B.Lines))) if (auto EC = Writer.writeArray(ArrayRef(B.Lines)))
return EC; return EC;
if (hasColumnInfo()) { if (hasColumnInfo()) {
if (auto EC = Writer.writeArray(makeArrayRef(B.Columns))) if (auto EC = Writer.writeArray(ArrayRef(B.Columns)))
return EC; return EC;
} }
} }
Context not available.

llvm/lib/DebugInfo/CodeView/DebugSymbolRVASubsection.cpp

Context not available.
: DebugSubsection(DebugSubsectionKind::CoffSymbolRVA) {} : DebugSubsection(DebugSubsectionKind::CoffSymbolRVA) {}
Error DebugSymbolRVASubsection::commit(BinaryStreamWriter &Writer) const { Error DebugSymbolRVASubsection::commit(BinaryStreamWriter &Writer) const {
return Writer.writeArray(makeArrayRef(RVAs)); return Writer.writeArray(ArrayRef(RVAs));
} }
uint32_t DebugSymbolRVASubsection::calculateSerializedSize() const { uint32_t DebugSymbolRVASubsection::calculateSerializedSize() const {
Context not available.

llvm/lib/DebugInfo/CodeView/EnumTables.cpp

Context not available.
namespace codeview { namespace codeview {
ArrayRef<EnumEntry<SymbolKind>> getSymbolTypeNames() { ArrayRef<EnumEntry<SymbolKind>> getSymbolTypeNames() {
return makeArrayRef(SymbolTypeNames); return ArrayRef(SymbolTypeNames);
} }
ArrayRef<EnumEntry<TypeLeafKind>> getTypeLeafNames() { ArrayRef<EnumEntry<TypeLeafKind>> getTypeLeafNames() {
return makeArrayRef(TypeLeafNames); return ArrayRef(TypeLeafNames);
} }
ArrayRef<EnumEntry<uint16_t>> getRegisterNames(CPUType Cpu) { ArrayRef<EnumEntry<uint16_t>> getRegisterNames(CPUType Cpu) {
if (Cpu == CPUType::ARMNT) { if (Cpu == CPUType::ARMNT) {
return makeArrayRef(RegisterNames_ARM); return ArrayRef(RegisterNames_ARM);
} else if (Cpu == CPUType::ARM64) { } else if (Cpu == CPUType::ARM64) {
return makeArrayRef(RegisterNames_ARM64); return ArrayRef(RegisterNames_ARM64);
} }
return makeArrayRef(RegisterNames_X86); return ArrayRef(RegisterNames_X86);
} }
ArrayRef<EnumEntry<uint32_t>> getPublicSymFlagNames() { ArrayRef<EnumEntry<uint32_t>> getPublicSymFlagNames() {
return makeArrayRef(PublicSymFlagNames); return ArrayRef(PublicSymFlagNames);
} }
ArrayRef<EnumEntry<uint8_t>> getProcSymFlagNames() { ArrayRef<EnumEntry<uint8_t>> getProcSymFlagNames() {
return makeArrayRef(ProcSymFlagNames); return ArrayRef(ProcSymFlagNames);
} }
ArrayRef<EnumEntry<uint16_t>> getLocalFlagNames() { ArrayRef<EnumEntry<uint16_t>> getLocalFlagNames() {
return makeArrayRef(LocalFlags); return ArrayRef(LocalFlags);
} }
ArrayRef<EnumEntry<uint8_t>> getFrameCookieKindNames() { ArrayRef<EnumEntry<uint8_t>> getFrameCookieKindNames() {
return makeArrayRef(FrameCookieKinds); return ArrayRef(FrameCookieKinds);
} }
ArrayRef<EnumEntry<SourceLanguage>> getSourceLanguageNames() { ArrayRef<EnumEntry<SourceLanguage>> getSourceLanguageNames() {
return makeArrayRef(SourceLanguages); return ArrayRef(SourceLanguages);
} }
ArrayRef<EnumEntry<uint32_t>> getCompileSym2FlagNames() { ArrayRef<EnumEntry<uint32_t>> getCompileSym2FlagNames() {
return makeArrayRef(CompileSym2FlagNames); return ArrayRef(CompileSym2FlagNames);
} }
ArrayRef<EnumEntry<uint32_t>> getCompileSym3FlagNames() { ArrayRef<EnumEntry<uint32_t>> getCompileSym3FlagNames() {
return makeArrayRef(CompileSym3FlagNames); return ArrayRef(CompileSym3FlagNames);
} }
ArrayRef<EnumEntry<uint32_t>> getFileChecksumNames() { ArrayRef<EnumEntry<uint32_t>> getFileChecksumNames() {
return makeArrayRef(FileChecksumNames); return ArrayRef(FileChecksumNames);
} }
ArrayRef<EnumEntry<unsigned>> getCPUTypeNames() { ArrayRef<EnumEntry<unsigned>> getCPUTypeNames() {
return makeArrayRef(CPUTypeNames); return ArrayRef(CPUTypeNames);
} }
ArrayRef<EnumEntry<uint32_t>> getFrameProcSymFlagNames() { ArrayRef<EnumEntry<uint32_t>> getFrameProcSymFlagNames() {
return makeArrayRef(FrameProcSymFlagNames); return ArrayRef(FrameProcSymFlagNames);
} }
ArrayRef<EnumEntry<uint16_t>> getExportSymFlagNames() { ArrayRef<EnumEntry<uint16_t>> getExportSymFlagNames() {
return makeArrayRef(ExportSymFlagNames); return ArrayRef(ExportSymFlagNames);
} }
ArrayRef<EnumEntry<uint32_t>> getModuleSubstreamKindNames() { ArrayRef<EnumEntry<uint32_t>> getModuleSubstreamKindNames() {
return makeArrayRef(ModuleSubstreamKindNames); return ArrayRef(ModuleSubstreamKindNames);
} }
ArrayRef<EnumEntry<uint8_t>> getThunkOrdinalNames() { ArrayRef<EnumEntry<uint8_t>> getThunkOrdinalNames() {
return makeArrayRef(ThunkOrdinalNames); return ArrayRef(ThunkOrdinalNames);
} }
ArrayRef<EnumEntry<uint16_t>> getTrampolineNames() { ArrayRef<EnumEntry<uint16_t>> getTrampolineNames() {
return makeArrayRef(TrampolineNames); return ArrayRef(TrampolineNames);
} }
ArrayRef<EnumEntry<COFF::SectionCharacteristics>> ArrayRef<EnumEntry<COFF::SectionCharacteristics>>
getImageSectionCharacteristicNames() { getImageSectionCharacteristicNames() {
return makeArrayRef(ImageSectionCharacteristicNames); return ArrayRef(ImageSectionCharacteristicNames);
} }
ArrayRef<EnumEntry<uint16_t>> getClassOptionNames() { ArrayRef<EnumEntry<uint16_t>> getClassOptionNames() {
return makeArrayRef(ClassOptionNames); return ArrayRef(ClassOptionNames);
} }
ArrayRef<EnumEntry<uint8_t>> getMemberAccessNames() { ArrayRef<EnumEntry<uint8_t>> getMemberAccessNames() {
return makeArrayRef(MemberAccessNames); return ArrayRef(MemberAccessNames);
} }
ArrayRef<EnumEntry<uint16_t>> getMethodOptionNames() { ArrayRef<EnumEntry<uint16_t>> getMethodOptionNames() {
return makeArrayRef(MethodOptionNames); return ArrayRef(MethodOptionNames);
} }
ArrayRef<EnumEntry<uint16_t>> getMemberKindNames() { ArrayRef<EnumEntry<uint16_t>> getMemberKindNames() {
return makeArrayRef(MemberKindNames); return ArrayRef(MemberKindNames);
} }
ArrayRef<EnumEntry<uint8_t>> getPtrKindNames() { ArrayRef<EnumEntry<uint8_t>> getPtrKindNames() {
return makeArrayRef(PtrKindNames); return ArrayRef(PtrKindNames);
} }
ArrayRef<EnumEntry<uint8_t>> getPtrModeNames() { ArrayRef<EnumEntry<uint8_t>> getPtrModeNames() {
return makeArrayRef(PtrModeNames); return ArrayRef(PtrModeNames);
} }
ArrayRef<EnumEntry<uint16_t>> getPtrMemberRepNames() { ArrayRef<EnumEntry<uint16_t>> getPtrMemberRepNames() {
return makeArrayRef(PtrMemberRepNames); return ArrayRef(PtrMemberRepNames);
} }
ArrayRef<EnumEntry<uint16_t>> getTypeModifierNames() { ArrayRef<EnumEntry<uint16_t>> getTypeModifierNames() {
return makeArrayRef(TypeModifierNames); return ArrayRef(TypeModifierNames);
} }
ArrayRef<EnumEntry<uint8_t>> getCallingConventions() { ArrayRef<EnumEntry<uint8_t>> getCallingConventions() {
return makeArrayRef(CallingConventions); return ArrayRef(CallingConventions);
} }
ArrayRef<EnumEntry<uint8_t>> getFunctionOptionEnum() { ArrayRef<EnumEntry<uint8_t>> getFunctionOptionEnum() {
return makeArrayRef(FunctionOptionEnum); return ArrayRef(FunctionOptionEnum);
} }
ArrayRef<EnumEntry<uint16_t>> getLabelTypeEnum() { ArrayRef<EnumEntry<uint16_t>> getLabelTypeEnum() {
return makeArrayRef(LabelTypeEnum); return ArrayRef(LabelTypeEnum);
} }
} // end namespace codeview } // end namespace codeview
Context not available.

llvm/lib/DebugInfo/CodeView/Formatters.cpp

Context not available.
using namespace llvm::codeview::detail; using namespace llvm::codeview::detail;
GuidAdapter::GuidAdapter(StringRef Guid) GuidAdapter::GuidAdapter(StringRef Guid)
: FormatAdapter(makeArrayRef(Guid.bytes_begin(), Guid.bytes_end())) {} : FormatAdapter(ArrayRef(Guid.bytes_begin(), Guid.bytes_end())) {}
GuidAdapter::GuidAdapter(ArrayRef<uint8_t> Guid) GuidAdapter::GuidAdapter(ArrayRef<uint8_t> Guid)
: FormatAdapter(std::move(Guid)) {} : FormatAdapter(std::move(Guid)) {}
Context not available.

llvm/lib/DebugInfo/CodeView/GlobalTypeTableBuilder.cpp

Context not available.
ArrayRef<uint8_t> Data) { ArrayRef<uint8_t> Data) {
uint8_t *Stable = Alloc.Allocate<uint8_t>(Data.size()); uint8_t *Stable = Alloc.Allocate<uint8_t>(Data.size());
memcpy(Stable, Data.data(), Data.size()); memcpy(Stable, Data.data(), Data.size());
return makeArrayRef(Stable, Data.size()); return ArrayRef(Stable, Data.size());
} }
TypeIndex GlobalTypeTableBuilder::insertRecordBytes(ArrayRef<uint8_t> Record) { TypeIndex GlobalTypeTableBuilder::insertRecordBytes(ArrayRef<uint8_t> Record) {
Context not available.

llvm/lib/DebugInfo/CodeView/LazyRandomTypeCollection.cpp

Context not available.
LazyRandomTypeCollection::LazyRandomTypeCollection(StringRef Data, LazyRandomTypeCollection::LazyRandomTypeCollection(StringRef Data,
uint32_t RecordCountHint) uint32_t RecordCountHint)
: LazyRandomTypeCollection( : LazyRandomTypeCollection(ArrayRef(Data.bytes_begin(), Data.bytes_end()),
makeArrayRef(Data.bytes_begin(), Data.bytes_end()), RecordCountHint) { RecordCountHint) {}
}
LazyRandomTypeCollection::LazyRandomTypeCollection(const CVTypeArray &Types, LazyRandomTypeCollection::LazyRandomTypeCollection(const CVTypeArray &Types,
uint32_t NumRecords) uint32_t NumRecords)
Context not available.

llvm/lib/DebugInfo/CodeView/MergingTypeTableBuilder.cpp

Context not available.
ArrayRef<uint8_t> Data) { ArrayRef<uint8_t> Data) {
uint8_t *Stable = Alloc.Allocate<uint8_t>(Data.size()); uint8_t *Stable = Alloc.Allocate<uint8_t>(Data.size());
memcpy(Stable, Data.data(), Data.size()); memcpy(Stable, Data.data(), Data.size());
return makeArrayRef(Stable, Data.size()); return ArrayRef(Stable, Data.size());
} }
TypeIndex MergingTypeTableBuilder::insertRecordAs(hash_code Hash, TypeIndex MergingTypeTableBuilder::insertRecordAs(hash_code Hash,
Context not available.

llvm/lib/DebugInfo/CodeView/TypeDumpVisitor.cpp

Context not available.
W->getOStream() << " {\n"; W->getOStream() << " {\n";
W->indent(); W->indent();
W->printEnum("TypeLeafKind", unsigned(Record.kind()), W->printEnum("TypeLeafKind", unsigned(Record.kind()),
makeArrayRef(LeafTypeNames)); ArrayRef(LeafTypeNames));
return Error::success(); return Error::success();
} }
Context not available.
W->startLine() << getLeafTypeName(Record.Kind); W->startLine() << getLeafTypeName(Record.Kind);
W->getOStream() << " {\n"; W->getOStream() << " {\n";
W->indent(); W->indent();
W->printEnum("TypeLeafKind", unsigned(Record.Kind), W->printEnum("TypeLeafKind", unsigned(Record.Kind), ArrayRef(LeafTypeNames));
makeArrayRef(LeafTypeNames));
return Error::success(); return Error::success();
} }
Context not available.
Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ClassRecord &Class) { Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ClassRecord &Class) {
uint16_t Props = static_cast<uint16_t>(Class.getOptions()); uint16_t Props = static_cast<uint16_t>(Class.getOptions());
W->printNumber("MemberCount", Class.getMemberCount()); W->printNumber("MemberCount", Class.getMemberCount());
W->printFlags("Properties", Props, makeArrayRef(ClassOptionNames)); W->printFlags("Properties", Props, ArrayRef(ClassOptionNames));
printTypeIndex("FieldList", Class.getFieldList()); printTypeIndex("FieldList", Class.getFieldList());
printTypeIndex("DerivedFrom", Class.getDerivationList()); printTypeIndex("DerivedFrom", Class.getDerivationList());
printTypeIndex("VShape", Class.getVTableShape()); printTypeIndex("VShape", Class.getVTableShape());
Context not available.
Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, UnionRecord &Union) { Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, UnionRecord &Union) {
uint16_t Props = static_cast<uint16_t>(Union.getOptions()); uint16_t Props = static_cast<uint16_t>(Union.getOptions());
W->printNumber("MemberCount", Union.getMemberCount()); W->printNumber("MemberCount", Union.getMemberCount());
W->printFlags("Properties", Props, makeArrayRef(ClassOptionNames)); W->printFlags("Properties", Props, ArrayRef(ClassOptionNames));
printTypeIndex("FieldList", Union.getFieldList()); printTypeIndex("FieldList", Union.getFieldList());
W->printNumber("SizeOf", Union.getSize()); W->printNumber("SizeOf", Union.getSize());
W->printString("Name", Union.getName()); W->printString("Name", Union.getName());
Context not available.
uint16_t Props = static_cast<uint16_t>(Enum.getOptions()); uint16_t Props = static_cast<uint16_t>(Enum.getOptions());
W->printNumber("NumEnumerators", Enum.getMemberCount()); W->printNumber("NumEnumerators", Enum.getMemberCount());
W->printFlags("Properties", uint16_t(Enum.getOptions()), W->printFlags("Properties", uint16_t(Enum.getOptions()),
makeArrayRef(ClassOptionNames)); ArrayRef(ClassOptionNames));
printTypeIndex("UnderlyingType", Enum.getUnderlyingType()); printTypeIndex("UnderlyingType", Enum.getUnderlyingType());
printTypeIndex("FieldListType", Enum.getFieldList()); printTypeIndex("FieldListType", Enum.getFieldList());
W->printString("Name", Enum.getName()); W->printString("Name", Enum.getName());
Context not available.
Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ProcedureRecord &Proc) { Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ProcedureRecord &Proc) {
printTypeIndex("ReturnType", Proc.getReturnType()); printTypeIndex("ReturnType", Proc.getReturnType());
W->printEnum("CallingConvention", uint8_t(Proc.getCallConv()), W->printEnum("CallingConvention", uint8_t(Proc.getCallConv()),
makeArrayRef(CallingConventions)); ArrayRef(CallingConventions));
W->printFlags("FunctionOptions", uint8_t(Proc.getOptions()), W->printFlags("FunctionOptions", uint8_t(Proc.getOptions()),
makeArrayRef(FunctionOptionEnum)); ArrayRef(FunctionOptionEnum));
W->printNumber("NumParameters", Proc.getParameterCount()); W->printNumber("NumParameters", Proc.getParameterCount());
printTypeIndex("ArgListType", Proc.getArgumentList()); printTypeIndex("ArgListType", Proc.getArgumentList());
return Error::success(); return Error::success();
Context not available.
printTypeIndex("ClassType", MF.getClassType()); printTypeIndex("ClassType", MF.getClassType());
printTypeIndex("ThisType", MF.getThisType()); printTypeIndex("ThisType", MF.getThisType());
W->printEnum("CallingConvention", uint8_t(MF.getCallConv()), W->printEnum("CallingConvention", uint8_t(MF.getCallConv()),
makeArrayRef(CallingConventions)); ArrayRef(CallingConventions));
W->printFlags("FunctionOptions", uint8_t(MF.getOptions()), W->printFlags("FunctionOptions", uint8_t(MF.getOptions()),
makeArrayRef(FunctionOptionEnum)); ArrayRef(FunctionOptionEnum));
W->printNumber("NumParameters", MF.getParameterCount()); W->printNumber("NumParameters", MF.getParameterCount());
printTypeIndex("ArgListType", MF.getArgumentList()); printTypeIndex("ArgListType", MF.getArgumentList());
W->printNumber("ThisAdjustment", MF.getThisPointerAdjustment()); W->printNumber("ThisAdjustment", MF.getThisPointerAdjustment());
Context not available.
Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, PointerRecord &Ptr) { Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, PointerRecord &Ptr) {
printTypeIndex("PointeeType", Ptr.getReferentType()); printTypeIndex("PointeeType", Ptr.getReferentType());
W->printEnum("PtrType", unsigned(Ptr.getPointerKind()), W->printEnum("PtrType", unsigned(Ptr.getPointerKind()),
makeArrayRef(PtrKindNames)); ArrayRef(PtrKindNames));
W->printEnum("PtrMode", unsigned(Ptr.getMode()), makeArrayRef(PtrModeNames)); W->printEnum("PtrMode", unsigned(Ptr.getMode()), ArrayRef(PtrModeNames));
W->printNumber("IsFlat", Ptr.isFlat()); W->printNumber("IsFlat", Ptr.isFlat());
W->printNumber("IsConst", Ptr.isConst()); W->printNumber("IsConst", Ptr.isConst());
Context not available.
printTypeIndex("ClassType", MI.getContainingType()); printTypeIndex("ClassType", MI.getContainingType());
W->printEnum("Representation", uint16_t(MI.getRepresentation()), W->printEnum("Representation", uint16_t(MI.getRepresentation()),
makeArrayRef(PtrMemberRepNames)); ArrayRef(PtrMemberRepNames));
} }
return Error::success(); return Error::success();
Context not available.
Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ModifierRecord &Mod) { Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ModifierRecord &Mod) {
uint16_t Mods = static_cast<uint16_t>(Mod.getModifiers()); uint16_t Mods = static_cast<uint16_t>(Mod.getModifiers());
printTypeIndex("ModifiedType", Mod.getModifiedType()); printTypeIndex("ModifiedType", Mod.getModifiedType());
W->printFlags("Modifiers", Mods, makeArrayRef(TypeModifierNames)); W->printFlags("Modifiers", Mods, ArrayRef(TypeModifierNames));
return Error::success(); return Error::success();
} }
Context not available.
void TypeDumpVisitor::printMemberAttributes(MemberAccess Access, void TypeDumpVisitor::printMemberAttributes(MemberAccess Access,
MethodKind Kind, MethodKind Kind,
MethodOptions Options) { MethodOptions Options) {
W->printEnum("AccessSpecifier", uint8_t(Access), W->printEnum("AccessSpecifier", uint8_t(Access), ArrayRef(MemberAccessNames));
makeArrayRef(MemberAccessNames));
// Data members will be vanilla. Don't try to print a method kind for them. // Data members will be vanilla. Don't try to print a method kind for them.
if (Kind != MethodKind::Vanilla) if (Kind != MethodKind::Vanilla)
W->printEnum("MethodKind", unsigned(Kind), makeArrayRef(MemberKindNames)); W->printEnum("MethodKind", unsigned(Kind), ArrayRef(MemberKindNames));
if (Options != MethodOptions::None) { if (Options != MethodOptions::None) {
W->printFlags("MethodOptions", unsigned(Options), W->printFlags("MethodOptions", unsigned(Options),
makeArrayRef(MethodOptionNames)); ArrayRef(MethodOptionNames));
} }
} }
Context not available.
} }
Error TypeDumpVisitor::visitUnknownType(CVType &Record) { Error TypeDumpVisitor::visitUnknownType(CVType &Record) {
W->printEnum("Kind", uint16_t(Record.kind()), makeArrayRef(LeafTypeNames)); W->printEnum("Kind", uint16_t(Record.kind()), ArrayRef(LeafTypeNames));
W->printNumber("Length", uint32_t(Record.content().size())); W->printNumber("Length", uint32_t(Record.content().size()));
return Error::success(); return Error::success();
} }
Context not available.
} }
Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, LabelRecord &LR) { Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, LabelRecord &LR) {
W->printEnum("Mode", uint16_t(LR.Mode), makeArrayRef(LabelTypeEnum)); W->printEnum("Mode", uint16_t(LR.Mode), ArrayRef(LabelTypeEnum));
return Error::success(); return Error::success();
} }
Context not available.

llvm/lib/DebugInfo/CodeView/TypeHashing.cpp

Context not available.
ArrayRef<uint8_t> BytesToHash; ArrayRef<uint8_t> BytesToHash;
if (TI.isSimple() || TI.isNoneType()) { if (TI.isSimple() || TI.isNoneType()) {
const uint8_t *IndexBytes = reinterpret_cast<const uint8_t *>(&TI); const uint8_t *IndexBytes = reinterpret_cast<const uint8_t *>(&TI);
BytesToHash = makeArrayRef(IndexBytes, sizeof(TypeIndex)); BytesToHash = ArrayRef(IndexBytes, sizeof(TypeIndex));
} else { } else {
if (TI.toArrayIndex() >= Prev.size() || if (TI.toArrayIndex() >= Prev.size() ||
Prev[TI.toArrayIndex()].empty()) { Prev[TI.toArrayIndex()].empty()) {
Context not available.

llvm/lib/DebugInfo/CodeView/TypeRecordMapping.cpp

Context not available.
if (!IO.isStreaming()) if (!IO.isStreaming())
return ""; return "";
std::string AccessSpecifier = std::string( std::string AccessSpecifier = std::string(
getEnumName(IO, uint8_t(Access), makeArrayRef(getMemberAccessNames()))); getEnumName(IO, uint8_t(Access), ArrayRef(getMemberAccessNames())));
std::string MemberAttrs(AccessSpecifier); std::string MemberAttrs(AccessSpecifier);
if (Kind != MethodKind::Vanilla) { if (Kind != MethodKind::Vanilla) {
std::string MethodKind = std::string( std::string MethodKind = std::string(
getEnumName(IO, unsigned(Kind), makeArrayRef(getMemberKindNames()))); getEnumName(IO, unsigned(Kind), ArrayRef(getMemberKindNames())));
MemberAttrs += ", " + MethodKind; MemberAttrs += ", " + MethodKind;
} }
if (Options != MethodOptions::None) { if (Options != MethodOptions::None) {
std::string MethodOptions = getFlagNames( std::string MethodOptions =
IO, unsigned(Options), makeArrayRef(getMethodOptionNames())); getFlagNames(IO, unsigned(Options), ArrayRef(getMethodOptionNames()));
MemberAttrs += ", " + MethodOptions; MemberAttrs += ", " + MethodOptions;
} }
return MemberAttrs; return MemberAttrs;
Context not available.
auto RecordKind = CVR.kind(); auto RecordKind = CVR.kind();
uint16_t RecordLen = CVR.length() - 2; uint16_t RecordLen = CVR.length() - 2;
std::string RecordKindName = std::string( std::string RecordKindName = std::string(
getEnumName(IO, unsigned(RecordKind), makeArrayRef(LeafTypeNames))); getEnumName(IO, unsigned(RecordKind), ArrayRef(LeafTypeNames)));
error(IO.mapInteger(RecordLen, "Record length")); error(IO.mapInteger(RecordLen, "Record length"));
error(IO.mapEnum(RecordKind, "Record kind: " + RecordKindName)); error(IO.mapEnum(RecordKind, "Record kind: " + RecordKindName));
} }
Context not available.
std::string MemberKindName = std::string(getLeafTypeName(Record.Kind)); std::string MemberKindName = std::string(getLeafTypeName(Record.Kind));
MemberKindName += MemberKindName +=
" ( " + " ( " +
(getEnumName(IO, unsigned(Record.Kind), makeArrayRef(LeafTypeNames))) (getEnumName(IO, unsigned(Record.Kind), ArrayRef(LeafTypeNames)))
.str() + .str() +
" )"; " )";
error(IO.mapEnum(Record.Kind, "Member kind: " + MemberKindName)); error(IO.mapEnum(Record.Kind, "Member kind: " + MemberKindName));
Context not available.
Error TypeRecordMapping::visitKnownRecord(CVType &CVR, ModifierRecord &Record) { Error TypeRecordMapping::visitKnownRecord(CVType &CVR, ModifierRecord &Record) {
std::string ModifierNames = std::string ModifierNames =
getFlagNames(IO, static_cast<uint16_t>(Record.Modifiers), getFlagNames(IO, static_cast<uint16_t>(Record.Modifiers),
makeArrayRef(getTypeModifierNames())); ArrayRef(getTypeModifierNames()));
error(IO.mapInteger(Record.ModifiedType, "ModifiedType")); error(IO.mapInteger(Record.ModifiedType, "ModifiedType"));
error(IO.mapEnum(Record.Modifiers, "Modifiers" + ModifierNames)); error(IO.mapEnum(Record.Modifiers, "Modifiers" + ModifierNames));
return Error::success(); return Error::success();
Context not available.
Error TypeRecordMapping::visitKnownRecord(CVType &CVR, Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
ProcedureRecord &Record) { ProcedureRecord &Record) {
std::string CallingConvName = std::string(getEnumName( std::string CallingConvName = std::string(getEnumName(
IO, uint8_t(Record.CallConv), makeArrayRef(getCallingConventions()))); IO, uint8_t(Record.CallConv), ArrayRef(getCallingConventions())));
std::string FuncOptionNames = std::string FuncOptionNames =
getFlagNames(IO, static_cast<uint16_t>(Record.Options), getFlagNames(IO, static_cast<uint16_t>(Record.Options),
makeArrayRef(getFunctionOptionEnum())); ArrayRef(getFunctionOptionEnum()));
error(IO.mapInteger(Record.ReturnType, "ReturnType")); error(IO.mapInteger(Record.ReturnType, "ReturnType"));
error(IO.mapEnum(Record.CallConv, "CallingConvention: " + CallingConvName)); error(IO.mapEnum(Record.CallConv, "CallingConvention: " + CallingConvName));
error(IO.mapEnum(Record.Options, "FunctionOptions" + FuncOptionNames)); error(IO.mapEnum(Record.Options, "FunctionOptions" + FuncOptionNames));
Context not available.
Error TypeRecordMapping::visitKnownRecord(CVType &CVR, Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
MemberFunctionRecord &Record) { MemberFunctionRecord &Record) {
std::string CallingConvName = std::string(getEnumName( std::string CallingConvName = std::string(getEnumName(
IO, uint8_t(Record.CallConv), makeArrayRef(getCallingConventions()))); IO, uint8_t(Record.CallConv), ArrayRef(getCallingConventions())));
std::string FuncOptionNames = std::string FuncOptionNames =
getFlagNames(IO, static_cast<uint16_t>(Record.Options), getFlagNames(IO, static_cast<uint16_t>(Record.Options),
makeArrayRef(getFunctionOptionEnum())); ArrayRef(getFunctionOptionEnum()));
error(IO.mapInteger(Record.ReturnType, "ReturnType")); error(IO.mapInteger(Record.ReturnType, "ReturnType"));
error(IO.mapInteger(Record.ClassType, "ClassType")); error(IO.mapInteger(Record.ClassType, "ClassType"));
error(IO.mapInteger(Record.ThisType, "ThisType")); error(IO.mapInteger(Record.ThisType, "ThisType"));
Context not available.
SmallString<128> Attr("Attrs: "); SmallString<128> Attr("Attrs: ");
if (IO.isStreaming()) { if (IO.isStreaming()) {
std::string PtrType = std::string PtrType = std::string(getEnumName(
std::string(getEnumName(IO, unsigned(Record.getPointerKind()), IO, unsigned(Record.getPointerKind()), ArrayRef(getPtrKindNames())));
makeArrayRef(getPtrKindNames())));
Attr += "[ Type: " + PtrType; Attr += "[ Type: " + PtrType;
std::string PtrMode = std::string(getEnumName( std::string PtrMode = std::string(getEnumName(
IO, unsigned(Record.getMode()), makeArrayRef(getPtrModeNames()))); IO, unsigned(Record.getMode()), ArrayRef(getPtrModeNames())));
Attr += ", Mode: " + PtrMode; Attr += ", Mode: " + PtrMode;
auto PtrSizeOf = Record.getSize(); auto PtrSizeOf = Record.getSize();
Context not available.
MemberPointerInfo &M = *Record.MemberInfo; MemberPointerInfo &M = *Record.MemberInfo;
error(IO.mapInteger(M.ContainingType, "ClassType")); error(IO.mapInteger(M.ContainingType, "ClassType"));
std::string PtrMemberGetRepresentation = std::string(getEnumName( std::string PtrMemberGetRepresentation = std::string(getEnumName(
IO, uint16_t(M.Representation), makeArrayRef(getPtrMemberRepNames()))); IO, uint16_t(M.Representation), ArrayRef(getPtrMemberRepNames())));
error(IO.mapEnum(M.Representation, error(IO.mapEnum(M.Representation,
"Representation: " + PtrMemberGetRepresentation)); "Representation: " + PtrMemberGetRepresentation));
} }
Context not available.
std::string PropertiesNames = std::string PropertiesNames =
getFlagNames(IO, static_cast<uint16_t>(Record.Options), getFlagNames(IO, static_cast<uint16_t>(Record.Options),
makeArrayRef(getClassOptionNames())); ArrayRef(getClassOptionNames()));
error(IO.mapInteger(Record.MemberCount, "MemberCount")); error(IO.mapInteger(Record.MemberCount, "MemberCount"));
error(IO.mapEnum(Record.Options, "Properties" + PropertiesNames)); error(IO.mapEnum(Record.Options, "Properties" + PropertiesNames));
error(IO.mapInteger(Record.FieldList, "FieldList")); error(IO.mapInteger(Record.FieldList, "FieldList"));
Context not available.
Error TypeRecordMapping::visitKnownRecord(CVType &CVR, UnionRecord &Record) { Error TypeRecordMapping::visitKnownRecord(CVType &CVR, UnionRecord &Record) {
std::string PropertiesNames = std::string PropertiesNames =
getFlagNames(IO, static_cast<uint16_t>(Record.Options), getFlagNames(IO, static_cast<uint16_t>(Record.Options),
makeArrayRef(getClassOptionNames())); ArrayRef(getClassOptionNames()));
error(IO.mapInteger(Record.MemberCount, "MemberCount")); error(IO.mapInteger(Record.MemberCount, "MemberCount"));
error(IO.mapEnum(Record.Options, "Properties" + PropertiesNames)); error(IO.mapEnum(Record.Options, "Properties" + PropertiesNames));
error(IO.mapInteger(Record.FieldList, "FieldList")); error(IO.mapInteger(Record.FieldList, "FieldList"));
Context not available.
Error TypeRecordMapping::visitKnownRecord(CVType &CVR, EnumRecord &Record) { Error TypeRecordMapping::visitKnownRecord(CVType &CVR, EnumRecord &Record) {
std::string PropertiesNames = std::string PropertiesNames =
getFlagNames(IO, static_cast<uint16_t>(Record.Options), getFlagNames(IO, static_cast<uint16_t>(Record.Options),
makeArrayRef(getClassOptionNames())); ArrayRef(getClassOptionNames()));
error(IO.mapInteger(Record.MemberCount, "NumEnumerators")); error(IO.mapInteger(Record.MemberCount, "NumEnumerators"));
error(IO.mapEnum(Record.Options, "Properties" + PropertiesNames)); error(IO.mapEnum(Record.Options, "Properties" + PropertiesNames));
error(IO.mapInteger(Record.UnderlyingType, "UnderlyingType")); error(IO.mapInteger(Record.UnderlyingType, "UnderlyingType"));
Context not available.
Error TypeRecordMapping::visitKnownRecord(CVType &CVR, LabelRecord &Record) { Error TypeRecordMapping::visitKnownRecord(CVType &CVR, LabelRecord &Record) {
std::string ModeName = std::string( std::string ModeName = std::string(
getEnumName(IO, uint16_t(Record.Mode), makeArrayRef(getLabelTypeEnum()))); getEnumName(IO, uint16_t(Record.Mode), ArrayRef(getLabelTypeEnum())));
error(IO.mapEnum(Record.Mode, "Mode: " + ModeName)); error(IO.mapEnum(Record.Mode, "Mode: " + ModeName));
return Error::success(); return Error::success();
} }
Context not available.

llvm/lib/DebugInfo/DWARF/DWARFFormValue.cpp

Context not available.
bool DWARFFormValue::isFormClass(DWARFFormValue::FormClass FC) const { bool DWARFFormValue::isFormClass(DWARFFormValue::FormClass FC) const {
// First, check DWARF5 form classes. // First, check DWARF5 form classes.
if (Form < makeArrayRef(DWARF5FormClasses).size() && if (Form < ArrayRef(DWARF5FormClasses).size() &&
DWARF5FormClasses[Form] == FC) DWARF5FormClasses[Form] == FC)
return true; return true;
// Check more forms from extensions and proposals. // Check more forms from extensions and proposals.
Context not available.
if (!isFormClass(FC_Block) && !isFormClass(FC_Exprloc) && if (!isFormClass(FC_Block) && !isFormClass(FC_Exprloc) &&
Form != DW_FORM_data16) Form != DW_FORM_data16)
return std::nullopt; return std::nullopt;
return makeArrayRef(Value.data, Value.uval); return ArrayRef(Value.data, Value.uval);
} }
std::optional<uint64_t> DWARFFormValue::getAsCStringOffset() const { std::optional<uint64_t> DWARFFormValue::getAsCStringOffset() const {
Context not available.

llvm/lib/DebugInfo/DWARF/DWARFVerifier.cpp

Context not available.
uint64_t Sig = E.getSignature(); uint64_t Sig = E.getSignature();
if (!E.getContributions()) if (!E.getContributions())
continue; continue;
for (auto E : enumerate(InfoColumnKind == DW_SECT_INFO for (auto E : enumerate(
? makeArrayRef(E.getContributions(), InfoColumnKind == DW_SECT_INFO
Index.getColumnKinds().size()) ? ArrayRef(E.getContributions(), Index.getColumnKinds().size())
: makeArrayRef(E.getContribution(), 1))) { : ArrayRef(E.getContribution(), 1))) {
const DWARFUnitIndex::Entry::SectionContribution &SC = E.value(); const DWARFUnitIndex::Entry::SectionContribution &SC = E.value();
int Col = E.index(); int Col = E.index();
if (SC.Length == 0) if (SC.Length == 0)
Context not available.

llvm/lib/DebugInfo/PDB/Native/DbiStreamBuilder.cpp

Context not available.
sizeof(object::FpoData) * OldFpoData.size(); sizeof(object::FpoData) * OldFpoData.size();
DbgStreams[(int)DbgHeaderType::FPO]->WriteFn = DbgStreams[(int)DbgHeaderType::FPO]->WriteFn =
[this](BinaryStreamWriter &Writer) { [this](BinaryStreamWriter &Writer) {
return Writer.writeArray(makeArrayRef(OldFpoData)); return Writer.writeArray(ArrayRef(OldFpoData));
}; };
} }
Context not available.
if (!SectionContribs.empty()) { if (!SectionContribs.empty()) {
if (auto EC = Writer.writeEnum(DbiSecContribVer60)) if (auto EC = Writer.writeEnum(DbiSecContribVer60))
return EC; return EC;
if (auto EC = Writer.writeArray(makeArrayRef(SectionContribs))) if (auto EC = Writer.writeArray(ArrayRef(SectionContribs)))
return EC; return EC;
} }
Context not available.
SecMapHeader SMHeader = {Size, Size}; SecMapHeader SMHeader = {Size, Size};
if (auto EC = Writer.writeObject(SMHeader)) if (auto EC = Writer.writeObject(SMHeader))
return EC; return EC;
if (auto EC = Writer.writeArray(makeArrayRef(SectionMap))) if (auto EC = Writer.writeArray(ArrayRef(SectionMap)))
return EC; return EC;
} }
Context not available.

llvm/lib/DebugInfo/PDB/Native/EnumTables.cpp

Context not available.
namespace llvm { namespace llvm {
namespace pdb { namespace pdb {
ArrayRef<EnumEntry<uint16_t>> getOMFSegMapDescFlagNames() { ArrayRef<EnumEntry<uint16_t>> getOMFSegMapDescFlagNames() {
return makeArrayRef(OMFSegMapDescFlagNames); return ArrayRef(OMFSegMapDescFlagNames);
} }
} }
} }
Context not available.

llvm/lib/DebugInfo/PDB/Native/GSIStreamBuilder.cpp

Context not available.
memcpy(NameMem, Pub.Name, NameLen); memcpy(NameMem, Pub.Name, NameLen);
// Zero the null terminator and remaining bytes. // Zero the null terminator and remaining bytes.
memset(&NameMem[NameLen], 0, Size - sizeof(PublicSym32Layout) - NameLen); memset(&NameMem[NameLen], 0, Size - sizeof(PublicSym32Layout) - NameLen);
return CVSymbol(makeArrayRef(reinterpret_cast<uint8_t *>(Mem), Size)); return CVSymbol(ArrayRef(reinterpret_cast<uint8_t *>(Mem), Size));
} }
uint32_t GSIHashStreamBuilder::calculateSerializedLength() const { uint32_t GSIHashStreamBuilder::calculateSerializedLength() const {
Context not available.
if (auto EC = Writer.writeObject(Header)) if (auto EC = Writer.writeObject(Header))
return EC; return EC;
if (auto EC = Writer.writeArray(makeArrayRef(HashRecords))) if (auto EC = Writer.writeArray(ArrayRef(HashRecords)))
return EC; return EC;
if (auto EC = Writer.writeArray(makeArrayRef(HashBitmap))) if (auto EC = Writer.writeArray(ArrayRef(HashBitmap)))
return EC; return EC;
if (auto EC = Writer.writeArray(makeArrayRef(HashBuckets))) if (auto EC = Writer.writeArray(ArrayRef(HashBuckets)))
return EC; return EC;
return Error::success(); return Error::success();
} }
Context not available.
std::vector<support::ulittle32_t> PubAddrMap = computeAddrMap(Publics); std::vector<support::ulittle32_t> PubAddrMap = computeAddrMap(Publics);
assert(PubAddrMap.size() == Publics.size()); assert(PubAddrMap.size() == Publics.size());
if (auto EC = Writer.writeArray(makeArrayRef(PubAddrMap))) if (auto EC = Writer.writeArray(ArrayRef(PubAddrMap)))
return EC; return EC;
return Error::success(); return Error::success();
Context not available.

llvm/lib/DebugInfo/PDB/Native/LinePrinter.cpp

Context not available.
void LinePrinter::formatMsfStreamBlocks( void LinePrinter::formatMsfStreamBlocks(
PDBFile &File, const msf::MSFStreamLayout &StreamLayout) { PDBFile &File, const msf::MSFStreamLayout &StreamLayout) {
auto Blocks = makeArrayRef(StreamLayout.Blocks); auto Blocks = ArrayRef(StreamLayout.Blocks);
uint64_t L = StreamLayout.Length; uint64_t L = StreamLayout.Length;
while (L > 0) { while (L > 0) {
Context not available.

llvm/lib/DebugInfo/PDB/Native/TpiStreamBuilder.cpp

Context not available.
"cause misalignment in the output TPI stream!"); "cause misalignment in the output TPI stream!");
assert(Record.size() <= codeview::MaxRecordLength); assert(Record.size() <= codeview::MaxRecordLength);
uint16_t OneSize = (uint16_t)Record.size(); uint16_t OneSize = (uint16_t)Record.size();
updateTypeIndexOffsets(makeArrayRef(&OneSize, 1)); updateTypeIndexOffsets(ArrayRef(&OneSize, 1));
TypeRecBuffers.push_back(Record); TypeRecBuffers.push_back(Record);
// FIXME: Require it. // FIXME: Require it.
Context not available.

llvm/lib/DebugInfo/PDB/UDTLayout.cpp

Context not available.
// physically lay it out if it's a topmost derived class. // physically lay it out if it's a topmost derived class.
addChildToLayout(std::move(BL)); addChildToLayout(std::move(BL));
} }
VirtualBases = makeArrayRef(AllBases).drop_front(NonVirtualBases.size()); VirtualBases = ArrayRef(AllBases).drop_front(NonVirtualBases.size());
if (Parent != nullptr) if (Parent != nullptr)
LayoutSize = UsedBytes.find_last() + 1; LayoutSize = UsedBytes.find_last() + 1;
Context not available.

llvm/lib/ExecutionEngine/Orc/COFFVCRuntimeSupport.cpp

Context not available.
StringRef VCLibs[] = {"libvcruntime.lib", "libcmt.lib", "libcpmt.lib"}; StringRef VCLibs[] = {"libvcruntime.lib", "libcmt.lib", "libcpmt.lib"};
StringRef UCRTLibs[] = {"libucrt.lib"}; StringRef UCRTLibs[] = {"libucrt.lib"};
std::vector<std::string> ImportedLibraries; std::vector<std::string> ImportedLibraries;
if (auto Err = loadVCRuntime(JD, ImportedLibraries, makeArrayRef(VCLibs), if (auto Err = loadVCRuntime(JD, ImportedLibraries, ArrayRef(VCLibs),
makeArrayRef(UCRTLibs))) ArrayRef(UCRTLibs)))
return std::move(Err); return std::move(Err);
return ImportedLibraries; return ImportedLibraries;
} }
Context not available.
StringRef VCLibs[] = {"vcruntime.lib", "msvcrt.lib", "msvcprt.lib"}; StringRef VCLibs[] = {"vcruntime.lib", "msvcrt.lib", "msvcprt.lib"};
StringRef UCRTLibs[] = {"ucrt.lib"}; StringRef UCRTLibs[] = {"ucrt.lib"};
std::vector<std::string> ImportedLibraries; std::vector<std::string> ImportedLibraries;
if (auto Err = loadVCRuntime(JD, ImportedLibraries, makeArrayRef(VCLibs), if (auto Err = loadVCRuntime(JD, ImportedLibraries, ArrayRef(VCLibs),
makeArrayRef(UCRTLibs))) ArrayRef(UCRTLibs)))
return std::move(Err); return std::move(Err);
return ImportedLibraries; return ImportedLibraries;
} }
Context not available.

llvm/lib/ExecutionEngine/Orc/IndirectionUtils.cpp

Context not available.
auto SymStartInBlock = auto SymStartInBlock =
(const uint8_t *)B.getContent().data() + Sym.getOffset(); (const uint8_t *)B.getContent().data() + Sym.getOffset();
auto SymSize = Sym.getSize() ? Sym.getSize() : B.getSize() - Sym.getOffset(); auto SymSize = Sym.getSize() ? Sym.getSize() : B.getSize() - Sym.getOffset();
auto Content = makeArrayRef(SymStartInBlock, SymSize); auto Content = ArrayRef(SymStartInBlock, SymSize);
LLVM_DEBUG(dbgs() << "Adding self-relocations to " << Sym.getName() << "\n"); LLVM_DEBUG(dbgs() << "Adding self-relocations to " << Sym.getName() << "\n");
Context not available.

llvm/lib/FuzzMutate/IRMutator.cpp

Context not available.
// Choose an insertion point for our new instruction. // Choose an insertion point for our new instruction.
size_t IP = uniform<size_t>(IB.Rand, 0, Insts.size() - 1); size_t IP = uniform<size_t>(IB.Rand, 0, Insts.size() - 1);
auto InstsBefore = makeArrayRef(Insts).slice(0, IP); auto InstsBefore = ArrayRef(Insts).slice(0, IP);
auto InstsAfter = makeArrayRef(Insts).slice(IP); auto InstsAfter = ArrayRef(Insts).slice(IP);
// Choose a source, which will be used to constrain the operation selection. // Choose a source, which will be used to constrain the operation selection.
SmallVector<Value *, 2> Srcs; SmallVector<Value *, 2> Srcs;
Context not available.
if (!OpDesc) if (!OpDesc)
return; return;
for (const auto &Pred : makeArrayRef(OpDesc->SourcePreds).slice(1)) for (const auto &Pred : ArrayRef(OpDesc->SourcePreds).slice(1))
Srcs.push_back(IB.findOrCreateSource(BB, InstsBefore, Srcs, Pred)); Srcs.push_back(IB.findOrCreateSource(BB, InstsBefore, Srcs, Pred));
if (Value *Op = OpDesc->BuilderFunc(Srcs, Insts[IP])) { if (Value *Op = OpDesc->BuilderFunc(Srcs, Insts[IP])) {
Context not available.
// Choose a point where we split the block. // Choose a point where we split the block.
uint64_t IP = uniform<uint64_t>(IB.Rand, 0, Insts.size() - 1); uint64_t IP = uniform<uint64_t>(IB.Rand, 0, Insts.size() - 1);
auto InstsBeforeSplit = makeArrayRef(Insts).slice(0, IP); auto InstsBeforeSplit = ArrayRef(Insts).slice(0, IP);
// `Sink` inherits Blocks' terminator, `Source` will have a BranchInst // `Sink` inherits Blocks' terminator, `Source` will have a BranchInst
// directly jumps to `Sink`. Here, we have to create a new terminator for // directly jumps to `Sink`. Here, we have to create a new terminator for
Context not available.
uint64_t Idx = uniform<uint64_t>(IB.Rand, 0, Insts.size() - 1); uint64_t Idx = uniform<uint64_t>(IB.Rand, 0, Insts.size() - 1);
Instruction *Inst = Insts[Idx]; Instruction *Inst = Insts[Idx];
// `Idx + 1` so we don't sink to ourselves. // `Idx + 1` so we don't sink to ourselves.
auto InstsAfter = makeArrayRef(Insts).slice(Idx + 1); auto InstsAfter = ArrayRef(Insts).slice(Idx + 1);
LLVMContext &C = BB.getParent()->getParent()->getContext(); LLVMContext &C = BB.getParent()->getParent()->getContext();
// Don't sink terminators, void function calls, etc. // Don't sink terminators, void function calls, etc.
if (Inst->getType() != Type::getVoidTy(C)) if (Inst->getType() != Type::getVoidTy(C))
Context not available.

llvm/lib/FuzzMutate/Operations.cpp

Context not available.
Type *Ty = Srcs[0]->getType()->isOpaquePointerTy() Type *Ty = Srcs[0]->getType()->isOpaquePointerTy()
? Srcs[1]->getType() ? Srcs[1]->getType()
: Srcs[0]->getType()->getNonOpaquePointerElementType(); : Srcs[0]->getType()->getNonOpaquePointerElementType();
auto Indices = makeArrayRef(Srcs).drop_front(2); auto Indices = ArrayRef(Srcs).drop_front(2);
return GetElementPtrInst::Create(Ty, Srcs[0], Indices, "G", Inst); return GetElementPtrInst::Create(Ty, Srcs[0], Indices, "G", Inst);
}; };
// TODO: Handle aggregates and vectors // TODO: Handle aggregates and vectors
Context not available.

llvm/lib/IR/AttributeImpl.h

Context not available.
iterator end() const { return begin() + NumAttrs; } iterator end() const { return begin() + NumAttrs; }
void Profile(FoldingSetNodeID &ID) const { void Profile(FoldingSetNodeID &ID) const {
Profile(ID, makeArrayRef(begin(), end())); Profile(ID, ArrayRef(begin(), end()));
} }
static void Profile(FoldingSetNodeID &ID, ArrayRef<Attribute> AttrList) { static void Profile(FoldingSetNodeID &ID, ArrayRef<Attribute> AttrList) {
Context not available.

llvm/lib/IR/Attributes.cpp

Context not available.
} }
void AttributeListImpl::Profile(FoldingSetNodeID &ID) const { void AttributeListImpl::Profile(FoldingSetNodeID &ID) const {
Profile(ID, makeArrayRef(begin(), end())); Profile(ID, ArrayRef(begin(), end()));
} }
void AttributeListImpl::Profile(FoldingSetNodeID &ID, void AttributeListImpl::Profile(FoldingSetNodeID &ID,
Context not available.

llvm/lib/IR/AutoUpgrade.cpp

Context not available.
Idxs[l + i] = Idx + l; Idxs[l + i] = Idx + l;
} }
Res = Builder.CreateShuffleVector(Res, Op, makeArrayRef(Idxs, NumElts)); Res = Builder.CreateShuffleVector(Res, Op, ArrayRef(Idxs, NumElts));
} }
// Bitcast back to a 64-bit element type. // Bitcast back to a 64-bit element type.
Context not available.
Idxs[l + i] = Idx + l; Idxs[l + i] = Idx + l;
} }
Res = Builder.CreateShuffleVector(Op, Res, makeArrayRef(Idxs, NumElts)); Res = Builder.CreateShuffleVector(Op, Res, ArrayRef(Idxs, NumElts));
} }
// Bitcast back to a 64-bit element type. // Bitcast back to a 64-bit element type.
Context not available.
int Indices[4]; int Indices[4];
for (unsigned i = 0; i != NumElts; ++i) for (unsigned i = 0; i != NumElts; ++i)
Indices[i] = i; Indices[i] = i;
Mask = Builder.CreateShuffleVector( Mask = Builder.CreateShuffleVector(Mask, Mask, ArrayRef(Indices, NumElts),
Mask, Mask, makeArrayRef(Indices, NumElts), "extract"); "extract");
} }
return Mask; return Mask;
Context not available.
} }
} }
Value *Align = Builder.CreateShuffleVector(Op1, Op0, Value *Align = Builder.CreateShuffleVector(
makeArrayRef(Indices, NumElts), Op1, Op0, ArrayRef(Indices, NumElts), "palignr");
"palignr");
return EmitX86Select(Builder, Mask, Align, Passthru); return EmitX86Select(Builder, Mask, Align, Passthru);
} }
Context not available.
// First extract half of each vector. This gives better codegen than // First extract half of each vector. This gives better codegen than
// doing it in a single shuffle. // doing it in a single shuffle.
LHS = Builder.CreateShuffleVector(LHS, LHS, LHS =
makeArrayRef(Indices, NumElts / 2)); Builder.CreateShuffleVector(LHS, LHS, ArrayRef(Indices, NumElts / 2));
RHS = Builder.CreateShuffleVector(RHS, RHS, RHS =
makeArrayRef(Indices, NumElts / 2)); Builder.CreateShuffleVector(RHS, RHS, ArrayRef(Indices, NumElts / 2));
// Concat the vectors. // Concat the vectors.
// NOTE: Operands have to be swapped to match intrinsic definition. // NOTE: Operands have to be swapped to match intrinsic definition.
Rep = Builder.CreateShuffleVector(RHS, LHS, Rep = Builder.CreateShuffleVector(RHS, LHS, ArrayRef(Indices, NumElts));
makeArrayRef(Indices, NumElts));
Rep = Builder.CreateBitCast(Rep, CI->getType()); Rep = Builder.CreateBitCast(Rep, CI->getType());
} else if (IsX86 && Name == "avx512.kand.w") { } else if (IsX86 && Name == "avx512.kand.w") {
Value *LHS = getX86MaskVec(Builder, CI->getArgOperand(0), 16); Value *LHS = getX86MaskVec(Builder, CI->getArgOperand(0), 16);
Context not available.

llvm/lib/IR/ConstantFold.cpp

Context not available.
if (Idxs.empty()) return C; if (Idxs.empty()) return C;
Type *GEPTy = GetElementPtrInst::getGEPReturnType( Type *GEPTy = GetElementPtrInst::getGEPReturnType(
PointeeTy, C, makeArrayRef((Value *const *)Idxs.data(), Idxs.size())); PointeeTy, C, ArrayRef((Value *const *)Idxs.data(), Idxs.size()));
if (isa<PoisonValue>(C)) if (isa<PoisonValue>(C))
return PoisonValue::get(GEPTy); return PoisonValue::get(GEPTy);
Context not available.

llvm/lib/IR/Constants.cpp

Context not available.
StringRef Str, bool AddNull) { StringRef Str, bool AddNull) {
if (!AddNull) { if (!AddNull) {
const uint8_t *Data = Str.bytes_begin(); const uint8_t *Data = Str.bytes_begin();
return get(Context, makeArrayRef(Data, Str.size())); return get(Context, ArrayRef(Data, Str.size()));
} }
SmallVector<uint8_t, 64> ElementVals; SmallVector<uint8_t, 64> ElementVals;
Context not available.

llvm/lib/IR/Core.cpp

Context not available.
unsigned Count) { unsigned Count) {
LLVMContext &Context = *unwrap(C); LLVMContext &Context = *unwrap(C);
SmallVector<Metadata *, 8> MDs; SmallVector<Metadata *, 8> MDs;
for (auto *OV : makeArrayRef(Vals, Count)) { for (auto *OV : ArrayRef(Vals, Count)) {
Value *V = unwrap(OV); Value *V = unwrap(OV);
Metadata *MD; Metadata *MD;
if (!V) if (!V)
Context not available.
unsigned NumWords, unsigned NumWords,
const uint64_t Words[]) { const uint64_t Words[]) {
IntegerType *Ty = unwrap<IntegerType>(IntTy); IntegerType *Ty = unwrap<IntegerType>(IntTy);
return wrap(ConstantInt::get(Ty->getContext(), return wrap(ConstantInt::get(
APInt(Ty->getBitWidth(), Ty->getContext(), APInt(Ty->getBitWidth(), ArrayRef(Words, NumWords))));
makeArrayRef(Words, NumWords))));
} }
LLVMValueRef LLVMConstIntOfString(LLVMTypeRef IntTy, const char Str[], LLVMValueRef LLVMConstIntOfString(LLVMTypeRef IntTy, const char Str[],
Context not available.
LLVMValueRef *ConstantVals, LLVMValueRef *ConstantVals,
unsigned Count, LLVMBool Packed) { unsigned Count, LLVMBool Packed) {
Constant **Elements = unwrap<Constant>(ConstantVals, Count); Constant **Elements = unwrap<Constant>(ConstantVals, Count);
return wrap(ConstantStruct::getAnon(*unwrap(C), makeArrayRef(Elements, Count), return wrap(ConstantStruct::getAnon(*unwrap(C), ArrayRef(Elements, Count),
Packed != 0)); Packed != 0));
} }
Context not available.
Constant **Elements = unwrap<Constant>(ConstantVals, Count); Constant **Elements = unwrap<Constant>(ConstantVals, Count);
StructType *Ty = unwrap<StructType>(StructTy); StructType *Ty = unwrap<StructType>(StructTy);
return wrap(ConstantStruct::get(Ty, makeArrayRef(Elements, Count))); return wrap(ConstantStruct::get(Ty, ArrayRef(Elements, Count)));
} }
LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size) { LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size) {
return wrap(ConstantVector::get(makeArrayRef( return wrap(ConstantVector::get(
unwrap<Constant>(ScalarConstantVals, Size), Size))); ArrayRef(unwrap<Constant>(ScalarConstantVals, Size), Size)));
} }
/*-- Opcode mapping */ /*-- Opcode mapping */
Context not available.
LLVMValueRef *Args, unsigned NumArgs, LLVMValueRef *Args, unsigned NumArgs,
LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch, LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
const char *Name) { const char *Name) {
return wrap(unwrap(B)->CreateInvoke( return wrap(unwrap(B)->CreateInvoke(unwrap<FunctionType>(Ty), unwrap(Fn),
unwrap<FunctionType>(Ty), unwrap(Fn), unwrap(Then), unwrap(Catch), unwrap(Then), unwrap(Catch),
makeArrayRef(unwrap(Args), NumArgs), Name)); ArrayRef(unwrap(Args), NumArgs), Name));
} }
LLVMValueRef LLVMBuildLandingPad(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef LLVMBuildLandingPad(LLVMBuilderRef B, LLVMTypeRef Ty,
Context not available.
LLVMValueRef *Args, unsigned NumArgs, LLVMValueRef *Args, unsigned NumArgs,
const char *Name) { const char *Name) {
return wrap(unwrap(B)->CreateCatchPad(unwrap(ParentPad), return wrap(unwrap(B)->CreateCatchPad(unwrap(ParentPad),
makeArrayRef(unwrap(Args), NumArgs), ArrayRef(unwrap(Args), NumArgs), Name));
Name));
} }
LLVMValueRef LLVMBuildCleanupPad(LLVMBuilderRef B, LLVMValueRef ParentPad, LLVMValueRef LLVMBuildCleanupPad(LLVMBuilderRef B, LLVMValueRef ParentPad,
Context not available.
Type *Ty = Type::getTokenTy(unwrap(B)->getContext()); Type *Ty = Type::getTokenTy(unwrap(B)->getContext());
ParentPad = wrap(Constant::getNullValue(Ty)); ParentPad = wrap(Constant::getNullValue(Ty));
} }
return wrap(unwrap(B)->CreateCleanupPad(unwrap(ParentPad), return wrap(unwrap(B)->CreateCleanupPad(
makeArrayRef(unwrap(Args), NumArgs), unwrap(ParentPad), ArrayRef(unwrap(Args), NumArgs), Name));
Name));
} }
LLVMValueRef LLVMBuildResume(LLVMBuilderRef B, LLVMValueRef Exn) { LLVMValueRef LLVMBuildResume(LLVMBuilderRef B, LLVMValueRef Exn) {
Context not available.
const char *Name) { const char *Name) {
FunctionType *FTy = unwrap<FunctionType>(Ty); FunctionType *FTy = unwrap<FunctionType>(Ty);
return wrap(unwrap(B)->CreateCall(FTy, unwrap(Fn), return wrap(unwrap(B)->CreateCall(FTy, unwrap(Fn),
makeArrayRef(unwrap(Args), NumArgs), Name)); ArrayRef(unwrap(Args), NumArgs), Name));
} }
LLVMValueRef LLVMBuildSelect(LLVMBuilderRef B, LLVMValueRef If, LLVMValueRef LLVMBuildSelect(LLVMBuilderRef B, LLVMValueRef If,
Context not available.

llvm/lib/IR/DebugInfoMetadata.cpp

Context not available.
if (Expr->Elements.size() == PatternSize) if (Expr->Elements.size() == PatternSize)
return nullptr; return nullptr;
return DIExpression::get(Expr->getContext(), return DIExpression::get(Expr->getContext(),
makeArrayRef(&*Expr->Elements.begin(), ArrayRef(&*Expr->Elements.begin(),
Expr->Elements.size() - PatternSize)); Expr->Elements.size() - PatternSize));
} }
return Expr; return Expr;
} }
Context not available.

llvm/lib/IR/Function.cpp

Context not available.
// We've either found the target or just fall back to the generic set, which // We've either found the target or just fall back to the generic set, which
// is always first. // is always first.
const auto &TI = It != Targets.end() && It->Name == Target ? *It : Targets[0]; const auto &TI = It != Targets.end() && It->Name == Target ? *It : Targets[0];
return makeArrayRef(&IntrinsicNameTable[1] + TI.Offset, TI.Count); return ArrayRef(&IntrinsicNameTable[1] + TI.Offset, TI.Count);
} }
/// This does the actual lookup of an intrinsic ID which /// This does the actual lookup of an intrinsic ID which
Context not available.

llvm/lib/IR/Verifier.cpp

Context not available.
return; return;
const Function *First = DeoptimizeDeclarations[0]; const Function *First = DeoptimizeDeclarations[0];
for (const auto *F : makeArrayRef(DeoptimizeDeclarations).slice(1)) { for (const auto *F : ArrayRef(DeoptimizeDeclarations).slice(1)) {
Check(First->getCallingConv() == F->getCallingConv(), Check(First->getCallingConv() == F->getCallingConv(),
"All llvm.experimental.deoptimize declarations must have the same " "All llvm.experimental.deoptimize declarations must have the same "
"calling convention", "calling convention",
Context not available.

llvm/lib/LTO/LTO.cpp

Context not available.
}; };
ArrayRef<const char*> LTO::getRuntimeLibcallSymbols() { ArrayRef<const char*> LTO::getRuntimeLibcallSymbols() {
return makeArrayRef(libcallRoutineNames); return ArrayRef(libcallRoutineNames);
} }
/// This class defines the interface to the ThinLTO backend. /// This class defines the interface to the ThinLTO backend.
Context not available.

llvm/lib/Linker/IRMover.cpp

Context not available.
cast<PointerType>(Ty)->getAddressSpace()); cast<PointerType>(Ty)->getAddressSpace());
case Type::FunctionTyID: case Type::FunctionTyID:
return *Entry = FunctionType::get(ElementTypes[0], return *Entry = FunctionType::get(ElementTypes[0],
makeArrayRef(ElementTypes).slice(1), ArrayRef(ElementTypes).slice(1),
cast<FunctionType>(Ty)->isVarArg()); cast<FunctionType>(Ty)->isVarArg());
case Type::StructTyID: { case Type::StructTyID: {
auto *STy = cast<StructType>(Ty); auto *STy = cast<StructType>(Ty);
Context not available.

llvm/lib/MC/ELFObjectWriter.cpp

Context not available.
raw_svector_ostream VecOS(UncompressedData); raw_svector_ostream VecOS(UncompressedData);
Asm.writeSectionData(VecOS, &Section, Layout); Asm.writeSectionData(VecOS, &Section, Layout);
ArrayRef<uint8_t> Uncompressed = ArrayRef<uint8_t> Uncompressed =
makeArrayRef(reinterpret_cast<uint8_t *>(UncompressedData.data()), ArrayRef(reinterpret_cast<uint8_t *>(UncompressedData.data()),
UncompressedData.size()); UncompressedData.size());
SmallVector<uint8_t, 128> Compressed; SmallVector<uint8_t, 128> Compressed;
uint32_t ChType; uint32_t ChType;
Context not available.

llvm/lib/MC/MCCodeView.cpp

Context not available.
return std::nullopt; return std::nullopt;
if (L >= MCCVLines.size()) if (L >= MCCVLines.size())
return std::nullopt; return std::nullopt;
return makeArrayRef(&MCCVLines[L], R - L); return ArrayRef(&MCCVLines[L], R - L);
} }
void CodeViewContext::emitLineTableForFunction(MCObjectStreamer &OS, void CodeViewContext::emitLineTableForFunction(MCObjectStreamer &OS,
Context not available.

llvm/lib/MC/MCDwarf.cpp

Context not available.
}; };
assert(std::size(StandardOpcodeLengths) >= assert(std::size(StandardOpcodeLengths) >=
(Params.DWARF2LineOpcodeBase - 1U)); (Params.DWARF2LineOpcodeBase - 1U));
return Emit( return Emit(MCOS, Params,
MCOS, Params, ArrayRef(StandardOpcodeLengths, Params.DWARF2LineOpcodeBase - 1),
makeArrayRef(StandardOpcodeLengths, Params.DWARF2LineOpcodeBase - 1), LineStr);
LineStr);
} }
static const MCExpr *forceExpAbs(MCStreamer &OS, const MCExpr* Expr) { static const MCExpr *forceExpAbs(MCStreamer &OS, const MCExpr* Expr) {
Context not available.

llvm/lib/MC/WinCOFFObjectWriter.cpp

Context not available.
// Calculate our CRC with an initial value of '0', this is not how // Calculate our CRC with an initial value of '0', this is not how
// JamCRC is specified but it aligns with the expected output. // JamCRC is specified but it aligns with the expected output.
JamCRC JC(/*Init=*/0); JamCRC JC(/*Init=*/0);
JC.update(makeArrayRef(reinterpret_cast<uint8_t*>(Buf.data()), Buf.size())); JC.update(ArrayRef(reinterpret_cast<uint8_t *>(Buf.data()), Buf.size()));
return JC.getCRC(); return JC.getCRC();
} }
Context not available.

llvm/lib/ObjCopy/COFF/COFFObjcopy.cpp

Context not available.
Characteristics = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_ALIGN_1BYTES; Characteristics = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_ALIGN_1BYTES;
addSection(Obj, NewSection.SectionName, addSection(Obj, NewSection.SectionName,
makeArrayRef(reinterpret_cast<const uint8_t *>( ArrayRef(reinterpret_cast<const uint8_t *>(
NewSection.SectionData->getBufferStart()), NewSection.SectionData->getBufferStart()),
NewSection.SectionData->getBufferSize()), NewSection.SectionData->getBufferSize()),
Characteristics); Characteristics);
} }
Context not available.

llvm/lib/ObjCopy/wasm/WasmObjcopy.cpp

Context not available.
NewSection.SectionData->getBufferSize()); NewSection.SectionData->getBufferSize());
std::unique_ptr<MemoryBuffer> BufferCopy = MemoryBuffer::getMemBufferCopy( std::unique_ptr<MemoryBuffer> BufferCopy = MemoryBuffer::getMemBufferCopy(
InputData, NewSection.SectionData->getBufferIdentifier()); InputData, NewSection.SectionData->getBufferIdentifier());
Sec.Contents = makeArrayRef<uint8_t>( Sec.Contents = ArrayRef<uint8_t>(
reinterpret_cast<const uint8_t *>(BufferCopy->getBufferStart()), reinterpret_cast<const uint8_t *>(BufferCopy->getBufferStart()),
BufferCopy->getBufferSize()); BufferCopy->getBufferSize());
Context not available.

llvm/lib/Object/COFFObjectFile.cpp

Context not available.
"Aux Symbol data did not point to the beginning of a symbol"); "Aux Symbol data did not point to the beginning of a symbol");
#endif #endif
} }
return makeArrayRef(Aux, Symbol.getNumberOfAuxSymbols() * SymbolSize); return ArrayRef(Aux, Symbol.getNumberOfAuxSymbols() * SymbolSize);
} }
uint32_t COFFObjectFile::getSymbolIndex(COFFSymbolRef Symbol) const { uint32_t COFFObjectFile::getSymbolIndex(COFFSymbolRef Symbol) const {
Context not available.
uint32_t SectionSize = getSectionSize(Sec); uint32_t SectionSize = getSectionSize(Sec);
if (Error E = checkOffset(Data, ConStart, SectionSize)) if (Error E = checkOffset(Data, ConStart, SectionSize))
return E; return E;
Res = makeArrayRef(reinterpret_cast<const uint8_t *>(ConStart), SectionSize); Res = ArrayRef(reinterpret_cast<const uint8_t *>(ConStart), SectionSize);
return Error::success(); return Error::success();
} }
Context not available.

llvm/lib/Object/ELF.cpp

Context not available.
for (const Elf_Phdr &Phdr : *ProgramHeadersOrError) { for (const Elf_Phdr &Phdr : *ProgramHeadersOrError) {
if (Phdr.p_type == ELF::PT_DYNAMIC) { if (Phdr.p_type == ELF::PT_DYNAMIC) {
Dyn = makeArrayRef( Dyn = ArrayRef(reinterpret_cast<const Elf_Dyn *>(base() + Phdr.p_offset),
reinterpret_cast<const Elf_Dyn *>(base() + Phdr.p_offset), Phdr.p_filesz / sizeof(Elf_Dyn));
Phdr.p_filesz / sizeof(Elf_Dyn));
break; break;
} }
} }
Context not available.

llvm/lib/Object/MachOObjectFile.cpp

Context not available.
assert(Sec.d.a < Sections.size() && "Should have detected this earlier"); assert(Sec.d.a < Sections.size() && "Should have detected this earlier");
const section_base *Base = const section_base *Base =
reinterpret_cast<const section_base *>(Sections[Sec.d.a]); reinterpret_cast<const section_base *>(Sections[Sec.d.a]);
return makeArrayRef(Base->sectname); return ArrayRef(Base->sectname);
} }
ArrayRef<char> ArrayRef<char>
Context not available.
assert(Sec.d.a < Sections.size() && "Should have detected this earlier"); assert(Sec.d.a < Sections.size() && "Should have detected this earlier");
const section_base *Base = const section_base *Base =
reinterpret_cast<const section_base *>(Sections[Sec.d.a]); reinterpret_cast<const section_base *>(Sections[Sec.d.a]);
return makeArrayRef(Base->segname); return ArrayRef(Base->segname);
} }
bool bool
Context not available.
MachO::dyld_info_command DyldInfo = DyldInfoOrErr.get(); MachO::dyld_info_command DyldInfo = DyldInfoOrErr.get();
const uint8_t *Ptr = const uint8_t *Ptr =
reinterpret_cast<const uint8_t *>(getPtr(*this, DyldInfo.rebase_off)); reinterpret_cast<const uint8_t *>(getPtr(*this, DyldInfo.rebase_off));
return makeArrayRef(Ptr, DyldInfo.rebase_size); return ArrayRef(Ptr, DyldInfo.rebase_size);
} }
ArrayRef<uint8_t> MachOObjectFile::getDyldInfoBindOpcodes() const { ArrayRef<uint8_t> MachOObjectFile::getDyldInfoBindOpcodes() const {
Context not available.
MachO::dyld_info_command DyldInfo = DyldInfoOrErr.get(); MachO::dyld_info_command DyldInfo = DyldInfoOrErr.get();
const uint8_t *Ptr = const uint8_t *Ptr =
reinterpret_cast<const uint8_t *>(getPtr(*this, DyldInfo.bind_off)); reinterpret_cast<const uint8_t *>(getPtr(*this, DyldInfo.bind_off));
return makeArrayRef(Ptr, DyldInfo.bind_size); return ArrayRef(Ptr, DyldInfo.bind_size);
} }
ArrayRef<uint8_t> MachOObjectFile::getDyldInfoWeakBindOpcodes() const { ArrayRef<uint8_t> MachOObjectFile::getDyldInfoWeakBindOpcodes() const {
Context not available.
MachO::dyld_info_command DyldInfo = DyldInfoOrErr.get(); MachO::dyld_info_command DyldInfo = DyldInfoOrErr.get();
const uint8_t *Ptr = const uint8_t *Ptr =
reinterpret_cast<const uint8_t *>(getPtr(*this, DyldInfo.weak_bind_off)); reinterpret_cast<const uint8_t *>(getPtr(*this, DyldInfo.weak_bind_off));
return makeArrayRef(Ptr, DyldInfo.weak_bind_size); return ArrayRef(Ptr, DyldInfo.weak_bind_size);
} }
ArrayRef<uint8_t> MachOObjectFile::getDyldInfoLazyBindOpcodes() const { ArrayRef<uint8_t> MachOObjectFile::getDyldInfoLazyBindOpcodes() const {
Context not available.
MachO::dyld_info_command DyldInfo = DyldInfoOrErr.get(); MachO::dyld_info_command DyldInfo = DyldInfoOrErr.get();
const uint8_t *Ptr = const uint8_t *Ptr =
reinterpret_cast<const uint8_t *>(getPtr(*this, DyldInfo.lazy_bind_off)); reinterpret_cast<const uint8_t *>(getPtr(*this, DyldInfo.lazy_bind_off));
return makeArrayRef(Ptr, DyldInfo.lazy_bind_size); return ArrayRef(Ptr, DyldInfo.lazy_bind_size);
} }
ArrayRef<uint8_t> MachOObjectFile::getDyldInfoExportsTrie() const { ArrayRef<uint8_t> MachOObjectFile::getDyldInfoExportsTrie() const {
Context not available.
MachO::dyld_info_command DyldInfo = DyldInfoOrErr.get(); MachO::dyld_info_command DyldInfo = DyldInfoOrErr.get();
const uint8_t *Ptr = const uint8_t *Ptr =
reinterpret_cast<const uint8_t *>(getPtr(*this, DyldInfo.export_off)); reinterpret_cast<const uint8_t *>(getPtr(*this, DyldInfo.export_off));
return makeArrayRef(Ptr, DyldInfo.export_size); return ArrayRef(Ptr, DyldInfo.export_size);
} }
Expected<std::optional<MachO::linkedit_data_command>> Expected<std::optional<MachO::linkedit_data_command>>
Context not available.
MachO::linkedit_data_command DyldExportsTrie = DyldExportsTrieOrError.get(); MachO::linkedit_data_command DyldExportsTrie = DyldExportsTrieOrError.get();
const uint8_t *Ptr = const uint8_t *Ptr =
reinterpret_cast<const uint8_t *>(getPtr(*this, DyldExportsTrie.dataoff)); reinterpret_cast<const uint8_t *>(getPtr(*this, DyldExportsTrie.dataoff));
return makeArrayRef(Ptr, DyldExportsTrie.datasize); return ArrayRef(Ptr, DyldExportsTrie.datasize);
} }
SmallVector<uint64_t> MachOObjectFile::getFunctionStarts() const { SmallVector<uint64_t> MachOObjectFile::getFunctionStarts() const {
Context not available.
return std::nullopt; return std::nullopt;
// Returning a pointer is fine as uuid doesn't need endian swapping. // Returning a pointer is fine as uuid doesn't need endian swapping.
const char *Ptr = UuidLoadCmd + offsetof(MachO::uuid_command, uuid); const char *Ptr = UuidLoadCmd + offsetof(MachO::uuid_command, uuid);
return makeArrayRef(reinterpret_cast<const uint8_t *>(Ptr), 16); return ArrayRef(reinterpret_cast<const uint8_t *>(Ptr), 16);
} }
StringRef MachOObjectFile::getStringTableData() const { StringRef MachOObjectFile::getStringTableData() const {
Context not available.

llvm/lib/Object/WindowsResource.cpp

Context not available.
EndianCorrectedSrc.resize(Src.size() + 1); EndianCorrectedSrc.resize(Src.size() + 1);
llvm::copy(Src, EndianCorrectedSrc.begin() + 1); llvm::copy(Src, EndianCorrectedSrc.begin() + 1);
EndianCorrectedSrc[0] = UNI_UTF16_BYTE_ORDER_MARK_SWAPPED; EndianCorrectedSrc[0] = UNI_UTF16_BYTE_ORDER_MARK_SWAPPED;
return convertUTF16ToUTF8String(makeArrayRef(EndianCorrectedSrc), Out); return convertUTF16ToUTF8String(ArrayRef(EndianCorrectedSrc), Out);
} }
static std::string makeDuplicateResourceError( static std::string makeDuplicateResourceError(
Context not available.

llvm/lib/Object/XCOFFObjectFile.cpp

Context not available.
Twine::utohexstr(OffsetToRaw) + " and size 0x" + Twine::utohexstr(OffsetToRaw) + " and size 0x" +
Twine::utohexstr(SectionSize) + " goes past the end of the file"); Twine::utohexstr(SectionSize) + " goes past the end of the file");
return makeArrayRef(ContentStart,SectionSize); return ArrayRef(ContentStart, SectionSize);
} }
uint64_t XCOFFObjectFile::getSectionAlignment(DataRefImpl Sec) const { uint64_t XCOFFObjectFile::getSectionAlignment(DataRefImpl Sec) const {
Context not available.

llvm/lib/ObjectYAML/ELFEmitter.cpp

Context not available.
return false; return false;
State.writeELFHeader(OS); State.writeELFHeader(OS);
writeArrayData(OS, makeArrayRef(PHeaders)); writeArrayData(OS, ArrayRef(PHeaders));
const ELFYAML::SectionHeaderTable &SHT = Doc.getSectionHeaderTable(); const ELFYAML::SectionHeaderTable &SHT = Doc.getSectionHeaderTable();
if (!SHT.NoHeaders.value_or(false)) if (!SHT.NoHeaders.value_or(false))
Context not available.

llvm/lib/ObjectYAML/MinidumpEmitter.cpp

Context not available.
allocateNewArray(const iterator_range<RangeType> &Range); allocateNewArray(const iterator_range<RangeType> &Range);
template <typename T> size_t allocateObject(const T &Data) { template <typename T> size_t allocateObject(const T &Data) {
return allocateArray(makeArrayRef(Data)); return allocateArray(ArrayRef(Data));
} }
template <typename T, typename... Types> template <typename T, typename... Types>
Context not available.
File.allocateNewObject<minidump::MemoryInfoListHeader>( File.allocateNewObject<minidump::MemoryInfoListHeader>(
sizeof(minidump::MemoryInfoListHeader), sizeof(minidump::MemoryInfo), sizeof(minidump::MemoryInfoListHeader), sizeof(minidump::MemoryInfo),
InfoList.Infos.size()); InfoList.Infos.size());
File.allocateArray(makeArrayRef(InfoList.Infos)); File.allocateArray(ArrayRef(InfoList.Infos));
break; break;
} }
case Stream::StreamKind::MemoryList: case Stream::StreamKind::MemoryList:
Context not available.
File.allocateObject(Obj.Header); File.allocateObject(Obj.Header);
std::vector<Directory> StreamDirectory(Obj.Streams.size()); std::vector<Directory> StreamDirectory(Obj.Streams.size());
Obj.Header.StreamDirectoryRVA = Obj.Header.StreamDirectoryRVA = File.allocateArray(ArrayRef(StreamDirectory));
File.allocateArray(makeArrayRef(StreamDirectory));
Obj.Header.NumberOfStreams = StreamDirectory.size(); Obj.Header.NumberOfStreams = StreamDirectory.size();
for (auto &Stream : enumerate(Obj.Streams)) for (auto &Stream : enumerate(Obj.Streams))
Context not available.

llvm/lib/ObjectYAML/MinidumpYAML.cpp

Context not available.
namespace yaml { namespace yaml {
template <std::size_t N> struct ScalarTraits<FixedSizeHex<N>> { template <std::size_t N> struct ScalarTraits<FixedSizeHex<N>> {
static void output(const FixedSizeHex<N> &Fixed, void *, raw_ostream &OS) { static void output(const FixedSizeHex<N> &Fixed, void *, raw_ostream &OS) {
OS << toHex(makeArrayRef(Fixed.Storage)); OS << toHex(ArrayRef(Fixed.Storage));
} }
static StringRef input(StringRef Scalar, void *, FixedSizeHex<N> &Fixed) { static StringRef input(StringRef Scalar, void *, FixedSizeHex<N> &Fixed) {
Context not available.

llvm/lib/Option/OptTable.cpp

Context not available.
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(ArrayRef(NewArgv), MAI, MAC);
if (MAC) if (MAC)
ErrorFn((Twine(Args.getArgString(MAI)) + ": missing argument").str()); ErrorFn((Twine(Args.getArgString(MAI)) + ": missing argument").str());
Context not available.

llvm/lib/ProfileData/Coverage/CoverageMappingReader.cpp

Context not available.
Expressions.clear(); Expressions.clear();
MappingRegions.clear(); MappingRegions.clear();
auto &R = MappingRecords[CurrentRecord]; auto &R = MappingRecords[CurrentRecord];
auto F = makeArrayRef(Filenames).slice(R.FilenamesBegin, R.FilenamesSize); auto F = ArrayRef(Filenames).slice(R.FilenamesBegin, R.FilenamesSize);
RawCoverageMappingReader Reader(R.CoverageMapping, F, FunctionsFilenames, RawCoverageMappingReader Reader(R.CoverageMapping, F, FunctionsFilenames,
Expressions, MappingRegions); Expressions, MappingRegions);
if (auto Err = Reader.read()) if (auto Err = Reader.read())
Context not available.

llvm/lib/ProfileData/InstrProf.cpp

Context not available.
if (!llvm::compression::zlib::isAvailable()) if (!llvm::compression::zlib::isAvailable())
return make_error<InstrProfError>(instrprof_error::zlib_unavailable); return make_error<InstrProfError>(instrprof_error::zlib_unavailable);
if (Error E = compression::zlib::decompress( if (Error E = compression::zlib::decompress(ArrayRef(P, CompressedSize),
makeArrayRef(P, CompressedSize), UncompressedNameStrings, UncompressedNameStrings,
UncompressedSize)) { UncompressedSize)) {
consumeError(std::move(E)); consumeError(std::move(E));
return make_error<InstrProfError>(instrprof_error::uncompress_failed); return make_error<InstrProfError>(instrprof_error::uncompress_failed);
} }
Context not available.

llvm/lib/ProfileData/SampleProfReader.cpp

Context not available.
uint8_t *Buffer = Allocator.Allocate<uint8_t>(DecompressBufSize); uint8_t *Buffer = Allocator.Allocate<uint8_t>(DecompressBufSize);
size_t UCSize = DecompressBufSize; size_t UCSize = DecompressBufSize;
llvm::Error E = compression::zlib::decompress( llvm::Error E = compression::zlib::decompress(ArrayRef(Data, *CompressSize),
makeArrayRef(Data, *CompressSize), Buffer, UCSize); Buffer, UCSize);
if (E) if (E)
return sampleprof_error::uncompress_failed; return sampleprof_error::uncompress_failed;
DecompressBuf = reinterpret_cast<const uint8_t *>(Buffer); DecompressBuf = reinterpret_cast<const uint8_t *>(Buffer);
Context not available.

llvm/lib/Support/APFloat.cpp

Context not available.
unsigned int width, bool isSigned, unsigned int width, bool isSigned,
roundingMode rounding_mode) { roundingMode rounding_mode) {
unsigned int partCount = partCountForBits(width); unsigned int partCount = partCountForBits(width);
APInt api = APInt(width, makeArrayRef(parts, partCount)); APInt api = APInt(width, ArrayRef(parts, partCount));
sign = false; sign = false;
if (isSigned && APInt::tcExtractBit(parts, width - 1)) { if (isSigned && APInt::tcExtractBit(parts, width - 1)) {
Context not available.
// Decompose the number into an APInt and an exponent. // Decompose the number into an APInt and an exponent.
int exp = exponent - ((int) semantics->precision - 1); int exp = exponent - ((int) semantics->precision - 1);
APInt significand(semantics->precision, APInt significand(
makeArrayRef(significandParts(), semantics->precision,
partCountForBits(semantics->precision))); ArrayRef(significandParts(), partCountForBits(semantics->precision)));
// Set FormatPrecision if zero. We want to do this before we // Set FormatPrecision if zero. We want to do this before we
// truncate trailing zeros, as those are part of the precision. // truncate trailing zeros, as those are part of the precision.
Context not available.

llvm/lib/Support/APInt.cpp

Context not available.
APInt::APInt(unsigned numBits, unsigned numWords, const uint64_t bigVal[]) APInt::APInt(unsigned numBits, unsigned numWords, const uint64_t bigVal[])
: BitWidth(numBits) { : BitWidth(numBits) {
initFromArray(makeArrayRef(bigVal, numWords)); initFromArray(ArrayRef(bigVal, numWords));
} }
APInt::APInt(unsigned numbits, StringRef Str, uint8_t radix) APInt::APInt(unsigned numbits, StringRef Str, uint8_t radix)
Context not available.
// Extracting bits that start on a source word boundary can be done // Extracting bits that start on a source word boundary can be done
// as a fast memory copy. // as a fast memory copy.
if (loBit == 0) if (loBit == 0)
return APInt(numBits, makeArrayRef(U.pVal + loWord, 1 + hiWord - loWord)); return APInt(numBits, ArrayRef(U.pVal + loWord, 1 + hiWord - loWord));
// General case - shift + copy source words directly into place. // General case - shift + copy source words directly into place.
APInt Result(numBits, 0); APInt Result(numBits, 0);
Context not available.

llvm/lib/Support/ARMAttributeParser.cpp

Context not available.
"ARM v9-A"}; "ARM v9-A"};
Error ARMAttributeParser::CPU_arch(AttrType tag) { Error ARMAttributeParser::CPU_arch(AttrType tag) {
return parseStringAttribute("CPU_arch", tag, makeArrayRef(CPU_arch_strings)); return parseStringAttribute("CPU_arch", tag, ArrayRef(CPU_arch_strings));
} }
Error ARMAttributeParser::CPU_arch_profile(AttrType tag) { Error ARMAttributeParser::CPU_arch_profile(AttrType tag) {
Context not available.
Error ARMAttributeParser::ARM_ISA_use(AttrType tag) { Error ARMAttributeParser::ARM_ISA_use(AttrType tag) {
static const char *strings[] = {"Not Permitted", "Permitted"}; static const char *strings[] = {"Not Permitted", "Permitted"};
return parseStringAttribute("ARM_ISA_use", tag, makeArrayRef(strings)); return parseStringAttribute("ARM_ISA_use", tag, ArrayRef(strings));
} }
Error ARMAttributeParser::THUMB_ISA_use(AttrType tag) { Error ARMAttributeParser::THUMB_ISA_use(AttrType tag) {
static const char *strings[] = {"Not Permitted", "Thumb-1", "Thumb-2", "Permitted"}; static const char *strings[] = {"Not Permitted", "Thumb-1", "Thumb-2", "Permitted"};
return parseStringAttribute("THUMB_ISA_use", tag, makeArrayRef(strings)); return parseStringAttribute("THUMB_ISA_use", tag, ArrayRef(strings));
} }
Error ARMAttributeParser::FP_arch(AttrType tag) { Error ARMAttributeParser::FP_arch(AttrType tag) {
static const char *strings[] = { static const char *strings[] = {
"Not Permitted", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "Not Permitted", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16",
"VFPv4", "VFPv4-D16", "ARMv8-a FP", "ARMv8-a FP-D16"}; "VFPv4", "VFPv4-D16", "ARMv8-a FP", "ARMv8-a FP-D16"};
return parseStringAttribute("FP_arch", tag, makeArrayRef(strings)); return parseStringAttribute("FP_arch", tag, ArrayRef(strings));
} }
Error ARMAttributeParser::WMMX_arch(AttrType tag) { Error ARMAttributeParser::WMMX_arch(AttrType tag) {
static const char *strings[] = {"Not Permitted", "WMMXv1", "WMMXv2"}; static const char *strings[] = {"Not Permitted", "WMMXv1", "WMMXv2"};
return parseStringAttribute("WMMX_arch", tag, makeArrayRef(strings)); return parseStringAttribute("WMMX_arch", tag, ArrayRef(strings));
} }
Error ARMAttributeParser::Advanced_SIMD_arch(AttrType tag) { Error ARMAttributeParser::Advanced_SIMD_arch(AttrType tag) {
static const char *strings[] = {"Not Permitted", "NEONv1", "NEONv2+FMA", static const char *strings[] = {"Not Permitted", "NEONv1", "NEONv2+FMA",
"ARMv8-a NEON", "ARMv8.1-a NEON"}; "ARMv8-a NEON", "ARMv8.1-a NEON"};
return parseStringAttribute("Advanced_SIMD_arch", tag, makeArrayRef(strings)); return parseStringAttribute("Advanced_SIMD_arch", tag, ArrayRef(strings));
} }
Error ARMAttributeParser::MVE_arch(AttrType tag) { Error ARMAttributeParser::MVE_arch(AttrType tag) {
static const char *strings[] = {"Not Permitted", "MVE integer", static const char *strings[] = {"Not Permitted", "MVE integer",
"MVE integer and float"}; "MVE integer and float"};
return parseStringAttribute("MVE_arch", tag, makeArrayRef(strings)); return parseStringAttribute("MVE_arch", tag, ArrayRef(strings));
} }
Error ARMAttributeParser::PCS_config(AttrType tag) { Error ARMAttributeParser::PCS_config(AttrType tag) {
static const char *strings[] = { static const char *strings[] = {
"None", "Bare Platform", "Linux Application", "Linux DSO", "Palm OS 2004", "None", "Bare Platform", "Linux Application", "Linux DSO", "Palm OS 2004",
"Reserved (Palm OS)", "Symbian OS 2004", "Reserved (Symbian OS)"}; "Reserved (Palm OS)", "Symbian OS 2004", "Reserved (Symbian OS)"};
return parseStringAttribute("PCS_config", tag, makeArrayRef(strings)); return parseStringAttribute("PCS_config", tag, ArrayRef(strings));
} }
Error ARMAttributeParser::ABI_PCS_R9_use(AttrType tag) { Error ARMAttributeParser::ABI_PCS_R9_use(AttrType tag) {
static const char *strings[] = {"v6", "Static Base", "TLS", "Unused"}; static const char *strings[] = {"v6", "Static Base", "TLS", "Unused"};
return parseStringAttribute("ABI_PCS_R9_use", tag, makeArrayRef(strings)); return parseStringAttribute("ABI_PCS_R9_use", tag, ArrayRef(strings));
} }
Error ARMAttributeParser::ABI_PCS_RW_data(AttrType tag) { Error ARMAttributeParser::ABI_PCS_RW_data(AttrType tag) {
static const char *strings[] = {"Absolute", "PC-relative", "SB-relative", static const char *strings[] = {"Absolute", "PC-relative", "SB-relative",
"Not Permitted"}; "Not Permitted"};
return parseStringAttribute("ABI_PCS_RW_data", tag, makeArrayRef(strings)); return parseStringAttribute("ABI_PCS_RW_data", tag, ArrayRef(strings));
} }
Error ARMAttributeParser::ABI_PCS_RO_data(AttrType tag) { Error ARMAttributeParser::ABI_PCS_RO_data(AttrType tag) {
static const char *strings[] = {"Absolute", "PC-relative", "Not Permitted"}; static const char *strings[] = {"Absolute", "PC-relative", "Not Permitted"};
return parseStringAttribute("ABI_PCS_RO_data", tag, makeArrayRef(strings)); return parseStringAttribute("ABI_PCS_RO_data", tag, ArrayRef(strings));
} }
Error ARMAttributeParser::ABI_PCS_GOT_use(AttrType tag) { Error ARMAttributeParser::ABI_PCS_GOT_use(AttrType tag) {
static const char *strings[] = {"Not Permitted", "Direct", "GOT-Indirect"}; static const char *strings[] = {"Not Permitted", "Direct", "GOT-Indirect"};
return parseStringAttribute("ABI_PCS_GOT_use", tag, makeArrayRef(strings)); return parseStringAttribute("ABI_PCS_GOT_use", tag, ArrayRef(strings));
} }
Error ARMAttributeParser::ABI_PCS_wchar_t(AttrType tag) { Error ARMAttributeParser::ABI_PCS_wchar_t(AttrType tag) {
static const char *strings[] = {"Not Permitted", "Unknown", "2-byte", static const char *strings[] = {"Not Permitted", "Unknown", "2-byte",
"Unknown", "4-byte"}; "Unknown", "4-byte"};
return parseStringAttribute("ABI_PCS_wchar_t", tag, makeArrayRef(strings)); return parseStringAttribute("ABI_PCS_wchar_t", tag, ArrayRef(strings));
} }
Error ARMAttributeParser::ABI_FP_rounding(AttrType tag) { Error ARMAttributeParser::ABI_FP_rounding(AttrType tag) {
static const char *strings[] = {"IEEE-754", "Runtime"}; static const char *strings[] = {"IEEE-754", "Runtime"};
return parseStringAttribute("ABI_FP_rounding", tag, makeArrayRef(strings)); return parseStringAttribute("ABI_FP_rounding", tag, ArrayRef(strings));
} }
Error ARMAttributeParser::ABI_FP_denormal(AttrType tag) { Error ARMAttributeParser::ABI_FP_denormal(AttrType tag) {
static const char *strings[] = {"Unsupported", "IEEE-754", "Sign Only"}; static const char *strings[] = {"Unsupported", "IEEE-754", "Sign Only"};
return parseStringAttribute("ABI_FP_denormal", tag, makeArrayRef(strings)); return parseStringAttribute("ABI_FP_denormal", tag, ArrayRef(strings));
} }
Error ARMAttributeParser::ABI_FP_exceptions(AttrType tag) { Error ARMAttributeParser::ABI_FP_exceptions(AttrType tag) {
static const char *strings[] = {"Not Permitted", "IEEE-754"}; static const char *strings[] = {"Not Permitted", "IEEE-754"};
return parseStringAttribute("ABI_FP_exceptions", tag, makeArrayRef(strings)); return parseStringAttribute("ABI_FP_exceptions", tag, ArrayRef(strings));
} }
Error ARMAttributeParser::ABI_FP_user_exceptions(AttrType tag) { Error ARMAttributeParser::ABI_FP_user_exceptions(AttrType tag) {
static const char *strings[] = {"Not Permitted", "IEEE-754"}; static const char *strings[] = {"Not Permitted", "IEEE-754"};
return parseStringAttribute("ABI_FP_user_exceptions", tag, return parseStringAttribute("ABI_FP_user_exceptions", tag, ArrayRef(strings));
makeArrayRef(strings));
} }
Error ARMAttributeParser::ABI_FP_number_model(AttrType tag) { Error ARMAttributeParser::ABI_FP_number_model(AttrType tag) {
static const char *strings[] = {"Not Permitted", "Finite Only", "RTABI", static const char *strings[] = {"Not Permitted", "Finite Only", "RTABI",
"IEEE-754"}; "IEEE-754"};
return parseStringAttribute("ABI_FP_number_model", tag, return parseStringAttribute("ABI_FP_number_model", tag, ArrayRef(strings));
makeArrayRef(strings));
} }
Error ARMAttributeParser::ABI_align_needed(AttrType tag) { Error ARMAttributeParser::ABI_align_needed(AttrType tag) {
Context not available.
Error ARMAttributeParser::ABI_enum_size(AttrType tag) { Error ARMAttributeParser::ABI_enum_size(AttrType tag) {
static const char *strings[] = {"Not Permitted", "Packed", "Int32", static const char *strings[] = {"Not Permitted", "Packed", "Int32",
"External Int32"}; "External Int32"};
return parseStringAttribute("ABI_enum_size", tag, makeArrayRef(strings)); return parseStringAttribute("ABI_enum_size", tag, ArrayRef(strings));
} }
Error ARMAttributeParser::ABI_HardFP_use(AttrType tag) { Error ARMAttributeParser::ABI_HardFP_use(AttrType tag) {
static const char *strings[] = {"Tag_FP_arch", "Single-Precision", "Reserved", static const char *strings[] = {"Tag_FP_arch", "Single-Precision", "Reserved",
"Tag_FP_arch (deprecated)"}; "Tag_FP_arch (deprecated)"};
return parseStringAttribute("ABI_HardFP_use", tag, makeArrayRef(strings)); return parseStringAttribute("ABI_HardFP_use", tag, ArrayRef(strings));
} }
Error ARMAttributeParser::ABI_VFP_args(AttrType tag) { Error ARMAttributeParser::ABI_VFP_args(AttrType tag) {
static const char *strings[] = {"AAPCS", "AAPCS VFP", "Custom", static const char *strings[] = {"AAPCS", "AAPCS VFP", "Custom",
"Not Permitted"}; "Not Permitted"};
return parseStringAttribute("ABI_VFP_args", tag, makeArrayRef(strings)); return parseStringAttribute("ABI_VFP_args", tag, ArrayRef(strings));
} }
Error ARMAttributeParser::ABI_WMMX_args(AttrType tag) { Error ARMAttributeParser::ABI_WMMX_args(AttrType tag) {
static const char *strings[] = {"AAPCS", "iWMMX", "Custom"}; static const char *strings[] = {"AAPCS", "iWMMX", "Custom"};
return parseStringAttribute("ABI_WMMX_args", tag, makeArrayRef(strings)); return parseStringAttribute("ABI_WMMX_args", tag, ArrayRef(strings));
} }
Error ARMAttributeParser::ABI_optimization_goals(AttrType tag) { Error ARMAttributeParser::ABI_optimization_goals(AttrType tag) {
Context not available.
"None", "Speed", "Aggressive Speed", "Size", "Aggressive Size", "Debugging", "None", "Speed", "Aggressive Speed", "Size", "Aggressive Size", "Debugging",
"Best Debugging" "Best Debugging"
}; };
return parseStringAttribute("ABI_optimization_goals", tag, return parseStringAttribute("ABI_optimization_goals", tag, ArrayRef(strings));
makeArrayRef(strings));
} }
Error ARMAttributeParser::ABI_FP_optimization_goals(AttrType tag) { Error ARMAttributeParser::ABI_FP_optimization_goals(AttrType tag) {
Context not available.
"None", "Speed", "Aggressive Speed", "Size", "Aggressive Size", "None", "Speed", "Aggressive Speed", "Size", "Aggressive Size",
"Accuracy", "Best Accuracy"}; "Accuracy", "Best Accuracy"};
return parseStringAttribute("ABI_FP_optimization_goals", tag, return parseStringAttribute("ABI_FP_optimization_goals", tag,
makeArrayRef(strings)); ArrayRef(strings));
} }
Error ARMAttributeParser::compatibility(AttrType tag) { Error ARMAttributeParser::compatibility(AttrType tag) {
Context not available.
Error ARMAttributeParser::CPU_unaligned_access(AttrType tag) { Error ARMAttributeParser::CPU_unaligned_access(AttrType tag) {
static const char *strings[] = {"Not Permitted", "v6-style"}; static const char *strings[] = {"Not Permitted", "v6-style"};
return parseStringAttribute("CPU_unaligned_access", tag, return parseStringAttribute("CPU_unaligned_access", tag, ArrayRef(strings));
makeArrayRef(strings));
} }
Error ARMAttributeParser::FP_HP_extension(AttrType tag) { Error ARMAttributeParser::FP_HP_extension(AttrType tag) {
static const char *strings[] = {"If Available", "Permitted"}; static const char *strings[] = {"If Available", "Permitted"};
return parseStringAttribute("FP_HP_extension", tag, makeArrayRef(strings)); return parseStringAttribute("FP_HP_extension", tag, ArrayRef(strings));
} }
Error ARMAttributeParser::ABI_FP_16bit_format(AttrType tag) { Error ARMAttributeParser::ABI_FP_16bit_format(AttrType tag) {
static const char *strings[] = {"Not Permitted", "IEEE-754", "VFPv3"}; static const char *strings[] = {"Not Permitted", "IEEE-754", "VFPv3"};
return parseStringAttribute("ABI_FP_16bit_format", tag, return parseStringAttribute("ABI_FP_16bit_format", tag, ArrayRef(strings));
makeArrayRef(strings));
} }
Error ARMAttributeParser::MPextension_use(AttrType tag) { Error ARMAttributeParser::MPextension_use(AttrType tag) {
static const char *strings[] = {"Not Permitted", "Permitted"}; static const char *strings[] = {"Not Permitted", "Permitted"};
return parseStringAttribute("MPextension_use", tag, makeArrayRef(strings)); return parseStringAttribute("MPextension_use", tag, ArrayRef(strings));
} }
Error ARMAttributeParser::DIV_use(AttrType tag) { Error ARMAttributeParser::DIV_use(AttrType tag) {
static const char *strings[] = {"If Available", "Not Permitted", "Permitted"}; static const char *strings[] = {"If Available", "Not Permitted", "Permitted"};
return parseStringAttribute("DIV_use", tag, makeArrayRef(strings)); return parseStringAttribute("DIV_use", tag, ArrayRef(strings));
} }
Error ARMAttributeParser::DSP_extension(AttrType tag) { Error ARMAttributeParser::DSP_extension(AttrType tag) {
static const char *strings[] = {"Not Permitted", "Permitted"}; static const char *strings[] = {"Not Permitted", "Permitted"};
return parseStringAttribute("DSP_extension", tag, makeArrayRef(strings)); return parseStringAttribute("DSP_extension", tag, ArrayRef(strings));
} }
Error ARMAttributeParser::T2EE_use(AttrType tag) { Error ARMAttributeParser::T2EE_use(AttrType tag) {
static const char *strings[] = {"Not Permitted", "Permitted"}; static const char *strings[] = {"Not Permitted", "Permitted"};
return parseStringAttribute("T2EE_use", tag, makeArrayRef(strings)); return parseStringAttribute("T2EE_use", tag, ArrayRef(strings));
} }
Error ARMAttributeParser::Virtualization_use(AttrType tag) { Error ARMAttributeParser::Virtualization_use(AttrType tag) {
static const char *strings[] = {"Not Permitted", "TrustZone", static const char *strings[] = {"Not Permitted", "TrustZone",
"Virtualization Extensions", "Virtualization Extensions",
"TrustZone + Virtualization Extensions"}; "TrustZone + Virtualization Extensions"};
return parseStringAttribute("Virtualization_use", tag, makeArrayRef(strings)); return parseStringAttribute("Virtualization_use", tag, ArrayRef(strings));
} }
Error ARMAttributeParser::PAC_extension(ARMBuildAttrs::AttrType tag) { Error ARMAttributeParser::PAC_extension(ARMBuildAttrs::AttrType tag) {
static const char *strings[] = {"Not Permitted", "Permitted in NOP space", static const char *strings[] = {"Not Permitted", "Permitted in NOP space",
"Permitted"}; "Permitted"};
return parseStringAttribute("PAC_extension", tag, makeArrayRef(strings)); return parseStringAttribute("PAC_extension", tag, ArrayRef(strings));
} }
Error ARMAttributeParser::BTI_extension(ARMBuildAttrs::AttrType tag) { Error ARMAttributeParser::BTI_extension(ARMBuildAttrs::AttrType tag) {
static const char *strings[] = {"Not Permitted", "Permitted in NOP space", static const char *strings[] = {"Not Permitted", "Permitted in NOP space",
"Permitted"}; "Permitted"};
return parseStringAttribute("BTI_extension", tag, makeArrayRef(strings)); return parseStringAttribute("BTI_extension", tag, ArrayRef(strings));
} }
Error ARMAttributeParser::PACRET_use(ARMBuildAttrs::AttrType tag) { Error ARMAttributeParser::PACRET_use(ARMBuildAttrs::AttrType tag) {
static const char *strings[] = {"Not Used", "Used"}; static const char *strings[] = {"Not Used", "Used"};
return parseStringAttribute("PACRET_use", tag, makeArrayRef(strings)); return parseStringAttribute("PACRET_use", tag, ArrayRef(strings));
} }
Error ARMAttributeParser::BTI_use(ARMBuildAttrs::AttrType tag) { Error ARMAttributeParser::BTI_use(ARMBuildAttrs::AttrType tag) {
static const char *strings[] = {"Not Used", "Used"}; static const char *strings[] = {"Not Used", "Used"};
return parseStringAttribute("BTI_use", tag, makeArrayRef(strings)); return parseStringAttribute("BTI_use", tag, ArrayRef(strings));
} }
Error ARMAttributeParser::nodefaults(AttrType tag) { Error ARMAttributeParser::nodefaults(AttrType tag) {
Context not available.
switch (InnerTag) { switch (InnerTag) {
case ARMBuildAttrs::CPU_arch: { case ARMBuildAttrs::CPU_arch: {
uint64_t InnerValue = de.getULEB128(cursor); uint64_t InnerValue = de.getULEB128(cursor);
auto strings = makeArrayRef(CPU_arch_strings); auto strings = ArrayRef(CPU_arch_strings);
if (InnerValue >= strings.size()) { if (InnerValue >= strings.size()) {
returnValue = createStringError( returnValue = createStringError(
errc::argument_out_of_domain, errc::argument_out_of_domain,
Context not available.

llvm/lib/Support/BinaryStreamRef.cpp

Context not available.
: BinaryStreamRefBase(std::make_shared<ArrayRefImpl>(Data, Endian), 0, : BinaryStreamRefBase(std::make_shared<ArrayRefImpl>(Data, Endian), 0,
Data.size()) {} Data.size()) {}
BinaryStreamRef::BinaryStreamRef(StringRef Data, endianness Endian) BinaryStreamRef::BinaryStreamRef(StringRef Data, endianness Endian)
: BinaryStreamRef(makeArrayRef(Data.bytes_begin(), Data.bytes_end()), : BinaryStreamRef(ArrayRef(Data.bytes_begin(), Data.bytes_end()), Endian) {}
Endian) {}
Error BinaryStreamRef::readBytes(uint64_t Offset, uint64_t Size, Error BinaryStreamRef::readBytes(uint64_t Offset, uint64_t Size,
ArrayRef<uint8_t> &Buffer) const { ArrayRef<uint8_t> &Buffer) const {
Context not available.

llvm/lib/Support/CSKYAttributeParser.cpp

Context not available.
Error CSKYAttributeParser::dspVersion(unsigned tag) { Error CSKYAttributeParser::dspVersion(unsigned tag) {
static const char *strings[] = {"Error", "DSP Extension", "DSP 2.0"}; static const char *strings[] = {"Error", "DSP Extension", "DSP 2.0"};
return parseStringAttribute("Tag_CSKY_DSP_VERSION", tag, return parseStringAttribute("Tag_CSKY_DSP_VERSION", tag, ArrayRef(strings));
makeArrayRef(strings));
} }
Error CSKYAttributeParser::vdspVersion(unsigned tag) { Error CSKYAttributeParser::vdspVersion(unsigned tag) {
static const char *strings[] = {"Error", "VDSP Version 1", "VDSP Version 2"}; static const char *strings[] = {"Error", "VDSP Version 1", "VDSP Version 2"};
return parseStringAttribute("Tag_CSKY_VDSP_VERSION", tag, return parseStringAttribute("Tag_CSKY_VDSP_VERSION", tag, ArrayRef(strings));
makeArrayRef(strings));
} }
Error CSKYAttributeParser::fpuVersion(unsigned tag) { Error CSKYAttributeParser::fpuVersion(unsigned tag) {
static const char *strings[] = {"Error", "FPU Version 1", "FPU Version 2", static const char *strings[] = {"Error", "FPU Version 1", "FPU Version 2",
"FPU Version 3"}; "FPU Version 3"};
return parseStringAttribute("Tag_CSKY_FPU_VERSION", tag, return parseStringAttribute("Tag_CSKY_FPU_VERSION", tag, ArrayRef(strings));
makeArrayRef(strings));
} }
Error CSKYAttributeParser::fpuABI(unsigned tag) { Error CSKYAttributeParser::fpuABI(unsigned tag) {
static const char *strings[] = {"Error", "Soft", "SoftFP", "Hard"}; static const char *strings[] = {"Error", "Soft", "SoftFP", "Hard"};
return parseStringAttribute("Tag_CSKY_FPU_ABI", tag, makeArrayRef(strings)); return parseStringAttribute("Tag_CSKY_FPU_ABI", tag, ArrayRef(strings));
} }
Error CSKYAttributeParser::fpuRounding(unsigned tag) { Error CSKYAttributeParser::fpuRounding(unsigned tag) {
static const char *strings[] = {"None", "Needed"}; static const char *strings[] = {"None", "Needed"};
return parseStringAttribute("Tag_CSKY_FPU_ROUNDING", tag, return parseStringAttribute("Tag_CSKY_FPU_ROUNDING", tag, ArrayRef(strings));
makeArrayRef(strings));
} }
Error CSKYAttributeParser::fpuDenormal(unsigned tag) { Error CSKYAttributeParser::fpuDenormal(unsigned tag) {
static const char *strings[] = {"None", "Needed"}; static const char *strings[] = {"None", "Needed"};
return parseStringAttribute("Tag_CSKY_FPU_DENORMAL", tag, return parseStringAttribute("Tag_CSKY_FPU_DENORMAL", tag, ArrayRef(strings));
makeArrayRef(strings));
} }
Error CSKYAttributeParser::fpuException(unsigned tag) { Error CSKYAttributeParser::fpuException(unsigned tag) {
static const char *strings[] = {"None", "Needed"}; static const char *strings[] = {"None", "Needed"};
return parseStringAttribute("Tag_CSKY_FPU_EXCEPTION", tag, return parseStringAttribute("Tag_CSKY_FPU_EXCEPTION", tag, ArrayRef(strings));
makeArrayRef(strings));
} }
Error CSKYAttributeParser::fpuHardFP(unsigned tag) { Error CSKYAttributeParser::fpuHardFP(unsigned tag) {
Context not available.

llvm/lib/Support/ELFAttributeParser.cpp

Context not available.
return cursor.takeError(); return cursor.takeError();
if (sw) { if (sw) {
sw->printEnum("Tag", tag, makeArrayRef(tagNames)); sw->printEnum("Tag", tag, ArrayRef(tagNames));
sw->printNumber("Size", size); sw->printNumber("Size", size);
} }
if (size < 5) if (size < 5)
Context not available.

llvm/lib/Support/MD5.cpp

Context not available.
memcpy(&InternalState.buffer[used], Ptr, free); memcpy(&InternalState.buffer[used], Ptr, free);
Ptr = Ptr + free; Ptr = Ptr + free;
Size -= free; Size -= free;
body(makeArrayRef(InternalState.buffer, 64)); body(ArrayRef(InternalState.buffer, 64));
} }
if (Size >= 64) { if (Size >= 64) {
Ptr = body(makeArrayRef(Ptr, Size & ~(unsigned long) 0x3f)); Ptr = body(ArrayRef(Ptr, Size & ~(unsigned long)0x3f));
Size &= 0x3f; Size &= 0x3f;
} }
Context not available.
if (free < 8) { if (free < 8) {
memset(&InternalState.buffer[used], 0, free); memset(&InternalState.buffer[used], 0, free);
body(makeArrayRef(InternalState.buffer, 64)); body(ArrayRef(InternalState.buffer, 64));
used = 0; used = 0;
free = 64; free = 64;
} }
Context not available.
support::endian::write32le(&InternalState.buffer[56], InternalState.lo); support::endian::write32le(&InternalState.buffer[56], InternalState.lo);
support::endian::write32le(&InternalState.buffer[60], InternalState.hi); support::endian::write32le(&InternalState.buffer[60], InternalState.hi);
body(makeArrayRef(InternalState.buffer, 64)); body(ArrayRef(InternalState.buffer, 64));
support::endian::write32le(&Result[0], InternalState.a); support::endian::write32le(&Result[0], InternalState.a);
support::endian::write32le(&Result[4], InternalState.b); support::endian::write32le(&Result[4], InternalState.b);
Context not available.

llvm/lib/Support/MSP430AttributeParser.cpp

Context not available.
Error MSP430AttributeParser::parseISA(AttrType Tag) { Error MSP430AttributeParser::parseISA(AttrType Tag) {
static const char *StringVals[] = {"None", "MSP430", "MSP430X"}; static const char *StringVals[] = {"None", "MSP430", "MSP430X"};
return parseStringAttribute("ISA", Tag, makeArrayRef(StringVals)); return parseStringAttribute("ISA", Tag, ArrayRef(StringVals));
} }
Error MSP430AttributeParser::parseCodeModel(AttrType Tag) { Error MSP430AttributeParser::parseCodeModel(AttrType Tag) {
static const char *StringVals[] = {"None", "Small", "Large"}; static const char *StringVals[] = {"None", "Small", "Large"};
return parseStringAttribute("Code Model", Tag, makeArrayRef(StringVals)); return parseStringAttribute("Code Model", Tag, ArrayRef(StringVals));
} }
Error MSP430AttributeParser::parseDataModel(AttrType Tag) { Error MSP430AttributeParser::parseDataModel(AttrType Tag) {
static const char *StringVals[] = {"None", "Small", "Large", "Restricted"}; static const char *StringVals[] = {"None", "Small", "Large", "Restricted"};
return parseStringAttribute("Data Model", Tag, makeArrayRef(StringVals)); return parseStringAttribute("Data Model", Tag, ArrayRef(StringVals));
} }
Error MSP430AttributeParser::parseEnumSize(AttrType Tag) { Error MSP430AttributeParser::parseEnumSize(AttrType Tag) {
static const char *StringVals[] = {"None", "Small", "Integer", "Don't Care"}; static const char *StringVals[] = {"None", "Small", "Integer", "Don't Care"};
return parseStringAttribute("Enum Size", Tag, makeArrayRef(StringVals)); return parseStringAttribute("Enum Size", Tag, ArrayRef(StringVals));
} }
Error MSP430AttributeParser::handler(uint64_t Tag, bool &Handled) { Error MSP430AttributeParser::handler(uint64_t Tag, bool &Handled) {
Context not available.

llvm/lib/Support/Path.cpp

Context not available.
if (!components.empty()) { if (!components.empty()) {
buffer += components[0]; buffer += components[0];
for (StringRef C : makeArrayRef(components).drop_front()) { for (StringRef C : ArrayRef(components).drop_front()) {
buffer += preferred_separator(style); buffer += preferred_separator(style);
buffer += C; buffer += C;
} }
Context not available.
BytesRead = read(FD, Buf.data(), BufSize); BytesRead = read(FD, Buf.data(), BufSize);
if (BytesRead <= 0) if (BytesRead <= 0)
break; break;
Hash.update(makeArrayRef(Buf.data(), BytesRead)); Hash.update(ArrayRef(Buf.data(), BytesRead));
} }
if (BytesRead < 0) if (BytesRead < 0)
Context not available.

llvm/lib/Support/RISCVAttributeParser.cpp

Context not available.
Error RISCVAttributeParser::unalignedAccess(unsigned tag) { Error RISCVAttributeParser::unalignedAccess(unsigned tag) {
static const char *strings[] = {"No unaligned access", "Unaligned access"}; static const char *strings[] = {"No unaligned access", "Unaligned access"};
return parseStringAttribute("Unaligned_access", tag, makeArrayRef(strings)); return parseStringAttribute("Unaligned_access", tag, ArrayRef(strings));
} }
Error RISCVAttributeParser::stackAlign(unsigned tag) { Error RISCVAttributeParser::stackAlign(unsigned tag) {
Context not available.

llvm/lib/Support/RISCVISAInfo.cpp

Context not available.
findDefaultVersion(StringRef ExtName) { findDefaultVersion(StringRef ExtName) {
// Find default version of an extension. // Find default version of an extension.
// TODO: We might set default version based on profile or ISA spec. // TODO: We might set default version based on profile or ISA spec.
for (auto &ExtInfo : {makeArrayRef(SupportedExtensions), for (auto &ExtInfo : {ArrayRef(SupportedExtensions),
makeArrayRef(SupportedExperimentalExtensions)}) { ArrayRef(SupportedExperimentalExtensions)}) {
auto ExtensionInfoIterator = llvm::find_if(ExtInfo, FindByName(ExtName)); auto ExtensionInfoIterator = llvm::find_if(ExtInfo, FindByName(ExtName));
if (ExtensionInfoIterator == ExtInfo.end()) { if (ExtensionInfoIterator == ExtInfo.end()) {
Context not available.
ExtName = ExtName.drop_front(1); // Drop '+' or '-' ExtName = ExtName.drop_front(1); // Drop '+' or '-'
Experimental = stripExperimentalPrefix(ExtName); Experimental = stripExperimentalPrefix(ExtName);
auto ExtensionInfos = Experimental auto ExtensionInfos = Experimental
? makeArrayRef(SupportedExperimentalExtensions) ? ArrayRef(SupportedExperimentalExtensions)
: makeArrayRef(SupportedExtensions); : ArrayRef(SupportedExtensions);
auto ExtensionInfoIterator = auto ExtensionInfoIterator =
llvm::find_if(ExtensionInfos, FindByName(ExtName)); llvm::find_if(ExtensionInfos, FindByName(ExtName));
Context not available.

llvm/lib/Support/SourceMgr.cpp

Context not available.
// Add any fix-its. // Add any fix-its.
// FIXME: Find the beginning of the line properly for multibyte characters. // FIXME: Find the beginning of the line properly for multibyte characters.
std::string FixItInsertionLine; std::string FixItInsertionLine;
buildFixItLine( buildFixItLine(CaretLine, FixItInsertionLine, FixIts,
CaretLine, FixItInsertionLine, FixIts, ArrayRef(Loc.getPointer() - ColumnNo, LineContents.size()));
makeArrayRef(Loc.getPointer() - ColumnNo, LineContents.size()));
// Finally, plop on the caret. // Finally, plop on the caret.
if (unsigned(ColumnNo) <= NumColumns) if (unsigned(ColumnNo) <= NumColumns)
Context not available.

llvm/lib/Support/StringRef.cpp

Context not available.
unsigned StringRef::edit_distance(llvm::StringRef Other, unsigned StringRef::edit_distance(llvm::StringRef Other,
bool AllowReplacements, bool AllowReplacements,
unsigned MaxEditDistance) const { unsigned MaxEditDistance) const {
return llvm::ComputeEditDistance( return llvm::ComputeEditDistance(ArrayRef(data(), size()),
makeArrayRef(data(), size()), ArrayRef(Other.data(), Other.size()),
makeArrayRef(Other.data(), Other.size()), AllowReplacements, MaxEditDistance);
AllowReplacements, MaxEditDistance);
} }
unsigned llvm::StringRef::edit_distance_insensitive( unsigned llvm::StringRef::edit_distance_insensitive(
StringRef Other, bool AllowReplacements, unsigned MaxEditDistance) const { StringRef Other, bool AllowReplacements, unsigned MaxEditDistance) const {
return llvm::ComputeMappedEditDistance( return llvm::ComputeMappedEditDistance(
makeArrayRef(data(), size()), makeArrayRef(Other.data(), Other.size()), ArrayRef(data(), size()), ArrayRef(Other.data(), Other.size()),
llvm::toLower, AllowReplacements, MaxEditDistance); llvm::toLower, AllowReplacements, MaxEditDistance);
} }
Context not available.

llvm/lib/TableGen/Record.cpp

Context not available.
} }
void BitsInit::Profile(FoldingSetNodeID &ID) const { void BitsInit::Profile(FoldingSetNodeID &ID) const {
ProfileBitsInit(ID, makeArrayRef(getTrailingObjects<Init *>(), NumBits)); ProfileBitsInit(ID, ArrayRef(getTrailingObjects<Init *>(), NumBits));
} }
Init *BitsInit::convertInitializerTo(RecTy *Ty) const { Init *BitsInit::convertInitializerTo(RecTy *Ty) const {
Context not available.
} }
void CondOpInit::Profile(FoldingSetNodeID &ID) const { void CondOpInit::Profile(FoldingSetNodeID &ID) const {
ProfileCondOpInit(ID, ProfileCondOpInit(ID, ArrayRef(getTrailingObjects<Init *>(), NumConds),
makeArrayRef(getTrailingObjects<Init *>(), NumConds), ArrayRef(getTrailingObjects<Init *>() + NumConds, NumConds),
makeArrayRef(getTrailingObjects<Init *>() + NumConds, NumConds), ValType);
ValType);
} }
CondOpInit *CondOpInit::get(ArrayRef<Init *> CondRange, CondOpInit *CondOpInit::get(ArrayRef<Init *> CondRange,
Context not available.
} }
void DagInit::Profile(FoldingSetNodeID &ID) const { void DagInit::Profile(FoldingSetNodeID &ID) const {
ProfileDagInit(ID, Val, ValName, makeArrayRef(getTrailingObjects<Init *>(), NumArgs), makeArrayRef(getTrailingObjects<StringInit *>(), NumArgNames)); ProfileDagInit(ID, Val, ValName,
ArrayRef(getTrailingObjects<Init *>(), NumArgs),
ArrayRef(getTrailingObjects<StringInit *>(), NumArgNames));
} }
Record *DagInit::getOperatorAsDef(ArrayRef<SMLoc> Loc) const { Record *DagInit::getOperatorAsDef(ArrayRef<SMLoc> Loc) const {
Context not available.
// the same vectors multiple times. // the same vectors multiple times.
auto Pair = ClassRecordsMap.try_emplace(ClassName); auto Pair = ClassRecordsMap.try_emplace(ClassName);
if (Pair.second) if (Pair.second)
Pair.first->second = getAllDerivedDefinitions(makeArrayRef(ClassName)); Pair.first->second = getAllDerivedDefinitions(ArrayRef(ClassName));
return Pair.first->second; return Pair.first->second;
} }
Context not available.

llvm/lib/Target/AArch64/AArch64ISelLowering.cpp

Context not available.
Shuffle = DAG.getNode( Shuffle = DAG.getNode(
ISD::INTRINSIC_WO_CHAIN, DL, IndexVT, ISD::INTRINSIC_WO_CHAIN, DL, IndexVT,
DAG.getConstant(Intrinsic::aarch64_neon_tbl1, DL, MVT::i32), V1Cst, DAG.getConstant(Intrinsic::aarch64_neon_tbl1, DL, MVT::i32), V1Cst,
DAG.getBuildVector(IndexVT, DL, DAG.getBuildVector(IndexVT, DL, ArrayRef(TBLMask.data(), IndexLen)));
makeArrayRef(TBLMask.data(), IndexLen)));
} else { } else {
if (IndexLen == 8) { if (IndexLen == 8) {
V1Cst = DAG.getNode(ISD::CONCAT_VECTORS, DL, MVT::v16i8, V1Cst, V2Cst); V1Cst = DAG.getNode(ISD::CONCAT_VECTORS, DL, MVT::v16i8, V1Cst, V2Cst);
Shuffle = DAG.getNode( Shuffle = DAG.getNode(
ISD::INTRINSIC_WO_CHAIN, DL, IndexVT, ISD::INTRINSIC_WO_CHAIN, DL, IndexVT,
DAG.getConstant(Intrinsic::aarch64_neon_tbl1, DL, MVT::i32), V1Cst, DAG.getConstant(Intrinsic::aarch64_neon_tbl1, DL, MVT::i32), V1Cst,
DAG.getBuildVector(IndexVT, DL, DAG.getBuildVector(IndexVT, DL, ArrayRef(TBLMask.data(), IndexLen)));
makeArrayRef(TBLMask.data(), IndexLen)));
} else { } else {
// FIXME: We cannot, for the moment, emit a TBL2 instruction because we // FIXME: We cannot, for the moment, emit a TBL2 instruction because we
// cannot currently represent the register constraints on the input // cannot currently represent the register constraints on the input
Context not available.
Shuffle = DAG.getNode( Shuffle = DAG.getNode(
ISD::INTRINSIC_WO_CHAIN, DL, IndexVT, ISD::INTRINSIC_WO_CHAIN, DL, IndexVT,
DAG.getConstant(Intrinsic::aarch64_neon_tbl2, DL, MVT::i32), V1Cst, DAG.getConstant(Intrinsic::aarch64_neon_tbl2, DL, MVT::i32), V1Cst,
V2Cst, DAG.getBuildVector(IndexVT, DL, V2Cst,
makeArrayRef(TBLMask.data(), IndexLen))); DAG.getBuildVector(IndexVT, DL, ArrayRef(TBLMask.data(), IndexLen)));
} }
} }
return DAG.getNode(ISD::BITCAST, DL, Op.getValueType(), Shuffle); return DAG.getNode(ISD::BITCAST, DL, Op.getValueType(), Shuffle);
Context not available.
Tys[n] = VecTy; Tys[n] = VecTy;
Tys[n++] = MVT::i64; // Type of write back register Tys[n++] = MVT::i64; // Type of write back register
Tys[n] = MVT::Other; // Type of the chain Tys[n] = MVT::Other; // Type of the chain
SDVTList SDTys = DAG.getVTList(makeArrayRef(Tys, NumResultVecs + 2)); SDVTList SDTys = DAG.getVTList(ArrayRef(Tys, NumResultVecs + 2));
MemIntrinsicSDNode *MemInt = cast<MemIntrinsicSDNode>(N); MemIntrinsicSDNode *MemInt = cast<MemIntrinsicSDNode>(N);
SDValue UpdN = DAG.getMemIntrinsicNode(NewOpc, SDLoc(N), SDTys, Ops, SDValue UpdN = DAG.getMemIntrinsicNode(NewOpc, SDLoc(N), SDTys, Ops,
Context not available.
APInt SplatLHSVal; APInt SplatLHSVal;
if (CmpLHS.getValueType() == N->getOperand(1).getValueType() && if (CmpLHS.getValueType() == N->getOperand(1).getValueType() &&
VT.isSimple() && VT.isSimple() &&
is_contained( is_contained(ArrayRef({MVT::v8i8, MVT::v16i8, MVT::v4i16, MVT::v8i16,
makeArrayRef({MVT::v8i8, MVT::v16i8, MVT::v4i16, MVT::v8i16, MVT::v2i32, MVT::v4i32, MVT::v2i64}),
MVT::v2i32, MVT::v4i32, MVT::v2i64}), VT.getSimpleVT().SimpleTy) &&
VT.getSimpleVT().SimpleTy) &&
ISD::isConstantSplatVector(SplatLHS, SplatLHSVal) && ISD::isConstantSplatVector(SplatLHS, SplatLHSVal) &&
SplatLHSVal.isOne() && ISD::isConstantSplatVectorAllOnes(CmpRHS) && SplatLHSVal.isOne() && ISD::isConstantSplatVectorAllOnes(CmpRHS) &&
ISD::isConstantSplatVectorAllOnes(SplatRHS)) { ISD::isConstantSplatVectorAllOnes(SplatRHS)) {
Context not available.

llvm/lib/Target/AArch64/AArch64InstrInfo.cpp

Context not available.
{MO_G3, "aarch64-g3"}, {MO_G2, "aarch64-g2"}, {MO_G3, "aarch64-g3"}, {MO_G2, "aarch64-g2"},
{MO_G1, "aarch64-g1"}, {MO_G0, "aarch64-g0"}, {MO_G1, "aarch64-g1"}, {MO_G0, "aarch64-g0"},
{MO_HI12, "aarch64-hi12"}}; {MO_HI12, "aarch64-hi12"}};
return makeArrayRef(TargetFlags); return ArrayRef(TargetFlags);
} }
ArrayRef<std::pair<unsigned, const char *>> ArrayRef<std::pair<unsigned, const char *>>
Context not available.
{MO_DLLIMPORTAUX, "aarch64-dllimportaux"}, {MO_DLLIMPORTAUX, "aarch64-dllimportaux"},
{MO_PREL, "aarch64-prel"}, {MO_PREL, "aarch64-prel"},
{MO_TAGGED, "aarch64-tagged"}}; {MO_TAGGED, "aarch64-tagged"}};
return makeArrayRef(TargetFlags); return ArrayRef(TargetFlags);
} }
ArrayRef<std::pair<MachineMemOperand::Flags, const char *>> ArrayRef<std::pair<MachineMemOperand::Flags, const char *>>
Context not available.
static const std::pair<MachineMemOperand::Flags, const char *> TargetFlags[] = static const std::pair<MachineMemOperand::Flags, const char *> TargetFlags[] =
{{MOSuppressPair, "aarch64-suppress-pair"}, {{MOSuppressPair, "aarch64-suppress-pair"},
{MOStridedAccess, "aarch64-strided-access"}}; {MOStridedAccess, "aarch64-strided-access"}};
return makeArrayRef(TargetFlags); return ArrayRef(TargetFlags);
} }
/// Constants defining how certain sequences should be outlined. /// Constants defining how certain sequences should be outlined.
Context not available.

llvm/lib/Target/AArch64/GISel/AArch64CallLowering.cpp

Context not available.
if (!determineAndHandleAssignments( if (!determineAndHandleAssignments(
UsingReturnedArg ? ReturnedArgHandler : Handler, Assigner, InArgs, UsingReturnedArg ? ReturnedArgHandler : Handler, Assigner, InArgs,
MIRBuilder, Info.CallConv, Info.IsVarArg, MIRBuilder, Info.CallConv, Info.IsVarArg,
UsingReturnedArg ? makeArrayRef(OutArgs[0].Regs) : std::nullopt)) UsingReturnedArg ? ArrayRef(OutArgs[0].Regs) : std::nullopt))
return false; return false;
} }
Context not available.

llvm/lib/Target/AMDGPU/AMDGPULegalizerInfo.cpp

Context not available.
Intrinsic::ID TrigIntrin = MI.getOpcode() == AMDGPU::G_FSIN ? Intrinsic::ID TrigIntrin = MI.getOpcode() == AMDGPU::G_FSIN ?
Intrinsic::amdgcn_sin : Intrinsic::amdgcn_cos; Intrinsic::amdgcn_sin : Intrinsic::amdgcn_cos;
B.buildIntrinsic(TrigIntrin, makeArrayRef<Register>(DstReg), false) B.buildIntrinsic(TrigIntrin, ArrayRef<Register>(DstReg), false)
.addUse(TrigVal) .addUse(TrigVal)
.setMIFlags(Flags); .setMIFlags(Flags);
MI.eraseFromParent(); MI.eraseFromParent();
return true; return true;
} }
Context not available.
.addUse(Scale) .addUse(Scale)
.setMIFlags(Flags); .setMIFlags(Flags);
B.buildIntrinsic(Intrinsic::amdgcn_div_fixup, makeArrayRef(Res), false) B.buildIntrinsic(Intrinsic::amdgcn_div_fixup, ArrayRef(Res), false)
.addUse(Fmas.getReg(0)) .addUse(Fmas.getReg(0))
.addUse(RHS) .addUse(RHS)
.addUse(LHS) .addUse(LHS)
.setMIFlags(Flags); .setMIFlags(Flags);
MI.eraseFromParent(); MI.eraseFromParent();
return true; return true;
Context not available.

llvm/lib/Target/AMDGPU/AMDGPURegisterBankInfo.cpp

Context not available.
}; };
const std::array<unsigned, 3> RegSrcOpIdx = { { 0, 2, 3 } }; const std::array<unsigned, 3> RegSrcOpIdx = { { 0, 2, 3 } };
return addMappingFromTable<3>(MI, MRI, RegSrcOpIdx, makeArrayRef(Table)); return addMappingFromTable<3>(MI, MRI, RegSrcOpIdx, ArrayRef(Table));
} }
case Intrinsic::amdgcn_writelane: { case Intrinsic::amdgcn_writelane: {
static const OpRegBankEntry<4> Table[4] = { static const OpRegBankEntry<4> Table[4] = {
Context not available.
// rsrc, voffset, offset // rsrc, voffset, offset
const std::array<unsigned, 4> RegSrcOpIdx = { { 0, 2, 3, 4 } }; const std::array<unsigned, 4> RegSrcOpIdx = { { 0, 2, 3, 4 } };
return addMappingFromTable<4>(MI, MRI, RegSrcOpIdx, makeArrayRef(Table)); return addMappingFromTable<4>(MI, MRI, RegSrcOpIdx, ArrayRef(Table));
} }
default: default:
return RegisterBankInfo::getInstrAlternativeMappings(MI); return RegisterBankInfo::getInstrAlternativeMappings(MI);
Context not available.
// rsrc, offset // rsrc, offset
const std::array<unsigned, 2> RegSrcOpIdx = { { 2, 3 } }; const std::array<unsigned, 2> RegSrcOpIdx = { { 2, 3 } };
return addMappingFromTable<2>(MI, MRI, RegSrcOpIdx, makeArrayRef(Table)); return addMappingFromTable<2>(MI, MRI, RegSrcOpIdx, ArrayRef(Table));
} }
case Intrinsic::amdgcn_ds_ordered_add: case Intrinsic::amdgcn_ds_ordered_add:
case Intrinsic::amdgcn_ds_ordered_swap: { case Intrinsic::amdgcn_ds_ordered_swap: {
Context not available.
}; };
const std::array<unsigned, 3> RegSrcOpIdx = { { 0, 2, 3 } }; const std::array<unsigned, 3> RegSrcOpIdx = { { 0, 2, 3 } };
return addMappingFromTable<3>(MI, MRI, RegSrcOpIdx, makeArrayRef(Table)); return addMappingFromTable<3>(MI, MRI, RegSrcOpIdx, ArrayRef(Table));
} }
case Intrinsic::amdgcn_s_sendmsg: case Intrinsic::amdgcn_s_sendmsg:
case Intrinsic::amdgcn_s_sendmsghalt: { case Intrinsic::amdgcn_s_sendmsghalt: {
Context not available.
}; };
const std::array<unsigned, 1> RegSrcOpIdx = { { 2 } }; const std::array<unsigned, 1> RegSrcOpIdx = { { 2 } };
return addMappingFromTable<1>(MI, MRI, RegSrcOpIdx, makeArrayRef(Table)); return addMappingFromTable<1>(MI, MRI, RegSrcOpIdx, ArrayRef(Table));
} }
default: default:
return RegisterBankInfo::getInstrAlternativeMappings(MI); return RegisterBankInfo::getInstrAlternativeMappings(MI);
Context not available.

llvm/lib/Target/AMDGPU/AsmParser/AMDGPUAsmParser.cpp

Context not available.
AMDGPUAsmVariants::DPP, AMDGPUAsmVariants::VOP3_DPP AMDGPUAsmVariants::DPP, AMDGPUAsmVariants::VOP3_DPP
}; };
return makeArrayRef(Variants); return ArrayRef(Variants);
} }
// What asm variants we should check // What asm variants we should check
ArrayRef<unsigned> AMDGPUAsmParser::getMatchedVariants() const { ArrayRef<unsigned> AMDGPUAsmParser::getMatchedVariants() const {
if (isForcedDPP() && isForcedVOP3()) { if (isForcedDPP() && isForcedVOP3()) {
static const unsigned Variants[] = {AMDGPUAsmVariants::VOP3_DPP}; static const unsigned Variants[] = {AMDGPUAsmVariants::VOP3_DPP};
return makeArrayRef(Variants); return ArrayRef(Variants);
} }
if (getForcedEncodingSize() == 32) { if (getForcedEncodingSize() == 32) {
static const unsigned Variants[] = {AMDGPUAsmVariants::DEFAULT}; static const unsigned Variants[] = {AMDGPUAsmVariants::DEFAULT};
return makeArrayRef(Variants); return ArrayRef(Variants);
} }
if (isForcedVOP3()) { if (isForcedVOP3()) {
static const unsigned Variants[] = {AMDGPUAsmVariants::VOP3}; static const unsigned Variants[] = {AMDGPUAsmVariants::VOP3};
return makeArrayRef(Variants); return ArrayRef(Variants);
} }
if (isForcedSDWA()) { if (isForcedSDWA()) {
static const unsigned Variants[] = {AMDGPUAsmVariants::SDWA, static const unsigned Variants[] = {AMDGPUAsmVariants::SDWA,
AMDGPUAsmVariants::SDWA9}; AMDGPUAsmVariants::SDWA9};
return makeArrayRef(Variants); return ArrayRef(Variants);
} }
if (isForcedDPP()) { if (isForcedDPP()) {
static const unsigned Variants[] = {AMDGPUAsmVariants::DPP}; static const unsigned Variants[] = {AMDGPUAsmVariants::DPP};
return makeArrayRef(Variants); return ArrayRef(Variants);
} }
return getAllVariants(); return getAllVariants();
Context not available.

llvm/lib/Target/AMDGPU/R600ISelLowering.cpp

Context not available.
NewVT = VT; NewVT = VT;
NumElements = VT.getVectorNumElements(); NumElements = VT.getVectorNumElements();
} }
SDValue Result = DAG.getBuildVector(NewVT, DL, makeArrayRef(Slots, NumElements)); SDValue Result = DAG.getBuildVector(NewVT, DL, ArrayRef(Slots, NumElements));
if (!VT.isVector()) { if (!VT.isVector()) {
Result = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::i32, Result, Result = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::i32, Result,
DAG.getConstant(0, DL, MVT::i32)); DAG.getConstant(0, DL, MVT::i32));
Context not available.

llvm/lib/Target/AMDGPU/SIISelLowering.cpp

Context not available.
if (Arg.isSet()) if (Arg.isSet())
return ArgDescriptor::createArg(Arg, Mask); return ArgDescriptor::createArg(Arg, Mask);
ArrayRef<MCPhysReg> ArgVGPRs ArrayRef<MCPhysReg> ArgVGPRs = ArrayRef(AMDGPU::VGPR_32RegClass.begin(), 32);
= makeArrayRef(AMDGPU::VGPR_32RegClass.begin(), 32);
unsigned RegIdx = CCInfo.getFirstUnallocated(ArgVGPRs); unsigned RegIdx = CCInfo.getFirstUnallocated(ArgVGPRs);
if (RegIdx == ArgVGPRs.size()) { if (RegIdx == ArgVGPRs.size()) {
// Spill to stack required. // Spill to stack required.
Context not available.
static ArgDescriptor allocateSGPR32InputImpl(CCState &CCInfo, static ArgDescriptor allocateSGPR32InputImpl(CCState &CCInfo,
const TargetRegisterClass *RC, const TargetRegisterClass *RC,
unsigned NumArgRegs) { unsigned NumArgRegs) {
ArrayRef<MCPhysReg> ArgSGPRs = makeArrayRef(RC->begin(), 32); ArrayRef<MCPhysReg> ArgSGPRs = ArrayRef(RC->begin(), 32);
unsigned RegIdx = CCInfo.getFirstUnallocated(ArgSGPRs); unsigned RegIdx = CCInfo.getFirstUnallocated(ArgSGPRs);
if (RegIdx == ArgSGPRs.size()) if (RegIdx == ArgSGPRs.size())
report_fatal_error("ran out of SGPRs for arguments"); report_fatal_error("ran out of SGPRs for arguments");
Context not available.
Ops[1] = BufferStoreExt; Ops[1] = BufferStoreExt;
unsigned Opc = (VDataType == MVT::i8) ? AMDGPUISD::BUFFER_STORE_BYTE : unsigned Opc = (VDataType == MVT::i8) ? AMDGPUISD::BUFFER_STORE_BYTE :
AMDGPUISD::BUFFER_STORE_SHORT; AMDGPUISD::BUFFER_STORE_SHORT;
ArrayRef<SDValue> OpsRef = makeArrayRef(&Ops[0], 9); ArrayRef<SDValue> OpsRef = ArrayRef(&Ops[0], 9);
return DAG.getMemIntrinsicNode(Opc, DL, M->getVTList(), OpsRef, VDataType, return DAG.getMemIntrinsicNode(Opc, DL, M->getVTList(), OpsRef, VDataType,
M->getMemOperand()); M->getMemOperand());
} }
Context not available.

llvm/lib/Target/AMDGPU/SIInstrInfo.cpp

Context not available.
{AMDGPU::TI_SCRATCH_RSRC_DWORD1, "amdgpu-scratch-rsrc-dword1"}, {AMDGPU::TI_SCRATCH_RSRC_DWORD1, "amdgpu-scratch-rsrc-dword1"},
{AMDGPU::TI_SCRATCH_RSRC_DWORD2, "amdgpu-scratch-rsrc-dword2"}, {AMDGPU::TI_SCRATCH_RSRC_DWORD2, "amdgpu-scratch-rsrc-dword2"},
{AMDGPU::TI_SCRATCH_RSRC_DWORD3, "amdgpu-scratch-rsrc-dword3"}}; {AMDGPU::TI_SCRATCH_RSRC_DWORD3, "amdgpu-scratch-rsrc-dword3"}};
return makeArrayRef(TargetIndices); return ArrayRef(TargetIndices);
} }
/// This is used by the post-RA scheduler (SchedulePostRAList.cpp). The /// This is used by the post-RA scheduler (SchedulePostRAList.cpp). The
Context not available.
{ MO_ABS32_HI, "amdgpu-abs32-hi" }, { MO_ABS32_HI, "amdgpu-abs32-hi" },
}; };
return makeArrayRef(TargetFlags); return ArrayRef(TargetFlags);
} }
ArrayRef<std::pair<MachineMemOperand::Flags, const char *>> ArrayRef<std::pair<MachineMemOperand::Flags, const char *>>
Context not available.
{MONoClobber, "amdgpu-noclobber"}, {MONoClobber, "amdgpu-noclobber"},
}; };
return makeArrayRef(TargetFlags); return ArrayRef(TargetFlags);
} }
bool SIInstrInfo::isBasicBlockPrologue(const MachineInstr &MI) const { bool SIInstrInfo::isBasicBlockPrologue(const MachineInstr &MI) const {
Context not available.

llvm/lib/Target/AMDGPU/SIMachineFunctionInfo.h

Context not available.
auto I = SGPRSpillToVGPRLanes.find(FrameIndex); auto I = SGPRSpillToVGPRLanes.find(FrameIndex);
return (I == SGPRSpillToVGPRLanes.end()) return (I == SGPRSpillToVGPRLanes.end())
? ArrayRef<SIRegisterInfo::SpilledReg>() ? ArrayRef<SIRegisterInfo::SpilledReg>()
: makeArrayRef(I->second); : ArrayRef(I->second);
} }
ArrayRef<Register> getSGPRSpillVGPRs() const { return SpillVGPRs; } ArrayRef<Register> getSGPRSpillVGPRs() const { return SpillVGPRs; }
Context not available.
auto I = PrologEpilogSGPRSpillToVGPRLanes.find(FrameIndex); auto I = PrologEpilogSGPRSpillToVGPRLanes.find(FrameIndex);
return (I == PrologEpilogSGPRSpillToVGPRLanes.end()) return (I == PrologEpilogSGPRSpillToVGPRLanes.end())
? ArrayRef<SIRegisterInfo::SpilledReg>() ? ArrayRef<SIRegisterInfo::SpilledReg>()
: makeArrayRef(I->second); : ArrayRef(I->second);
} }
void allocateWWMSpill(MachineFunction &MF, Register VGPR, uint64_t Size = 4, void allocateWWMSpill(MachineFunction &MF, Register VGPR, uint64_t Size = 4,
Context not available.

llvm/lib/Target/AMDGPU/SIRegisterInfo.cpp

Context not available.
const std::vector<int16_t> &Parts = RegSplitParts[EltDWORDs - 1]; const std::vector<int16_t> &Parts = RegSplitParts[EltDWORDs - 1];
const unsigned NumParts = RegDWORDs / EltDWORDs; const unsigned NumParts = RegDWORDs / EltDWORDs;
return makeArrayRef(Parts.data(), NumParts); return ArrayRef(Parts.data(), NumParts);
} }
const TargetRegisterClass* const TargetRegisterClass*
Context not available.
ArrayRef<MCPhysReg> ArrayRef<MCPhysReg>
SIRegisterInfo::getAllSGPR128(const MachineFunction &MF) const { SIRegisterInfo::getAllSGPR128(const MachineFunction &MF) const {
return makeArrayRef(AMDGPU::SGPR_128RegClass.begin(), return ArrayRef(AMDGPU::SGPR_128RegClass.begin(), ST.getMaxNumSGPRs(MF) / 4);
ST.getMaxNumSGPRs(MF) / 4);
} }
ArrayRef<MCPhysReg> ArrayRef<MCPhysReg>
SIRegisterInfo::getAllSGPR64(const MachineFunction &MF) const { SIRegisterInfo::getAllSGPR64(const MachineFunction &MF) const {
return makeArrayRef(AMDGPU::SGPR_64RegClass.begin(), return ArrayRef(AMDGPU::SGPR_64RegClass.begin(), ST.getMaxNumSGPRs(MF) / 2);
ST.getMaxNumSGPRs(MF) / 2);
} }
ArrayRef<MCPhysReg> ArrayRef<MCPhysReg>
SIRegisterInfo::getAllSGPR32(const MachineFunction &MF) const { SIRegisterInfo::getAllSGPR32(const MachineFunction &MF) const {
return makeArrayRef(AMDGPU::SGPR_32RegClass.begin(), ST.getMaxNumSGPRs(MF)); return ArrayRef(AMDGPU::SGPR_32RegClass.begin(), ST.getMaxNumSGPRs(MF));
} }
Context not available.

llvm/lib/Target/AMDGPU/Utils/AMDKernelCodeTUtils.cpp

Context not available.
#include "AMDKernelCodeTInfo.h" #include "AMDKernelCodeTInfo.h"
#undef RECORD #undef RECORD
}; };
return makeArrayRef(Table); return ArrayRef(Table);
} }
static ArrayRef<StringRef> get_amd_kernel_code_t_FldAltNames() { static ArrayRef<StringRef> get_amd_kernel_code_t_FldAltNames() {
Context not available.
#include "AMDKernelCodeTInfo.h" #include "AMDKernelCodeTInfo.h"
#undef RECORD #undef RECORD
}; };
return makeArrayRef(Table); return ArrayRef(Table);
} }
static StringMap<int> createIndexMap(const ArrayRef<StringRef> &names, static StringMap<int> createIndexMap(const ArrayRef<StringRef> &names,
Context not available.
#include "AMDKernelCodeTInfo.h" #include "AMDKernelCodeTInfo.h"
#undef RECORD #undef RECORD
}; };
return makeArrayRef(Table); return ArrayRef(Table);
} }
void llvm::printAmdKernelCodeField(const amd_kernel_code_t &C, void llvm::printAmdKernelCodeField(const amd_kernel_code_t &C,
Context not available.
#include "AMDKernelCodeTInfo.h" #include "AMDKernelCodeTInfo.h"
#undef RECORD #undef RECORD
}; };
return makeArrayRef(Table); return ArrayRef(Table);
} }
bool llvm::parseAmdKernelCodeField(StringRef ID, bool llvm::parseAmdKernelCodeField(StringRef ID,
Context not available.

llvm/lib/Target/ARM/ARMBaseInstrInfo.cpp

Context not available.
static const std::pair<unsigned, const char *> TargetFlags[] = { static const std::pair<unsigned, const char *> TargetFlags[] = {
{MO_LO16, "arm-lo16"}, {MO_HI16, "arm-hi16"}}; {MO_LO16, "arm-lo16"}, {MO_HI16, "arm-hi16"}};
return makeArrayRef(TargetFlags); return ArrayRef(TargetFlags);
} }
ArrayRef<std::pair<unsigned, const char *>> ArrayRef<std::pair<unsigned, const char *>>
Context not available.
{MO_DLLIMPORT, "arm-dllimport"}, {MO_DLLIMPORT, "arm-dllimport"},
{MO_SECREL, "arm-secrel"}, {MO_SECREL, "arm-secrel"},
{MO_NONLAZY, "arm-nonlazy"}}; {MO_NONLAZY, "arm-nonlazy"}};
return makeArrayRef(TargetFlags); return ArrayRef(TargetFlags);
} }
std::optional<RegImmPair> std::optional<RegImmPair>
Context not available.

llvm/lib/Target/ARM/ARMISelDAGToDAG.cpp

Context not available.
Ops.push_back(getAL(CurDAG, Loc)); Ops.push_back(getAL(CurDAG, Loc));
Ops.push_back(CurDAG->getRegister(0, MVT::i32)); Ops.push_back(CurDAG->getRegister(0, MVT::i32));
CurDAG->SelectNodeTo(N, Opcode, N->getVTList(), makeArrayRef(Ops)); CurDAG->SelectNodeTo(N, Opcode, N->getVTList(), ArrayRef(Ops));
} }
void ARMDAGToDAGISel::SelectMVE_VADCSBC(SDNode *N, uint16_t OpcodeWithCarry, void ARMDAGToDAGISel::SelectMVE_VADCSBC(SDNode *N, uint16_t OpcodeWithCarry,
Context not available.
else else
AddEmptyMVEPredicateToOps(Ops, Loc, N->getValueType(0)); AddEmptyMVEPredicateToOps(Ops, Loc, N->getValueType(0));
CurDAG->SelectNodeTo(N, Opcode, N->getVTList(), makeArrayRef(Ops)); CurDAG->SelectNodeTo(N, Opcode, N->getVTList(), ArrayRef(Ops));
} }
void ARMDAGToDAGISel::SelectMVE_VSHLC(SDNode *N, bool Predicated) { void ARMDAGToDAGISel::SelectMVE_VSHLC(SDNode *N, bool Predicated) {
Context not available.
else else
AddEmptyMVEPredicateToOps(Ops, Loc); AddEmptyMVEPredicateToOps(Ops, Loc);
CurDAG->SelectNodeTo(N, ARM::MVE_VSHLC, N->getVTList(), makeArrayRef(Ops)); CurDAG->SelectNodeTo(N, ARM::MVE_VSHLC, N->getVTList(), ArrayRef(Ops));
} }
static bool SDValueToConstBool(SDValue SDVal) { static bool SDValueToConstBool(SDValue SDVal) {
Context not available.
else else
AddEmptyMVEPredicateToOps(Ops, Loc); AddEmptyMVEPredicateToOps(Ops, Loc);
CurDAG->SelectNodeTo(N, Opcode, N->getVTList(), makeArrayRef(Ops)); CurDAG->SelectNodeTo(N, Opcode, N->getVTList(), ArrayRef(Ops));
} }
void ARMDAGToDAGISel::SelectMVE_VMLLDAV(SDNode *N, bool Predicated, void ARMDAGToDAGISel::SelectMVE_VMLLDAV(SDNode *N, bool Predicated,
Context not available.
else else
AddEmptyMVEPredicateToOps(Ops, Loc, N->getValueType(0)); AddEmptyMVEPredicateToOps(Ops, Loc, N->getValueType(0));
CurDAG->SelectNodeTo(N, Opcode, N->getVTList(), makeArrayRef(Ops)); CurDAG->SelectNodeTo(N, Opcode, N->getVTList(), ArrayRef(Ops));
} }
void ARMDAGToDAGISel::SelectCDE_CXxD(SDNode *N, uint16_t Opcode, void ARMDAGToDAGISel::SelectCDE_CXxD(SDNode *N, uint16_t Opcode,
Context not available.

llvm/lib/Target/ARM/ARMISelLowering.cpp

Context not available.
SmallVector<SDValue, 64> Ops(Op->op_begin(), Op->op_begin() + NumElts); SmallVector<SDValue, 64> Ops(Op->op_begin(), Op->op_begin() + NumElts);
EVT ExtVT = VT.getVectorElementType(); EVT ExtVT = VT.getVectorElementType();
EVT HVT = EVT::getVectorVT(*DAG.getContext(), ExtVT, NumElts / 2); EVT HVT = EVT::getVectorVT(*DAG.getContext(), ExtVT, NumElts / 2);
SDValue Lower = SDValue Lower = DAG.getBuildVector(HVT, dl, ArrayRef(&Ops[0], NumElts / 2));
DAG.getBuildVector(HVT, dl, makeArrayRef(&Ops[0], NumElts / 2));
if (Lower.getOpcode() == ISD::BUILD_VECTOR) if (Lower.getOpcode() == ISD::BUILD_VECTOR)
Lower = LowerBUILD_VECTOR(Lower, DAG, ST); Lower = LowerBUILD_VECTOR(Lower, DAG, ST);
SDValue Upper = DAG.getBuildVector( SDValue Upper =
HVT, dl, makeArrayRef(&Ops[NumElts / 2], NumElts / 2)); DAG.getBuildVector(HVT, dl, ArrayRef(&Ops[NumElts / 2], NumElts / 2));
if (Upper.getOpcode() == ISD::BUILD_VECTOR) if (Upper.getOpcode() == ISD::BUILD_VECTOR)
Upper = LowerBUILD_VECTOR(Upper, DAG, ST); Upper = LowerBUILD_VECTOR(Upper, DAG, ST);
if (Lower && Upper) if (Lower && Upper)
Context not available.
Tys[n] = AlignedVecTy; Tys[n] = AlignedVecTy;
Tys[n++] = MVT::i32; Tys[n++] = MVT::i32;
Tys[n] = MVT::Other; Tys[n] = MVT::Other;
SDVTList SDTys = DAG.getVTList(makeArrayRef(Tys, NumResultVecs + 2)); SDVTList SDTys = DAG.getVTList(ArrayRef(Tys, NumResultVecs + 2));
// Then, gather the new node's operands. // Then, gather the new node's operands.
SmallVector<SDValue, 8> Ops; SmallVector<SDValue, 8> Ops;
Context not available.
Tys[n] = VecTy; Tys[n] = VecTy;
Tys[n++] = MVT::i32; Tys[n++] = MVT::i32;
Tys[n] = MVT::Other; Tys[n] = MVT::Other;
SDVTList SDTys = DAG.getVTList(makeArrayRef(Tys, NumResultVecs + 2)); SDVTList SDTys = DAG.getVTList(ArrayRef(Tys, NumResultVecs + 2));
// Then, gather the new node's operands. // Then, gather the new node's operands.
SmallVector<SDValue, 8> Ops; SmallVector<SDValue, 8> Ops;
Context not available.
for (n = 0; n < NumVecs; ++n) for (n = 0; n < NumVecs; ++n)
Tys[n] = VT; Tys[n] = VT;
Tys[n] = MVT::Other; Tys[n] = MVT::Other;
SDVTList SDTys = DAG.getVTList(makeArrayRef(Tys, NumVecs+1)); SDVTList SDTys = DAG.getVTList(ArrayRef(Tys, NumVecs + 1));
SDValue Ops[] = { VLD->getOperand(0), VLD->getOperand(2) }; SDValue Ops[] = { VLD->getOperand(0), VLD->getOperand(2) };
MemIntrinsicSDNode *VLDMemInt = cast<MemIntrinsicSDNode>(VLD); MemIntrinsicSDNode *VLDMemInt = cast<MemIntrinsicSDNode>(VLD);
SDValue VLDDup = DAG.getMemIntrinsicNode(NewOpc, SDLoc(VLD), SDTys, SDValue VLDDup = DAG.getMemIntrinsicNode(NewOpc, SDLoc(VLD), SDTys,
Context not available.

llvm/lib/Target/ARM/ARMSelectionDAGInfo.cpp

Context not available.
SrcOff += VTSize; SrcOff += VTSize;
BytesLeft -= VTSize; BytesLeft -= VTSize;
} }
Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, ArrayRef(TFOps, i));
makeArrayRef(TFOps, i));
i = 0; i = 0;
BytesLeft = BytesLeftSave; BytesLeft = BytesLeftSave;
Context not available.
DstOff += VTSize; DstOff += VTSize;
BytesLeft -= VTSize; BytesLeft -= VTSize;
} }
return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, ArrayRef(TFOps, i));
makeArrayRef(TFOps, i));
} }
SDValue ARMSelectionDAGInfo::EmitTargetCodeForMemmove( SDValue ARMSelectionDAGInfo::EmitTargetCodeForMemmove(
Context not available.

llvm/lib/Target/AVR/AVRISelLowering.cpp

Context not available.
ArrayRef<MCPhysReg> RegList8; ArrayRef<MCPhysReg> RegList8;
ArrayRef<MCPhysReg> RegList16; ArrayRef<MCPhysReg> RegList16;
if (Tiny) { if (Tiny) {
RegList8 = makeArrayRef(RegList8Tiny, std::size(RegList8Tiny)); RegList8 = ArrayRef(RegList8Tiny, std::size(RegList8Tiny));
RegList16 = makeArrayRef(RegList16Tiny, std::size(RegList16Tiny)); RegList16 = ArrayRef(RegList16Tiny, std::size(RegList16Tiny));
} else { } else {
RegList8 = makeArrayRef(RegList8AVR, std::size(RegList8AVR)); RegList8 = ArrayRef(RegList8AVR, std::size(RegList8AVR));
RegList16 = makeArrayRef(RegList16AVR, std::size(RegList16AVR)); RegList16 = ArrayRef(RegList16AVR, std::size(RegList16AVR));
} }
unsigned NumArgs = Args.size(); unsigned NumArgs = Args.size();
Context not available.
ArrayRef<MCPhysReg> RegList8; ArrayRef<MCPhysReg> RegList8;
ArrayRef<MCPhysReg> RegList16; ArrayRef<MCPhysReg> RegList16;
if (Tiny) { if (Tiny) {
RegList8 = makeArrayRef(RegList8Tiny, std::size(RegList8Tiny)); RegList8 = ArrayRef(RegList8Tiny, std::size(RegList8Tiny));
RegList16 = makeArrayRef(RegList16Tiny, std::size(RegList16Tiny)); RegList16 = ArrayRef(RegList16Tiny, std::size(RegList16Tiny));
} else { } else {
RegList8 = makeArrayRef(RegList8AVR, std::size(RegList8AVR)); RegList8 = ArrayRef(RegList8AVR, std::size(RegList8AVR));
RegList16 = makeArrayRef(RegList16AVR, std::size(RegList16AVR)); RegList16 = ArrayRef(RegList16AVR, std::size(RegList16AVR));
} }
// GCC-ABI says that the size is rounded up to the next even number, // GCC-ABI says that the size is rounded up to the next even number,
Context not available.

llvm/lib/Target/CSKY/CSKYISelLowering.cpp

Context not available.
const unsigned XLenInBytes = 4; const unsigned XLenInBytes = 4;
const MVT XLenVT = MVT::i32; const MVT XLenVT = MVT::i32;
ArrayRef<MCPhysReg> ArgRegs = makeArrayRef(GPRArgRegs); ArrayRef<MCPhysReg> ArgRegs = ArrayRef(GPRArgRegs);
unsigned Idx = CCInfo.getFirstUnallocated(ArgRegs); unsigned Idx = CCInfo.getFirstUnallocated(ArgRegs);
const TargetRegisterClass *RC = &CSKY::GPRRegClass; const TargetRegisterClass *RC = &CSKY::GPRRegClass;
MachineFrameInfo &MFI = MF.getFrameInfo(); MachineFrameInfo &MFI = MF.getFrameInfo();
Context not available.

llvm/lib/Target/DirectX/DXILWriter/DXILValueEnumerator.h

Context not available.
/// Get the MDString metadata for this block. /// Get the MDString metadata for this block.
ArrayRef<const Metadata *> getMDStrings() const { ArrayRef<const Metadata *> getMDStrings() const {
return makeArrayRef(MDs).slice(NumModuleMDs, NumMDStrings); return ArrayRef(MDs).slice(NumModuleMDs, NumMDStrings);
} }
/// Get the non-MDString metadata for this block. /// Get the non-MDString metadata for this block.
ArrayRef<const Metadata *> getNonMDStrings() const { ArrayRef<const Metadata *> getNonMDStrings() const {
return makeArrayRef(MDs).slice(NumModuleMDs).slice(NumMDStrings); return ArrayRef(MDs).slice(NumModuleMDs).slice(NumMDStrings);
} }
const TypeList &getTypes() const { return Types; } const TypeList &getTypes() const { return Types; }
Context not available.

llvm/lib/Target/Hexagon/HexagonHardwareLoops.cpp

Context not available.
static const Register Regs01[] = { LC0, SA0, LC1, SA1 }; static const Register Regs01[] = { LC0, SA0, LC1, SA1 };
static const Register Regs1[] = { LC1, SA1 }; static const Register Regs1[] = { LC1, SA1 };
auto CheckRegs = IsInnerHWLoop ? makeArrayRef(Regs01, std::size(Regs01)) auto CheckRegs = IsInnerHWLoop ? ArrayRef(Regs01, std::size(Regs01))
: makeArrayRef(Regs1, std::size(Regs1)); : ArrayRef(Regs1, std::size(Regs1));
for (Register R : CheckRegs) for (Register R : CheckRegs)
if (MI->modifiesRegister(R, TRI)) if (MI->modifiesRegister(R, TRI))
return true; return true;
Context not available.

llvm/lib/Target/Hexagon/HexagonInstrInfo.cpp

Context not available.
{MO_IEGOT, "hexagon-iegot"}, {MO_IEGOT, "hexagon-iegot"},
{MO_TPREL, "hexagon-tprel"} {MO_TPREL, "hexagon-tprel"}
}; };
return makeArrayRef(Flags); return ArrayRef(Flags);
} }
ArrayRef<std::pair<unsigned, const char*>> ArrayRef<std::pair<unsigned, const char*>>
Context not available.
static const std::pair<unsigned, const char*> Flags[] = { static const std::pair<unsigned, const char*> Flags[] = {
{HMOTF_ConstExtended, "hexagon-ext"} {HMOTF_ConstExtended, "hexagon-ext"}
}; };
return makeArrayRef(Flags); return ArrayRef(Flags);
} }
Register HexagonInstrInfo::createVR(MachineFunction *MF, MVT VT) const { Register HexagonInstrInfo::createVR(MachineFunction *MF, MVT VT) const {
Context not available.

llvm/lib/Target/Hexagon/HexagonSubtarget.h

Context not available.
static MVT TypesV68[] = {MVT::i8, MVT::i16, MVT::i32, MVT::f16, MVT::f32}; static MVT TypesV68[] = {MVT::i8, MVT::i16, MVT::i32, MVT::f16, MVT::f32};
if (useHVXV68Ops() && useHVXFloatingPoint()) if (useHVXV68Ops() && useHVXFloatingPoint())
return makeArrayRef(TypesV68); return ArrayRef(TypesV68);
return makeArrayRef(Types); return ArrayRef(Types);
} }
bool isHVXElementType(MVT Ty, bool IncludeBool = false) const; bool isHVXElementType(MVT Ty, bool IncludeBool = false) const;
Context not available.

llvm/lib/Target/Hexagon/MCTargetDesc/HexagonMCTargetDesc.cpp

Context not available.
} }
llvm::ArrayRef<MCPhysReg> Hexagon_MC::GetVectRegRev() { llvm::ArrayRef<MCPhysReg> Hexagon_MC::GetVectRegRev() {
return makeArrayRef(VectRegRev); return ArrayRef(VectRegRev);
} }
namespace { namespace {
Context not available.

llvm/lib/Target/Lanai/LanaiInstrInfo.cpp

Context not available.
{MO_ABS_HI, "lanai-hi"}, {MO_ABS_HI, "lanai-hi"},
{MO_ABS_LO, "lanai-lo"}, {MO_ABS_LO, "lanai-lo"},
{MO_NO_FLAG, "lanai-nf"}}; {MO_NO_FLAG, "lanai-nf"}};
return makeArrayRef(TargetFlags); return ArrayRef(TargetFlags);
} }
bool LanaiInstrInfo::analyzeCompare(const MachineInstr &MI, Register &SrcReg, bool LanaiInstrInfo::analyzeCompare(const MachineInstr &MI, Register &SrcReg,
Context not available.

llvm/lib/Target/LoongArch/LoongArchISelLowering.cpp

Context not available.
} }
if (IsVarArg) { if (IsVarArg) {
ArrayRef<MCPhysReg> ArgRegs = makeArrayRef(ArgGPRs); ArrayRef<MCPhysReg> ArgRegs = ArrayRef(ArgGPRs);
unsigned Idx = CCInfo.getFirstUnallocated(ArgRegs); unsigned Idx = CCInfo.getFirstUnallocated(ArgRegs);
const TargetRegisterClass *RC = &LoongArch::GPRRegClass; const TargetRegisterClass *RC = &LoongArch::GPRRegClass;
MachineFrameInfo &MFI = MF.getFrameInfo(); MachineFrameInfo &MFI = MF.getFrameInfo();
Context not available.

llvm/lib/Target/LoongArch/LoongArchInstrInfo.cpp

Context not available.
{MO_IE_PC_LO, "loongarch-ie-pc-lo"}, {MO_IE_PC_LO, "loongarch-ie-pc-lo"},
{MO_LD_PC_HI, "loongarch-ld-pc-hi"}, {MO_LD_PC_HI, "loongarch-ld-pc-hi"},
{MO_GD_PC_HI, "loongarch-gd-pc-hi"}}; {MO_GD_PC_HI, "loongarch-gd-pc-hi"}};
return makeArrayRef(TargetFlags); return ArrayRef(TargetFlags);
} }
Context not available.

llvm/lib/Target/M68k/M68kInstrInfo.cpp

Context not available.
{MO_GOTOFF, "m68k-gotoff"}, {MO_GOTOFF, "m68k-gotoff"},
{MO_GOTPCREL, "m68k-gotpcrel"}, {MO_GOTPCREL, "m68k-gotpcrel"},
{MO_PLT, "m68k-plt"}}; {MO_PLT, "m68k-plt"}};
return makeArrayRef(TargetFlags); return ArrayRef(TargetFlags);
} }
namespace { namespace {
Context not available.

llvm/lib/Target/Mips/MCTargetDesc/MipsABIInfo.cpp

Context not available.
ArrayRef<MCPhysReg> MipsABIInfo::GetByValArgRegs() const { ArrayRef<MCPhysReg> MipsABIInfo::GetByValArgRegs() const {
if (IsO32()) if (IsO32())
return makeArrayRef(O32IntRegs); return ArrayRef(O32IntRegs);
if (IsN32() || IsN64()) if (IsN32() || IsN64())
return makeArrayRef(Mips64IntRegs); return ArrayRef(Mips64IntRegs);
llvm_unreachable("Unhandled ABI"); llvm_unreachable("Unhandled ABI");
} }
ArrayRef<MCPhysReg> MipsABIInfo::GetVarArgRegs() const { ArrayRef<MCPhysReg> MipsABIInfo::GetVarArgRegs() const {
if (IsO32()) if (IsO32())
return makeArrayRef(O32IntRegs); return ArrayRef(O32IntRegs);
if (IsN32() || IsN64()) if (IsN32() || IsN64())
return makeArrayRef(Mips64IntRegs); return ArrayRef(Mips64IntRegs);
llvm_unreachable("Unhandled ABI"); llvm_unreachable("Unhandled ABI");
} }
Context not available.

llvm/lib/Target/Mips/MipsInstrInfo.cpp

Context not available.
{MO_CALL_LO16, "mips-call-lo16"}, {MO_CALL_LO16, "mips-call-lo16"},
{MO_JALR, "mips-jalr"} {MO_JALR, "mips-jalr"}
}; };
return makeArrayRef(Flags); return ArrayRef(Flags);
} }
std::optional<ParamLoadedValue> std::optional<ParamLoadedValue>
Context not available.

llvm/lib/Target/Mips/MipsSEISelLowering.cpp

Context not available.
SDValue Ops[] = { Op0->getOperand(0), Op0->getOperand(1), Op0Op2 }; SDValue Ops[] = { Op0->getOperand(0), Op0->getOperand(1), Op0Op2 };
return DAG.getNode(MipsISD::VEXTRACT_ZEXT_ELT, SDLoc(Op0), return DAG.getNode(MipsISD::VEXTRACT_ZEXT_ELT, SDLoc(Op0),
Op0->getVTList(), Op0->getVTList(),
makeArrayRef(Ops, Op0->getNumOperands())); ArrayRef(Ops, Op0->getNumOperands()));
} }
} }
Context not available.
Op0Op0->getOperand(2) }; Op0Op0->getOperand(2) };
return DAG.getNode(MipsISD::VEXTRACT_SEXT_ELT, SDLoc(Op0Op0), return DAG.getNode(MipsISD::VEXTRACT_SEXT_ELT, SDLoc(Op0Op0),
Op0Op0->getVTList(), Op0Op0->getVTList(),
makeArrayRef(Ops, Op0Op0->getNumOperands())); ArrayRef(Ops, Op0Op0->getNumOperands()));
} }
} }
} }
Context not available.
LaneA, LaneB, LaneA, LaneB, LaneA, LaneB, LaneA, LaneB }; LaneA, LaneB, LaneA, LaneB, LaneA, LaneB, LaneA, LaneB };
SDValue Result = DAG.getBuildVector( SDValue Result = DAG.getBuildVector(
ViaVecTy, DL, makeArrayRef(Ops, ViaVecTy.getVectorNumElements())); ViaVecTy, DL, ArrayRef(Ops, ViaVecTy.getVectorNumElements()));
if (ViaVecTy != ResVecTy) { if (ViaVecTy != ResVecTy) {
SDValue One = DAG.getConstant(1, DL, ViaVecTy); SDValue One = DAG.getConstant(1, DL, ViaVecTy);
Context not available.
SplatValueA, SplatValueB, SplatValueA, SplatValueB }; SplatValueA, SplatValueB, SplatValueA, SplatValueB };
SDValue Result = DAG.getBuildVector( SDValue Result = DAG.getBuildVector(
ViaVecTy, DL, makeArrayRef(Ops, ViaVecTy.getVectorNumElements())); ViaVecTy, DL, ArrayRef(Ops, ViaVecTy.getVectorNumElements()));
if (VecTy != ViaVecTy) if (VecTy != ViaVecTy)
Result = DAG.getNode(ISD::BITCAST, DL, VecTy, Result); Result = DAG.getNode(ISD::BITCAST, DL, VecTy, Result);
Context not available.

llvm/lib/Target/NVPTX/NVPTXGenericToNVVM.cpp

Context not available.
} else { } else {
for (unsigned i = 0; i < NumOperands; ++i) { for (unsigned i = 0; i < NumOperands; ++i) {
NewValue = NewValue =
Builder.CreateInsertValue(NewValue, NewOperands[i], makeArrayRef(i)); Builder.CreateInsertValue(NewValue, NewOperands[i], ArrayRef(i));
} }
} }
Context not available.
// GetElementPtrConstantExpr // GetElementPtrConstantExpr
return Builder.CreateGEP(cast<GEPOperator>(C)->getSourceElementType(), return Builder.CreateGEP(cast<GEPOperator>(C)->getSourceElementType(),
NewOperands[0], NewOperands[0],
makeArrayRef(&NewOperands[1], NumOperands - 1), "", ArrayRef(&NewOperands[1], NumOperands - 1), "",
cast<GEPOperator>(C)->isInBounds()); cast<GEPOperator>(C)->isInBounds());
case Instruction::Select: case Instruction::Select:
// SelectConstantExpr // SelectConstantExpr
Context not available.

llvm/lib/Target/PowerPC/PPCISelLowering.cpp

Context not available.
const SDLoc &dl) { const SDLoc &dl) {
SDValue MTCTROps[] = {Chain, Callee, Glue}; SDValue MTCTROps[] = {Chain, Callee, Glue};
EVT ReturnTypes[] = {MVT::Other, MVT::Glue}; EVT ReturnTypes[] = {MVT::Other, MVT::Glue};
Chain = DAG.getNode(PPCISD::MTCTR, dl, makeArrayRef(ReturnTypes, 2), Chain = DAG.getNode(PPCISD::MTCTR, dl, ArrayRef(ReturnTypes, 2),
makeArrayRef(MTCTROps, Glue.getNode() ? 3 : 2)); ArrayRef(MTCTROps, Glue.getNode() ? 3 : 2));
// The glue is the second value produced. // The glue is the second value produced.
Glue = Chain.getValue(1); Glue = Chain.getValue(1);
} }
Context not available.
SDVTList VTs = DAG.getVTList(MVT::Other, MVT::Glue); SDVTList VTs = DAG.getVTList(MVT::Other, MVT::Glue);
SDValue Ops[] = { Chain, InFlag }; SDValue Ops[] = { Chain, InFlag };
Chain = DAG.getNode(seenFloatArg ? PPCISD::CR6SET : PPCISD::CR6UNSET, Chain = DAG.getNode(seenFloatArg ? PPCISD::CR6SET : PPCISD::CR6UNSET, dl,
dl, VTs, makeArrayRef(Ops, InFlag.getNode() ? 2 : 1)); VTs, ArrayRef(Ops, InFlag.getNode() ? 2 : 1));
InFlag = Chain.getValue(1); InFlag = Chain.getValue(1);
} }
Context not available.
if (Subtarget.isISAFuture()) { if (Subtarget.isISAFuture()) {
EVT ReturnTypes[] = {MVT::v256i1, MVT::v256i1}; EVT ReturnTypes[] = {MVT::v256i1, MVT::v256i1};
SDValue WideVec = SDValue(DAG.getMachineNode(PPC::DMXXEXTFDMR512, dl, SDValue WideVec = SDValue(DAG.getMachineNode(PPC::DMXXEXTFDMR512, dl,
makeArrayRef(ReturnTypes, 2), ArrayRef(ReturnTypes, 2),
Op.getOperand(1)), Op.getOperand(1)),
0); 0);
SmallVector<SDValue, 4> RetOps; SmallVector<SDValue, 4> RetOps;
Context not available.
if (StoreVT == MVT::v512i1) { if (StoreVT == MVT::v512i1) {
if (Subtarget.isISAFuture()) { if (Subtarget.isISAFuture()) {
EVT ReturnTypes[] = {MVT::v256i1, MVT::v256i1}; EVT ReturnTypes[] = {MVT::v256i1, MVT::v256i1};
MachineSDNode *ExtNode = DAG.getMachineNode(PPC::DMXXEXTFDMR512, dl, MachineSDNode *ExtNode = DAG.getMachineNode(
makeArrayRef(ReturnTypes, 2), PPC::DMXXEXTFDMR512, dl, ArrayRef(ReturnTypes, 2), Op.getOperand(1));
Op.getOperand(1));
Value = SDValue(ExtNode, 0); Value = SDValue(ExtNode, 0);
Value2 = SDValue(ExtNode, 1); Value2 = SDValue(ExtNode, 1);
Context not available.

llvm/lib/Target/PowerPC/PPCInstrInfo.cpp

Context not available.
{MO_TLSLD_LO, "ppc-tlsld-lo"}, {MO_TLSLD_LO, "ppc-tlsld-lo"},
{MO_TOC_LO, "ppc-toc-lo"}, {MO_TOC_LO, "ppc-toc-lo"},
{MO_TLS, "ppc-tls"}}; {MO_TLS, "ppc-tls"}};
return makeArrayRef(TargetFlags); return ArrayRef(TargetFlags);
} }
ArrayRef<std::pair<unsigned, const char *>> ArrayRef<std::pair<unsigned, const char *>>
Context not available.
{MO_GOT_TLSGD_PCREL_FLAG, "ppc-got-tlsgd-pcrel"}, {MO_GOT_TLSGD_PCREL_FLAG, "ppc-got-tlsgd-pcrel"},
{MO_GOT_TLSLD_PCREL_FLAG, "ppc-got-tlsld-pcrel"}, {MO_GOT_TLSLD_PCREL_FLAG, "ppc-got-tlsld-pcrel"},
{MO_GOT_TPREL_PCREL_FLAG, "ppc-got-tprel-pcrel"}}; {MO_GOT_TPREL_PCREL_FLAG, "ppc-got-tprel-pcrel"}};
return makeArrayRef(TargetFlags); return ArrayRef(TargetFlags);
} }
// Expand VSX Memory Pseudo instruction to either a VSX or a FP instruction. // Expand VSX Memory Pseudo instruction to either a VSX or a FP instruction.
Context not available.

llvm/lib/Target/RISCV/RISCVGatherScatterLowering.cpp

Context not available.
Ops[*VecOperand] = Start; Ops[*VecOperand] = Start;
Type *SourceTy = GEP->getSourceElementType(); Type *SourceTy = GEP->getSourceElementType();
Value *BasePtr = Value *BasePtr =
Builder.CreateGEP(SourceTy, Ops[0], makeArrayRef(Ops).drop_front()); Builder.CreateGEP(SourceTy, Ops[0], ArrayRef(Ops).drop_front());
// Convert stride to pointer size if needed. // Convert stride to pointer size if needed.
Type *IntPtrTy = DL->getIntPtrType(BasePtr->getType()); Type *IntPtrTy = DL->getIntPtrType(BasePtr->getType());
Context not available.
Ops[*VecOperand] = BasePhi; Ops[*VecOperand] = BasePhi;
Type *SourceTy = GEP->getSourceElementType(); Type *SourceTy = GEP->getSourceElementType();
Value *BasePtr = Value *BasePtr =
Builder.CreateGEP(SourceTy, Ops[0], makeArrayRef(Ops).drop_front()); Builder.CreateGEP(SourceTy, Ops[0], ArrayRef(Ops).drop_front());
// Final adjustments to stride should go in the start block. // Final adjustments to stride should go in the start block.
Builder.SetInsertPoint( Builder.SetInsertPoint(
Context not available.

llvm/lib/Target/RISCV/RISCVISelLowering.cpp

Context not available.
MF.getInfo<RISCVMachineFunctionInfo>()->setIsVectorCall(); MF.getInfo<RISCVMachineFunctionInfo>()->setIsVectorCall();
if (IsVarArg) { if (IsVarArg) {
ArrayRef<MCPhysReg> ArgRegs = makeArrayRef(ArgGPRs); ArrayRef<MCPhysReg> ArgRegs = ArrayRef(ArgGPRs);
unsigned Idx = CCInfo.getFirstUnallocated(ArgRegs); unsigned Idx = CCInfo.getFirstUnallocated(ArgRegs);
const TargetRegisterClass *RC = &RISCV::GPRRegClass; const TargetRegisterClass *RC = &RISCV::GPRRegClass;
MachineFrameInfo &MFI = MF.getFrameInfo(); MachineFrameInfo &MFI = MF.getFrameInfo();
Context not available.

llvm/lib/Target/RISCV/RISCVInstrInfo.cpp

Context not available.
{MO_TPREL_ADD, "riscv-tprel-add"}, {MO_TPREL_ADD, "riscv-tprel-add"},
{MO_TLS_GOT_HI, "riscv-tls-got-hi"}, {MO_TLS_GOT_HI, "riscv-tls-got-hi"},
{MO_TLS_GD_HI, "riscv-tls-gd-hi"}}; {MO_TLS_GD_HI, "riscv-tls-gd-hi"}};
return makeArrayRef(TargetFlags); return ArrayRef(TargetFlags);
} }
bool RISCVInstrInfo::isFunctionSafeToOutlineFrom( bool RISCVInstrInfo::isFunctionSafeToOutlineFrom(
MachineFunction &MF, bool OutlineFromLinkOnceODRs) const { MachineFunction &MF, bool OutlineFromLinkOnceODRs) const {
Context not available.

llvm/lib/Target/SystemZ/SystemZISelLowering.cpp

Context not available.
} }
// Join the stores, which are independent of one another. // Join the stores, which are independent of one another.
Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other,
makeArrayRef(&MemOps[NumFixedFPRs], ArrayRef(&MemOps[NumFixedFPRs],
SystemZ::ELFNumArgFPRs-NumFixedFPRs)); SystemZ::ELFNumArgFPRs - NumFixedFPRs));
} }
} }
Context not available.
bool IsReturnValueUsed = false; bool IsReturnValueUsed = false;
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
SDValue AllocaCall = SDValue AllocaCall =
makeExternalCall(Chain, DAG, "@@ALCAXP", VT, makeArrayRef(NeededSpace), makeExternalCall(Chain, DAG, "@@ALCAXP", VT, ArrayRef(NeededSpace),
CallingConv::C, IsSigned, DL, DoesNotReturn, CallingConv::C, IsSigned, DL, DoesNotReturn,
IsReturnValueUsed) IsReturnValueUsed)
.first; .first;
Context not available.

llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.cpp

Context not available.
{WebAssembly::TI_OPERAND_STACK, "wasm-operand-stack"}, {WebAssembly::TI_OPERAND_STACK, "wasm-operand-stack"},
{WebAssembly::TI_GLOBAL_RELOC, "wasm-global-reloc"}, {WebAssembly::TI_GLOBAL_RELOC, "wasm-global-reloc"},
{WebAssembly::TI_LOCAL_INDIRECT, "wasm-local-indirect"}}; {WebAssembly::TI_LOCAL_INDIRECT, "wasm-local-indirect"}};
return makeArrayRef(TargetIndices); return ArrayRef(TargetIndices);
} }
const MachineOperand & const MachineOperand &
Context not available.

llvm/lib/Target/X86/ImmutableGraph.h

Context not available.
// node. // node.
const Edge *edges_end() const { return (this + 1)->Edges; } const Edge *edges_end() const { return (this + 1)->Edges; }
ArrayRef<Edge> edges() const { ArrayRef<Edge> edges() const {
return makeArrayRef(edges_begin(), edges_end()); return ArrayRef(edges_begin(), edges_end());
} }
}; };
Context not available.
ImmutableGraph &operator=(ImmutableGraph &&) = delete; ImmutableGraph &operator=(ImmutableGraph &&) = delete;
public: public:
ArrayRef<Node> nodes() const { return makeArrayRef(Nodes.get(), NodesSize); } ArrayRef<Node> nodes() const { return ArrayRef(Nodes.get(), NodesSize); }
const Node *nodes_begin() const { return nodes().begin(); } const Node *nodes_begin() const { return nodes().begin(); }
const Node *nodes_end() const { return nodes().end(); } const Node *nodes_end() const { return nodes().end(); }
ArrayRef<Edge> edges() const { return makeArrayRef(Edges.get(), EdgesSize); } ArrayRef<Edge> edges() const { return ArrayRef(Edges.get(), EdgesSize); }
const Edge *edges_begin() const { return edges().begin(); } const Edge *edges_begin() const { return edges().begin(); }
const Edge *edges_end() const { return edges().end(); } const Edge *edges_end() const { return edges().end(); }
Context not available.

llvm/lib/Target/X86/X86CallingConv.cpp

Context not available.
if (ValVT.is512BitVector()) { if (ValVT.is512BitVector()) {
static const MCPhysReg RegListZMM[] = {X86::ZMM0, X86::ZMM1, X86::ZMM2, static const MCPhysReg RegListZMM[] = {X86::ZMM0, X86::ZMM1, X86::ZMM2,
X86::ZMM3, X86::ZMM4, X86::ZMM5}; X86::ZMM3, X86::ZMM4, X86::ZMM5};
return makeArrayRef(std::begin(RegListZMM), std::end(RegListZMM)); return ArrayRef(std::begin(RegListZMM), std::end(RegListZMM));
} }
if (ValVT.is256BitVector()) { if (ValVT.is256BitVector()) {
static const MCPhysReg RegListYMM[] = {X86::YMM0, X86::YMM1, X86::YMM2, static const MCPhysReg RegListYMM[] = {X86::YMM0, X86::YMM1, X86::YMM2,
X86::YMM3, X86::YMM4, X86::YMM5}; X86::YMM3, X86::YMM4, X86::YMM5};
return makeArrayRef(std::begin(RegListYMM), std::end(RegListYMM)); return ArrayRef(std::begin(RegListYMM), std::end(RegListYMM));
} }
static const MCPhysReg RegListXMM[] = {X86::XMM0, X86::XMM1, X86::XMM2, static const MCPhysReg RegListXMM[] = {X86::XMM0, X86::XMM1, X86::XMM2,
X86::XMM3, X86::XMM4, X86::XMM5}; X86::XMM3, X86::XMM4, X86::XMM5};
return makeArrayRef(std::begin(RegListXMM), std::end(RegListXMM)); return ArrayRef(std::begin(RegListXMM), std::end(RegListXMM));
} }
static ArrayRef<MCPhysReg> CC_X86_64_VectorCallGetGPRs() { static ArrayRef<MCPhysReg> CC_X86_64_VectorCallGetGPRs() {
static const MCPhysReg RegListGPR[] = {X86::RCX, X86::RDX, X86::R8, X86::R9}; static const MCPhysReg RegListGPR[] = {X86::RCX, X86::RDX, X86::R8, X86::R9};
return makeArrayRef(std::begin(RegListGPR), std::end(RegListGPR)); return ArrayRef(std::begin(RegListGPR), std::end(RegListGPR));
} }
static bool CC_X86_VectorCallAssignRegister(unsigned &ValNo, MVT &ValVT, static bool CC_X86_VectorCallAssignRegister(unsigned &ValNo, MVT &ValVT,
Context not available.

llvm/lib/Target/X86/X86EvexToVex.cpp

Context not available.
// Use the VEX.L bit to select the 128 or 256-bit table. // Use the VEX.L bit to select the 128 or 256-bit table.
ArrayRef<X86EvexToVexCompressTableEntry> Table = ArrayRef<X86EvexToVexCompressTableEntry> Table =
(Desc.TSFlags & X86II::VEX_L) ? makeArrayRef(X86EvexToVex256CompressTable) (Desc.TSFlags & X86II::VEX_L) ? ArrayRef(X86EvexToVex256CompressTable)
: makeArrayRef(X86EvexToVex128CompressTable); : ArrayRef(X86EvexToVex128CompressTable);
const auto *I = llvm::lower_bound(Table, MI.getOpcode()); const auto *I = llvm::lower_bound(Table, MI.getOpcode());
if (I == Table.end() || I->EvexOpcode != MI.getOpcode()) if (I == Table.end() || I->EvexOpcode != MI.getOpcode())
Context not available.

llvm/lib/Target/X86/X86ISelLowering.cpp

Context not available.
static const MCPhysReg GPR64ArgRegsWin64[] = { static const MCPhysReg GPR64ArgRegsWin64[] = {
X86::RCX, X86::RDX, X86::R8, X86::R9 X86::RCX, X86::RDX, X86::R8, X86::R9
}; };
return makeArrayRef(std::begin(GPR64ArgRegsWin64), std::end(GPR64ArgRegsWin64)); return ArrayRef(std::begin(GPR64ArgRegsWin64), std::end(GPR64ArgRegsWin64));
} }
static const MCPhysReg GPR64ArgRegs64Bit[] = { static const MCPhysReg GPR64ArgRegs64Bit[] = {
X86::RDI, X86::RSI, X86::RDX, X86::RCX, X86::R8, X86::R9 X86::RDI, X86::RSI, X86::RDX, X86::RCX, X86::R8, X86::R9
}; };
return makeArrayRef(std::begin(GPR64ArgRegs64Bit), std::end(GPR64ArgRegs64Bit)); return ArrayRef(std::begin(GPR64ArgRegs64Bit), std::end(GPR64ArgRegs64Bit));
} }
// FIXME: Get this from tablegen. // FIXME: Get this from tablegen.
Context not available.
X86::XMM0, X86::XMM1, X86::XMM2, X86::XMM3, X86::XMM0, X86::XMM1, X86::XMM2, X86::XMM3,
X86::XMM4, X86::XMM5, X86::XMM6, X86::XMM7 X86::XMM4, X86::XMM5, X86::XMM6, X86::XMM7
}; };
return makeArrayRef(std::begin(XMMArgRegs64Bit), std::end(XMMArgRegs64Bit)); return ArrayRef(std::begin(XMMArgRegs64Bit), std::end(XMMArgRegs64Bit));
} }
#ifndef NDEBUG #ifndef NDEBUG
Context not available.
unsigned SeqLen = Sequence.size(); unsigned SeqLen = Sequence.size();
bool UpperZeroOrUndef = bool UpperZeroOrUndef =
SeqLen == 1 || SeqLen == 1 ||
llvm::all_of(makeArrayRef(Sequence).drop_front(), [](SDValue V) { llvm::all_of(ArrayRef(Sequence).drop_front(), [](SDValue V) {
return !V || V.isUndef() || isNullConstant(V); return !V || V.isUndef() || isNullConstant(V);
}); });
SDValue Op0 = Sequence[0]; SDValue Op0 = Sequence[0];
Context not available.
const int Mask[] = {1, -1, 3, -1, 5, -1, 7, -1, const int Mask[] = {1, -1, 3, -1, 5, -1, 7, -1,
9, -1, 11, -1, 13, -1, 15, -1}; 9, -1, 11, -1, 13, -1, 15, -1};
// <a|b|c|d> => <b|undef|d|undef> // <a|b|c|d> => <b|undef|d|undef>
SDValue Odd0 = DAG.getVectorShuffle(VT, dl, A, A, SDValue Odd0 =
makeArrayRef(&Mask[0], NumElts)); DAG.getVectorShuffle(VT, dl, A, A, ArrayRef(&Mask[0], NumElts));
// <e|f|g|h> => <f|undef|h|undef> // <e|f|g|h> => <f|undef|h|undef>
SDValue Odd1 = DAG.getVectorShuffle(VT, dl, B, B, SDValue Odd1 =
makeArrayRef(&Mask[0], NumElts)); DAG.getVectorShuffle(VT, dl, B, B, ArrayRef(&Mask[0], NumElts));
// Emit two multiplies, one for the lower 2 ints and one for the higher 2 // Emit two multiplies, one for the lower 2 ints and one for the higher 2
// ints. // ints.
Context not available.
// See if this reduces to a PSHUFD which is no more expensive and can // See if this reduces to a PSHUFD which is no more expensive and can
// combine with more operations. Note that it has to at least flip the // combine with more operations. Note that it has to at least flip the
// dwords as otherwise it would have been removed as a no-op. // dwords as otherwise it would have been removed as a no-op.
if (makeArrayRef(Mask).equals({2, 3, 0, 1})) { if (ArrayRef(Mask).equals({2, 3, 0, 1})) {
int DMask[] = {0, 1, 2, 3}; int DMask[] = {0, 1, 2, 3};
int DOffset = N.getOpcode() == X86ISD::PSHUFLW ? 0 : 2; int DOffset = N.getOpcode() == X86ISD::PSHUFLW ? 0 : 2;
DMask[DOffset + 0] = DOffset + 1; DMask[DOffset + 0] = DOffset + 1;
Context not available.
int MappedMask[8]; int MappedMask[8];
for (int i = 0; i < 8; ++i) for (int i = 0; i < 8; ++i)
MappedMask[i] = 2 * DMask[WordMask[i] / 2] + WordMask[i] % 2; MappedMask[i] = 2 * DMask[WordMask[i] / 2] + WordMask[i] % 2;
if (makeArrayRef(MappedMask).equals({0, 0, 1, 1, 2, 2, 3, 3}) || if (ArrayRef(MappedMask).equals({0, 0, 1, 1, 2, 2, 3, 3}) ||
makeArrayRef(MappedMask).equals({4, 4, 5, 5, 6, 6, 7, 7})) { ArrayRef(MappedMask).equals({4, 4, 5, 5, 6, 6, 7, 7})) {
// We can replace all three shuffles with an unpack. // We can replace all three shuffles with an unpack.
V = DAG.getBitcast(VT, D.getOperand(0)); V = DAG.getBitcast(VT, D.getOperand(0));
return DAG.getNode(MappedMask[0] == 0 ? X86ISD::UNPCKL return DAG.getNode(MappedMask[0] == 0 ? X86ISD::UNPCKL
Context not available.

llvm/lib/Target/X86/X86InstCombineIntrinsic.cpp

Context not available.
auto V1 = II.getArgOperand(0); auto V1 = II.getArgOperand(0);
auto V2 = Constant::getNullValue(VecTy); auto V2 = Constant::getNullValue(VecTy);
return Builder.CreateShuffleVector(V1, V2, makeArrayRef(Indexes, NumElts)); return Builder.CreateShuffleVector(V1, V2, ArrayRef(Indexes, NumElts));
} }
/// Attempt to convert vpermilvar* to shufflevector if the mask is constant. /// Attempt to convert vpermilvar* to shufflevector if the mask is constant.
Context not available.
} }
auto V1 = II.getArgOperand(0); auto V1 = II.getArgOperand(0);
return Builder.CreateShuffleVector(V1, makeArrayRef(Indexes, NumElts)); return Builder.CreateShuffleVector(V1, ArrayRef(Indexes, NumElts));
} }
/// Attempt to convert vpermd/vpermps to shufflevector if the mask is constant. /// Attempt to convert vpermd/vpermps to shufflevector if the mask is constant.
Context not available.
} }
auto V1 = II.getArgOperand(0); auto V1 = II.getArgOperand(0);
return Builder.CreateShuffleVector(V1, makeArrayRef(Indexes, Size)); return Builder.CreateShuffleVector(V1, ArrayRef(Indexes, Size));
} }
std::optional<Instruction *> std::optional<Instruction *>
Context not available.

llvm/lib/Target/X86/X86InstrFMA3Info.cpp

Context not available.
ArrayRef<X86InstrFMA3Group> Table; ArrayRef<X86InstrFMA3Group> Table;
if (TSFlags & X86II::EVEX_RC) if (TSFlags & X86II::EVEX_RC)
Table = makeArrayRef(RoundGroups); Table = ArrayRef(RoundGroups);
else if (TSFlags & X86II::EVEX_B) else if (TSFlags & X86II::EVEX_B)
Table = makeArrayRef(BroadcastGroups); Table = ArrayRef(BroadcastGroups);
else else
Table = makeArrayRef(Groups); Table = ArrayRef(Groups);
// FMA 132 instructions have an opcode of 0x96-0x9F // FMA 132 instructions have an opcode of 0x96-0x9F
// FMA 213 instructions have an opcode of 0xA6-0xAF // FMA 213 instructions have an opcode of 0xA6-0xAF
Context not available.

llvm/lib/Target/X86/X86InstrFoldTables.cpp

Context not available.
llvm::lookupFoldTable(unsigned RegOp, unsigned OpNum) { llvm::lookupFoldTable(unsigned RegOp, unsigned OpNum) {
ArrayRef<X86MemoryFoldTableEntry> FoldTable; ArrayRef<X86MemoryFoldTableEntry> FoldTable;
if (OpNum == 0) if (OpNum == 0)
FoldTable = makeArrayRef(MemoryFoldTable0); FoldTable = ArrayRef(MemoryFoldTable0);
else if (OpNum == 1) else if (OpNum == 1)
FoldTable = makeArrayRef(MemoryFoldTable1); FoldTable = ArrayRef(MemoryFoldTable1);
else if (OpNum == 2) else if (OpNum == 2)
FoldTable = makeArrayRef(MemoryFoldTable2); FoldTable = ArrayRef(MemoryFoldTable2);
else if (OpNum == 3) else if (OpNum == 3)
FoldTable = makeArrayRef(MemoryFoldTable3); FoldTable = ArrayRef(MemoryFoldTable3);
else if (OpNum == 4) else if (OpNum == 4)
FoldTable = makeArrayRef(MemoryFoldTable4); FoldTable = ArrayRef(MemoryFoldTable4);
else else
return nullptr; return nullptr;
Context not available.

llvm/lib/Target/X86/X86InstrInfo.cpp

Context not available.
{MO_TLVP_PIC_BASE, "x86-tlvp-pic-base"}, {MO_TLVP_PIC_BASE, "x86-tlvp-pic-base"},
{MO_SECREL, "x86-secrel"}, {MO_SECREL, "x86-secrel"},
{MO_COFFSTUB, "x86-coffstub"}}; {MO_COFFSTUB, "x86-coffstub"}};
return makeArrayRef(TargetFlags); return ArrayRef(TargetFlags);
} }
namespace { namespace {
Context not available.

llvm/lib/Target/X86/X86InterleavedAccess.cpp

Context not available.
return; return;
} }
reorderSubVector(VT, TransposedMatrix, VecOut, makeArrayRef(Concat, 16), reorderSubVector(VT, TransposedMatrix, VecOut, ArrayRef(Concat, 16), NumOfElm,
NumOfElm, 4, Builder); 4, Builder);
} }
// createShuffleStride returns shuffle mask of size N. // createShuffleStride returns shuffle mask of size N.
Context not available.
for (unsigned j = 0; j < VecElems / 32; j++) for (unsigned j = 0; j < VecElems / 32; j++)
for (int i = 0; i < 3; i++) for (int i = 0; i < 3; i++)
Vec[i + j * 3] = Builder.CreateShuffleVector( Vec[i + j * 3] = Builder.CreateShuffleVector(
InVec[j * 6 + i], InVec[j * 6 + i + 3], makeArrayRef(Concat, 32)); InVec[j * 6 + i], InVec[j * 6 + i + 3], ArrayRef(Concat, 32));
if (VecElems == 32) if (VecElems == 32)
return; return;
Context not available.
// dst = src1[0,1],src2[0,1] // dst = src1[0,1],src2[0,1]
static constexpr int IntMask1[] = {0, 1, 4, 5}; static constexpr int IntMask1[] = {0, 1, 4, 5};
ArrayRef<int> Mask = makeArrayRef(IntMask1, 4); ArrayRef<int> Mask = ArrayRef(IntMask1, 4);
Value *IntrVec1 = Builder.CreateShuffleVector(Matrix[0], Matrix[2], Mask); Value *IntrVec1 = Builder.CreateShuffleVector(Matrix[0], Matrix[2], Mask);
Value *IntrVec2 = Builder.CreateShuffleVector(Matrix[1], Matrix[3], Mask); Value *IntrVec2 = Builder.CreateShuffleVector(Matrix[1], Matrix[3], Mask);
// dst = src1[2,3],src2[2,3] // dst = src1[2,3],src2[2,3]
static constexpr int IntMask2[] = {2, 3, 6, 7}; static constexpr int IntMask2[] = {2, 3, 6, 7};
Mask = makeArrayRef(IntMask2, 4); Mask = ArrayRef(IntMask2, 4);
Value *IntrVec3 = Builder.CreateShuffleVector(Matrix[0], Matrix[2], Mask); Value *IntrVec3 = Builder.CreateShuffleVector(Matrix[0], Matrix[2], Mask);
Value *IntrVec4 = Builder.CreateShuffleVector(Matrix[1], Matrix[3], Mask); Value *IntrVec4 = Builder.CreateShuffleVector(Matrix[1], Matrix[3], Mask);
// dst = src1[0],src2[0],src1[2],src2[2] // dst = src1[0],src2[0],src1[2],src2[2]
static constexpr int IntMask3[] = {0, 4, 2, 6}; static constexpr int IntMask3[] = {0, 4, 2, 6};
Mask = makeArrayRef(IntMask3, 4); Mask = ArrayRef(IntMask3, 4);
TransposedMatrix[0] = Builder.CreateShuffleVector(IntrVec1, IntrVec2, Mask); TransposedMatrix[0] = Builder.CreateShuffleVector(IntrVec1, IntrVec2, Mask);
TransposedMatrix[2] = Builder.CreateShuffleVector(IntrVec3, IntrVec4, Mask); TransposedMatrix[2] = Builder.CreateShuffleVector(IntrVec3, IntrVec4, Mask);
// dst = src1[1],src2[1],src1[3],src2[3] // dst = src1[1],src2[1],src1[3],src2[3]
static constexpr int IntMask4[] = {1, 5, 3, 7}; static constexpr int IntMask4[] = {1, 5, 3, 7};
Mask = makeArrayRef(IntMask4, 4); Mask = ArrayRef(IntMask4, 4);
TransposedMatrix[1] = Builder.CreateShuffleVector(IntrVec1, IntrVec2, Mask); TransposedMatrix[1] = Builder.CreateShuffleVector(IntrVec1, IntrVec2, Mask);
TransposedMatrix[3] = Builder.CreateShuffleVector(IntrVec3, IntrVec4, Mask); TransposedMatrix[3] = Builder.CreateShuffleVector(IntrVec3, IntrVec4, Mask);
} }
Context not available.
for (unsigned i = 0; i < Factor; i++) for (unsigned i = 0; i < Factor; i++)
Indices.push_back(Mask[i]); Indices.push_back(Mask[i]);
ArrayRef<ShuffleVectorInst *> Shuffles = makeArrayRef(SVI); ArrayRef<ShuffleVectorInst *> Shuffles = ArrayRef(SVI);
// Create an interleaved access group. // Create an interleaved access group.
IRBuilder<> Builder(SI); IRBuilder<> Builder(SI);
Context not available.

llvm/lib/Target/X86/X86LowerAMXIntrinsics.cpp

Context not available.
Value *SubVecB = B.CreateBitCast(EltB, V2I16Ty); Value *SubVecB = B.CreateBitCast(EltB, V2I16Ty);
Value *ZeroV2I16 = Constant::getNullValue(V2I16Ty); Value *ZeroV2I16 = Constant::getNullValue(V2I16Ty);
int ShuffleMask[4] = {2, 0, 3, 1}; int ShuffleMask[4] = {2, 0, 3, 1};
auto ShuffleArray = makeArrayRef(ShuffleMask); auto ShuffleArray = ArrayRef(ShuffleMask);
Value *AV2F32 = B.CreateBitCast( Value *AV2F32 = B.CreateBitCast(
B.CreateShuffleVector(SubVecA, ZeroV2I16, ShuffleArray), V2F32Ty); B.CreateShuffleVector(SubVecA, ZeroV2I16, ShuffleArray), V2F32Ty);
Value *BV2F32 = B.CreateBitCast( Value *BV2F32 = B.CreateBitCast(
Context not available.

llvm/lib/Target/X86/X86WinEHState.cpp

Context not available.
Type *ArgTys[5] = {Int8PtrType, Int8PtrType, Int8PtrType, Int8PtrType, Type *ArgTys[5] = {Int8PtrType, Int8PtrType, Int8PtrType, Int8PtrType,
Int8PtrType}; Int8PtrType};
FunctionType *TrampolineTy = FunctionType *TrampolineTy =
FunctionType::get(Int32Ty, makeArrayRef(&ArgTys[0], 4), FunctionType::get(Int32Ty, ArrayRef(&ArgTys[0], 4),
/*isVarArg=*/false); /*isVarArg=*/false);
FunctionType *TargetFuncTy = FunctionType *TargetFuncTy =
FunctionType::get(Int32Ty, makeArrayRef(&ArgTys[0], 5), FunctionType::get(Int32Ty, ArrayRef(&ArgTys[0], 5),
/*isVarArg=*/false); /*isVarArg=*/false);
Function *Trampoline = Function *Trampoline =
Function::Create(TrampolineTy, GlobalValue::InternalLinkage, Function::Create(TrampolineTy, GlobalValue::InternalLinkage,
Context not available.

llvm/lib/Transforms/IPO/LowerTypeTests.cpp

Context not available.
} }
ArrayRef<MDNode *> types() const { ArrayRef<MDNode *> types() const {
return makeArrayRef(getTrailingObjects<MDNode *>(), NTypes); return ArrayRef(getTrailingObjects<MDNode *>(), NTypes);
} }
}; };
Context not available.
CallInst *CI; CallInst *CI;
ArrayRef<GlobalTypeMember *> targets() const { ArrayRef<GlobalTypeMember *> targets() const {
return makeArrayRef(getTrailingObjects<GlobalTypeMember *>(), NTargets); return ArrayRef(getTrailingObjects<GlobalTypeMember *>(), NTargets);
} }
unsigned UniqueId; unsigned UniqueId;
Context not available.

llvm/lib/Transforms/IPO/MergeFunctions.cpp

Context not available.
assert(SrcTy->getStructNumElements() == DestTy->getStructNumElements()); assert(SrcTy->getStructNumElements() == DestTy->getStructNumElements());
Value *Result = PoisonValue::get(DestTy); Value *Result = PoisonValue::get(DestTy);
for (unsigned int I = 0, E = SrcTy->getStructNumElements(); I < E; ++I) { for (unsigned int I = 0, E = SrcTy->getStructNumElements(); I < E; ++I) {
Value *Element = createCast( Value *Element =
Builder, Builder.CreateExtractValue(V, makeArrayRef(I)), createCast(Builder, Builder.CreateExtractValue(V, ArrayRef(I)),
DestTy->getStructElementType(I)); DestTy->getStructElementType(I));
Result = Result = Builder.CreateInsertValue(Result, Element, ArrayRef(I));
Builder.CreateInsertValue(Result, Element, makeArrayRef(I));
} }
return Result; return Result;
} }
Context not available.

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

Context not available.
auto *V1 = II.getArgOperand(0); auto *V1 = II.getArgOperand(0);
auto *V2 = Constant::getNullValue(V1->getType()); auto *V2 = Constant::getNullValue(V1->getType());
return Builder.CreateShuffleVector(V1, V2, makeArrayRef(Indexes)); return Builder.CreateShuffleVector(V1, V2, ArrayRef(Indexes));
} }
// Returns true iff the 2 intrinsics have the same operands, limiting the // Returns true iff the 2 intrinsics have the same operands, limiting the
Context not available.

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

Context not available.
// Cast base to the expected type. // Cast base to the expected type.
Value *NewVal = Builder.CreateBitOrPointerCast( Value *NewVal = Builder.CreateBitOrPointerCast(
Base, PtrTy, Start->getName() + "to.ptr"); Base, PtrTy, Start->getName() + "to.ptr");
NewVal = Builder.CreateInBoundsGEP( NewVal = Builder.CreateInBoundsGEP(ElemTy, NewVal, ArrayRef(NewInsts[Val]),
ElemTy, NewVal, makeArrayRef(NewInsts[Val]), Val->getName() + ".ptr"); Val->getName() + ".ptr");
NewVal = Builder.CreateBitOrPointerCast( NewVal = Builder.CreateBitOrPointerCast(
NewVal, Val->getType(), Val->getName() + ".conv"); NewVal, Val->getType(), Val->getName() + ".conv");
Val->replaceAllUsesWith(NewVal); Val->replaceAllUsesWith(NewVal);
Context not available.

llvm/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp

Context not available.
Zero, Zero,
ConstantInt::get(IdxType, i), ConstantInt::get(IdxType, i),
}; };
auto *Ptr = IC.Builder.CreateInBoundsGEP(ST, Addr, makeArrayRef(Indices), auto *Ptr = IC.Builder.CreateInBoundsGEP(ST, Addr, ArrayRef(Indices),
Name + ".elt"); Name + ".elt");
auto *L = IC.Builder.CreateAlignedLoad( auto *L = IC.Builder.CreateAlignedLoad(
ST->getElementType(i), Ptr, ST->getElementType(i), Ptr,
Context not available.
Zero, Zero,
ConstantInt::get(IdxType, i), ConstantInt::get(IdxType, i),
}; };
auto *Ptr = IC.Builder.CreateInBoundsGEP(AT, Addr, makeArrayRef(Indices), auto *Ptr = IC.Builder.CreateInBoundsGEP(AT, Addr, ArrayRef(Indices),
Name + ".elt"); Name + ".elt");
auto *L = IC.Builder.CreateAlignedLoad(AT->getElementType(), Ptr, auto *L = IC.Builder.CreateAlignedLoad(AT->getElementType(), Ptr,
commonAlignment(Align, Offset), commonAlignment(Align, Offset),
Context not available.
Zero, Zero,
ConstantInt::get(IdxType, i), ConstantInt::get(IdxType, i),
}; };
auto *Ptr = IC.Builder.CreateInBoundsGEP(ST, Addr, makeArrayRef(Indices), auto *Ptr =
AddrName); IC.Builder.CreateInBoundsGEP(ST, Addr, ArrayRef(Indices), AddrName);
auto *Val = IC.Builder.CreateExtractValue(V, i, EltName); auto *Val = IC.Builder.CreateExtractValue(V, i, EltName);
auto EltAlign = commonAlignment(Align, SL->getElementOffset(i)); auto EltAlign = commonAlignment(Align, SL->getElementOffset(i));
llvm::Instruction *NS = IC.Builder.CreateAlignedStore(Val, Ptr, EltAlign); llvm::Instruction *NS = IC.Builder.CreateAlignedStore(Val, Ptr, EltAlign);
Context not available.
Zero, Zero,
ConstantInt::get(IdxType, i), ConstantInt::get(IdxType, i),
}; };
auto *Ptr = IC.Builder.CreateInBoundsGEP(AT, Addr, makeArrayRef(Indices), auto *Ptr =
AddrName); IC.Builder.CreateInBoundsGEP(AT, Addr, ArrayRef(Indices), AddrName);
auto *Val = IC.Builder.CreateExtractValue(V, i, EltName); auto *Val = IC.Builder.CreateExtractValue(V, i, EltName);
auto EltAlign = commonAlignment(Align, Offset); auto EltAlign = commonAlignment(Align, Offset);
Instruction *NS = IC.Builder.CreateAlignedStore(Val, Ptr, EltAlign); Instruction *NS = IC.Builder.CreateAlignedStore(Val, Ptr, EltAlign);
Context not available.

llvm/lib/Transforms/InstCombine/InstCombinePHI.cpp

Context not available.
Value *Base = FixedOperands[0]; Value *Base = FixedOperands[0];
GetElementPtrInst *NewGEP = GetElementPtrInst *NewGEP =
GetElementPtrInst::Create(FirstInst->getSourceElementType(), Base, GetElementPtrInst::Create(FirstInst->getSourceElementType(), Base,
makeArrayRef(FixedOperands).slice(1)); ArrayRef(FixedOperands).slice(1));
if (AllInBounds) NewGEP->setIsInBounds(); if (AllInBounds) NewGEP->setIsInBounds();
PHIArgMergedDebugLoc(NewGEP, PN); PHIArgMergedDebugLoc(NewGEP, PN);
return NewGEP; return NewGEP;
Context not available.

llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

Context not available.
Value *NewEV = Builder.CreateExtractValue(IV->getAggregateOperand(), Value *NewEV = Builder.CreateExtractValue(IV->getAggregateOperand(),
EV.getIndices()); EV.getIndices());
return InsertValueInst::Create(NewEV, IV->getInsertedValueOperand(), return InsertValueInst::Create(NewEV, IV->getInsertedValueOperand(),
makeArrayRef(insi, inse)); ArrayRef(insi, inse));
} }
if (insi == inse) if (insi == inse)
// The insert list is a prefix of the extract list // The insert list is a prefix of the extract list
Context not available.
// with // with
// %E extractvalue { i32 } { i32 42 }, 0 // %E extractvalue { i32 } { i32 42 }, 0
return ExtractValueInst::Create(IV->getInsertedValueOperand(), return ExtractValueInst::Create(IV->getInsertedValueOperand(),
makeArrayRef(exti, exte)); ArrayRef(exti, exte));
} }
if (Instruction *R = foldExtractOfOverflowIntrinsic(EV)) if (Instruction *R = foldExtractOfOverflowIntrinsic(EV))
Context not available.

llvm/lib/Transforms/Instrumentation/DataFlowSanitizer.cpp

Context not available.
return AttributeList::get(Ctx, CallSiteAttrs.getFnAttrs(), return AttributeList::get(Ctx, CallSiteAttrs.getFnAttrs(),
CallSiteAttrs.getRetAttrs(), CallSiteAttrs.getRetAttrs(),
llvm::makeArrayRef(ArgumentAttributes)); llvm::ArrayRef(ArgumentAttributes));
} }
class DataFlowSanitizer { class DataFlowSanitizer {
Context not available.
(int)AtomicOrderingCABI::seq_cst; (int)AtomicOrderingCABI::seq_cst;
return ConstantDataVector::get(IRB.getContext(), return ConstantDataVector::get(IRB.getContext(),
makeArrayRef(OrderingTable, NumOrderings)); ArrayRef(OrderingTable, NumOrderings));
} }
void DFSanVisitor::visitLibAtomicLoad(CallBase &CB) { void DFSanVisitor::visitLibAtomicLoad(CallBase &CB) {
Context not available.
(int)AtomicOrderingCABI::seq_cst; (int)AtomicOrderingCABI::seq_cst;
return ConstantDataVector::get(IRB.getContext(), return ConstantDataVector::get(IRB.getContext(),
makeArrayRef(OrderingTable, NumOrderings)); ArrayRef(OrderingTable, NumOrderings));
} }
void DFSanVisitor::visitLibAtomicStore(CallBase &CB) { void DFSanVisitor::visitLibAtomicStore(CallBase &CB) {
Context not available.

llvm/lib/Transforms/Instrumentation/InstrProfiling.cpp

Context not available.
#include "llvm/ProfileData/InstrProfData.inc" #include "llvm/ProfileData/InstrProfData.inc"
}; };
auto *ValueProfilingCallTy = auto *ValueProfilingCallTy =
FunctionType::get(ReturnTy, makeArrayRef(ParamTypes), false); FunctionType::get(ReturnTy, ArrayRef(ParamTypes), false);
StringRef FuncName = CallType == ValueProfilingCallType::Default StringRef FuncName = CallType == ValueProfilingCallType::Default
? getInstrProfValueProfFuncName() ? getInstrProfValueProfFuncName()
: getInstrProfValueProfMemOpFuncName(); : getInstrProfValueProfMemOpFuncName();
Context not available.
#define INSTR_PROF_DATA(Type, LLVMType, Name, Init) LLVMType, #define INSTR_PROF_DATA(Type, LLVMType, Name, Init) LLVMType,
#include "llvm/ProfileData/InstrProfData.inc" #include "llvm/ProfileData/InstrProfData.inc"
}; };
auto *DataTy = StructType::get(Ctx, makeArrayRef(DataTypes)); auto *DataTy = StructType::get(Ctx, ArrayRef(DataTypes));
Constant *FunctionAddr = shouldRecordFunctionAddr(Fn) Constant *FunctionAddr = shouldRecordFunctionAddr(Fn)
? ConstantExpr::getBitCast(Fn, Int8PtrTy) ? ConstantExpr::getBitCast(Fn, Int8PtrTy)
Context not available.
#define INSTR_PROF_VALUE_NODE(Type, LLVMType, Name, Init) LLVMType, #define INSTR_PROF_VALUE_NODE(Type, LLVMType, Name, Init) LLVMType,
#include "llvm/ProfileData/InstrProfData.inc" #include "llvm/ProfileData/InstrProfData.inc"
}; };
auto *VNodeTy = StructType::get(Ctx, makeArrayRef(VNodeTypes)); auto *VNodeTy = StructType::get(Ctx, ArrayRef(VNodeTypes));
ArrayType *VNodesTy = ArrayType::get(VNodeTy, NumCounters); ArrayType *VNodesTy = ArrayType::get(VNodeTy, NumCounters);
auto *VNodesVar = new GlobalVariable( auto *VNodesVar = new GlobalVariable(
Context not available.
if (NamesVar) { if (NamesVar) {
Type *ParamTypes[] = {VoidPtrTy, Int64Ty}; Type *ParamTypes[] = {VoidPtrTy, Int64Ty};
auto *NamesRegisterTy = auto *NamesRegisterTy =
FunctionType::get(VoidTy, makeArrayRef(ParamTypes), false); FunctionType::get(VoidTy, ArrayRef(ParamTypes), false);
auto *NamesRegisterF = auto *NamesRegisterF =
Function::Create(NamesRegisterTy, GlobalVariable::ExternalLinkage, Function::Create(NamesRegisterTy, GlobalVariable::ExternalLinkage,
getInstrProfNamesRegFuncName(), M); getInstrProfNamesRegFuncName(), M);
Context not available.

llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp

Context not available.
(int)AtomicOrderingCABI::seq_cst; (int)AtomicOrderingCABI::seq_cst;
return ConstantDataVector::get(IRB.getContext(), return ConstantDataVector::get(IRB.getContext(),
makeArrayRef(OrderingTable, NumOrderings)); ArrayRef(OrderingTable, NumOrderings));
} }
AtomicOrdering addAcquireOrdering(AtomicOrdering a) { AtomicOrdering addAcquireOrdering(AtomicOrdering a) {
Context not available.
(int)AtomicOrderingCABI::seq_cst; (int)AtomicOrderingCABI::seq_cst;
return ConstantDataVector::get(IRB.getContext(), return ConstantDataVector::get(IRB.getContext(),
makeArrayRef(OrderingTable, NumOrderings)); ArrayRef(OrderingTable, NumOrderings));
} }
// ------------------- Visitors. // ------------------- Visitors.
Context not available.
Value *Op = I.getArgOperand(0); Value *Op = I.getArgOperand(0);
Type *OpType = Op->getType(); Type *OpType = Op->getType();
Function *BswapFunc = Intrinsic::getDeclaration( Function *BswapFunc = Intrinsic::getDeclaration(
F.getParent(), Intrinsic::bswap, makeArrayRef(&OpType, 1)); F.getParent(), Intrinsic::bswap, ArrayRef(&OpType, 1));
setShadow(&I, IRB.CreateCall(BswapFunc, getShadow(Op))); setShadow(&I, IRB.CreateCall(BswapFunc, getShadow(Op)));
setOrigin(&I, getOrigin(Op)); setOrigin(&I, getOrigin(Op));
} }
Context not available.

llvm/lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp

Context not available.
auto NewBlocksEnd = auto NewBlocksEnd =
std::remove(std::begin(NewBlocks), std::end(NewBlocks), nullptr); std::remove(std::begin(NewBlocks), std::end(NewBlocks), nullptr);
addToParentLoopIfNeeded(makeArrayRef(std::begin(NewBlocks), NewBlocksEnd)); addToParentLoopIfNeeded(ArrayRef(std::begin(NewBlocks), NewBlocksEnd));
DT.recalculate(F); DT.recalculate(F);
Context not available.

llvm/lib/Transforms/Scalar/LoopDeletion.cpp

Context not available.
// blocks, then it is impossible to statically determine which value // blocks, then it is impossible to statically determine which value
// should be used. // should be used.
AllOutgoingValuesSame = AllOutgoingValuesSame =
all_of(makeArrayRef(ExitingBlocks).slice(1), [&](BasicBlock *BB) { all_of(ArrayRef(ExitingBlocks).slice(1), [&](BasicBlock *BB) {
return incoming == P.getIncomingValueForBlock(BB); return incoming == P.getIncomingValueForBlock(BB);
}); });
Context not available.

llvm/lib/Transforms/Scalar/LoopSink.cpp

Context not available.
BasicBlock *MoveBB = *SortedBBsToSinkInto.begin(); BasicBlock *MoveBB = *SortedBBsToSinkInto.begin();
// FIXME: Optimize the efficiency for cloned value replacement. The current // FIXME: Optimize the efficiency for cloned value replacement. The current
// implementation is O(SortedBBsToSinkInto.size() * I.num_uses()). // implementation is O(SortedBBsToSinkInto.size() * I.num_uses()).
for (BasicBlock *N : makeArrayRef(SortedBBsToSinkInto).drop_front(1)) { for (BasicBlock *N : ArrayRef(SortedBBsToSinkInto).drop_front(1)) {
assert(LoopBlockNumber.find(N)->second > assert(LoopBlockNumber.find(N)->second >
LoopBlockNumber.find(MoveBB)->second && LoopBlockNumber.find(MoveBB)->second &&
"BBs not sorted!"); "BBs not sorted!");
Context not available.

llvm/lib/Transforms/Scalar/NewGVN.cpp

Context not available.
if (auto Simplified = checkExprResults(E, I, V)) if (auto Simplified = checkExprResults(E, I, V))
return Simplified; return Simplified;
} else if (auto *GEPI = dyn_cast<GetElementPtrInst>(I)) { } else if (auto *GEPI = dyn_cast<GetElementPtrInst>(I)) {
Value *V = Value *V = simplifyGEPInst(GEPI->getSourceElementType(), *E->op_begin(),
simplifyGEPInst(GEPI->getSourceElementType(), *E->op_begin(), ArrayRef(std::next(E->op_begin()), E->op_end()),
makeArrayRef(std::next(E->op_begin()), E->op_end()), GEPI->isInBounds(), Q);
GEPI->isInBounds(), Q);
if (auto Simplified = checkExprResults(E, I, V)) if (auto Simplified = checkExprResults(E, I, V))
return Simplified; return Simplified;
} else if (AllConstant) { } else if (AllConstant) {
Context not available.

llvm/lib/Transforms/Scalar/SROA.cpp

Context not available.
// Try to build up a sub-structure. // Try to build up a sub-structure.
StructType *SubTy = StructType *SubTy =
StructType::get(STy->getContext(), makeArrayRef(EI, EE), STy->isPacked()); StructType::get(STy->getContext(), ArrayRef(EI, EE), STy->isPacked());
const StructLayout *SubSL = DL.getStructLayout(SubTy); const StructLayout *SubSL = DL.getStructLayout(SubTy);
if (Size != SubSL->getSizeInBytes()) if (Size != SubSL->getSizeInBytes())
return nullptr; // The sub-struct doesn't have quite the size needed. return nullptr; // The sub-struct doesn't have quite the size needed.
Context not available.

llvm/lib/Transforms/Scalar/SimpleLoopUnswitch.cpp

Context not available.
// We need a stable insertion order. We use the order of the original loop // We need a stable insertion order. We use the order of the original loop
// order and map into the correct parent loop. // order and map into the correct parent loop.
for (auto *BB : llvm::concat<BasicBlock *const>( for (auto *BB : llvm::concat<BasicBlock *const>(
makeArrayRef(ClonedPH), ClonedLoopBlocks, ClonedExitsInLoops)) ArrayRef(ClonedPH), ClonedLoopBlocks, ClonedExitsInLoops))
if (Loop *OuterL = ExitLoopMap.lookup(BB)) if (Loop *OuterL = ExitLoopMap.lookup(BB))
OuterL->addBasicBlockToLoop(BB, LI); OuterL->addBasicBlockToLoop(BB, LI);
Context not available.
// some *other* successor with a single data structure. We use this to // some *other* successor with a single data structure. We use this to
// significantly reduce cloning. // significantly reduce cloning.
SmallDenseMap<BasicBlock *, BasicBlock *, 16> DominatingSucc; SmallDenseMap<BasicBlock *, BasicBlock *, 16> DominatingSucc;
for (auto *SuccBB : llvm::concat<BasicBlock *const>( for (auto *SuccBB : llvm::concat<BasicBlock *const>(ArrayRef(RetainedSuccBB),
makeArrayRef(RetainedSuccBB), UnswitchedSuccBBs)) UnswitchedSuccBBs))
if (SuccBB->getUniquePredecessor() || if (SuccBB->getUniquePredecessor() ||
llvm::all_of(predecessors(SuccBB), [&](BasicBlock *PredBB) { llvm::all_of(predecessors(SuccBB), [&](BasicBlock *PredBB) {
return PredBB == ParentBB || DT.dominates(SuccBB, PredBB); return PredBB == ParentBB || DT.dominates(SuccBB, PredBB);
Context not available.

llvm/lib/Transforms/Utils/ModuleUtils.cpp

Context not available.
CSVals[2] = Data ? ConstantExpr::getPointerCast(Data, IRB.getInt8PtrTy()) CSVals[2] = Data ? ConstantExpr::getPointerCast(Data, IRB.getInt8PtrTy())
: Constant::getNullValue(IRB.getInt8PtrTy()); : Constant::getNullValue(IRB.getInt8PtrTy());
Constant *RuntimeCtorInit = Constant *RuntimeCtorInit =
ConstantStruct::get(EltTy, makeArrayRef(CSVals, EltTy->getNumElements())); ConstantStruct::get(EltTy, ArrayRef(CSVals, EltTy->getNumElements()));
CurrentCtors.push_back(RuntimeCtorInit); CurrentCtors.push_back(RuntimeCtorInit);
Context not available.
StringRef SectionName, Align Alignment) { StringRef SectionName, Align Alignment) {
// Embed the memory buffer into the module. // Embed the memory buffer into the module.
Constant *ModuleConstant = ConstantDataArray::get( Constant *ModuleConstant = ConstantDataArray::get(
M.getContext(), makeArrayRef(Buf.getBufferStart(), Buf.getBufferSize())); M.getContext(), ArrayRef(Buf.getBufferStart(), Buf.getBufferSize()));
GlobalVariable *GV = new GlobalVariable( GlobalVariable *GV = new GlobalVariable(
M, ModuleConstant->getType(), true, GlobalValue::PrivateLinkage, M, ModuleConstant->getType(), true, GlobalValue::PrivateLinkage,
ModuleConstant, "llvm.embedded.object"); ModuleConstant, "llvm.embedded.object");
Context not available.

llvm/lib/Transforms/Utils/SCCPSolver.cpp

Context not available.
} }
Constant *Ptr = Operands[0]; Constant *Ptr = Operands[0];
auto Indices = makeArrayRef(Operands.begin() + 1, Operands.end()); auto Indices = ArrayRef(Operands.begin() + 1, Operands.end());
Constant *C = Constant *C =
ConstantExpr::getGetElementPtr(I.getSourceElementType(), Ptr, Indices); ConstantExpr::getGetElementPtr(I.getSourceElementType(), Ptr, Indices);
markConstant(&I, C); markConstant(&I, C);
Context not available.

llvm/lib/Transforms/Utils/ValueMapper.cpp

Context not available.
AppendingInits.resize(PrefixSize); AppendingInits.resize(PrefixSize);
mapAppendingVariable(*E.Data.AppendingGV.GV, mapAppendingVariable(*E.Data.AppendingGV.GV,
E.Data.AppendingGV.InitPrefix, E.Data.AppendingGV.InitPrefix,
E.AppendingGVIsOldCtorDtor, makeArrayRef(NewInits)); E.AppendingGVIsOldCtorDtor, ArrayRef(NewInits));
break; break;
} }
case WorklistEntry::MapAliasOrIFunc: { case WorklistEntry::MapAliasOrIFunc: {
Context not available.

llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp

Context not available.
auto *It = ResOrder.begin(); auto *It = ResOrder.begin();
for (unsigned K = 0; K < VF; K += Sz) { for (unsigned K = 0; K < VF; K += Sz) {
OrdersType CurrentOrder(TE.ReorderIndices); OrdersType CurrentOrder(TE.ReorderIndices);
SmallVector<int> SubMask(makeArrayRef(ReusedMask).slice(K, Sz)); SmallVector<int> SubMask{ArrayRef(ReusedMask).slice(K, Sz)};
if (SubMask.front() == UndefMaskElem) if (SubMask.front() == UndefMaskElem)
std::iota(SubMask.begin(), SubMask.end(), 0); std::iota(SubMask.begin(), SubMask.end(), 0);
reorderOrder(CurrentOrder, SubMask); reorderOrder(CurrentOrder, SubMask);
Context not available.
// Clear reorder since it is going to be applied to the new mask. // Clear reorder since it is going to be applied to the new mask.
TE.ReorderIndices.clear(); TE.ReorderIndices.clear();
// Try to improve gathered nodes with clustered reuses, if possible. // Try to improve gathered nodes with clustered reuses, if possible.
reorderScalars(TE.Scalars, makeArrayRef(NewMask).slice(0, Sz)); reorderScalars(TE.Scalars, ArrayRef(NewMask).slice(0, Sz));
// Fill the reuses mask with the identity submasks. // Fill the reuses mask with the identity submasks.
for (auto *It = TE.ReuseShuffleIndices.begin(), for (auto *It = TE.ReuseShuffleIndices.begin(),
*End = TE.ReuseShuffleIndices.end(); *End = TE.ReuseShuffleIndices.end();
Context not available.
if (E->State != TreeEntry::NeedToGather && if (E->State != TreeEntry::NeedToGather &&
E->getOpcode() == Instruction::Store) { E->getOpcode() == Instruction::Store) {
ArrayRef<int> Mask = ArrayRef<int> Mask =
makeArrayRef(reinterpret_cast<const int *>(E->ReorderIndices.begin()), ArrayRef(reinterpret_cast<const int *>(E->ReorderIndices.begin()),
E->ReorderIndices.size()); E->ReorderIndices.size());
ShuffleBuilder.add(V, Mask); ShuffleBuilder.add(V, Mask);
} else { } else {
ShuffleBuilder.addOrdered(V, E->ReorderIndices); ShuffleBuilder.addOrdered(V, E->ReorderIndices);
Context not available.
unsigned StartIdx = 0; unsigned StartIdx = 0;
for (unsigned Size = MaxVF; Size >= MinVF; Size /= 2) { for (unsigned Size = MaxVF; Size >= MinVF; Size /= 2) {
for (unsigned Cnt = StartIdx, E = Operands.size(); Cnt + Size <= E;) { for (unsigned Cnt = StartIdx, E = Operands.size(); Cnt + Size <= E;) {
ArrayRef<Value *> Slice = makeArrayRef(Operands).slice(Cnt, Size); ArrayRef<Value *> Slice = ArrayRef(Operands).slice(Cnt, Size);
if (!VectorizedStores.count(Slice.front()) && if (!VectorizedStores.count(Slice.front()) &&
!VectorizedStores.count(Slice.back()) && !VectorizedStores.count(Slice.back()) &&
vectorizeStoreChain(Slice, R, Cnt, MinVF)) { vectorizeStoreChain(Slice, R, Cnt, MinVF)) {
Context not available.
continue; continue;
unsigned NumOps = VectorizedVals.lookup(RdxVal); unsigned NumOps = VectorizedVals.lookup(RdxVal);
for (Instruction *RedOp : for (Instruction *RedOp :
makeArrayRef(ReducedValsToOps.find(RdxVal)->second) ArrayRef(ReducedValsToOps.find(RdxVal)->second)
.drop_back(NumOps)) .drop_back(NumOps))
ExtraReductions.emplace_back(RedOp, RdxVal); ExtraReductions.emplace_back(RedOp, RdxVal);
} }
Context not available.
// same/alternate ops only, this may result in some extra final // same/alternate ops only, this may result in some extra final
// vectorization. // vectorization.
if (NumElts > 1 && if (NumElts > 1 &&
TryToVectorizeHelper(makeArrayRef(IncIt, NumElts), LimitForRegisterSize)) { TryToVectorizeHelper(ArrayRef(IncIt, NumElts), LimitForRegisterSize)) {
// Success start over because instructions might have been changed. // Success start over because instructions might have been changed.
Changed = true; Changed = true;
} else if (NumElts < Limit(*IncIt) && } else if (NumElts < Limit(*IncIt) &&
Context not available.
while (SameTypeIt != End && AreCompatible(*SameTypeIt, *It)) while (SameTypeIt != End && AreCompatible(*SameTypeIt, *It))
++SameTypeIt; ++SameTypeIt;
unsigned NumElts = (SameTypeIt - It); unsigned NumElts = (SameTypeIt - It);
if (NumElts > 1 && TryToVectorizeHelper(makeArrayRef(It, NumElts), if (NumElts > 1 &&
/*LimitForRegisterSize=*/false)) TryToVectorizeHelper(ArrayRef(It, NumElts),
/*LimitForRegisterSize=*/false))
Changed = true; Changed = true;
It = SameTypeIt; It = SameTypeIt;
} }
Context not available.

llvm/tools/dsymutil/MachOUtils.cpp

Context not available.
} }
static bool runLipo(StringRef SDKPath, SmallVectorImpl<StringRef> &Args) { static bool runLipo(StringRef SDKPath, SmallVectorImpl<StringRef> &Args) {
auto Path = sys::findProgramByName("lipo", makeArrayRef(SDKPath)); auto Path = sys::findProgramByName("lipo", ArrayRef(SDKPath));
if (!Path) if (!Path)
Path = sys::findProgramByName("lipo"); Path = sys::findProgramByName("lipo");
Context not available.

llvm/tools/dsymutil/dsymutil.cpp

Context not available.
DsymutilOptTable T; DsymutilOptTable T;
unsigned MAI; unsigned MAI;
unsigned MAC; unsigned MAC;
ArrayRef<const char *> ArgsArr = makeArrayRef(argv + 1, argc - 1); ArrayRef<const char *> ArgsArr = ArrayRef(argv + 1, argc - 1);
opt::InputArgList Args = T.ParseArgs(ArgsArr, MAI, MAC); opt::InputArgList Args = T.ParseArgs(ArgsArr, MAI, MAC);
void *P = (void *)(intptr_t)getOutputFileName; void *P = (void *)(intptr_t)getOutputFileName;
Context not available.

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

Context not available.
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(ArrayRef(argv, argc)), Argv);
// Get BitMode from enviorment variable "OBJECT_MODE" for AIX OS, if // Get BitMode from enviorment variable "OBJECT_MODE" for AIX OS, if
// specified. // specified.
Context not available.
}; };
if (Is("dlltool")) if (Is("dlltool"))
return dlltoolDriverMain(makeArrayRef(argv, argc)); return dlltoolDriverMain(ArrayRef(argv, argc));
if (Is("ranlib")) if (Is("ranlib"))
return ranlib_main(argc, argv); return ranlib_main(argc, argv);
if (Is("lib")) if (Is("lib"))
return libDriverMain(makeArrayRef(argv, argc)); return libDriverMain(ArrayRef(argv, argc));
if (Is("ar")) if (Is("ar"))
return ar_main(argc, argv); return ar_main(argc, argv);
Context not available.

llvm/tools/llvm-cvtres/llvm-cvtres.cpp

Context not available.
CvtResOptTable T; CvtResOptTable T;
unsigned MAI, MAC; unsigned MAI, MAC;
ArrayRef<const char *> ArgsArr = makeArrayRef(Argv + 1, Argc - 1); ArrayRef<const char *> ArgsArr = ArrayRef(Argv + 1, Argc - 1);
opt::InputArgList InputArgs = T.ParseArgs(ArgsArr, MAI, MAC); opt::InputArgList InputArgs = T.ParseArgs(ArgsArr, MAI, MAC);
if (InputArgs.hasArg(OPT_HELP)) { if (InputArgs.hasArg(OPT_HELP)) {
Context not available.

llvm/tools/llvm-cxxdump/llvm-cxxdump.cpp

Context not available.
// Complete object locators in the MS-ABI start with '??_R4' // Complete object locators in the MS-ABI start with '??_R4'
else if (SymName.startswith("??_R4")) { else if (SymName.startswith("??_R4")) {
CompleteObjectLocator COL; CompleteObjectLocator COL;
COL.Data = makeArrayRef( COL.Data =
reinterpret_cast<const little32_t *>(SymContents.data()), 3); ArrayRef(reinterpret_cast<const little32_t *>(SymContents.data()), 3);
StringRef *I = std::begin(COL.Symbols), *E = std::end(COL.Symbols); StringRef *I = std::begin(COL.Symbols), *E = std::end(COL.Symbols);
collectRelocatedSymbols(Obj, Sec, SecAddress, SymAddress, SymSize, I, E); collectRelocatedSymbols(Obj, Sec, SecAddress, SymAddress, SymSize, I, E);
COLs[SymName] = COL; COLs[SymName] = COL;
Context not available.
// Class hierarchy descriptors in the MS-ABI start with '??_R3' // Class hierarchy descriptors in the MS-ABI start with '??_R3'
else if (SymName.startswith("??_R3")) { else if (SymName.startswith("??_R3")) {
ClassHierarchyDescriptor CHD; ClassHierarchyDescriptor CHD;
CHD.Data = makeArrayRef( CHD.Data =
reinterpret_cast<const little32_t *>(SymContents.data()), 3); ArrayRef(reinterpret_cast<const little32_t *>(SymContents.data()), 3);
StringRef *I = std::begin(CHD.Symbols), *E = std::end(CHD.Symbols); StringRef *I = std::begin(CHD.Symbols), *E = std::end(CHD.Symbols);
collectRelocatedSymbols(Obj, Sec, SecAddress, SymAddress, SymSize, I, E); collectRelocatedSymbols(Obj, Sec, SecAddress, SymAddress, SymSize, I, E);
CHDs[SymName] = CHD; CHDs[SymName] = CHD;
Context not available.
// Base class descriptors in the MS-ABI start with '??_R1' // Base class descriptors in the MS-ABI start with '??_R1'
else if (SymName.startswith("??_R1")) { else if (SymName.startswith("??_R1")) {
BaseClassDescriptor BCD; BaseClassDescriptor BCD;
BCD.Data = makeArrayRef( BCD.Data = ArrayRef(
reinterpret_cast<const little32_t *>(SymContents.data()) + 1, 5); reinterpret_cast<const little32_t *>(SymContents.data()) + 1, 5);
StringRef *I = std::begin(BCD.Symbols), *E = std::end(BCD.Symbols); StringRef *I = std::begin(BCD.Symbols), *E = std::end(BCD.Symbols);
collectRelocatedSymbols(Obj, Sec, SecAddress, SymAddress, SymSize, I, E); collectRelocatedSymbols(Obj, Sec, SecAddress, SymAddress, SymSize, I, E);
Context not available.

llvm/tools/llvm-dwarfutil/llvm-dwarfutil.cpp

Context not available.
DwarfutilOptTable T; DwarfutilOptTable T;
unsigned MAI; unsigned MAI;
unsigned MAC; unsigned MAC;
ArrayRef<const char *> ArgsArr = makeArrayRef(Argv + 1, Argc - 1); ArrayRef<const char *> ArgsArr = ArrayRef(Argv + 1, Argc - 1);
opt::InputArgList Args = T.ParseArgs(ArgsArr, MAI, MAC); opt::InputArgList Args = T.ParseArgs(ArgsArr, MAI, MAC);
if (Args.hasArg(OPT_help) || Args.size() == 0) { if (Args.hasArg(OPT_help) || Args.size() == 0) {
Context not available.

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

Context not available.
ExecutionMode::ALWAYS_PARALLEL_MISSING_USE_OR_DEF, ExecutionMode::ALWAYS_PARALLEL_MISSING_USE_OR_DEF,
ExecutionMode::PARALLEL_VIA_EXPLICIT_REGS, ExecutionMode::PARALLEL_VIA_EXPLICIT_REGS,
}; };
return makeArrayRef(kAllExecutionModeBits); return ArrayRef(kAllExecutionModeBits);
} }
SmallVector<ExecutionMode, 4> getExecutionModeBits(ExecutionMode Execution) { SmallVector<ExecutionMode, 4> getExecutionModeBits(ExecutionMode Execution) {
Context not available.

llvm/tools/llvm-exegesis/lib/X86/Target.cpp

Context not available.
ArrayRef<unsigned> getUnavailableRegisters() const override { ArrayRef<unsigned> getUnavailableRegisters() const override {
if (DisableUpperSSERegisters) if (DisableUpperSSERegisters)
return makeArrayRef(kUnavailableRegistersSSE, return ArrayRef(kUnavailableRegistersSSE,
sizeof(kUnavailableRegistersSSE) / sizeof(kUnavailableRegistersSSE) /
sizeof(kUnavailableRegistersSSE[0])); sizeof(kUnavailableRegistersSSE[0]));
return makeArrayRef(kUnavailableRegisters, return ArrayRef(kUnavailableRegisters, std::size(kUnavailableRegisters));
std::size(kUnavailableRegisters));
} }
bool allowAsBackToBack(const Instruction &Instr) const override { bool allowAsBackToBack(const Instruction &Instr) const override {
Context not available.

llvm/tools/llvm-lipo/llvm-lipo.cpp

Context not available.
llvm::InitializeAllTargetMCs(); llvm::InitializeAllTargetMCs();
llvm::InitializeAllAsmParsers(); llvm::InitializeAllAsmParsers();
Config C = parseLipoOptions(makeArrayRef(argv + 1, argc - 1)); Config C = parseLipoOptions(ArrayRef(argv + 1, argc - 1));
LLVMContext LLVMCtx; LLVMContext LLVMCtx;
SmallVector<OwningBinary<Binary>, 1> InputBinaries = SmallVector<OwningBinary<Binary>, 1> InputBinaries =
readInputBinaries(LLVMCtx, C.InputFiles); readInputBinaries(LLVMCtx, C.InputFiles);
Context not available.

llvm/tools/llvm-ml/llvm-ml.cpp

Context not available.
MLOptTable T; MLOptTable T;
unsigned MissingArgIndex, MissingArgCount; unsigned MissingArgIndex, MissingArgCount;
ArrayRef<const char *> ArgsArr = makeArrayRef(Argv + 1, Argc - 1); ArrayRef<const char *> ArgsArr = ArrayRef(Argv + 1, Argc - 1);
opt::InputArgList InputArgs = opt::InputArgList InputArgs =
T.ParseArgs(ArgsArr, MissingArgIndex, MissingArgCount); T.ParseArgs(ArgsArr, MissingArgIndex, MissingArgCount);
Context not available.

llvm/tools/llvm-mt/llvm-mt.cpp

Context not available.
CvtResOptTable T; CvtResOptTable T;
unsigned MAI, MAC; unsigned MAI, MAC;
ArrayRef<const char *> ArgsArr = makeArrayRef(Argv + 1, Argc - 1); ArrayRef<const char *> ArgsArr = ArrayRef(Argv + 1, Argc - 1);
opt::InputArgList InputArgs = T.ParseArgs(ArgsArr, MAI, MAC); opt::InputArgList InputArgs = T.ParseArgs(ArgsArr, MAI, MAC);
for (auto *Arg : InputArgs.filtered(OPT_INPUT)) { for (auto *Arg : InputArgs.filtered(OPT_INPUT)) {
Context not available.

llvm/tools/llvm-nm/llvm-nm.cpp

Context not available.
}; };
static const char *getDarwinStabString(uint8_t NType) { static const char *getDarwinStabString(uint8_t NType) {
for (auto I : makeArrayRef(DarwinStabNames)) for (auto I : ArrayRef(DarwinStabNames))
if (I.NType == NType) if (I.NType == NType)
return I.Name; return I.Name;
return nullptr; return nullptr;
Context not available.

llvm/tools/llvm-objcopy/ObjcopyOptions.cpp

Context not available.
if (NameAndFlags.size() > 1) { if (NameAndFlags.size() > 1) {
Expected<SectionFlag> ParsedFlagSet = Expected<SectionFlag> ParsedFlagSet =
parseSectionFlagSet(makeArrayRef(NameAndFlags).drop_front()); parseSectionFlagSet(ArrayRef(NameAndFlags).drop_front());
if (!ParsedFlagSet) if (!ParsedFlagSet)
return ParsedFlagSet.takeError(); return ParsedFlagSet.takeError();
SR.NewFlags = *ParsedFlagSet; SR.NewFlags = *ParsedFlagSet;
Context not available.
const char *const *DashDash = const char *const *DashDash =
llvm::find_if(RawArgsArr, [](StringRef Str) { return Str == "--"; }); llvm::find_if(RawArgsArr, [](StringRef Str) { return Str == "--"; });
ArrayRef<const char *> ArgsArr = makeArrayRef(RawArgsArr.begin(), DashDash); ArrayRef<const char *> ArgsArr = ArrayRef(RawArgsArr.begin(), DashDash);
if (DashDash != RawArgsArr.end()) if (DashDash != RawArgsArr.end())
DashDash = std::next(DashDash); DashDash = std::next(DashDash);
Context not available.
function_ref<Error(Error)> ErrorCallback) { function_ref<Error(Error)> ErrorCallback) {
const char *const *DashDash = const char *const *DashDash =
llvm::find_if(RawArgsArr, [](StringRef Str) { return Str == "--"; }); llvm::find_if(RawArgsArr, [](StringRef Str) { return Str == "--"; });
ArrayRef<const char *> ArgsArr = makeArrayRef(RawArgsArr.begin(), DashDash); ArrayRef<const char *> ArgsArr = ArrayRef(RawArgsArr.begin(), DashDash);
if (DashDash != RawArgsArr.end()) if (DashDash != RawArgsArr.end())
DashDash = std::next(DashDash); DashDash = std::next(DashDash);
Context not available.

llvm/tools/llvm-objcopy/llvm-objcopy.cpp

Context not available.
: cl::TokenizeGNUCommandLine, : cl::TokenizeGNUCommandLine,
NewArgv); NewArgv);
auto Args = makeArrayRef(NewArgv).drop_front(); auto Args = ArrayRef(NewArgv).drop_front();
Expected<DriverConfig> DriverConfig = getDriverConfig(Args); Expected<DriverConfig> DriverConfig = getDriverConfig(Args);
if (!DriverConfig) { if (!DriverConfig) {
Context not available.

llvm/tools/llvm-objdump/COFFDump.cpp

Context not available.
}; };
printU16("Magic", Hdr.Magic, "%04x"); printU16("Magic", Hdr.Magic, "%04x");
printOptionalEnumName(Hdr.Magic, makeArrayRef(PEHeaderMagic)); printOptionalEnumName(Hdr.Magic, ArrayRef(PEHeaderMagic));
outs() << '\n'; outs() << '\n';
print("MajorLinkerVersion", Hdr.MajorLinkerVersion); print("MajorLinkerVersion", Hdr.MajorLinkerVersion);
print("MinorLinkerVersion", Hdr.MinorLinkerVersion); print("MinorLinkerVersion", Hdr.MinorLinkerVersion);
Context not available.
printU32("SizeOfHeaders", Hdr.SizeOfHeaders, "%08x\n"); printU32("SizeOfHeaders", Hdr.SizeOfHeaders, "%08x\n");
printU32("CheckSum", Hdr.CheckSum, "%08x\n"); printU32("CheckSum", Hdr.CheckSum, "%08x\n");
printU16("Subsystem", Hdr.Subsystem, "%08x"); printU16("Subsystem", Hdr.Subsystem, "%08x");
printOptionalEnumName(Hdr.Subsystem, makeArrayRef(PEWindowsSubsystem)); printOptionalEnumName(Hdr.Subsystem, ArrayRef(PEWindowsSubsystem));
outs() << '\n'; outs() << '\n';
printU16("DllCharacteristics", Hdr.DLLCharacteristics, "%08x\n"); printU16("DllCharacteristics", Hdr.DLLCharacteristics, "%08x\n");
Context not available.
<< " remaining in buffer"; << " remaining in buffer";
return ; return ;
} }
printUnwindCode(makeArrayRef(I, E)); printUnwindCode(ArrayRef(I, E));
I += UsedSlots; I += UsedSlots;
} }
} }
Context not available.
if (UI->NumCodes) if (UI->NumCodes)
outs() << " Unwind Codes:\n"; outs() << " Unwind Codes:\n";
printAllUnwindCodes(makeArrayRef(&UI->UnwindCodes[0], UI->NumCodes)); printAllUnwindCodes(ArrayRef(&UI->UnwindCodes[0], UI->NumCodes));
outs() << "\n"; outs() << "\n";
outs().flush(); outs().flush();
Context not available.

llvm/tools/llvm-objdump/MachODump.cpp

Context not available.
case MachO::DICE_KIND_DATA: case MachO::DICE_KIND_DATA:
if (Length >= 4) { if (Length >= 4) {
if (ShowRawInsn) if (ShowRawInsn)
dumpBytes(makeArrayRef(bytes, 4), outs()); dumpBytes(ArrayRef(bytes, 4), outs());
Value = bytes[3] << 24 | bytes[2] << 16 | bytes[1] << 8 | bytes[0]; Value = bytes[3] << 24 | bytes[2] << 16 | bytes[1] << 8 | bytes[0];
outs() << "\t.long " << Value; outs() << "\t.long " << Value;
Size = 4; Size = 4;
} else if (Length >= 2) { } else if (Length >= 2) {
if (ShowRawInsn) if (ShowRawInsn)
dumpBytes(makeArrayRef(bytes, 2), outs()); dumpBytes(ArrayRef(bytes, 2), outs());
Value = bytes[1] << 8 | bytes[0]; Value = bytes[1] << 8 | bytes[0];
outs() << "\t.short " << Value; outs() << "\t.short " << Value;
Size = 2; Size = 2;
} else { } else {
if (ShowRawInsn) if (ShowRawInsn)
dumpBytes(makeArrayRef(bytes, 2), outs()); dumpBytes(ArrayRef(bytes, 2), outs());
Value = bytes[0]; Value = bytes[0];
outs() << "\t.byte " << Value; outs() << "\t.byte " << Value;
Size = 1; Size = 1;
Context not available.
break; break;
case MachO::DICE_KIND_JUMP_TABLE8: case MachO::DICE_KIND_JUMP_TABLE8:
if (ShowRawInsn) if (ShowRawInsn)
dumpBytes(makeArrayRef(bytes, 1), outs()); dumpBytes(ArrayRef(bytes, 1), outs());
Value = bytes[0]; Value = bytes[0];
outs() << "\t.byte " << format("%3u", Value) << "\t@ KIND_JUMP_TABLE8\n"; outs() << "\t.byte " << format("%3u", Value) << "\t@ KIND_JUMP_TABLE8\n";
Size = 1; Size = 1;
break; break;
case MachO::DICE_KIND_JUMP_TABLE16: case MachO::DICE_KIND_JUMP_TABLE16:
if (ShowRawInsn) if (ShowRawInsn)
dumpBytes(makeArrayRef(bytes, 2), outs()); dumpBytes(ArrayRef(bytes, 2), outs());
Value = bytes[1] << 8 | bytes[0]; Value = bytes[1] << 8 | bytes[0];
outs() << "\t.short " << format("%5u", Value & 0xffff) outs() << "\t.short " << format("%5u", Value & 0xffff)
<< "\t@ KIND_JUMP_TABLE16\n"; << "\t@ KIND_JUMP_TABLE16\n";
Context not available.
case MachO::DICE_KIND_JUMP_TABLE32: case MachO::DICE_KIND_JUMP_TABLE32:
case MachO::DICE_KIND_ABS_JUMP_TABLE32: case MachO::DICE_KIND_ABS_JUMP_TABLE32:
if (ShowRawInsn) if (ShowRawInsn)
dumpBytes(makeArrayRef(bytes, 4), outs()); dumpBytes(ArrayRef(bytes, 4), outs());
Value = bytes[3] << 24 | bytes[2] << 16 | bytes[1] << 8 | bytes[0]; Value = bytes[3] << 24 | bytes[2] << 16 | bytes[1] << 8 | bytes[0];
outs() << "\t.long " << Value; outs() << "\t.long " << Value;
if (Kind == MachO::DICE_KIND_JUMP_TABLE32) if (Kind == MachO::DICE_KIND_JUMP_TABLE32)
Context not available.
Annotations); Annotations);
if (gotInst) { if (gotInst) {
if (ShowRawInsn || Arch == Triple::arm) { if (ShowRawInsn || Arch == Triple::arm) {
dumpBytes(makeArrayRef(Bytes.data() + Index, Size), outs()); dumpBytes(ArrayRef(Bytes.data() + Index, Size), outs());
} }
formatted_raw_ostream FormattedOS(outs()); formatted_raw_ostream FormattedOS(outs());
StringRef AnnotationsStr = Annotations.str(); StringRef AnnotationsStr = Annotations.str();
Context not available.
} }
if (ShowRawInsn || Arch == Triple::arm) { if (ShowRawInsn || Arch == Triple::arm) {
outs() << "\t"; outs() << "\t";
dumpBytes(makeArrayRef(Bytes.data() + Index, InstSize), outs()); dumpBytes(ArrayRef(Bytes.data() + Index, InstSize), outs());
} }
StringRef AnnotationsStr = Annotations.str(); StringRef AnnotationsStr = Annotations.str();
IP->printInst(&Inst, PC, AnnotationsStr, *STI, outs()); IP->printInst(&Inst, PC, AnnotationsStr, *STI, outs());
Context not available.

llvm/tools/llvm-objdump/llvm-objdump.cpp

Context not available.
if (Bytes.size() >= 4) { if (Bytes.size() >= 4) {
// D should be casted to uint32_t here as it is passed by format to // D should be casted to uint32_t here as it is passed by format to
// snprintf as vararg. // snprintf as vararg.
for (uint32_t D : makeArrayRef( for (uint32_t D :
reinterpret_cast<const support::little32_t *>(Bytes.data()), ArrayRef(reinterpret_cast<const support::little32_t *>(Bytes.data()),
Bytes.size() / 4)) Bytes.size() / 4))
OS << format(" %08" PRIX32, D); OS << format(" %08" PRIX32, D);
} else { } else {
for (unsigned char B : Bytes) for (unsigned char B : Bytes)
OS << format(" %02" PRIX8, B); OS << format(" %02" PRIX8, B);
Context not available.

llvm/tools/llvm-rc/llvm-rc.cpp

Context not available.
char **DashDash = std::find_if(Argv + 1, Argv + Argc, char **DashDash = std::find_if(Argv + 1, Argv + Argc,
[](StringRef Str) { return Str == "--"; }); [](StringRef Str) { return Str == "--"; });
ArrayRef<const char *> ArgsArr = makeArrayRef(Argv + 1, DashDash); ArrayRef<const char *> ArgsArr = ArrayRef(Argv + 1, DashDash);
ArrayRef<const char *> FileArgsArr; ArrayRef<const char *> FileArgsArr;
if (DashDash != Argv + Argc) if (DashDash != Argv + Argc)
FileArgsArr = makeArrayRef(DashDash + 1, Argv + Argc); FileArgsArr = ArrayRef(DashDash + 1, Argv + Argc);
RcOptions Opts = getOptions(Argv[0], ArgsArr, FileArgsArr); RcOptions Opts = getOptions(Argv[0], ArgsArr, FileArgsArr);
Context not available.

llvm/tools/llvm-readobj/ARMEHABIPrinter.h

Context not available.
{0xf8, 0xd0, &OpcodeDecoder::Decode_11010nnn}, {0xf8, 0xd0, &OpcodeDecoder::Decode_11010nnn},
{0xc0, 0xc0, &OpcodeDecoder::Decode_11xxxyyy}, {0xc0, 0xc0, &OpcodeDecoder::Decode_11xxxyyy},
}; };
return makeArrayRef(Ring); return ArrayRef(Ring);
} }
inline void OpcodeDecoder::Decode_00xxxxxx(const uint8_t *Opcodes, inline void OpcodeDecoder::Decode_00xxxxxx(const uint8_t *Opcodes,
Context not available.

llvm/tools/llvm-readobj/COFFDumper.cpp

Context not available.
{ {
DictScope D(W, "ImageFileHeader"); DictScope D(W, "ImageFileHeader");
W.printEnum ("Machine", Obj->getMachine(), W.printEnum("Machine", Obj->getMachine(), ArrayRef(ImageFileMachineType));
makeArrayRef(ImageFileMachineType));
W.printNumber("SectionCount", Obj->getNumberOfSections()); W.printNumber("SectionCount", Obj->getNumberOfSections());
W.printHex ("TimeDateStamp", FormattedTime, Obj->getTimeDateStamp()); W.printHex ("TimeDateStamp", FormattedTime, Obj->getTimeDateStamp());
W.printHex ("PointerToSymbolTable", Obj->getPointerToSymbolTable()); W.printHex ("PointerToSymbolTable", Obj->getPointerToSymbolTable());
W.printNumber("SymbolCount", Obj->getNumberOfSymbols()); W.printNumber("SymbolCount", Obj->getNumberOfSymbols());
W.printNumber("StringTableSize", Obj->getStringTableSize()); W.printNumber("StringTableSize", Obj->getStringTableSize());
W.printNumber("OptionalHeaderSize", Obj->getSizeOfOptionalHeader()); W.printNumber("OptionalHeaderSize", Obj->getSizeOfOptionalHeader());
W.printFlags ("Characteristics", Obj->getCharacteristics(), W.printFlags("Characteristics", Obj->getCharacteristics(),
makeArrayRef(ImageFileCharacteristics)); ArrayRef(ImageFileCharacteristics));
} }
// Print PE header. This header does not exist if this is an object file and // Print PE header. This header does not exist if this is an object file and
Context not available.
W.printNumber("SizeOfImage", Hdr->SizeOfImage); W.printNumber("SizeOfImage", Hdr->SizeOfImage);
W.printNumber("SizeOfHeaders", Hdr->SizeOfHeaders); W.printNumber("SizeOfHeaders", Hdr->SizeOfHeaders);
W.printHex ("CheckSum", Hdr->CheckSum); W.printHex ("CheckSum", Hdr->CheckSum);
W.printEnum ("Subsystem", Hdr->Subsystem, makeArrayRef(PEWindowsSubsystem)); W.printEnum("Subsystem", Hdr->Subsystem, ArrayRef(PEWindowsSubsystem));
W.printFlags ("Characteristics", Hdr->DLLCharacteristics, W.printFlags("Characteristics", Hdr->DLLCharacteristics,
makeArrayRef(PEDLLCharacteristics)); ArrayRef(PEDLLCharacteristics));
W.printNumber("SizeOfStackReserve", Hdr->SizeOfStackReserve); W.printNumber("SizeOfStackReserve", Hdr->SizeOfStackReserve);
W.printNumber("SizeOfStackCommit", Hdr->SizeOfStackCommit); W.printNumber("SizeOfStackCommit", Hdr->SizeOfStackCommit);
W.printNumber("SizeOfHeapReserve", Hdr->SizeOfHeapReserve); W.printNumber("SizeOfHeapReserve", Hdr->SizeOfHeapReserve);
Context not available.
W.printHex("TimeDateStamp", FormattedTime, D.TimeDateStamp); W.printHex("TimeDateStamp", FormattedTime, D.TimeDateStamp);
W.printHex("MajorVersion", D.MajorVersion); W.printHex("MajorVersion", D.MajorVersion);
W.printHex("MinorVersion", D.MinorVersion); W.printHex("MinorVersion", D.MinorVersion);
W.printEnum("Type", D.Type, makeArrayRef(ImageDebugType)); W.printEnum("Type", D.Type, ArrayRef(ImageDebugType));
W.printHex("SizeOfData", D.SizeOfData); W.printHex("SizeOfData", D.SizeOfData);
W.printHex("AddressOfRawData", D.AddressOfRawData); W.printHex("AddressOfRawData", D.AddressOfRawData);
W.printHex("PointerToRawData", D.PointerToRawData); W.printHex("PointerToRawData", D.PointerToRawData);
Context not available.
DictScope PDBScope(W, "PDBInfo"); DictScope PDBScope(W, "PDBInfo");
W.printHex("PDBSignature", DebugInfo->Signature.CVSignature); W.printHex("PDBSignature", DebugInfo->Signature.CVSignature);
if (DebugInfo->Signature.CVSignature == OMF::Signature::PDB70) { if (DebugInfo->Signature.CVSignature == OMF::Signature::PDB70) {
W.printBinary("PDBGUID", makeArrayRef(DebugInfo->PDB70.Signature)); W.printBinary("PDBGUID", ArrayRef(DebugInfo->PDB70.Signature));
W.printNumber("PDBAge", DebugInfo->PDB70.Age); W.printNumber("PDBAge", DebugInfo->PDB70.Age);
W.printString("PDBFileName", PDBFileName); W.printString("PDBFileName", PDBFileName);
} }
Context not available.
// but that might change in the future // but that might change in the future
uint16_t Characteristics = RawData[0]; uint16_t Characteristics = RawData[0];
W.printFlags("ExtendedCharacteristics", Characteristics, W.printFlags("ExtendedCharacteristics", Characteristics,
makeArrayRef(PEExtendedDLLCharacteristics)); ArrayRef(PEExtendedDLLCharacteristics));
} }
W.printBinaryBlock("RawData", RawData); W.printBinaryBlock("RawData", RawData);
} }
Context not available.
W.printHex("GuardCFCheckDispatch", Conf->GuardCFCheckDispatch); W.printHex("GuardCFCheckDispatch", Conf->GuardCFCheckDispatch);
W.printHex("GuardCFFunctionTable", Conf->GuardCFFunctionTable); W.printHex("GuardCFFunctionTable", Conf->GuardCFFunctionTable);
W.printNumber("GuardCFFunctionCount", Conf->GuardCFFunctionCount); W.printNumber("GuardCFFunctionCount", Conf->GuardCFFunctionCount);
W.printFlags("GuardFlags", Conf->GuardFlags, W.printFlags("GuardFlags", Conf->GuardFlags, ArrayRef(PELoadConfigGuardFlags),
makeArrayRef(PELoadConfigGuardFlags),
(uint32_t)COFF::GuardFlags::CF_FUNCTION_TABLE_SIZE_MASK); (uint32_t)COFF::GuardFlags::CF_FUNCTION_TABLE_SIZE_MASK);
Tables.GuardFidTableVA = Conf->GuardCFFunctionTable; Tables.GuardFidTableVA = Conf->GuardCFFunctionTable;
Context not available.
W.printHex("IgnoredSubsectionKind", SubType); W.printHex("IgnoredSubsectionKind", SubType);
SubType &= ~SubsectionIgnoreFlag; SubType &= ~SubsectionIgnoreFlag;
} }
W.printEnum("SubSectionType", SubType, makeArrayRef(SubSectionTypes)); W.printEnum("SubSectionType", SubType, ArrayRef(SubSectionTypes));
W.printHex("SubSectionSize", SubSectionSize); W.printHex("SubSectionSize", SubSectionSize);
// Get the contents of the subsection. // Get the contents of the subsection.
Context not available.
W.printHex("MaxStackSize", FD.MaxStackSize); W.printHex("MaxStackSize", FD.MaxStackSize);
W.printHex("PrologSize", FD.PrologSize); W.printHex("PrologSize", FD.PrologSize);
W.printHex("SavedRegsSize", FD.SavedRegsSize); W.printHex("SavedRegsSize", FD.SavedRegsSize);
W.printFlags("Flags", FD.Flags, makeArrayRef(FrameDataFlags)); W.printFlags("Flags", FD.Flags, ArrayRef(FrameDataFlags));
// The FrameFunc string is a small RPN program. It can be broken up into // The FrameFunc string is a small RPN program. It can be broken up into
// statements that end in the '=' operator, which assigns the value on // statements that end in the '=' operator, which assigns the value on
Context not available.
W.printHex("Filename", Filename, FC.FileNameOffset); W.printHex("Filename", Filename, FC.FileNameOffset);
W.printHex("ChecksumSize", FC.Checksum.size()); W.printHex("ChecksumSize", FC.Checksum.size());
W.printEnum("ChecksumKind", uint8_t(FC.Kind), W.printEnum("ChecksumKind", uint8_t(FC.Kind),
makeArrayRef(FileChecksumKindNames)); ArrayRef(FileChecksumKindNames));
W.printBinary("ChecksumBytes", FC.Checksum); W.printBinary("ChecksumBytes", FC.Checksum);
} }
Context not available.
W.printHex ("PointerToLineNumbers", Section->PointerToLinenumbers); W.printHex ("PointerToLineNumbers", Section->PointerToLinenumbers);
W.printNumber("RelocationCount", Section->NumberOfRelocations); W.printNumber("RelocationCount", Section->NumberOfRelocations);
W.printNumber("LineNumberCount", Section->NumberOfLinenumbers); W.printNumber("LineNumberCount", Section->NumberOfLinenumbers);
W.printFlags ("Characteristics", Section->Characteristics, W.printFlags("Characteristics", Section->Characteristics,
makeArrayRef(ImageSectionCharacteristics), ArrayRef(ImageSectionCharacteristics),
COFF::SectionCharacteristics(0x00F00000)); COFF::SectionCharacteristics(0x00F00000));
if (opts::SectionRelocations) { if (opts::SectionRelocations) {
ListScope D(W, "Relocations"); ListScope D(W, "Relocations");
Context not available.
W.printString("Name", SymbolName); W.printString("Name", SymbolName);
W.printNumber("Value", Symbol.getValue()); W.printNumber("Value", Symbol.getValue());
W.printNumber("Section", SectionName, Symbol.getSectionNumber()); W.printNumber("Section", SectionName, Symbol.getSectionNumber());
W.printEnum ("BaseType", Symbol.getBaseType(), makeArrayRef(ImageSymType)); W.printEnum("BaseType", Symbol.getBaseType(), ArrayRef(ImageSymType));
W.printEnum ("ComplexType", Symbol.getComplexType(), W.printEnum("ComplexType", Symbol.getComplexType(), ArrayRef(ImageSymDType));
makeArrayRef(ImageSymDType)); W.printEnum("StorageClass", Symbol.getStorageClass(),
W.printEnum ("StorageClass", Symbol.getStorageClass(), ArrayRef(ImageSymClass));
makeArrayRef(ImageSymClass));
W.printNumber("AuxSymbolCount", Symbol.getNumberOfAuxSymbols()); W.printNumber("AuxSymbolCount", Symbol.getNumberOfAuxSymbols());
for (uint8_t I = 0; I < Symbol.getNumberOfAuxSymbols(); ++I) { for (uint8_t I = 0; I < Symbol.getNumberOfAuxSymbols(); ++I) {
Context not available.
DictScope AS(W, "AuxWeakExternal"); DictScope AS(W, "AuxWeakExternal");
W.printNumber("Linked", getSymbolName(Aux->TagIndex), Aux->TagIndex); W.printNumber("Linked", getSymbolName(Aux->TagIndex), Aux->TagIndex);
W.printEnum ("Search", Aux->Characteristics, W.printEnum("Search", Aux->Characteristics,
makeArrayRef(WeakExternalCharacteristics)); ArrayRef(WeakExternalCharacteristics));
} else if (Symbol.isFileRecord()) { } else if (Symbol.isFileRecord()) {
const char *FileName; const char *FileName;
Context not available.
W.printNumber("LineNumberCount", Aux->NumberOfLinenumbers); W.printNumber("LineNumberCount", Aux->NumberOfLinenumbers);
W.printHex("Checksum", Aux->CheckSum); W.printHex("Checksum", Aux->CheckSum);
W.printNumber("Number", AuxNumber); W.printNumber("Number", AuxNumber);
W.printEnum("Selection", Aux->Selection, makeArrayRef(ImageCOMDATSelect)); W.printEnum("Selection", Aux->Selection, ArrayRef(ImageCOMDATSelect));
if (Section && Section->Characteristics & COFF::IMAGE_SCN_LNK_COMDAT if (Section && Section->Characteristics & COFF::IMAGE_SCN_LNK_COMDAT
&& Aux->Selection == COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE) { && Aux->Selection == COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE) {
Context not available.
} }
default: default:
W.printEnum("unsupported Image Machine", Obj->getMachine(), W.printEnum("unsupported Image Machine", Obj->getMachine(),
makeArrayRef(ImageFileMachineType)); ArrayRef(ImageFileMachineType));
break; break;
} }
} }
Context not available.
std::copy(RawEntryNameString.begin(), RawEntryNameString.end(), std::copy(RawEntryNameString.begin(), RawEntryNameString.end(),
EndianCorrectedNameString.begin() + 1); EndianCorrectedNameString.begin() + 1);
EndianCorrectedNameString[0] = UNI_UTF16_BYTE_ORDER_MARK_SWAPPED; EndianCorrectedNameString[0] = UNI_UTF16_BYTE_ORDER_MARK_SWAPPED;
RawEntryNameString = makeArrayRef(EndianCorrectedNameString); RawEntryNameString = ArrayRef(EndianCorrectedNameString);
} }
std::string EntryNameString; std::string EntryNameString;
if (!llvm::convertUTF16ToUTF8String(RawEntryNameString, EntryNameString)) if (!llvm::convertUTF16ToUTF8String(RawEntryNameString, EntryNameString))
Context not available.
W.printHex("AddressOfCallBacks", TlsTable->AddressOfCallBacks); W.printHex("AddressOfCallBacks", TlsTable->AddressOfCallBacks);
W.printHex("SizeOfZeroFill", TlsTable->SizeOfZeroFill); W.printHex("SizeOfZeroFill", TlsTable->SizeOfZeroFill);
W.printFlags("Characteristics", TlsTable->Characteristics, W.printFlags("Characteristics", TlsTable->Characteristics,
makeArrayRef(ImageSectionCharacteristics), ArrayRef(ImageSectionCharacteristics),
COFF::SectionCharacteristics(COFF::IMAGE_SCN_ALIGN_MASK)); COFF::SectionCharacteristics(COFF::IMAGE_SCN_ALIGN_MASK));
} }
Context not available.

llvm/tools/llvm-readobj/ELFDumper.cpp

Context not available.
case DT_MIPS_XHASH: case DT_MIPS_XHASH:
return FormatHexValue(Value); return FormatHexValue(Value);
case DT_MIPS_FLAGS: case DT_MIPS_FLAGS:
return FormatFlags(Value, makeArrayRef(ElfDynamicDTMipsFlags)); return FormatFlags(Value, ArrayRef(ElfDynamicDTMipsFlags));
default: default:
break; break;
} }
Context not available.
.str(); .str();
} }
case DT_FLAGS: case DT_FLAGS:
return FormatFlags(Value, makeArrayRef(ElfDynamicDTFlags)); return FormatFlags(Value, ArrayRef(ElfDynamicDTFlags));
case DT_FLAGS_1: case DT_FLAGS_1:
return FormatFlags(Value, makeArrayRef(ElfDynamicDTFlags1)); return FormatFlags(Value, ArrayRef(ElfDynamicDTFlags1));
default: default:
return FormatHexValue(Value); return FormatHexValue(Value);
} }
Context not available.
auto It = llvm::find_if(ElfObjectFileType, [&](const EnumEntry<unsigned> &E) { auto It = llvm::find_if(ElfObjectFileType, [&](const EnumEntry<unsigned> &E) {
return E.Value == Type; return E.Value == Type;
}); });
if (It != makeArrayRef(ElfObjectFileType).end()) if (It != ArrayRef(ElfObjectFileType).end())
return It; return It;
return nullptr; return nullptr;
} }
Context not available.
for (int i = 0; i < ELF::EI_NIDENT; i++) for (int i = 0; i < ELF::EI_NIDENT; i++)
OS << format(" %02x", static_cast<int>(e.e_ident[i])); OS << format(" %02x", static_cast<int>(e.e_ident[i]));
OS << "\n"; OS << "\n";
Str = enumToString(e.e_ident[ELF::EI_CLASS], makeArrayRef(ElfClass)); Str = enumToString(e.e_ident[ELF::EI_CLASS], ArrayRef(ElfClass));
printFields(OS, "Class:", Str); printFields(OS, "Class:", Str);
Str = enumToString(e.e_ident[ELF::EI_DATA], makeArrayRef(ElfDataEncoding)); Str = enumToString(e.e_ident[ELF::EI_DATA], ArrayRef(ElfDataEncoding));
printFields(OS, "Data:", Str); printFields(OS, "Data:", Str);
OS.PadToColumn(2u); OS.PadToColumn(2u);
OS << "Version:"; OS << "Version:";
Context not available.
if (e.e_version == ELF::EV_CURRENT) if (e.e_version == ELF::EV_CURRENT)
OS << " (current)"; OS << " (current)";
OS << "\n"; OS << "\n";
Str = enumToString(e.e_ident[ELF::EI_OSABI], makeArrayRef(ElfOSABI)); Str = enumToString(e.e_ident[ELF::EI_OSABI], ArrayRef(ElfOSABI));
printFields(OS, "OS/ABI:", Str); printFields(OS, "OS/ABI:", Str);
printFields(OS, printFields(OS,
"ABI Version:", std::to_string(e.e_ident[ELF::EI_ABIVERSION])); "ABI Version:", std::to_string(e.e_ident[ELF::EI_ABIVERSION]));
Context not available.
} }
printFields(OS, "Type:", Str); printFields(OS, "Type:", Str);
Str = enumToString(e.e_machine, makeArrayRef(ElfMachineType)); Str = enumToString(e.e_machine, ArrayRef(ElfMachineType));
printFields(OS, "Machine:", Str); printFields(OS, "Machine:", Str);
Str = "0x" + utohexstr(e.e_version); Str = "0x" + utohexstr(e.e_version);
printFields(OS, "Version:", Str); printFields(OS, "Version:", Str);
Context not available.
printFields(OS, "Start of section headers:", Str); printFields(OS, "Start of section headers:", Str);
std::string ElfFlags; std::string ElfFlags;
if (e.e_machine == EM_MIPS) if (e.e_machine == EM_MIPS)
ElfFlags = ElfFlags = printFlags(
printFlags(e.e_flags, makeArrayRef(ElfHeaderMipsFlags), e.e_flags, ArrayRef(ElfHeaderMipsFlags), unsigned(ELF::EF_MIPS_ARCH),
unsigned(ELF::EF_MIPS_ARCH), unsigned(ELF::EF_MIPS_ABI), unsigned(ELF::EF_MIPS_ABI), unsigned(ELF::EF_MIPS_MACH));
unsigned(ELF::EF_MIPS_MACH));
else if (e.e_machine == EM_RISCV) else if (e.e_machine == EM_RISCV)
ElfFlags = printFlags(e.e_flags, makeArrayRef(ElfHeaderRISCVFlags)); ElfFlags = printFlags(e.e_flags, ArrayRef(ElfHeaderRISCVFlags));
else if (e.e_machine == EM_AVR) else if (e.e_machine == EM_AVR)
ElfFlags = printFlags(e.e_flags, makeArrayRef(ElfHeaderAVRFlags), ElfFlags = printFlags(e.e_flags, ArrayRef(ElfHeaderAVRFlags),
unsigned(ELF::EF_AVR_ARCH_MASK)); unsigned(ELF::EF_AVR_ARCH_MASK));
else if (e.e_machine == EM_LOONGARCH) else if (e.e_machine == EM_LOONGARCH)
ElfFlags = printFlags(e.e_flags, makeArrayRef(ElfHeaderLoongArchFlags), ElfFlags = printFlags(e.e_flags, ArrayRef(ElfHeaderLoongArchFlags),
unsigned(ELF::EF_LOONGARCH_ABI_MODIFIER_MASK), unsigned(ELF::EF_LOONGARCH_ABI_MODIFIER_MASK),
unsigned(ELF::EF_LOONGARCH_OBJABI_MASK)); unsigned(ELF::EF_LOONGARCH_OBJABI_MASK));
else if (e.e_machine == EM_XTENSA) else if (e.e_machine == EM_XTENSA)
ElfFlags = printFlags(e.e_flags, makeArrayRef(ElfHeaderXtensaFlags), ElfFlags = printFlags(e.e_flags, ArrayRef(ElfHeaderXtensaFlags),
unsigned(ELF::EF_XTENSA_MACH)); unsigned(ELF::EF_XTENSA_MACH));
Str = "0x" + utohexstr(e.e_flags); Str = "0x" + utohexstr(e.e_flags);
if (!ElfFlags.empty()) if (!ElfFlags.empty())
Context not available.
unsigned char SymbolType = Symbol.getType(); unsigned char SymbolType = Symbol.getType();
if (this->Obj.getHeader().e_machine == ELF::EM_AMDGPU && if (this->Obj.getHeader().e_machine == ELF::EM_AMDGPU &&
SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS) SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS)
Fields[3].Str = enumToString(SymbolType, makeArrayRef(AMDGPUSymbolTypes)); Fields[3].Str = enumToString(SymbolType, ArrayRef(AMDGPUSymbolTypes));
else else
Fields[3].Str = enumToString(SymbolType, makeArrayRef(ElfSymbolTypes)); Fields[3].Str = enumToString(SymbolType, ArrayRef(ElfSymbolTypes));
Fields[4].Str = Fields[4].Str =
enumToString(Symbol.getBinding(), makeArrayRef(ElfSymbolBindings)); enumToString(Symbol.getBinding(), ArrayRef(ElfSymbolBindings));
Fields[5].Str = Fields[5].Str =
enumToString(Symbol.getVisibility(), makeArrayRef(ElfSymbolVisibilities)); enumToString(Symbol.getVisibility(), ArrayRef(ElfSymbolVisibilities));
if (Symbol.st_other & ~0x3) { if (Symbol.st_other & ~0x3) {
if (this->Obj.getHeader().e_machine == ELF::EM_AARCH64) { if (this->Obj.getHeader().e_machine == ELF::EM_AARCH64) {
Context not available.
unsigned char SymbolType = Symbol->getType(); unsigned char SymbolType = Symbol->getType();
if (this->Obj.getHeader().e_machine == ELF::EM_AMDGPU && if (this->Obj.getHeader().e_machine == ELF::EM_AMDGPU &&
SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS) SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS)
Fields[4].Str = enumToString(SymbolType, makeArrayRef(AMDGPUSymbolTypes)); Fields[4].Str = enumToString(SymbolType, ArrayRef(AMDGPUSymbolTypes));
else else
Fields[4].Str = enumToString(SymbolType, makeArrayRef(ElfSymbolTypes)); Fields[4].Str = enumToString(SymbolType, ArrayRef(ElfSymbolTypes));
Fields[5].Str = Fields[5].Str =
enumToString(Symbol->getBinding(), makeArrayRef(ElfSymbolBindings)); enumToString(Symbol->getBinding(), ArrayRef(ElfSymbolBindings));
Fields[6].Str = enumToString(Symbol->getVisibility(), Fields[6].Str =
makeArrayRef(ElfSymbolVisibilities)); enumToString(Symbol->getVisibility(), ArrayRef(ElfSymbolVisibilities));
Fields[7].Str = getSymbolSectionNdx(*Symbol, SymIndex, ShndxTable); Fields[7].Str = getSymbolSectionNdx(*Symbol, SymIndex, ShndxTable);
Fields[8].Str = Fields[8].Str =
this->getFullSymbolName(*Symbol, SymIndex, ShndxTable, StrTable, true); this->getFullSymbolName(*Symbol, SymIndex, ShndxTable, StrTable, true);
Context not available.
Field Fields[8] = {2, 17, 26, 37 + Bias, Field Fields[8] = {2, 17, 26, 37 + Bias,
48 + Bias, 56 + Bias, 64 + Bias, 68 + Bias}; 48 + Bias, 56 + Bias, 64 + Bias, 68 + Bias};
OS << "\nElf file type is " OS << "\nElf file type is "
<< enumToString(Header.e_type, makeArrayRef(ElfObjectFileType)) << "\n" << enumToString(Header.e_type, ArrayRef(ElfObjectFileType)) << "\n"
<< "Entry point " << format_hex(Header.e_entry, 3) << "\n" << "Entry point " << format_hex(Header.e_entry, 3) << "\n"
<< "There are " << Header.e_phnum << " program headers," << "There are " << Header.e_phnum << " program headers,"
<< " starting at offset " << Header.e_phoff << "\n\n" << " starting at offset " << Header.e_phoff << "\n\n"
Context not available.
support::endian::read32<ELFT::TargetEndianness>(Desc.data()); support::endian::read32<ELFT::TargetEndianness>(Desc.data());
std::string FlagsStr; std::string FlagsStr;
raw_string_ostream OS(FlagsStr); raw_string_ostream OS(FlagsStr);
printFlags(Value, makeArrayRef(FreeBSDFeatureCtlFlags), OS); printFlags(Value, ArrayRef(FreeBSDFeatureCtlFlags), OS);
if (OS.str().empty()) if (OS.str().empty())
OS << "0x" << utohexstr(Value); OS << "0x" << utohexstr(Value);
else else
Context not available.
OS.PadToColumn(31 + 2 * Bias); OS.PadToColumn(31 + 2 * Bias);
OS << to_string(format_hex_no_prefix(Sym.st_value, 8 + Bias)); OS << to_string(format_hex_no_prefix(Sym.st_value, 8 + Bias));
OS.PadToColumn(40 + 3 * Bias); OS.PadToColumn(40 + 3 * Bias);
OS << enumToString(Sym.getType(), makeArrayRef(ElfSymbolTypes)); OS << enumToString(Sym.getType(), ArrayRef(ElfSymbolTypes));
OS.PadToColumn(48 + 3 * Bias); OS.PadToColumn(48 + 3 * Bias);
OS << getSymbolSectionNdx(Sym, &Sym - this->dynamic_symbols().begin(), OS << getSymbolSectionNdx(Sym, &Sym - this->dynamic_symbols().begin(),
ShndxTable); ShndxTable);
Context not available.
OS.PadToColumn(20 + 2 * Bias); OS.PadToColumn(20 + 2 * Bias);
OS << to_string(format_hex_no_prefix(Sym.st_value, 8 + Bias)); OS << to_string(format_hex_no_prefix(Sym.st_value, 8 + Bias));
OS.PadToColumn(29 + 3 * Bias); OS.PadToColumn(29 + 3 * Bias);
OS << enumToString(Sym.getType(), makeArrayRef(ElfSymbolTypes)); OS << enumToString(Sym.getType(), ArrayRef(ElfSymbolTypes));
OS.PadToColumn(37 + 3 * Bias); OS.PadToColumn(37 + 3 * Bias);
OS << getSymbolSectionNdx(Sym, &Sym - this->dynamic_symbols().begin(), OS << getSymbolSectionNdx(Sym, &Sym - this->dynamic_symbols().begin(),
ShndxTable); ShndxTable);
Context not available.
OS << "GPR size: " << getMipsRegisterSize(Flags->gpr_size) << "\n"; OS << "GPR size: " << getMipsRegisterSize(Flags->gpr_size) << "\n";
OS << "CPR1 size: " << getMipsRegisterSize(Flags->cpr1_size) << "\n"; OS << "CPR1 size: " << getMipsRegisterSize(Flags->cpr1_size) << "\n";
OS << "CPR2 size: " << getMipsRegisterSize(Flags->cpr2_size) << "\n"; OS << "CPR2 size: " << getMipsRegisterSize(Flags->cpr2_size) << "\n";
OS << "FP ABI: " OS << "FP ABI: " << enumToString(Flags->fp_abi, ArrayRef(ElfMipsFpABIType))
<< enumToString(Flags->fp_abi, makeArrayRef(ElfMipsFpABIType)) << "\n"; << "\n";
OS << "ISA Extension: " OS << "ISA Extension: "
<< enumToString(Flags->isa_ext, makeArrayRef(ElfMipsISAExtType)) << "\n"; << enumToString(Flags->isa_ext, ArrayRef(ElfMipsISAExtType)) << "\n";
if (Flags->ases == 0) if (Flags->ases == 0)
OS << "ASEs: None\n"; OS << "ASEs: None\n";
else else
// FIXME: Print each flag on a separate line. // FIXME: Print each flag on a separate line.
OS << "ASEs: " << printFlags(Flags->ases, makeArrayRef(ElfMipsASEFlags)) OS << "ASEs: " << printFlags(Flags->ases, ArrayRef(ElfMipsASEFlags))
<< "\n"; << "\n";
OS << "FLAGS 1: " << format_hex_no_prefix(Flags->flags1, 8, false) << "\n"; OS << "FLAGS 1: " << format_hex_no_prefix(Flags->flags1, 8, false) << "\n";
OS << "FLAGS 2: " << format_hex_no_prefix(Flags->flags2, 8, false) << "\n"; OS << "FLAGS 2: " << format_hex_no_prefix(Flags->flags2, 8, false) << "\n";
Context not available.
DictScope D(W, "ElfHeader"); DictScope D(W, "ElfHeader");
{ {
DictScope D(W, "Ident"); DictScope D(W, "Ident");
W.printBinary("Magic", makeArrayRef(E.e_ident).slice(ELF::EI_MAG0, 4)); W.printBinary("Magic", ArrayRef(E.e_ident).slice(ELF::EI_MAG0, 4));
W.printEnum("Class", E.e_ident[ELF::EI_CLASS], makeArrayRef(ElfClass)); W.printEnum("Class", E.e_ident[ELF::EI_CLASS], ArrayRef(ElfClass));
W.printEnum("DataEncoding", E.e_ident[ELF::EI_DATA], W.printEnum("DataEncoding", E.e_ident[ELF::EI_DATA],
makeArrayRef(ElfDataEncoding)); ArrayRef(ElfDataEncoding));
W.printNumber("FileVersion", E.e_ident[ELF::EI_VERSION]); W.printNumber("FileVersion", E.e_ident[ELF::EI_VERSION]);
auto OSABI = makeArrayRef(ElfOSABI); auto OSABI = ArrayRef(ElfOSABI);
if (E.e_ident[ELF::EI_OSABI] >= ELF::ELFOSABI_FIRST_ARCH && if (E.e_ident[ELF::EI_OSABI] >= ELF::ELFOSABI_FIRST_ARCH &&
E.e_ident[ELF::EI_OSABI] <= ELF::ELFOSABI_LAST_ARCH) { E.e_ident[ELF::EI_OSABI] <= ELF::ELFOSABI_LAST_ARCH) {
switch (E.e_machine) { switch (E.e_machine) {
case ELF::EM_AMDGPU: case ELF::EM_AMDGPU:
OSABI = makeArrayRef(AMDGPUElfOSABI); OSABI = ArrayRef(AMDGPUElfOSABI);
break; break;
case ELF::EM_ARM: case ELF::EM_ARM:
OSABI = makeArrayRef(ARMElfOSABI); OSABI = ArrayRef(ARMElfOSABI);
break; break;
case ELF::EM_TI_C6000: case ELF::EM_TI_C6000:
OSABI = makeArrayRef(C6000ElfOSABI); OSABI = ArrayRef(C6000ElfOSABI);
break; break;
} }
} }
W.printEnum("OS/ABI", E.e_ident[ELF::EI_OSABI], OSABI); W.printEnum("OS/ABI", E.e_ident[ELF::EI_OSABI], OSABI);
W.printNumber("ABIVersion", E.e_ident[ELF::EI_ABIVERSION]); W.printNumber("ABIVersion", E.e_ident[ELF::EI_ABIVERSION]);
W.printBinary("Unused", makeArrayRef(E.e_ident).slice(ELF::EI_PAD)); W.printBinary("Unused", ArrayRef(E.e_ident).slice(ELF::EI_PAD));
} }
std::string TypeStr; std::string TypeStr;
Context not available.
} }
W.printString("Type", TypeStr + " (0x" + utohexstr(E.e_type) + ")"); W.printString("Type", TypeStr + " (0x" + utohexstr(E.e_type) + ")");
W.printEnum("Machine", E.e_machine, makeArrayRef(ElfMachineType)); W.printEnum("Machine", E.e_machine, ArrayRef(ElfMachineType));
W.printNumber("Version", E.e_version); W.printNumber("Version", E.e_version);
W.printHex("Entry", E.e_entry); W.printHex("Entry", E.e_entry);
W.printHex("ProgramHeaderOffset", E.e_phoff); W.printHex("ProgramHeaderOffset", E.e_phoff);
W.printHex("SectionHeaderOffset", E.e_shoff); W.printHex("SectionHeaderOffset", E.e_shoff);
if (E.e_machine == EM_MIPS) if (E.e_machine == EM_MIPS)
W.printFlags("Flags", E.e_flags, makeArrayRef(ElfHeaderMipsFlags), W.printFlags("Flags", E.e_flags, ArrayRef(ElfHeaderMipsFlags),
unsigned(ELF::EF_MIPS_ARCH), unsigned(ELF::EF_MIPS_ABI), unsigned(ELF::EF_MIPS_ARCH), unsigned(ELF::EF_MIPS_ABI),
unsigned(ELF::EF_MIPS_MACH)); unsigned(ELF::EF_MIPS_MACH));
else if (E.e_machine == EM_AMDGPU) { else if (E.e_machine == EM_AMDGPU) {
Context not available.
[[fallthrough]]; [[fallthrough]];
case ELF::ELFABIVERSION_AMDGPU_HSA_V3: case ELF::ELFABIVERSION_AMDGPU_HSA_V3:
W.printFlags("Flags", E.e_flags, W.printFlags("Flags", E.e_flags,
makeArrayRef(ElfHeaderAMDGPUFlagsABIVersion3), ArrayRef(ElfHeaderAMDGPUFlagsABIVersion3),
unsigned(ELF::EF_AMDGPU_MACH)); unsigned(ELF::EF_AMDGPU_MACH));
break; break;
case ELF::ELFABIVERSION_AMDGPU_HSA_V4: case ELF::ELFABIVERSION_AMDGPU_HSA_V4:
case ELF::ELFABIVERSION_AMDGPU_HSA_V5: case ELF::ELFABIVERSION_AMDGPU_HSA_V5:
W.printFlags("Flags", E.e_flags, W.printFlags("Flags", E.e_flags,
makeArrayRef(ElfHeaderAMDGPUFlagsABIVersion4), ArrayRef(ElfHeaderAMDGPUFlagsABIVersion4),
unsigned(ELF::EF_AMDGPU_MACH), unsigned(ELF::EF_AMDGPU_MACH),
unsigned(ELF::EF_AMDGPU_FEATURE_XNACK_V4), unsigned(ELF::EF_AMDGPU_FEATURE_XNACK_V4),
unsigned(ELF::EF_AMDGPU_FEATURE_SRAMECC_V4)); unsigned(ELF::EF_AMDGPU_FEATURE_SRAMECC_V4));
break; break;
} }
} else if (E.e_machine == EM_RISCV) } else if (E.e_machine == EM_RISCV)
W.printFlags("Flags", E.e_flags, makeArrayRef(ElfHeaderRISCVFlags)); W.printFlags("Flags", E.e_flags, ArrayRef(ElfHeaderRISCVFlags));
else if (E.e_machine == EM_AVR) else if (E.e_machine == EM_AVR)
W.printFlags("Flags", E.e_flags, makeArrayRef(ElfHeaderAVRFlags), W.printFlags("Flags", E.e_flags, ArrayRef(ElfHeaderAVRFlags),
unsigned(ELF::EF_AVR_ARCH_MASK)); unsigned(ELF::EF_AVR_ARCH_MASK));
else if (E.e_machine == EM_LOONGARCH) else if (E.e_machine == EM_LOONGARCH)
W.printFlags("Flags", E.e_flags, makeArrayRef(ElfHeaderLoongArchFlags), W.printFlags("Flags", E.e_flags, ArrayRef(ElfHeaderLoongArchFlags),
unsigned(ELF::EF_LOONGARCH_ABI_MODIFIER_MASK), unsigned(ELF::EF_LOONGARCH_ABI_MODIFIER_MASK),
unsigned(ELF::EF_LOONGARCH_OBJABI_MASK)); unsigned(ELF::EF_LOONGARCH_OBJABI_MASK));
else if (E.e_machine == EM_XTENSA) else if (E.e_machine == EM_XTENSA)
W.printFlags("Flags", E.e_flags, makeArrayRef(ElfHeaderXtensaFlags), W.printFlags("Flags", E.e_flags, ArrayRef(ElfHeaderXtensaFlags),
unsigned(ELF::EF_XTENSA_MACH)); unsigned(ELF::EF_XTENSA_MACH));
else else
W.printFlags("Flags", E.e_flags); W.printFlags("Flags", E.e_flags);
Context not available.
object::getELFSectionTypeName(this->Obj.getHeader().e_machine, object::getELFSectionTypeName(this->Obj.getHeader().e_machine,
Sec.sh_type), Sec.sh_type),
Sec.sh_type); Sec.sh_type);
W.printFlags("Flags", Sec.sh_flags, makeArrayRef(FlagsList)); W.printFlags("Flags", Sec.sh_flags, ArrayRef(FlagsList));
W.printHex("Address", Sec.sh_addr); W.printHex("Address", Sec.sh_addr);
W.printHex("Offset", Sec.sh_offset); W.printHex("Offset", Sec.sh_offset);
W.printNumber("Size", Sec.sh_size); W.printNumber("Size", Sec.sh_size);
Context not available.
W.printNumber("Name", FullSymbolName, Symbol.st_name); W.printNumber("Name", FullSymbolName, Symbol.st_name);
W.printHex("Value", Symbol.st_value); W.printHex("Value", Symbol.st_value);
W.printNumber("Size", Symbol.st_size); W.printNumber("Size", Symbol.st_size);
W.printEnum("Binding", Symbol.getBinding(), makeArrayRef(ElfSymbolBindings)); W.printEnum("Binding", Symbol.getBinding(), ArrayRef(ElfSymbolBindings));
if (this->Obj.getHeader().e_machine == ELF::EM_AMDGPU && if (this->Obj.getHeader().e_machine == ELF::EM_AMDGPU &&
SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS) SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS)
W.printEnum("Type", SymbolType, makeArrayRef(AMDGPUSymbolTypes)); W.printEnum("Type", SymbolType, ArrayRef(AMDGPUSymbolTypes));
else else
W.printEnum("Type", SymbolType, makeArrayRef(ElfSymbolTypes)); W.printEnum("Type", SymbolType, ArrayRef(ElfSymbolTypes));
if (Symbol.st_other == 0) if (Symbol.st_other == 0)
// Usually st_other flag is zero. Do not pollute the output // Usually st_other flag is zero. Do not pollute the output
// by flags enumeration in that case. // by flags enumeration in that case.
Context not available.
std::begin(ElfRISCVSymOtherFlags), std::begin(ElfRISCVSymOtherFlags),
std::end(ElfRISCVSymOtherFlags)); std::end(ElfRISCVSymOtherFlags));
} }
W.printFlags("Other", Symbol.st_other, makeArrayRef(SymOtherFlags), 0x3u); W.printFlags("Other", Symbol.st_other, ArrayRef(SymOtherFlags), 0x3u);
} }
printSymbolSection(Symbol, SymIndex, ShndxTable); printSymbolSection(Symbol, SymIndex, ShndxTable);
} }
Context not available.
W.printHex("PhysicalAddress", Phdr.p_paddr); W.printHex("PhysicalAddress", Phdr.p_paddr);
W.printNumber("FileSize", Phdr.p_filesz); W.printNumber("FileSize", Phdr.p_filesz);
W.printNumber("MemSize", Phdr.p_memsz); W.printNumber("MemSize", Phdr.p_memsz);
W.printFlags("Flags", Phdr.p_flags, makeArrayRef(ElfSegmentFlags)); W.printFlags("Flags", Phdr.p_flags, ArrayRef(ElfSegmentFlags));
W.printNumber("Alignment", Phdr.p_align); W.printNumber("Alignment", Phdr.p_align);
} }
} }
Context not available.
for (const VerDef &D : *V) { for (const VerDef &D : *V) {
DictScope Def(W, "Definition"); DictScope Def(W, "Definition");
W.printNumber("Version", D.Version); W.printNumber("Version", D.Version);
W.printFlags("Flags", D.Flags, makeArrayRef(SymVersionFlags)); W.printFlags("Flags", D.Flags, ArrayRef(SymVersionFlags));
W.printNumber("Index", D.Ndx); W.printNumber("Index", D.Ndx);
W.printNumber("Hash", D.Hash); W.printNumber("Hash", D.Hash);
W.printString("Name", D.Name.c_str()); W.printString("Name", D.Name.c_str());
Context not available.
for (const VernAux &Aux : VN.AuxV) { for (const VernAux &Aux : VN.AuxV) {
DictScope Entry(W, "Entry"); DictScope Entry(W, "Entry");
W.printNumber("Hash", Aux.Hash); W.printNumber("Hash", Aux.Hash);
W.printFlags("Flags", Aux.Flags, makeArrayRef(SymVersionFlags)); W.printFlags("Flags", Aux.Flags, ArrayRef(SymVersionFlags));
W.printNumber("Index", Aux.Other); W.printNumber("Index", Aux.Other);
W.printString("Name", Aux.Name.c_str()); W.printString("Name", Aux.Name.c_str());
} }
Context not available.
const Elf_Sym &Sym = *Parser.getGotSym(&E); const Elf_Sym &Sym = *Parser.getGotSym(&E);
W.printHex("Value", Sym.st_value); W.printHex("Value", Sym.st_value);
W.printEnum("Type", Sym.getType(), makeArrayRef(ElfSymbolTypes)); W.printEnum("Type", Sym.getType(), ArrayRef(ElfSymbolTypes));
const unsigned SymIndex = &Sym - this->dynamic_symbols().begin(); const unsigned SymIndex = &Sym - this->dynamic_symbols().begin();
DataRegion<Elf_Word> ShndxTable( DataRegion<Elf_Word> ShndxTable(
Context not available.
const Elf_Sym &Sym = *Parser.getPltSym(&E); const Elf_Sym &Sym = *Parser.getPltSym(&E);
W.printHex("Value", Sym.st_value); W.printHex("Value", Sym.st_value);
W.printEnum("Type", Sym.getType(), makeArrayRef(ElfSymbolTypes)); W.printEnum("Type", Sym.getType(), ArrayRef(ElfSymbolTypes));
printSymbolSection(Sym, &Sym - this->dynamic_symbols().begin(), printSymbolSection(Sym, &Sym - this->dynamic_symbols().begin(),
ShndxTable); ShndxTable);
Context not available.
else else
OS << format("MIPS%ur%u", Flags->isa_level, Flags->isa_rev); OS << format("MIPS%ur%u", Flags->isa_level, Flags->isa_rev);
OS << "\n"; OS << "\n";
W.printEnum("ISA Extension", Flags->isa_ext, makeArrayRef(ElfMipsISAExtType)); W.printEnum("ISA Extension", Flags->isa_ext, ArrayRef(ElfMipsISAExtType));
W.printFlags("ASEs", Flags->ases, makeArrayRef(ElfMipsASEFlags)); W.printFlags("ASEs", Flags->ases, ArrayRef(ElfMipsASEFlags));
W.printEnum("FP ABI", Flags->fp_abi, makeArrayRef(ElfMipsFpABIType)); W.printEnum("FP ABI", Flags->fp_abi, ArrayRef(ElfMipsFpABIType));
W.printNumber("GPR size", getMipsRegisterSize(Flags->gpr_size)); W.printNumber("GPR size", getMipsRegisterSize(Flags->gpr_size));
W.printNumber("CPR1 size", getMipsRegisterSize(Flags->cpr1_size)); W.printNumber("CPR1 size", getMipsRegisterSize(Flags->cpr1_size));
W.printNumber("CPR2 size", getMipsRegisterSize(Flags->cpr2_size)); W.printNumber("CPR2 size", getMipsRegisterSize(Flags->cpr2_size));
W.printFlags("Flags 1", Flags->flags1, makeArrayRef(ElfMipsFlags1)); W.printFlags("Flags 1", Flags->flags1, ArrayRef(ElfMipsFlags1));
W.printHex("Flags 2", Flags->flags2); W.printHex("Flags 2", Flags->flags2);
} }
Context not available.

llvm/tools/llvm-readobj/MachODumper.cpp

Context not available.
template<class MachHeader> template<class MachHeader>
void MachODumper::printFileHeaders(const MachHeader &Header) { void MachODumper::printFileHeaders(const MachHeader &Header) {
W.printEnum("Magic", Header.magic, makeArrayRef(MachOMagics)); W.printEnum("Magic", Header.magic, ArrayRef(MachOMagics));
W.printEnum("CpuType", Header.cputype, makeArrayRef(MachOHeaderCpuTypes)); W.printEnum("CpuType", Header.cputype, ArrayRef(MachOHeaderCpuTypes));
uint32_t subtype = Header.cpusubtype & ~MachO::CPU_SUBTYPE_MASK; uint32_t subtype = Header.cpusubtype & ~MachO::CPU_SUBTYPE_MASK;
switch (Header.cputype) { switch (Header.cputype) {
case MachO::CPU_TYPE_X86: case MachO::CPU_TYPE_X86:
W.printEnum("CpuSubType", subtype, makeArrayRef(MachOHeaderCpuSubtypesX86)); W.printEnum("CpuSubType", subtype, ArrayRef(MachOHeaderCpuSubtypesX86));
break; break;
case MachO::CPU_TYPE_X86_64: case MachO::CPU_TYPE_X86_64:
W.printEnum("CpuSubType", subtype, makeArrayRef(MachOHeaderCpuSubtypesX64)); W.printEnum("CpuSubType", subtype, ArrayRef(MachOHeaderCpuSubtypesX64));
break; break;
case MachO::CPU_TYPE_ARM: case MachO::CPU_TYPE_ARM:
W.printEnum("CpuSubType", subtype, makeArrayRef(MachOHeaderCpuSubtypesARM)); W.printEnum("CpuSubType", subtype, ArrayRef(MachOHeaderCpuSubtypesARM));
break; break;
case MachO::CPU_TYPE_POWERPC: case MachO::CPU_TYPE_POWERPC:
W.printEnum("CpuSubType", subtype, makeArrayRef(MachOHeaderCpuSubtypesPPC)); W.printEnum("CpuSubType", subtype, ArrayRef(MachOHeaderCpuSubtypesPPC));
break; break;
case MachO::CPU_TYPE_SPARC: case MachO::CPU_TYPE_SPARC:
W.printEnum("CpuSubType", subtype, makeArrayRef(MachOHeaderCpuSubtypesSPARC)); W.printEnum("CpuSubType", subtype, ArrayRef(MachOHeaderCpuSubtypesSPARC));
break; break;
case MachO::CPU_TYPE_ARM64: case MachO::CPU_TYPE_ARM64:
W.printEnum("CpuSubType", subtype, makeArrayRef(MachOHeaderCpuSubtypesARM64)); W.printEnum("CpuSubType", subtype, ArrayRef(MachOHeaderCpuSubtypesARM64));
break; break;
case MachO::CPU_TYPE_POWERPC64: case MachO::CPU_TYPE_POWERPC64:
default: default:
W.printHex("CpuSubtype", subtype); W.printHex("CpuSubtype", subtype);
} }
W.printEnum("FileType", Header.filetype, makeArrayRef(MachOHeaderFileTypes)); W.printEnum("FileType", Header.filetype, ArrayRef(MachOHeaderFileTypes));
W.printNumber("NumOfLoadCommands", Header.ncmds); W.printNumber("NumOfLoadCommands", Header.ncmds);
W.printNumber("SizeOfLoadCommands", Header.sizeofcmds); W.printNumber("SizeOfLoadCommands", Header.sizeofcmds);
W.printFlags("Flags", Header.flags, makeArrayRef(MachOHeaderFlags)); W.printFlags("Flags", Header.flags, ArrayRef(MachOHeaderFlags));
} }
void MachODumper::printSectionHeaders() { return printSectionHeaders(Obj); } void MachODumper::printSectionHeaders() { return printSectionHeaders(Obj); }
Context not available.
W.printNumber("Alignment", MOSection.Alignment); W.printNumber("Alignment", MOSection.Alignment);
W.printHex("RelocationOffset", MOSection.RelocationTableOffset); W.printHex("RelocationOffset", MOSection.RelocationTableOffset);
W.printNumber("RelocationCount", MOSection.NumRelocationTableEntries); W.printNumber("RelocationCount", MOSection.NumRelocationTableEntries);
W.printEnum("Type", MOSection.Flags & 0xFF, W.printEnum("Type", MOSection.Flags & 0xFF, ArrayRef(MachOSectionTypes));
makeArrayRef(MachOSectionTypes));
W.printFlags("Attributes", MOSection.Flags >> 8, W.printFlags("Attributes", MOSection.Flags >> 8,
makeArrayRef(MachOSectionAttributes)); ArrayRef(MachOSectionAttributes));
W.printHex("Reserved1", MOSection.Reserved1); W.printHex("Reserved1", MOSection.Reserved1);
W.printHex("Reserved2", MOSection.Reserved2); W.printHex("Reserved2", MOSection.Reserved2);
if (Obj->is64Bit()) if (Obj->is64Bit())
Context not available.
if (MOSymbol.Type & MachO::N_EXT) if (MOSymbol.Type & MachO::N_EXT)
W.startLine() << "Extern\n"; W.startLine() << "Extern\n";
W.printEnum("Type", uint8_t(MOSymbol.Type & MachO::N_TYPE), W.printEnum("Type", uint8_t(MOSymbol.Type & MachO::N_TYPE),
makeArrayRef(MachOSymbolTypes)); ArrayRef(MachOSymbolTypes));
} }
W.printHex("Section", SectionName, MOSymbol.SectionIndex); W.printHex("Section", SectionName, MOSymbol.SectionIndex);
W.printEnum("RefType", static_cast<uint16_t>(MOSymbol.Flags & 0x7), W.printEnum("RefType", static_cast<uint16_t>(MOSymbol.Flags & 0x7),
makeArrayRef(MachOSymbolRefTypes)); ArrayRef(MachOSymbolRefTypes));
W.printFlags("Flags", static_cast<uint16_t>(MOSymbol.Flags & ~0x7), W.printFlags("Flags", static_cast<uint16_t>(MOSymbol.Flags & ~0x7),
makeArrayRef(MachOSymbolFlags)); ArrayRef(MachOSymbolFlags));
W.printHex("Value", MOSymbol.Value); W.printHex("Value", MOSymbol.Value);
} }
Context not available.

llvm/tools/llvm-readobj/WasmDumper.cpp

Context not available.
for (const SectionRef &Section : Obj->sections()) { for (const SectionRef &Section : Obj->sections()) {
const WasmSection &WasmSec = Obj->getWasmSection(Section); const WasmSection &WasmSec = Obj->getWasmSection(Section);
DictScope SectionD(W, "Section"); DictScope SectionD(W, "Section");
W.printEnum("Type", WasmSec.Type, makeArrayRef(WasmSectionTypes)); W.printEnum("Type", WasmSec.Type, ArrayRef(WasmSectionTypes));
W.printNumber("Size", static_cast<uint64_t>(WasmSec.Content.size())); W.printNumber("Size", static_cast<uint64_t>(WasmSec.Content.size()));
W.printNumber("Offset", WasmSec.Offset); W.printNumber("Offset", WasmSec.Offset);
switch (WasmSec.Type) { switch (WasmSec.Type) {
Context not available.
DictScope D(W, "Symbol"); DictScope D(W, "Symbol");
WasmSymbol Symbol = Obj->getWasmSymbol(Sym.getRawDataRefImpl()); WasmSymbol Symbol = Obj->getWasmSymbol(Sym.getRawDataRefImpl());
W.printString("Name", Symbol.Info.Name); W.printString("Name", Symbol.Info.Name);
W.printEnum("Type", Symbol.Info.Kind, makeArrayRef(WasmSymbolTypes)); W.printEnum("Type", Symbol.Info.Kind, ArrayRef(WasmSymbolTypes));
W.printFlags("Flags", Symbol.Info.Flags, makeArrayRef(WasmSymbolFlags)); W.printFlags("Flags", Symbol.Info.Flags, ArrayRef(WasmSymbolFlags));
if (Symbol.Info.Flags & wasm::WASM_SYMBOL_UNDEFINED) { if (Symbol.Info.Flags & wasm::WASM_SYMBOL_UNDEFINED) {
if (Symbol.Info.ImportName) { if (Symbol.Info.ImportName) {
Context not available.

llvm/tools/llvm-readobj/Win64EHDumper.cpp

Context not available.
off_t Offset, const UnwindInfo &UI) { off_t Offset, const UnwindInfo &UI) {
DictScope UIS(SW, "UnwindInfo"); DictScope UIS(SW, "UnwindInfo");
SW.printNumber("Version", UI.getVersion()); SW.printNumber("Version", UI.getVersion());
SW.printFlags("Flags", UI.getFlags(), makeArrayRef(UnwindFlags)); SW.printFlags("Flags", UI.getFlags(), ArrayRef(UnwindFlags));
SW.printNumber("PrologSize", UI.PrologSize); SW.printNumber("PrologSize", UI.PrologSize);
if (UI.getFrameRegister()) { if (UI.getFrameRegister()) {
SW.printEnum("FrameRegister", UI.getFrameRegister(), SW.printEnum("FrameRegister", UI.getFrameRegister(),
makeArrayRef(UnwindOpInfo)); ArrayRef(UnwindOpInfo));
SW.printHex("FrameOffset", UI.getFrameOffset()); SW.printHex("FrameOffset", UI.getFrameOffset());
} else { } else {
SW.printString("FrameRegister", StringRef("-")); SW.printString("FrameRegister", StringRef("-"));
Context not available.
return; return;
} }
printUnwindCode(UI, makeArrayRef(UCI, UCE)); printUnwindCode(UI, ArrayRef(UCI, UCE));
UCI = UCI + UsedSlots - 1; UCI = UCI + UsedSlots - 1;
} }
} }
Context not available.

llvm/tools/llvm-readobj/XCOFFDumper.cpp

Context not available.
W.printHex("SymbolType", LoadSecSymEntPtr->SymbolType); W.printHex("SymbolType", LoadSecSymEntPtr->SymbolType);
W.printEnum("StorageClass", W.printEnum("StorageClass",
static_cast<uint8_t>(LoadSecSymEntPtr->StorageClass), static_cast<uint8_t>(LoadSecSymEntPtr->StorageClass),
makeArrayRef(SymStorageClass)); ArrayRef(SymStorageClass));
W.printHex("ImportFileID", LoadSecSymEntPtr->ImportFileID); W.printHex("ImportFileID", LoadSecSymEntPtr->ImportFileID);
W.printNumber("ParameterTypeCheck", LoadSecSymEntPtr->ParameterTypeCheck); W.printNumber("ParameterTypeCheck", LoadSecSymEntPtr->ParameterTypeCheck);
} }
Context not available.
W.printNumber("FixupBitValue", IsFixupIndicated(Info) ? 1 : 0); W.printNumber("FixupBitValue", IsFixupIndicated(Info) ? 1 : 0);
W.printNumber("Length", GetRelocatedLength(Info)); W.printNumber("Length", GetRelocatedLength(Info));
W.printEnum("Type", static_cast<uint8_t>(Type), W.printEnum("Type", static_cast<uint8_t>(Type),
makeArrayRef(RelocationTypeNameclass)); ArrayRef(RelocationTypeNameclass));
W.printNumber("SectionNumber", LoaderSecRelEntPtr->SectionNum); W.printNumber("SectionNumber", LoaderSecRelEntPtr->SectionNum);
} else { } else {
W.startLine() << format_hex(LoaderSecRelEntPtr->VirtualAddr, W.startLine() << format_hex(LoaderSecRelEntPtr->VirtualAddr,
Context not available.
W.printString("IsSigned", Reloc.isRelocationSigned() ? "Yes" : "No"); W.printString("IsSigned", Reloc.isRelocationSigned() ? "Yes" : "No");
W.printNumber("FixupBitValue", Reloc.isFixupIndicated() ? 1 : 0); W.printNumber("FixupBitValue", Reloc.isFixupIndicated() ? 1 : 0);
W.printNumber("Length", Reloc.getRelocatedLength()); W.printNumber("Length", Reloc.getRelocatedLength());
W.printEnum("Type", (uint8_t)Reloc.Type, W.printEnum("Type", (uint8_t)Reloc.Type, ArrayRef(RelocationTypeNameclass));
makeArrayRef(RelocationTypeNameclass));
} else { } else {
raw_ostream &OS = W.startLine(); raw_ostream &OS = W.startLine();
OS << W.hex(Reloc.VirtualAddress) << " " << RelocName << " " << SymbolName OS << W.hex(Reloc.VirtualAddress) << " " << RelocName << " " << SymbolName
Context not available.
Obj.getSymbolIndex(reinterpret_cast<uintptr_t>(AuxEntPtr))); Obj.getSymbolIndex(reinterpret_cast<uintptr_t>(AuxEntPtr)));
W.printString("Name", FileName); W.printString("Name", FileName);
W.printEnum("Type", static_cast<uint8_t>(AuxEntPtr->Type), W.printEnum("Type", static_cast<uint8_t>(AuxEntPtr->Type),
makeArrayRef(FileStringType)); ArrayRef(FileStringType));
if (Obj.is64Bit()) { if (Obj.is64Bit()) {
W.printEnum("Auxiliary Type", static_cast<uint8_t>(AuxEntPtr->AuxType), W.printEnum("Auxiliary Type", static_cast<uint8_t>(AuxEntPtr->AuxType),
makeArrayRef(SymAuxType)); ArrayRef(SymAuxType));
} }
} }
Context not available.
// Print out symbol alignment and type. // Print out symbol alignment and type.
W.printNumber("SymbolAlignmentLog2", AuxEntRef.getAlignmentLog2()); W.printNumber("SymbolAlignmentLog2", AuxEntRef.getAlignmentLog2());
W.printEnum("SymbolType", AuxEntRef.getSymbolType(), W.printEnum("SymbolType", AuxEntRef.getSymbolType(),
makeArrayRef(CsectSymbolTypeClass)); ArrayRef(CsectSymbolTypeClass));
W.printEnum("StorageMappingClass", W.printEnum("StorageMappingClass",
static_cast<uint8_t>(AuxEntRef.getStorageMappingClass()), static_cast<uint8_t>(AuxEntRef.getStorageMappingClass()),
makeArrayRef(CsectStorageMappingClass)); ArrayRef(CsectStorageMappingClass));
if (Obj.is64Bit()) { if (Obj.is64Bit()) {
W.printEnum("Auxiliary Type", static_cast<uint8_t>(XCOFF::AUX_CSECT), W.printEnum("Auxiliary Type", static_cast<uint8_t>(XCOFF::AUX_CSECT),
makeArrayRef(SymAuxType)); ArrayRef(SymAuxType));
} else { } else {
W.printHex("StabInfoIndex", AuxEntRef.getStabInfoIndex32()); W.printHex("StabInfoIndex", AuxEntRef.getStabInfoIndex32());
W.printHex("StabSectNum", AuxEntRef.getStabSectNum32()); W.printHex("StabSectNum", AuxEntRef.getStabSectNum32());
Context not available.
W.printHex("SizeOfFunction", AuxEntPtr->SizeOfFunction); W.printHex("SizeOfFunction", AuxEntPtr->SizeOfFunction);
W.printNumber("SymbolIndexOfNextBeyond", AuxEntPtr->SymIdxOfNextBeyond); W.printNumber("SymbolIndexOfNextBeyond", AuxEntPtr->SymIdxOfNextBeyond);
W.printEnum("Auxiliary Type", static_cast<uint8_t>(AuxEntPtr->AuxType), W.printEnum("Auxiliary Type", static_cast<uint8_t>(AuxEntPtr->AuxType),
makeArrayRef(SymAuxType)); ArrayRef(SymAuxType));
} }
void XCOFFDumper::printFunctionAuxEnt(const XCOFFFunctionAuxEnt32 *AuxEntPtr) { void XCOFFDumper::printFunctionAuxEnt(const XCOFFFunctionAuxEnt32 *AuxEntPtr) {
Context not available.
W.printHex("PointerToLineNum", AuxEntPtr->PtrToLineNum); W.printHex("PointerToLineNum", AuxEntPtr->PtrToLineNum);
W.printNumber("SymbolIndexOfNextBeyond", AuxEntPtr->SymIdxOfNextBeyond); W.printNumber("SymbolIndexOfNextBeyond", AuxEntPtr->SymIdxOfNextBeyond);
W.printEnum("Auxiliary Type", static_cast<uint8_t>(AuxEntPtr->AuxType), W.printEnum("Auxiliary Type", static_cast<uint8_t>(AuxEntPtr->AuxType),
makeArrayRef(SymAuxType)); ArrayRef(SymAuxType));
} }
void XCOFFDumper::printBlockAuxEnt(const XCOFFBlockAuxEnt32 *AuxEntPtr) { void XCOFFDumper::printBlockAuxEnt(const XCOFFBlockAuxEnt32 *AuxEntPtr) {
Context not available.
Obj.getSymbolIndex(reinterpret_cast<uintptr_t>(AuxEntPtr))); Obj.getSymbolIndex(reinterpret_cast<uintptr_t>(AuxEntPtr)));
W.printHex("LineNumber", AuxEntPtr->LineNum); W.printHex("LineNumber", AuxEntPtr->LineNum);
W.printEnum("Auxiliary Type", static_cast<uint8_t>(AuxEntPtr->AuxType), W.printEnum("Auxiliary Type", static_cast<uint8_t>(AuxEntPtr->AuxType),
makeArrayRef(SymAuxType)); ArrayRef(SymAuxType));
} }
template <typename T> template <typename T>
Context not available.
W.printNumber("NumberOfRelocEntries", AuxEntPtr->NumberOfRelocEnt); W.printNumber("NumberOfRelocEntries", AuxEntPtr->NumberOfRelocEnt);
if (Obj.is64Bit()) if (Obj.is64Bit())
W.printEnum("Auxiliary Type", static_cast<uint8_t>(XCOFF::AUX_SECT), W.printEnum("Auxiliary Type", static_cast<uint8_t>(XCOFF::AUX_SECT),
makeArrayRef(SymAuxType)); ArrayRef(SymAuxType));
} }
static StringRef GetSymbolValueName(XCOFF::StorageClass SC) { static StringRef GetSymbolValueName(XCOFF::StorageClass SC) {
Context not available.
W.printString("Section", SectionName); W.printString("Section", SectionName);
if (SymbolClass == XCOFF::C_FILE) { if (SymbolClass == XCOFF::C_FILE) {
W.printEnum("Source Language ID", SymbolEntRef.getLanguageIdForCFile(), W.printEnum("Source Language ID", SymbolEntRef.getLanguageIdForCFile(),
makeArrayRef(CFileLangIdClass)); ArrayRef(CFileLangIdClass));
W.printEnum("CPU Version ID", SymbolEntRef.getCPUTypeIddForCFile(), W.printEnum("CPU Version ID", SymbolEntRef.getCPUTypeIddForCFile(),
makeArrayRef(CFileCpuIdClass)); ArrayRef(CFileCpuIdClass));
} else } else
W.printHex("Type", SymbolEntRef.getSymbolType()); W.printHex("Type", SymbolEntRef.getSymbolType());
W.printEnum("StorageClass", static_cast<uint8_t>(SymbolClass), W.printEnum("StorageClass", static_cast<uint8_t>(SymbolClass),
makeArrayRef(SymStorageClass)); ArrayRef(SymStorageClass));
W.printNumber("NumberOfAuxEntries", NumberOfAuxEntries); W.printNumber("NumberOfAuxEntries", NumberOfAuxEntries);
if (NumberOfAuxEntries == 0) if (NumberOfAuxEntries == 0)
Context not available.
if (NumberOfAuxEntries > 1) if (NumberOfAuxEntries > 1)
reportUniqueWarning("the " + reportUniqueWarning("the " +
enumToString(static_cast<uint8_t>(SymbolClass), enumToString(static_cast<uint8_t>(SymbolClass),
makeArrayRef(SymStorageClass)) + ArrayRef(SymStorageClass)) +
" symbol at index " + Twine(SymbolIdx) + " symbol at index " + Twine(SymbolIdx) +
" should not have more than 1 " " should not have more than 1 "
"auxiliary entry"); "auxiliary entry");
Context not available.
if (Sec.isReservedSectionType()) if (Sec.isReservedSectionType())
W.printHex("Flags", "Reserved", SectionType); W.printHex("Flags", "Reserved", SectionType);
else else
W.printEnum("Type", SectionType, makeArrayRef(SectionTypeFlagsNames)); W.printEnum("Type", SectionType, ArrayRef(SectionTypeFlagsNames));
} }
if (opts::SectionRelocations) if (opts::SectionRelocations)
Context not available.

llvm/tools/llvm-stress/llvm-stress.cpp

Context not available.
for (unsigned i = 0; i < 2; ++i) for (unsigned i = 0; i < 2; ++i)
RandomBits[i] = Ran->Rand64(); RandomBits[i] = Ran->Rand64();
APInt RandomInt(Ty->getPrimitiveSizeInBits(), makeArrayRef(RandomBits)); APInt RandomInt(Ty->getPrimitiveSizeInBits(), ArrayRef(RandomBits));
APFloat RandomFloat(Ty->getFltSemantics(), RandomInt); APFloat RandomFloat(Ty->getFltSemantics(), RandomInt);
if (getRandom() & 1) if (getRandom() & 1)
Context not available.

llvm/tools/lto/lto.cpp

Context not available.
SmallVector<StringRef, 4> Options; SmallVector<StringRef, 4> Options;
for (int i = 0; i < number; ++i) for (int i = 0; i < number; ++i)
Options.push_back(options[i]); Options.push_back(options[i]);
unwrap(cg)->setCodeGenDebugOptions(makeArrayRef(Options)); unwrap(cg)->setCodeGenDebugOptions(ArrayRef(Options));
} }
unsigned int lto_api_version() { return LTO_API_VERSION; } unsigned int lto_api_version() { return LTO_API_VERSION; }
Context not available.

llvm/tools/obj2yaml/elf2yaml.cpp

Context not available.
else else
ExpectedOffset = sizeof(typename ELFT::Ehdr); ExpectedOffset = sizeof(typename ELFT::Ehdr);
for (const std::unique_ptr<ELFYAML::Chunk> &C : for (const std::unique_ptr<ELFYAML::Chunk> &C : ArrayRef(V).drop_front()) {
makeArrayRef(V).drop_front()) {
ELFYAML::Section &Sec = *cast<ELFYAML::Section>(C.get()); ELFYAML::Section &Sec = *cast<ELFYAML::Section>(C.get());
const typename ELFT::Shdr &SecHdr = S[Sec.OriginalSecNdx]; const typename ELFT::Shdr &SecHdr = S[Sec.OriginalSecNdx];
Context not available.
std::vector<ELFYAML::Section *> OriginalOrder; std::vector<ELFYAML::Section *> OriginalOrder;
if (!Chunks.empty()) if (!Chunks.empty())
for (const std::unique_ptr<ELFYAML::Chunk> &C : for (const std::unique_ptr<ELFYAML::Chunk> &C :
makeArrayRef(Chunks).drop_front()) ArrayRef(Chunks).drop_front())
OriginalOrder.push_back(cast<ELFYAML::Section>(C.get())); OriginalOrder.push_back(cast<ELFYAML::Section>(C.get()));
// Sometimes the order of sections in the section header table does not match // Sometimes the order of sections in the section header table does not match
Context not available.

llvm/unittests/ADT/ArrayRefTest.cpp

Context not available.
TEST(ArrayRefTest, AllocatorCopy) { TEST(ArrayRefTest, AllocatorCopy) {
BumpPtrAllocator Alloc; BumpPtrAllocator Alloc;
static const uint16_t Words1[] = { 1, 4, 200, 37 }; static const uint16_t Words1[] = { 1, 4, 200, 37 };
ArrayRef<uint16_t> Array1 = makeArrayRef(Words1, 4); ArrayRef<uint16_t> Array1 = ArrayRef(Words1, 4);
static const uint16_t Words2[] = { 11, 4003, 67, 64000, 13 }; static const uint16_t Words2[] = { 11, 4003, 67, 64000, 13 };
ArrayRef<uint16_t> Array2 = makeArrayRef(Words2, 5); ArrayRef<uint16_t> Array2 = ArrayRef(Words2, 5);
ArrayRef<uint16_t> Array1c = Array1.copy(Alloc); ArrayRef<uint16_t> Array1c = Array1.copy(Alloc);
ArrayRef<uint16_t> Array2c = Array2.copy(Alloc); ArrayRef<uint16_t> Array2c = Array2.copy(Alloc);
EXPECT_TRUE(Array1.equals(Array1c)); EXPECT_TRUE(Array1.equals(Array1c));
Context not available.
void operator=(const NonAssignable &RHS) { assert(RHS.Ptr != nullptr); } void operator=(const NonAssignable &RHS) { assert(RHS.Ptr != nullptr); }
bool operator==(const NonAssignable &RHS) const { return Ptr == RHS.Ptr; } bool operator==(const NonAssignable &RHS) const { return Ptr == RHS.Ptr; }
} Array3Src[] = {"hello", "world"}; } Array3Src[] = {"hello", "world"};
ArrayRef<NonAssignable> Array3Copy = makeArrayRef(Array3Src).copy(Alloc); ArrayRef<NonAssignable> Array3Copy = ArrayRef(Array3Src).copy(Alloc);
EXPECT_EQ(makeArrayRef(Array3Src), Array3Copy); EXPECT_EQ(ArrayRef(Array3Src), Array3Copy);
EXPECT_NE(makeArrayRef(Array3Src).data(), Array3Copy.data()); EXPECT_NE(ArrayRef(Array3Src).data(), Array3Copy.data());
} }
// This test is pure UB given the ArrayRef<> implementation. // This test is pure UB given the ArrayRef<> implementation.
Context not available.
EXPECT_TRUE(A.empty()); EXPECT_TRUE(A.empty());
} }
TEST(ArrayRefTest, makeArrayRef) { TEST(ArrayRefTest, ArrayRef) {
static const int A1[] = {1, 2, 3, 4, 5, 6, 7, 8}; static const int A1[] = {1, 2, 3, 4, 5, 6, 7, 8};
// No copy expected for non-const ArrayRef (true no-op) // A copy is expected for non-const ArrayRef (thin copy)
ArrayRef<int> AR1(A1); ArrayRef<int> AR1(A1);
ArrayRef<int> &AR1Ref = makeArrayRef(AR1); const ArrayRef<int> &AR1Ref = ArrayRef(AR1);
EXPECT_EQ(&AR1, &AR1Ref); EXPECT_NE(&AR1, &AR1Ref);
EXPECT_TRUE(AR1.equals(AR1Ref));
// A copy is expected for non-const ArrayRef (thin copy) // A copy is expected for non-const ArrayRef (thin copy)
const ArrayRef<int> AR2(A1); const ArrayRef<int> AR2(A1);
const ArrayRef<int> &AR2Ref = makeArrayRef(AR2); const ArrayRef<int> &AR2Ref = ArrayRef(AR2);
EXPECT_NE(&AR2Ref, &AR2); EXPECT_NE(&AR2Ref, &AR2);
EXPECT_TRUE(AR2.equals(AR2Ref)); EXPECT_TRUE(AR2.equals(AR2Ref));
} }
TEST(ArrayRefTest, OwningArrayRef) { TEST(ArrayRefTest, OwningArrayRef) {
static const int A1[] = {0, 1}; static const int A1[] = {0, 1};
OwningArrayRef<int> A(makeArrayRef(A1)); OwningArrayRef<int> A{ArrayRef(A1)};
OwningArrayRef<int> B(std::move(A)); OwningArrayRef<int> B(std::move(A));
EXPECT_EQ(A.data(), nullptr); EXPECT_EQ(A.data(), nullptr);
} }
TEST(ArrayRefTest, makeArrayRefFromStdArray) { TEST(ArrayRefTest, ArrayRefFromStdArray) {
std::array<int, 5> A1{{42, -5, 0, 1000000, -1000000}}; std::array<int, 5> A1{{42, -5, 0, 1000000, -1000000}};
ArrayRef<int> A2 = makeArrayRef(A1); ArrayRef<int> A2 = ArrayRef(A1);
EXPECT_EQ(A1.size(), A2.size()); EXPECT_EQ(A1.size(), A2.size());
for (std::size_t i = 0; i < A1.size(); ++i) { for (std::size_t i = 0; i < A1.size(); ++i) {
Context not available.

llvm/unittests/ADT/EditDistanceTest.cpp

Context not available.
return X; return X;
}; };
unsigned EditDist = llvm::ComputeMappedEditDistance( unsigned EditDist = llvm::ComputeMappedEditDistance(
makeArrayRef(A.data(), A.size()), makeArrayRef(B.data(), B.size()), ArrayRef(A.data(), A.size()), ArrayRef(B.data(), B.size()), TrackMaps,
TrackMaps, true, MaxEditDistance); true, MaxEditDistance);
return {NumMaps, EditDist}; return {NumMaps, EditDist};
} }
Context not available.

llvm/unittests/ADT/SmallVectorTest.cpp

Context not available.
SmallVector<int, 2> V1 = {}; SmallVector<int, 2> V1 = {};
EXPECT_TRUE(V1.empty()); EXPECT_TRUE(V1.empty());
V1 = {0, 0}; V1 = {0, 0};
EXPECT_TRUE(makeArrayRef(V1).equals({0, 0})); EXPECT_TRUE(ArrayRef(V1).equals({0, 0}));
V1 = {-1, -1}; V1 = {-1, -1};
EXPECT_TRUE(makeArrayRef(V1).equals({-1, -1})); EXPECT_TRUE(ArrayRef(V1).equals({-1, -1}));
SmallVector<int, 2> V2 = {1, 2, 3, 4}; SmallVector<int, 2> V2 = {1, 2, 3, 4};
EXPECT_TRUE(makeArrayRef(V2).equals({1, 2, 3, 4})); EXPECT_TRUE(ArrayRef(V2).equals({1, 2, 3, 4}));
V2.assign({4}); V2.assign({4});
EXPECT_TRUE(makeArrayRef(V2).equals({4})); EXPECT_TRUE(ArrayRef(V2).equals({4}));
V2.append({3, 2}); V2.append({3, 2});
EXPECT_TRUE(makeArrayRef(V2).equals({4, 3, 2})); EXPECT_TRUE(ArrayRef(V2).equals({4, 3, 2}));
V2.insert(V2.begin() + 1, 5); V2.insert(V2.begin() + 1, 5);
EXPECT_TRUE(makeArrayRef(V2).equals({4, 5, 3, 2})); EXPECT_TRUE(ArrayRef(V2).equals({4, 5, 3, 2}));
} }
TEST(SmallVectorTest, ToVector) { TEST(SmallVectorTest, ToVector) {
Context not available.

llvm/unittests/ADT/TinyPtrVectorTest.cpp

Context not available.
PtrT makePtr(ValueT *V) { return PtrT(V); } PtrT makePtr(ValueT *V) { return PtrT(V); }
ArrayRef<PtrT> testArray(size_t N) { ArrayRef<PtrT> testArray(size_t N) { return ArrayRef(&TestPtrs[0], N); }
return makeArrayRef(&TestPtrs[0], N);
}
void appendValues(VectorT &V, ArrayRef<PtrT> Values) { void appendValues(VectorT &V, ArrayRef<PtrT> Values) {
for (size_t i = 0, e = Values.size(); i != e; ++i) for (size_t i = 0, e = Values.size(); i != e; ++i)
Context not available.

llvm/unittests/Analysis/MemoryProfileInfoTest.cpp

Context not available.
StackIds.push_back(*ContextIter); StackIds.push_back(*ContextIter);
if (First) { if (First) {
std::vector<uint64_t> Expected = {2, 3, 4}; std::vector<uint64_t> Expected = {2, 3, 4};
EXPECT_EQ(makeArrayRef(StackIds), makeArrayRef(Expected)); EXPECT_EQ(ArrayRef(StackIds), ArrayRef(Expected));
} else { } else {
std::vector<uint64_t> Expected = {2, 3, 5}; std::vector<uint64_t> Expected = {2, 3, 5};
EXPECT_EQ(makeArrayRef(StackIds), makeArrayRef(Expected)); EXPECT_EQ(ArrayRef(StackIds), ArrayRef(Expected));
} }
First = false; First = false;
} }
Context not available.
StackIds.push_back(Index->getStackIdAtIndex(StackIdIndex)); StackIds.push_back(Index->getStackIdAtIndex(StackIdIndex));
if (First) { if (First) {
std::vector<uint64_t> Expected = {3, 4}; std::vector<uint64_t> Expected = {3, 4};
EXPECT_EQ(makeArrayRef(StackIds), makeArrayRef(Expected)); EXPECT_EQ(ArrayRef(StackIds), ArrayRef(Expected));
} else { } else {
std::vector<uint64_t> Expected = {3, 5}; std::vector<uint64_t> Expected = {3, 5};
EXPECT_EQ(makeArrayRef(StackIds), makeArrayRef(Expected)); EXPECT_EQ(ArrayRef(StackIds), ArrayRef(Expected));
} }
First = false; First = false;
} }
Context not available.
StackIds.push_back(Index->getStackIdAtIndex(StackIdIndex)); StackIds.push_back(Index->getStackIdAtIndex(StackIdIndex));
if (First) { if (First) {
std::vector<uint64_t> Expected = {1, 2, 3, 4}; std::vector<uint64_t> Expected = {1, 2, 3, 4};
EXPECT_EQ(makeArrayRef(StackIds), makeArrayRef(Expected)); EXPECT_EQ(ArrayRef(StackIds), ArrayRef(Expected));
} else { } else {
std::vector<uint64_t> Expected = {1, 2, 3, 5}; std::vector<uint64_t> Expected = {1, 2, 3, 5};
EXPECT_EQ(makeArrayRef(StackIds), makeArrayRef(Expected)); EXPECT_EQ(ArrayRef(StackIds), ArrayRef(Expected));
} }
First = false; First = false;
} }
Context not available.

llvm/unittests/Analysis/VectorUtilsTest.cpp

Context not available.
TEST_F(BasicTest, narrowShuffleMaskElts) { TEST_F(BasicTest, narrowShuffleMaskElts) {
SmallVector<int, 16> ScaledMask; SmallVector<int, 16> ScaledMask;
narrowShuffleMaskElts(1, {3,2,0,-2}, ScaledMask); narrowShuffleMaskElts(1, {3,2,0,-2}, ScaledMask);
EXPECT_EQ(makeArrayRef(ScaledMask), makeArrayRef({3,2,0,-2})); EXPECT_EQ(ArrayRef(ScaledMask), ArrayRef({3, 2, 0, -2}));
narrowShuffleMaskElts(4, {3,2,0,-1}, ScaledMask); narrowShuffleMaskElts(4, {3,2,0,-1}, ScaledMask);
EXPECT_EQ(makeArrayRef(ScaledMask), makeArrayRef({12,13,14,15,8,9,10,11,0,1,2,3,-1,-1,-1,-1})); EXPECT_EQ(ArrayRef(ScaledMask), ArrayRef({12, 13, 14, 15, 8, 9, 10, 11, 0, 1,
2, 3, -1, -1, -1, -1}));
} }
TEST_F(BasicTest, widenShuffleMaskElts) { TEST_F(BasicTest, widenShuffleMaskElts) {
Context not available.
// scale == 1 is a copy // scale == 1 is a copy
EXPECT_TRUE(widenShuffleMaskElts(1, {3,2,0,-1}, WideMask)); EXPECT_TRUE(widenShuffleMaskElts(1, {3,2,0,-1}, WideMask));
EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({3,2,0,-1})); EXPECT_EQ(ArrayRef(WideMask), ArrayRef({3, 2, 0, -1}));
// back to original mask // back to original mask
narrowShuffleMaskElts(1, makeArrayRef(WideMask), NarrowMask); narrowShuffleMaskElts(1, ArrayRef(WideMask), NarrowMask);
EXPECT_EQ(makeArrayRef(NarrowMask), makeArrayRef({3,2,0,-1})); EXPECT_EQ(ArrayRef(NarrowMask), ArrayRef({3, 2, 0, -1}));
// can't widen non-consecutive 3/2 // can't widen non-consecutive 3/2
EXPECT_FALSE(widenShuffleMaskElts(2, {3,2,0,-1}, WideMask)); EXPECT_FALSE(widenShuffleMaskElts(2, {3,2,0,-1}, WideMask));
Context not available.
// can always widen identity to single element // can always widen identity to single element
EXPECT_TRUE(widenShuffleMaskElts(3, {0,1,2}, WideMask)); EXPECT_TRUE(widenShuffleMaskElts(3, {0,1,2}, WideMask));
EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({0})); EXPECT_EQ(ArrayRef(WideMask), ArrayRef({0}));
// back to original mask // back to original mask
narrowShuffleMaskElts(3, makeArrayRef(WideMask), NarrowMask); narrowShuffleMaskElts(3, ArrayRef(WideMask), NarrowMask);
EXPECT_EQ(makeArrayRef(NarrowMask), makeArrayRef({0,1,2})); EXPECT_EQ(ArrayRef(NarrowMask), ArrayRef({0, 1, 2}));
// groups of 4 must be consecutive/undef // groups of 4 must be consecutive/undef
EXPECT_TRUE(widenShuffleMaskElts(4, {12,13,14,15,8,9,10,11,0,1,2,3,-1,-1,-1,-1}, WideMask)); EXPECT_TRUE(widenShuffleMaskElts(4, {12,13,14,15,8,9,10,11,0,1,2,3,-1,-1,-1,-1}, WideMask));
EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({3,2,0,-1})); EXPECT_EQ(ArrayRef(WideMask), ArrayRef({3, 2, 0, -1}));
// back to original mask // back to original mask
narrowShuffleMaskElts(4, makeArrayRef(WideMask), NarrowMask); narrowShuffleMaskElts(4, ArrayRef(WideMask), NarrowMask);
EXPECT_EQ(makeArrayRef(NarrowMask), makeArrayRef({12,13,14,15,8,9,10,11,0,1,2,3,-1,-1,-1,-1})); EXPECT_EQ(ArrayRef(NarrowMask), ArrayRef({12, 13, 14, 15, 8, 9, 10, 11, 0, 1,
2, 3, -1, -1, -1, -1}));
// groups of 2 must be consecutive/undef // groups of 2 must be consecutive/undef
EXPECT_FALSE(widenShuffleMaskElts(2, {12,12,14,15,8,9,10,11,0,1,2,3,-1,-1,-1,-1}, WideMask)); EXPECT_FALSE(widenShuffleMaskElts(2, {12,12,14,15,8,9,10,11,0,1,2,3,-1,-1,-1,-1}, WideMask));
// groups of 3 must be consecutive/undef // groups of 3 must be consecutive/undef
EXPECT_TRUE(widenShuffleMaskElts(3, {6,7,8,0,1,2,-1,-1,-1}, WideMask)); EXPECT_TRUE(widenShuffleMaskElts(3, {6,7,8,0,1,2,-1,-1,-1}, WideMask));
EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({2,0,-1})); EXPECT_EQ(ArrayRef(WideMask), ArrayRef({2, 0, -1}));
// back to original mask // back to original mask
narrowShuffleMaskElts(3, makeArrayRef(WideMask), NarrowMask); narrowShuffleMaskElts(3, ArrayRef(WideMask), NarrowMask);
EXPECT_EQ(makeArrayRef(NarrowMask), makeArrayRef({6,7,8,0,1,2,-1,-1,-1})); EXPECT_EQ(ArrayRef(NarrowMask), ArrayRef({6, 7, 8, 0, 1, 2, -1, -1, -1}));
// groups of 3 must be consecutive/undef (partial undefs are not ok) // groups of 3 must be consecutive/undef (partial undefs are not ok)
EXPECT_FALSE(widenShuffleMaskElts(3, {-1,7,8,0,-1,2,-1,-1,-1}, WideMask)); EXPECT_FALSE(widenShuffleMaskElts(3, {-1,7,8,0,-1,2,-1,-1,-1}, WideMask));
Context not available.
// negative indexes must match across a wide element // negative indexes must match across a wide element
EXPECT_TRUE(widenShuffleMaskElts(2, {-2,-2,-3,-3}, WideMask)); EXPECT_TRUE(widenShuffleMaskElts(2, {-2,-2,-3,-3}, WideMask));
EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({-2,-3})); EXPECT_EQ(ArrayRef(WideMask), ArrayRef({-2, -3}));
} }
TEST_F(BasicTest, getShuffleMaskWithWidestElts) { TEST_F(BasicTest, getShuffleMaskWithWidestElts) {
Context not available.
// can not widen anything here. // can not widen anything here.
getShuffleMaskWithWidestElts({3, 2, 0, -1}, WideMask); getShuffleMaskWithWidestElts({3, 2, 0, -1}, WideMask);
EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({3, 2, 0, -1})); EXPECT_EQ(ArrayRef(WideMask), ArrayRef({3, 2, 0, -1}));
// can't widen non-consecutive 3/2 // can't widen non-consecutive 3/2
getShuffleMaskWithWidestElts({3, 2, 0, -1}, WideMask); getShuffleMaskWithWidestElts({3, 2, 0, -1}, WideMask);
EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({3, 2, 0, -1})); EXPECT_EQ(ArrayRef(WideMask), ArrayRef({3, 2, 0, -1}));
// can always widen identity to single element // can always widen identity to single element
getShuffleMaskWithWidestElts({0, 1, 2}, WideMask); getShuffleMaskWithWidestElts({0, 1, 2}, WideMask);
EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({0})); EXPECT_EQ(ArrayRef(WideMask), ArrayRef({0}));
// groups of 4 must be consecutive/undef // groups of 4 must be consecutive/undef
getShuffleMaskWithWidestElts( getShuffleMaskWithWidestElts(
{12, 13, 14, 15, 8, 9, 10, 11, 0, 1, 2, 3, -1, -1, -1, -1}, WideMask); {12, 13, 14, 15, 8, 9, 10, 11, 0, 1, 2, 3, -1, -1, -1, -1}, WideMask);
EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({3, 2, 0, -1})); EXPECT_EQ(ArrayRef(WideMask), ArrayRef({3, 2, 0, -1}));
// groups of 2 must be consecutive/undef // groups of 2 must be consecutive/undef
getShuffleMaskWithWidestElts( getShuffleMaskWithWidestElts(
{12, 12, 14, 15, 8, 9, 10, 11, 0, 1, 2, 3, -1, -1, -1, -1}, WideMask); {12, 12, 14, 15, 8, 9, 10, 11, 0, 1, 2, 3, -1, -1, -1, -1}, WideMask);
EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({12, 12, 14, 15, 8, 9, 10, 11, EXPECT_EQ(ArrayRef(WideMask), ArrayRef({12, 12, 14, 15, 8, 9, 10, 11, 0, 1, 2,
0, 1, 2, 3, -1, -1, -1, -1})); 3, -1, -1, -1, -1}));
// groups of 3 must be consecutive/undef // groups of 3 must be consecutive/undef
getShuffleMaskWithWidestElts({6, 7, 8, 0, 1, 2, -1, -1, -1}, WideMask); getShuffleMaskWithWidestElts({6, 7, 8, 0, 1, 2, -1, -1, -1}, WideMask);
EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({2, 0, -1})); EXPECT_EQ(ArrayRef(WideMask), ArrayRef({2, 0, -1}));
// groups of 3 must be consecutive/undef (partial undefs are not ok) // groups of 3 must be consecutive/undef (partial undefs are not ok)
getShuffleMaskWithWidestElts({-1, 7, 8, 0, -1, 2, -1, -1, -1}, WideMask); getShuffleMaskWithWidestElts({-1, 7, 8, 0, -1, 2, -1, -1, -1}, WideMask);
EXPECT_EQ(makeArrayRef(WideMask), EXPECT_EQ(ArrayRef(WideMask), ArrayRef({-1, 7, 8, 0, -1, 2, -1, -1, -1}));
makeArrayRef({-1, 7, 8, 0, -1, 2, -1, -1, -1}));
// negative indexes must match across a wide element // negative indexes must match across a wide element
getShuffleMaskWithWidestElts({-1, -2, -1, -1}, WideMask); getShuffleMaskWithWidestElts({-1, -2, -1, -1}, WideMask);
EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({-1, -2, -1, -1})); EXPECT_EQ(ArrayRef(WideMask), ArrayRef({-1, -2, -1, -1}));
// negative indexes must match across a wide element // negative indexes must match across a wide element
getShuffleMaskWithWidestElts({-2, -2, -3, -3}, WideMask); getShuffleMaskWithWidestElts({-2, -2, -3, -3}, WideMask);
EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({-2, -3})); EXPECT_EQ(ArrayRef(WideMask), ArrayRef({-2, -3}));
} }
TEST_F(BasicTest, getShuffleDemandedElts) { TEST_F(BasicTest, getShuffleDemandedElts) {
Context not available.

llvm/unittests/Bitstream/BitstreamReaderTest.cpp

Context not available.
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
AbbrevID = Stream.EmitAbbrev(std::move(Abbrev)); AbbrevID = Stream.EmitAbbrev(std::move(Abbrev));
unsigned Record[] = {RecordID}; unsigned Record[] = {RecordID};
Stream.EmitRecordWithBlob(AbbrevID, makeArrayRef(Record), BlobIn); Stream.EmitRecordWithBlob(AbbrevID, ArrayRef(Record), BlobIn);
Stream.ExitBlock(); Stream.ExitBlock();
} }
Context not available.

llvm/unittests/DebugInfo/MSF/MappedBlockStreamTest.cpp

Context not available.
MATCHER_P3(BlockIsFilledWith, Layout, BlockIndex, Byte, "succeeded") { MATCHER_P3(BlockIsFilledWith, Layout, BlockIndex, Byte, "succeeded") {
uint64_t Offset = msf::blockToOffset(BlockIndex, Layout.SB->BlockSize); uint64_t Offset = msf::blockToOffset(BlockIndex, Layout.SB->BlockSize);
ArrayRef<uint8_t> BufferRef = makeArrayRef(arg); ArrayRef<uint8_t> BufferRef = ArrayRef(arg);
BufferRef = BufferRef.slice(Offset, Layout.SB->BlockSize); BufferRef = BufferRef.slice(Offset, Layout.SB->BlockSize);
return llvm::all_of(BufferRef, [this](uint8_t B) { return B == Byte; }); return llvm::all_of(BufferRef, [this](uint8_t B) { return B == Byte; });
} }
Context not available.

llvm/unittests/FuzzMutate/RandomIRBuilderTest.cpp

Context not available.
// Choose an instruction and connect to later operations. // Choose an instruction and connect to later operations.
size_t IP = uniform<size_t>(IB.Rand, 1, Insts.size() - 1); size_t IP = uniform<size_t>(IB.Rand, 1, Insts.size() - 1);
Instruction *Inst = Insts[IP - 1]; Instruction *Inst = Insts[IP - 1];
auto ConnectAfter = makeArrayRef(Insts).slice(IP); auto ConnectAfter = ArrayRef(Insts).slice(IP);
IB.connectToSink(*BB, ConnectAfter, Inst); IB.connectToSink(*BB, ConnectAfter, Inst);
ASSERT_FALSE(verifyModule(*M, &errs())); ASSERT_FALSE(verifyModule(*M, &errs()));
} }
Context not available.

llvm/unittests/IR/AttributesTest.cpp

Context not available.
{ {
AttributeSet AS1 = AttributeSet::get( AttributeSet AS1 = AttributeSet::get(
C1, makeArrayRef(Attribute::get(C1, Attribute::NoReturn))); C1, ArrayRef(Attribute::get(C1, Attribute::NoReturn)));
AttributeSet AS2 = AttributeSet::get( AttributeSet AS2 = AttributeSet::get(
C2, makeArrayRef(Attribute::get(C2, Attribute::NoReturn))); C2, ArrayRef(Attribute::get(C2, Attribute::NoReturn)));
EXPECT_TRUE(AS1.hasParentContext(C1)); EXPECT_TRUE(AS1.hasParentContext(C1));
EXPECT_FALSE(AS1.hasParentContext(C2)); EXPECT_FALSE(AS1.hasParentContext(C2));
EXPECT_FALSE(AS2.hasParentContext(C1)); EXPECT_FALSE(AS2.hasParentContext(C1));
Context not available.

llvm/unittests/IR/DebugInfoTest.cpp

Context not available.
{ \ { \
SmallVector<DINode::DIFlags, 8> V; \ SmallVector<DINode::DIFlags, 8> V; \
EXPECT_EQ(REMAINDER, DINode::splitFlags(FLAGS, V)); \ EXPECT_EQ(REMAINDER, DINode::splitFlags(FLAGS, V)); \
EXPECT_TRUE(makeArrayRef(V).equals(VECTOR)); \ EXPECT_TRUE(ArrayRef(V).equals(VECTOR)); \
} }
CHECK_SPLIT(DINode::FlagPublic, {DINode::FlagPublic}, DINode::FlagZero); CHECK_SPLIT(DINode::FlagPublic, {DINode::FlagPublic}, DINode::FlagZero);
CHECK_SPLIT(DINode::FlagProtected, {DINode::FlagProtected}, DINode::FlagZero); CHECK_SPLIT(DINode::FlagProtected, {DINode::FlagProtected}, DINode::FlagZero);
Context not available.

llvm/unittests/IR/MetadataTest.cpp

Context not available.
TEST_F(DIExpressionTest, get) { TEST_F(DIExpressionTest, get) {
uint64_t Elements[] = {2, 6, 9, 78, 0}; uint64_t Elements[] = {2, 6, 9, 78, 0};
auto *N = DIExpression::get(Context, Elements); auto *N = DIExpression::get(Context, Elements);
EXPECT_EQ(makeArrayRef(Elements), N->getElements()); EXPECT_EQ(ArrayRef(Elements), N->getElements());
EXPECT_EQ(N, DIExpression::get(Context, Elements)); EXPECT_EQ(N, DIExpression::get(Context, Elements));
EXPECT_EQ(5u, N->getNumElements()); EXPECT_EQ(5u, N->getNumElements());
Context not available.

llvm/unittests/Object/ELFTypesTest.cpp

Context not available.
TEST(ELFTypesTest, NoteTest) { TEST(ELFTypesTest, NoteTest) {
static const uint8_t Random[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; static const uint8_t Random[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
ArrayRef<uint8_t> RandomData = makeArrayRef(Random); ArrayRef<uint8_t> RandomData = ArrayRef(Random);
NoteTestData<ELF64LE> TestData; NoteTestData<ELF64LE> TestData;
auto Note1 = TestData.getElfNote(StringRef("AMD"), ELF::NT_AMDGPU_METADATA, auto Note1 = TestData.getElfNote(StringRef("AMD"), ELF::NT_AMDGPU_METADATA,
Context not available.

llvm/unittests/ObjectYAML/MinidumpYAMLTest.cpp

Context not available.
EXPECT_EQ(OSPlatform::Linux, SysInfo.PlatformId); EXPECT_EQ(OSPlatform::Linux, SysInfo.PlatformId);
EXPECT_EQ( EXPECT_EQ(
(ArrayRef<uint8_t>{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}), (ArrayRef<uint8_t>{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}),
makeArrayRef(SysInfo.CPU.Other.ProcessorFeatures)); ArrayRef(SysInfo.CPU.Other.ProcessorFeatures));
} }
// Test that we can parse a normal-looking ExceptionStream. // Test that we can parse a normal-looking ExceptionStream.
Context not available.

llvm/unittests/ProfileData/CoverageMappingTest.cpp

Context not available.
Filenames.resize(Files.size() + 1); Filenames.resize(Files.size() + 1);
for (const auto &E : Files) for (const auto &E : Files)
Filenames[E.getValue()] = E.getKey().str(); Filenames[E.getValue()] = E.getKey().str();
ArrayRef<std::string> FilenameRefs = llvm::makeArrayRef(Filenames); ArrayRef<std::string> FilenameRefs = llvm::ArrayRef(Filenames);
RawCoverageMappingReader Reader(Coverage, FilenameRefs, Data.Filenames, RawCoverageMappingReader Reader(Coverage, FilenameRefs, Data.Filenames,
Data.Expressions, Data.Regions); Data.Expressions, Data.Regions);
EXPECT_THAT_ERROR(Reader.read(), Succeeded()); EXPECT_THAT_ERROR(Reader.read(), Succeeded());
Context not available.
InputFunctionCoverageData &Input = InputFunctions.back(); InputFunctionCoverageData &Input = InputFunctions.back();
OutputFunctionCoverageData &Output = OutputFunctions.back(); OutputFunctionCoverageData &Output = OutputFunctions.back();
size_t N = makeArrayRef(Input.Regions).size(); size_t N = ArrayRef(Input.Regions).size();
ASSERT_EQ(N, Output.Regions.size()); ASSERT_EQ(N, Output.Regions.size());
for (size_t I = 0; I < N; ++I) { for (size_t I = 0; I < N; ++I) {
ASSERT_EQ(Input.Regions[I].Count, Output.Regions[I].Count); ASSERT_EQ(Input.Regions[I].Count, Output.Regions[I].Count);
Context not available.

llvm/unittests/ProfileData/InstrProfTest.cpp

Context not available.
// Annotate with 4 records. // Annotate with 4 records.
InstrProfValueData VD0Sorted[] = {{1000, 6}, {2000, 5}, {3000, 4}, {4000, 3}, InstrProfValueData VD0Sorted[] = {{1000, 6}, {2000, 5}, {3000, 4}, {4000, 3},
{5000, 2}, {6000, 1}}; {5000, 2}, {6000, 1}};
annotateValueSite(*M, *Inst, makeArrayRef(VD0Sorted).slice(2), 10, annotateValueSite(*M, *Inst, ArrayRef(VD0Sorted).slice(2), 10,
IPVK_IndirectCallTarget, 5); IPVK_IndirectCallTarget, 5);
Res = getValueProfDataFromInst(*Inst, IPVK_IndirectCallTarget, 5, Res = getValueProfDataFromInst(*Inst, IPVK_IndirectCallTarget, 5,
ValueData, N, T); ValueData, N, T);
Context not available.

llvm/unittests/Remarks/YAMLRemarksSerializerTest.cpp

Context not available.
StringRef ExpectedR, StringRef ExpectedMeta, StringRef ExpectedR, StringRef ExpectedMeta,
std::optional<remarks::StringTable> StrTab = std::nullopt) { std::optional<remarks::StringTable> StrTab = std::nullopt) {
return check(SerializerFormat, remarks::SerializerMode::Separate, return check(SerializerFormat, remarks::SerializerMode::Separate,
makeArrayRef(&R, &R + 1), ExpectedR, ExpectedMeta, ArrayRef(&R, &R + 1), ExpectedR, ExpectedMeta,
std::move(StrTab)); std::move(StrTab));
} }
Context not available.
StringRef ExpectedR, StringRef ExpectedR,
std::optional<remarks::StringTable> StrTab = std::nullopt) { std::optional<remarks::StringTable> StrTab = std::nullopt) {
return check(SerializerFormat, remarks::SerializerMode::Standalone, return check(SerializerFormat, remarks::SerializerMode::Standalone,
makeArrayRef(&R, &R + 1), ExpectedR, ArrayRef(&R, &R + 1), ExpectedR,
/*ExpectedMeta=*/std::nullopt, std::move(StrTab)); /*ExpectedMeta=*/std::nullopt, std::move(StrTab));
} }
Context not available.

llvm/unittests/Support/BinaryStreamTest.cpp

Context not available.
uint8_t *Ptr = Allocator.Allocate<uint8_t>(Size); uint8_t *Ptr = Allocator.Allocate<uint8_t>(Size);
::memcpy(Ptr, Ref.data(), Ref.size()); ::memcpy(Ptr, Ref.data(), Ref.size());
::memcpy(Ptr + Ref.size(), Data.data(), BytesLeft); ::memcpy(Ptr + Ref.size(), Data.data(), BytesLeft);
Buffer = makeArrayRef<uint8_t>(Ptr, Size); Buffer = ArrayRef<uint8_t>(Ptr, Size);
return Error::success(); return Error::success();
} }
Context not available.
// 1. If the read fits it should work. // 1. If the read fits it should work.
ASSERT_EQ(InputData.size(), Stream.Input->getLength()); ASSERT_EQ(InputData.size(), Stream.Input->getLength());
ASSERT_THAT_ERROR(Stream.Input->readBytes(2, 1, Buffer), Succeeded()); ASSERT_THAT_ERROR(Stream.Input->readBytes(2, 1, Buffer), Succeeded());
EXPECT_EQ(makeArrayRef(InputData).slice(2, 1), Buffer); EXPECT_EQ(ArrayRef(InputData).slice(2, 1), Buffer);
ASSERT_THAT_ERROR(Stream.Input->readBytes(0, 4, Buffer), Succeeded()); ASSERT_THAT_ERROR(Stream.Input->readBytes(0, 4, Buffer), Succeeded());
EXPECT_EQ(makeArrayRef(InputData).slice(0, 4), Buffer); EXPECT_EQ(ArrayRef(InputData).slice(0, 4), Buffer);
// 2. Reading past the bounds of the input should fail. // 2. Reading past the bounds of the input should fail.
EXPECT_THAT_ERROR(Stream.Input->readBytes(4, 2, Buffer), Failed()); EXPECT_THAT_ERROR(Stream.Input->readBytes(4, 2, Buffer), Failed());
Context not available.
// Read 1 byte from offset 2 should work // Read 1 byte from offset 2 should work
ASSERT_EQ(InputData.size(), Ref.getLength()); ASSERT_EQ(InputData.size(), Ref.getLength());
ASSERT_THAT_ERROR(Ref.readBytes(2, 1, Buffer), Succeeded()); ASSERT_THAT_ERROR(Ref.readBytes(2, 1, Buffer), Succeeded());
EXPECT_EQ(makeArrayRef(InputData).slice(2, 1), Buffer); EXPECT_EQ(ArrayRef(InputData).slice(2, 1), Buffer);
// Reading everything from offset 2 on. // Reading everything from offset 2 on.
ASSERT_THAT_ERROR(Ref.readLongestContiguousChunk(2, Buffer), Succeeded()); ASSERT_THAT_ERROR(Ref.readLongestContiguousChunk(2, Buffer), Succeeded());
if (Stream.IsContiguous) if (Stream.IsContiguous)
EXPECT_EQ(makeArrayRef(InputData).slice(2), Buffer); EXPECT_EQ(ArrayRef(InputData).slice(2), Buffer);
else else
EXPECT_FALSE(Buffer.empty()); EXPECT_FALSE(Buffer.empty());
Context not available.
Ref = Ref.drop_front(1); Ref = Ref.drop_front(1);
ASSERT_THAT_ERROR(Ref.readBytes(2, 1, Buffer), Succeeded()); ASSERT_THAT_ERROR(Ref.readBytes(2, 1, Buffer), Succeeded());
if (Stream.IsContiguous) if (Stream.IsContiguous)
EXPECT_EQ(makeArrayRef(InputData).slice(3, 1), Buffer); EXPECT_EQ(ArrayRef(InputData).slice(3, 1), Buffer);
else else
EXPECT_FALSE(Buffer.empty()); EXPECT_FALSE(Buffer.empty());
// Reading everything from offset 2 on after dropping 1 byte. // Reading everything from offset 2 on after dropping 1 byte.
ASSERT_THAT_ERROR(Ref.readLongestContiguousChunk(2, Buffer), Succeeded()); ASSERT_THAT_ERROR(Ref.readLongestContiguousChunk(2, Buffer), Succeeded());
if (Stream.IsContiguous) if (Stream.IsContiguous)
EXPECT_EQ(makeArrayRef(InputData).slice(3), Buffer); EXPECT_EQ(ArrayRef(InputData).slice(3), Buffer);
else else
EXPECT_FALSE(Buffer.empty()); EXPECT_FALSE(Buffer.empty());
Context not available.
// But if we read the longest contiguous chunk instead, we should still // But if we read the longest contiguous chunk instead, we should still
// get the 1 byte at the end. // get the 1 byte at the end.
ASSERT_THAT_ERROR(Ref.readLongestContiguousChunk(2, Buffer), Succeeded()); ASSERT_THAT_ERROR(Ref.readLongestContiguousChunk(2, Buffer), Succeeded());
EXPECT_EQ(makeArrayRef(InputData).take_back(), Buffer); EXPECT_EQ(ArrayRef(InputData).take_back(), Buffer);
} }
} }
Context not available.
TEST_F(BinaryStreamTest, DropOperations) { TEST_F(BinaryStreamTest, DropOperations) {
std::vector<uint8_t> InputData = {1, 2, 3, 4, 5, 4, 3, 2, 1}; std::vector<uint8_t> InputData = {1, 2, 3, 4, 5, 4, 3, 2, 1};
auto RefData = makeArrayRef(InputData); auto RefData = ArrayRef(InputData);
initializeInput(InputData, 1); initializeInput(InputData, 1);
ArrayRef<uint8_t> Result; ArrayRef<uint8_t> Result;
Context not available.
ArrayRef<uint8_t> Data2; ArrayRef<uint8_t> Data2;
ASSERT_THAT_ERROR(Stream.Output->readBytes(Offset, ExpectedSize, Data2), ASSERT_THAT_ERROR(Stream.Output->readBytes(Offset, ExpectedSize, Data2),
Succeeded()); Succeeded());
EXPECT_EQ(makeArrayRef(InputData).drop_front(Offset), Data2); EXPECT_EQ(ArrayRef(InputData).drop_front(Offset), Data2);
} }
std::vector<uint8_t> BigData = {0, 1, 2, 3, 4}; std::vector<uint8_t> BigData = {0, 1, 2, 3, 4};
Context not available.
EXPECT_EQ(0U, Stream.getLength()); EXPECT_EQ(0U, Stream.getLength());
std::vector<uint8_t> InputData = {'T', 'e', 's', 't', 'T', 'e', 's', 't'}; std::vector<uint8_t> InputData = {'T', 'e', 's', 't', 'T', 'e', 's', 't'};
auto Test = makeArrayRef(InputData).take_front(4); auto Test = ArrayRef(InputData).take_front(4);
// Writing past the end of the stream is an error. // Writing past the end of the stream is an error.
EXPECT_THAT_ERROR(Stream.writeBytes(4, Test), Failed()); EXPECT_THAT_ERROR(Stream.writeBytes(4, Test), Failed());
Context not available.
ArrayRef<int> IntsRef; ArrayRef<int> IntsRef;
ASSERT_THAT_ERROR(Reader.readArray(IntsRef, Ints.size()), Succeeded()); ASSERT_THAT_ERROR(Reader.readArray(IntsRef, Ints.size()), Succeeded());
ASSERT_EQ(0U, Reader.bytesRemaining()); ASSERT_EQ(0U, Reader.bytesRemaining());
EXPECT_EQ(makeArrayRef(Ints), IntsRef); EXPECT_EQ(ArrayRef(Ints), IntsRef);
Reader.setOffset(0); Reader.setOffset(0);
FixedStreamArray<int> FixedIntsRef; FixedStreamArray<int> FixedIntsRef;
Context not available.
const uint8_t *Bytes = reinterpret_cast<const uint8_t *>(&Foos[0]); const uint8_t *Bytes = reinterpret_cast<const uint8_t *>(&Foos[0]);
initializeInput(makeArrayRef(Bytes, 3 * sizeof(Foo)), alignof(Foo)); initializeInput(ArrayRef(Bytes, 3 * sizeof(Foo)), alignof(Foo));
for (auto &Stream : Streams) { for (auto &Stream : Streams) {
// 1. Reading object pointers. // 1. Reading object pointers.
Context not available.
ASSERT_THAT_ERROR(ReaderBacker.readArray(Ints2, SourceInts.size()), ASSERT_THAT_ERROR(ReaderBacker.readArray(Ints2, SourceInts.size()),
Succeeded()); Succeeded());
EXPECT_EQ(makeArrayRef(SourceInts), Ints2); EXPECT_EQ(ArrayRef(SourceInts), Ints2);
} }
} }
Context not available.
ASSERT_THAT_ERROR(Reader.readCString(S), Succeeded()); ASSERT_THAT_ERROR(Reader.readCString(S), Succeeded());
InStrings.push_back(S); InStrings.push_back(S);
} }
EXPECT_EQ(makeArrayRef(Strings), makeArrayRef(InStrings)); EXPECT_EQ(ArrayRef(Strings), ArrayRef(InStrings));
} }
} }
Context not available.

llvm/unittests/Support/CRCTest.cpp

Context not available.
// Test expectation generated with: // Test expectation generated with:
// $ truncate --size=`echo 2^32-1+42 | bc` /tmp/foo // $ truncate --size=`echo 2^32-1+42 | bc` /tmp/foo
// $ crc32 /tmp/foo // $ crc32 /tmp/foo
EXPECT_EQ(0xE46F28FBU, llvm::crc32(makeArrayRef(TestData, TestSize))); EXPECT_EQ(0xE46F28FBU, llvm::crc32(ArrayRef(TestData, TestSize)));
free(TestData); free(TestData);
} }
Context not available.

llvm/unittests/Support/CommandLineTest.cpp

Context not available.
const cl::OptionCategory *VisibleCategories[] = {&TestCategory, const cl::OptionCategory *VisibleCategories[] = {&TestCategory,
&TestCategory2}; &TestCategory2};
cl::HideUnrelatedOptions(makeArrayRef(VisibleCategories)); cl::HideUnrelatedOptions(ArrayRef(VisibleCategories));
ASSERT_EQ(cl::ReallyHidden, TestOption1.getOptionHiddenFlag()) ASSERT_EQ(cl::ReallyHidden, TestOption1.getOptionHiddenFlag())
<< "Failed to hide extra option."; << "Failed to hide extra option.";
Context not available.

llvm/unittests/Support/ConvertUTFTest.cpp

Context not available.
TEST(ConvertUTFTest, OddLengthInput) { TEST(ConvertUTFTest, OddLengthInput) {
std::string Result; std::string Result;
bool Success = convertUTF16ToUTF8String(makeArrayRef("xxxxx", 5), Result); bool Success = convertUTF16ToUTF8String(ArrayRef("xxxxx", 5), Result);
EXPECT_FALSE(Success); EXPECT_FALSE(Success);
} }
Context not available.
} }
TEST(ConvertUTFTest, HasUTF16BOM) { TEST(ConvertUTFTest, HasUTF16BOM) {
bool HasBOM = hasUTF16ByteOrderMark(makeArrayRef("\xff\xfe", 2)); bool HasBOM = hasUTF16ByteOrderMark(ArrayRef("\xff\xfe", 2));
EXPECT_TRUE(HasBOM); EXPECT_TRUE(HasBOM);
HasBOM = hasUTF16ByteOrderMark(makeArrayRef("\xfe\xff", 2)); HasBOM = hasUTF16ByteOrderMark(ArrayRef("\xfe\xff", 2));
EXPECT_TRUE(HasBOM); EXPECT_TRUE(HasBOM);
HasBOM = hasUTF16ByteOrderMark(makeArrayRef("\xfe\xff ", 3)); HasBOM = hasUTF16ByteOrderMark(ArrayRef("\xfe\xff ", 3));
EXPECT_TRUE(HasBOM); // Don't care about odd lengths. EXPECT_TRUE(HasBOM); // Don't care about odd lengths.
HasBOM = hasUTF16ByteOrderMark(makeArrayRef("\xfe\xff\x00asdf", 6)); HasBOM = hasUTF16ByteOrderMark(ArrayRef("\xfe\xff\x00asdf", 6));
EXPECT_TRUE(HasBOM); EXPECT_TRUE(HasBOM);
HasBOM = hasUTF16ByteOrderMark(std::nullopt); HasBOM = hasUTF16ByteOrderMark(std::nullopt);
EXPECT_FALSE(HasBOM); EXPECT_FALSE(HasBOM);
HasBOM = hasUTF16ByteOrderMark(makeArrayRef("\xfe", 1)); HasBOM = hasUTF16ByteOrderMark(ArrayRef("\xfe", 1));
EXPECT_FALSE(HasBOM); EXPECT_FALSE(HasBOM);
} }
TEST(ConvertUTFTest, UTF16WrappersForConvertUTF16ToUTF8String) { TEST(ConvertUTFTest, UTF16WrappersForConvertUTF16ToUTF8String) {
// Src is the look of disapproval. // Src is the look of disapproval.
alignas(UTF16) static const char Src[] = "\xff\xfe\xa0\x0c_\x00\xa0\x0c"; alignas(UTF16) static const char Src[] = "\xff\xfe\xa0\x0c_\x00\xa0\x0c";
ArrayRef<UTF16> SrcRef = makeArrayRef((const UTF16 *)Src, 4); ArrayRef<UTF16> SrcRef = ArrayRef((const UTF16 *)Src, 4);
std::string Result; std::string Result;
bool Success = convertUTF16ToUTF8String(SrcRef, Result); bool Success = convertUTF16ToUTF8String(SrcRef, Result);
EXPECT_TRUE(Success); EXPECT_TRUE(Success);
Context not available.

llvm/unittests/Support/HashBuilderTest.cpp

Context not available.
constexpr auto E = HE::Endianness; constexpr auto E = HE::Endianness;
H Hasher; H Hasher;
auto SwappedData = llvm::support::endian::byte_swap(Data, E); auto SwappedData = llvm::support::endian::byte_swap(Data, E);
Hasher.update(llvm::makeArrayRef( Hasher.update(llvm::ArrayRef(
reinterpret_cast<const uint8_t *>(&SwappedData), sizeof(Data))); reinterpret_cast<const uint8_t *>(&SwappedData), sizeof(Data)));
return Hasher.final(); return Hasher.final();
}; };
Context not available.
friend void addHash(llvm::HashBuilderImpl<HasherT, Endianness> &HBuilder, friend void addHash(llvm::HashBuilderImpl<HasherT, Endianness> &HBuilder,
const StructWithFastHash &Value) { const StructWithFastHash &Value) {
if (Endianness == llvm::support::endian::system_endianness()) { if (Endianness == llvm::support::endian::system_endianness()) {
HBuilder.update(llvm::makeArrayRef( HBuilder.update(llvm::ArrayRef(reinterpret_cast<const uint8_t *>(&Value),
reinterpret_cast<const uint8_t *>(&Value), sizeof(Value))); sizeof(Value)));
} else { } else {
// Rely on existing `add` methods to handle endianness. // Rely on existing `add` methods to handle endianness.
HBuilder.add(Value.I); HBuilder.add(Value.I);
Context not available.
friend void addHash(llvm::HashBuilderImpl<HasherT, Endianness> &HBuilder, friend void addHash(llvm::HashBuilderImpl<HasherT, Endianness> &HBuilder,
const CustomContainer &Value) { const CustomContainer &Value) {
if (Endianness == llvm::support::endian::system_endianness()) { if (Endianness == llvm::support::endian::system_endianness()) {
HBuilder.update(llvm::makeArrayRef( HBuilder.update(llvm::ArrayRef(
reinterpret_cast<const uint8_t *>(&Value.Size), reinterpret_cast<const uint8_t *>(&Value.Size),
sizeof(Value.Size) + Value.Size * sizeof(Value.Elements[0]))); sizeof(Value.Size) + Value.Size * sizeof(Value.Elements[0])));
} else { } else {
Context not available.

llvm/unittests/Support/IndexedAccessorTest.cpp

Context not available.
namespace { namespace {
TEST(AccessorRange, SliceTest) { TEST(AccessorRange, SliceTest) {
int rawData[] = {0, 1, 2, 3, 4}; int rawData[] = {0, 1, 2, 3, 4};
ArrayRef<int> data = llvm::makeArrayRef(rawData); ArrayRef<int> data = llvm::ArrayRef(rawData);
ArrayIndexedAccessorRange<int> range(rawData, /*start=*/0, /*numElements=*/5); ArrayIndexedAccessorRange<int> range(rawData, /*start=*/0, /*numElements=*/5);
compareData(range, data); compareData(range, data);
Context not available.

llvm/unittests/Support/MD5Test.cpp

Context not available.
} }
TEST(MD5Test, MD5) { TEST(MD5Test, MD5) {
TestMD5Sum(makeArrayRef((const uint8_t *)"", (size_t) 0), TestMD5Sum(ArrayRef((const uint8_t *)"", (size_t)0),
"d41d8cd98f00b204e9800998ecf8427e"); "d41d8cd98f00b204e9800998ecf8427e");
TestMD5Sum(makeArrayRef((const uint8_t *)"a", (size_t) 1), TestMD5Sum(ArrayRef((const uint8_t *)"a", (size_t)1),
"0cc175b9c0f1b6a831c399e269772661"); "0cc175b9c0f1b6a831c399e269772661");
TestMD5Sum(makeArrayRef((const uint8_t *)"abcdefghijklmnopqrstuvwxyz", TestMD5Sum(
(size_t) 26), ArrayRef((const uint8_t *)"abcdefghijklmnopqrstuvwxyz", (size_t)26),
"c3fcd3d76192e4007dfb496cca67e13b"); "c3fcd3d76192e4007dfb496cca67e13b");
TestMD5Sum(makeArrayRef((const uint8_t *)"\0", (size_t) 1), TestMD5Sum(ArrayRef((const uint8_t *)"\0", (size_t)1),
"93b885adfe0da089cdf634904fd59f71"); "93b885adfe0da089cdf634904fd59f71");
TestMD5Sum(makeArrayRef((const uint8_t *)"a\0", (size_t) 2), TestMD5Sum(ArrayRef((const uint8_t *)"a\0", (size_t)2),
"4144e195f46de78a3623da7364d04f11"); "4144e195f46de78a3623da7364d04f11");
TestMD5Sum(makeArrayRef((const uint8_t *)"abcdefghijklmnopqrstuvwxyz\0", TestMD5Sum(
(size_t) 27), ArrayRef((const uint8_t *)"abcdefghijklmnopqrstuvwxyz\0", (size_t)27),
"81948d1f1554f58cd1a56ebb01f808cb"); "81948d1f1554f58cd1a56ebb01f808cb");
TestMD5Sum("abcdefghijklmnopqrstuvwxyz", "c3fcd3d76192e4007dfb496cca67e13b"); TestMD5Sum("abcdefghijklmnopqrstuvwxyz", "c3fcd3d76192e4007dfb496cca67e13b");
} }
Context not available.

llvm/unittests/Support/ScopedPrinterTest.cpp

Context not available.
{"Name3", "AltName3", 3}, {"Name3", "AltName3", 3},
{"Name4", "AltName4", 2}}; {"Name4", "AltName4", 2}};
EnumEntry<int> OtherEnum{"Name5", "AltName5", 5}; EnumEntry<int> OtherEnum{"Name5", "AltName5", 5};
W.printEnum("Exists", EnumList[1].Value, makeArrayRef(EnumList)); W.printEnum("Exists", EnumList[1].Value, ArrayRef(EnumList));
W.printEnum("DoesNotExist", OtherEnum.Value, makeArrayRef(EnumList)); W.printEnum("DoesNotExist", OtherEnum.Value, ArrayRef(EnumList));
}; };
const char *ExpectedOut = R"(Exists: Name2 (0x2) const char *ExpectedOut = R"(Exists: Name2 (0x2)
Context not available.
{"SecondByte2", "Second2", 0x20u}, {"SecondByte3", "Second3", 0x30u}, {"SecondByte2", "Second2", 0x20u}, {"SecondByte3", "Second3", 0x30u},
{"ThirdByte1", "Third1", 0x100u}, {"ThirdByte2", "Third2", 0x200u}, {"ThirdByte1", "Third1", 0x100u}, {"ThirdByte2", "Third2", 0x200u},
{"ThirdByte3", "Third3", 0x300u}}; {"ThirdByte3", "Third3", 0x300u}};
W.printFlags("ZeroFlag", 0, makeArrayRef(SingleBitFlags)); W.printFlags("ZeroFlag", 0, ArrayRef(SingleBitFlags));
W.printFlags("NoFlag", 1 << 3, makeArrayRef(SingleBitFlags)); W.printFlags("NoFlag", 1 << 3, ArrayRef(SingleBitFlags));
W.printFlags("Flag1", SingleBitFlags[1].Value, W.printFlags("Flag1", SingleBitFlags[1].Value, ArrayRef(SingleBitFlags));
makeArrayRef(SingleBitFlags)); W.printFlags("Flag1&3", (1 << 2) + 1, ArrayRef(SingleBitFlags));
W.printFlags("Flag1&3", (1 << 2) + 1, makeArrayRef(SingleBitFlags));
W.printFlags("ZeroFlagRaw", 0); W.printFlags("ZeroFlagRaw", 0);
W.printFlags("NoFlagRaw", 1 << 3); W.printFlags("NoFlagRaw", 1 << 3);
Context not available.
W.printFlags("Flag1&3Raw", (1 << 2) + 1); W.printFlags("Flag1&3Raw", (1 << 2) + 1);
W.printFlags("FlagSorted", (1 << 2) + (1 << 1) + 1, W.printFlags("FlagSorted", (1 << 2) + (1 << 1) + 1,
makeArrayRef(UnsortedFlags)); ArrayRef(UnsortedFlags));
uint16_t NoBitMask = 0; uint16_t NoBitMask = 0;
uint16_t FirstByteMask = 0xFu; uint16_t FirstByteMask = 0xFu;
uint16_t SecondByteMask = 0xF0u; uint16_t SecondByteMask = 0xF0u;
uint16_t ThirdByteMask = 0xF00u; uint16_t ThirdByteMask = 0xF00u;
W.printFlags("NoBitMask", 0xFFFu, makeArrayRef(EnumFlags), NoBitMask); W.printFlags("NoBitMask", 0xFFFu, ArrayRef(EnumFlags), NoBitMask);
W.printFlags("FirstByteMask", 0x3u, makeArrayRef(EnumFlags), FirstByteMask); W.printFlags("FirstByteMask", 0x3u, ArrayRef(EnumFlags), FirstByteMask);
W.printFlags("SecondByteMask", 0x30u, makeArrayRef(EnumFlags), W.printFlags("SecondByteMask", 0x30u, ArrayRef(EnumFlags), SecondByteMask);
SecondByteMask); W.printFlags("ValueOutsideMask", 0x1u, ArrayRef(EnumFlags), SecondByteMask);
W.printFlags("ValueOutsideMask", 0x1u, makeArrayRef(EnumFlags), W.printFlags("FirstSecondByteMask", 0xFFu, ArrayRef(EnumFlags),
SecondByteMask);
W.printFlags("FirstSecondByteMask", 0xFFu, makeArrayRef(EnumFlags),
FirstByteMask, SecondByteMask); FirstByteMask, SecondByteMask);
W.printFlags("FirstSecondThirdByteMask", 0x333u, makeArrayRef(EnumFlags), W.printFlags("FirstSecondThirdByteMask", 0x333u, ArrayRef(EnumFlags),
FirstByteMask, SecondByteMask, ThirdByteMask); FirstByteMask, SecondByteMask, ThirdByteMask);
}; };
Context not available.
APSInt("-9999999999999999999999")}; APSInt("-9999999999999999999999")};
W.printList("EmptyList", EmptyList); W.printList("EmptyList", EmptyList);
W.printList("StringList", StringList); W.printList("StringList", StringList);
W.printList("BoolList", makeArrayRef(BoolList)); W.printList("BoolList", ArrayRef(BoolList));
W.printList("uint64List", Unsigned64List); W.printList("uint64List", Unsigned64List);
W.printList("uint32List", Unsigned32List); W.printList("uint32List", Unsigned32List);
W.printList("uint16List", Unsigned16List); W.printList("uint16List", Unsigned16List);
Context not available.

llvm/unittests/Support/SourceMgrTest.cpp

Context not available.
TEST_F(SourceMgrTest, BasicFixit) { TEST_F(SourceMgrTest, BasicFixit) {
setMainBuffer("aaa bbb\nccc ddd\n", "file.in"); setMainBuffer("aaa bbb\nccc ddd\n", "file.in");
printMessage(getLoc(4), SourceMgr::DK_Error, "message", std::nullopt, printMessage(getLoc(4), SourceMgr::DK_Error, "message", std::nullopt,
makeArrayRef(SMFixIt(getRange(4, 3), "zzz"))); ArrayRef(SMFixIt(getRange(4, 3), "zzz")));
EXPECT_EQ("file.in:1:5: error: message\n" EXPECT_EQ("file.in:1:5: error: message\n"
"aaa bbb\n" "aaa bbb\n"
Context not available.
TEST_F(SourceMgrTest, FixitForTab) { TEST_F(SourceMgrTest, FixitForTab) {
setMainBuffer("aaa\tbbb\nccc ddd\n", "file.in"); setMainBuffer("aaa\tbbb\nccc ddd\n", "file.in");
printMessage(getLoc(3), SourceMgr::DK_Error, "message", std::nullopt, printMessage(getLoc(3), SourceMgr::DK_Error, "message", std::nullopt,
makeArrayRef(SMFixIt(getRange(3, 1), "zzz"))); ArrayRef(SMFixIt(getRange(3, 1), "zzz")));
EXPECT_EQ("file.in:1:4: error: message\n" EXPECT_EQ("file.in:1:4: error: message\n"
"aaa bbb\n" "aaa bbb\n"
Context not available.

llvm/unittests/TableGen/AutomataTest.cpp

Context not available.
#include "AutomataAutomata.inc" #include "AutomataAutomata.inc"
TEST(Automata, SimpleAutomatonAcceptsFromInitialState) { TEST(Automata, SimpleAutomatonAcceptsFromInitialState) {
Automaton<SymKind> A(makeArrayRef(SimpleAutomatonTransitions)); Automaton<SymKind> A{ArrayRef(SimpleAutomatonTransitions)};
EXPECT_TRUE(A.add(SK_a)); EXPECT_TRUE(A.add(SK_a));
A.reset(); A.reset();
EXPECT_TRUE(A.add(SK_b)); EXPECT_TRUE(A.add(SK_b));
Context not available.
} }
TEST(Automata, SimpleAutomatonAcceptsSequences) { TEST(Automata, SimpleAutomatonAcceptsSequences) {
Automaton<SymKind> A(makeArrayRef(SimpleAutomatonTransitions)); Automaton<SymKind> A{ArrayRef(SimpleAutomatonTransitions)};
// Test sequence <a b> // Test sequence <a b>
A.reset(); A.reset();
EXPECT_TRUE(A.add(SK_a)); EXPECT_TRUE(A.add(SK_a));
Context not available.
} }
TEST(Automata, TupleAutomatonAccepts) { TEST(Automata, TupleAutomatonAccepts) {
Automaton<TupleAutomatonAction> A(makeArrayRef(TupleAutomatonTransitions)); Automaton<TupleAutomatonAction> A{ArrayRef(TupleAutomatonTransitions)};
A.reset(); A.reset();
EXPECT_TRUE( EXPECT_TRUE(
A.add(TupleAutomatonAction{SK_a, SK_b, "yeet"})); A.add(TupleAutomatonAction{SK_a, SK_b, "yeet"}));
Context not available.
} }
TEST(Automata, NfaAutomatonAccepts) { TEST(Automata, NfaAutomatonAccepts) {
Automaton<SymKind> A(makeArrayRef(NfaAutomatonTransitions)); Automaton<SymKind> A{ArrayRef(NfaAutomatonTransitions)};
// Test sequences <a a>, <a b>, <b a>, <b b>. All should be accepted. // Test sequences <a a>, <a b>, <b a>, <b b>. All should be accepted.
A.reset(); A.reset();
Context not available.
} }
TEST(Automata, BinPackerAutomatonAccepts) { TEST(Automata, BinPackerAutomatonAccepts) {
Automaton<BinPackerAutomatonAction> A(makeArrayRef(BinPackerAutomatonTransitions)); Automaton<BinPackerAutomatonAction> A{
ArrayRef(BinPackerAutomatonTransitions)};
// Expect that we can pack two double-bins in 0-4, then no more in 0-4. // Expect that we can pack two double-bins in 0-4, then no more in 0-4.
A.reset(); A.reset();
Context not available.
((a << 5) | (b << 4) | (c << 3) | (d << 2) | (e << 1) | (f << 0)) ((a << 5) | (b << 4) | (c << 3) | (d << 2) | (e << 1) | (f << 0))
TEST(Automata, BinPackerAutomatonExplains) { TEST(Automata, BinPackerAutomatonExplains) {
Automaton<BinPackerAutomatonAction> A(makeArrayRef(BinPackerAutomatonTransitions), Automaton<BinPackerAutomatonAction> A{
makeArrayRef(BinPackerAutomatonTransitionInfo)); ArrayRef(BinPackerAutomatonTransitions),
ArrayRef(BinPackerAutomatonTransitionInfo)};
// Pack two double-bins in 0-4, then a single bin in 0-6. // Pack two double-bins in 0-4, then a single bin in 0-6.
EXPECT_TRUE(A.add(BRK_0_to_4_dbl)); EXPECT_TRUE(A.add(BRK_0_to_4_dbl));
EXPECT_TRUE(A.add(BRK_0_to_4_dbl)); EXPECT_TRUE(A.add(BRK_0_to_4_dbl));
Context not available.

llvm/unittests/Target/AArch64/AArch64InstPrinterTest.cpp

Context not available.
MCInstrInfo MII; MCInstrInfo MII;
MCRegisterInfo MRI; MCRegisterInfo MRI;
MCSubtargetInfo STI(Triple(""), "", "", "", MCSubtargetInfo STI(Triple(""), "", "", "",
makeArrayRef((SubtargetFeatureKV *)NULL, 0), ArrayRef((SubtargetFeatureKV *)NULL, 0),
makeArrayRef((SubtargetSubTypeKV *)NULL, 0), NULL, NULL, ArrayRef((SubtargetSubTypeKV *)NULL, 0), NULL, NULL, NULL,
NULL, NULL, NULL, NULL); NULL, NULL, NULL);
MCContext Ctx(Triple(""), &MAI, &MRI, &STI); MCContext Ctx(Triple(""), &MAI, &MRI, &STI);
MCInst MI; MCInst MI;
Context not available.

llvm/utils/TableGen/AsmWriterEmitter.cpp

Context not available.
O << "#endif\n\n"; O << "#endif\n\n";
O.indent(2) << "AliasMatchingData M {\n"; O.indent(2) << "AliasMatchingData M {\n";
O.indent(2) << " makeArrayRef(OpToPatterns),\n"; O.indent(2) << " ArrayRef(OpToPatterns),\n";
O.indent(2) << " makeArrayRef(Patterns),\n"; O.indent(2) << " ArrayRef(Patterns),\n";
O.indent(2) << " makeArrayRef(Conds),\n"; O.indent(2) << " ArrayRef(Conds),\n";
O.indent(2) << " StringRef(AsmStrings, std::size(AsmStrings)),\n"; O.indent(2) << " StringRef(AsmStrings, std::size(AsmStrings)),\n";
if (MCOpPredicates.empty()) if (MCOpPredicates.empty())
O.indent(2) << " nullptr,\n"; O.indent(2) << " nullptr,\n";
Context not available.

llvm/utils/TableGen/CodeEmitterGen.cpp

Context not available.
o << " const unsigned opcode = MI.getOpcode();\n" o << " const unsigned opcode = MI.getOpcode();\n"
<< " if (Scratch.getBitWidth() != " << BitWidth << ")\n" << " if (Scratch.getBitWidth() != " << BitWidth << ")\n"
<< " Scratch = Scratch.zext(" << BitWidth << ");\n" << " Scratch = Scratch.zext(" << BitWidth << ");\n"
<< " Inst = APInt(" << BitWidth << " Inst = APInt(" << BitWidth << ", ArrayRef(InstBits + opcode * "
<< ", makeArrayRef(InstBits + opcode * " << NumWords << ", " << NumWords << NumWords << ", " << NumWords << "));\n"
<< "));\n"
<< " APInt &Value = Inst;\n" << " APInt &Value = Inst;\n"
<< " APInt &op = Scratch;\n" << " APInt &op = Scratch;\n"
<< " switch (opcode) {\n"; << " switch (opcode) {\n";
Context not available.

llvm/utils/TableGen/CodeGenRegisters.h

Context not available.
const RegUnitList &getRegUnits() const { return RegUnits; } const RegUnitList &getRegUnits() const { return RegUnits; }
ArrayRef<LaneBitmask> getRegUnitLaneMasks() const { ArrayRef<LaneBitmask> getRegUnitLaneMasks() const {
return makeArrayRef(RegUnitLaneMasks).slice(0, NativeRegUnits.count()); return ArrayRef(RegUnitLaneMasks).slice(0, NativeRegUnits.count());
} }
// Get the native register units. This is a prefix of getRegUnits(). // Get the native register units. This is a prefix of getRegUnits().
Context not available.
ArrayRef<const CodeGenRegister*> getRoots() const { ArrayRef<const CodeGenRegister*> getRoots() const {
assert(!(Roots[1] && !Roots[0]) && "Invalid roots array"); assert(!(Roots[1] && !Roots[0]) && "Invalid roots array");
return makeArrayRef(Roots, !!Roots[0] + !!Roots[1]); return ArrayRef(Roots, !!Roots[0] + !!Roots[1]);
} }
}; };
Context not available.

llvm/utils/TableGen/CodeGenSchedule.h

Context not available.
bool isKeyEqual(Record *IC, ArrayRef<unsigned> W, bool isKeyEqual(Record *IC, ArrayRef<unsigned> W,
ArrayRef<unsigned> R) const { ArrayRef<unsigned> R) const {
return ItinClassDef == IC && makeArrayRef(Writes) == W && return ItinClassDef == IC && ArrayRef(Writes) == W && ArrayRef(Reads) == R;
makeArrayRef(Reads) == R;
} }
// Is this class generated from a variants if existing classes? Instructions // Is this class generated from a variants if existing classes? Instructions
Context not available.

llvm/utils/TableGen/CodeGenSchedule.cpp

Context not available.
std::vector<CodeGenSchedRW> &RWVec = IsRead ? SchedReads : SchedWrites; std::vector<CodeGenSchedRW> &RWVec = IsRead ? SchedReads : SchedWrites;
auto I = find_if(RWVec, [Seq](CodeGenSchedRW &RW) { auto I = find_if(RWVec, [Seq](CodeGenSchedRW &RW) {
return makeArrayRef(RW.Sequence) == Seq; return ArrayRef(RW.Sequence) == Seq;
}); });
// Index zero reserved for invalid RW. // Index zero reserved for invalid RW.
return I == RWVec.end() ? 0 : std::distance(RWVec.begin(), I); return I == RWVec.end() ? 0 : std::distance(RWVec.begin(), I);
Context not available.

llvm/utils/TableGen/GlobalISelEmitter.cpp

Context not available.
// Treat G_BUILD_VECTOR as the canonical opcode, and G_BUILD_VECTOR_TRUNC // Treat G_BUILD_VECTOR as the canonical opcode, and G_BUILD_VECTOR_TRUNC
// as an alternative. // as an alternative.
InsnOperand.getInsnMatcher().addPredicate<InstructionOpcodeMatcher>( InsnOperand.getInsnMatcher().addPredicate<InstructionOpcodeMatcher>(
makeArrayRef({&BuildVector, &BuildVectorTrunc})); ArrayRef({&BuildVector, &BuildVectorTrunc}));
// TODO: Handle both G_BUILD_VECTOR and G_BUILD_VECTOR_TRUNC We could // TODO: Handle both G_BUILD_VECTOR and G_BUILD_VECTOR_TRUNC We could
// theoretically not emit any opcode check, but getOpcodeMatcher currently // theoretically not emit any opcode check, but getOpcodeMatcher currently
Context not available.

llvm/utils/TableGen/IntrinsicEmitter.cpp

Context not available.
OS << " }\n"; OS << " }\n";
OS << " }\n"; OS << " }\n";
OS << " return AttributeList::get(C, makeArrayRef(AS, NumAttrs));\n"; OS << " return AttributeList::get(C, ArrayRef(AS, NumAttrs));\n";
OS << "}\n"; OS << "}\n";
OS << "#endif // GET_INTRINSIC_ATTRIBUTES\n\n"; OS << "#endif // GET_INTRINSIC_ATTRIBUTES\n\n";
} }
Context not available.

llvm/utils/TableGen/PseudoLoweringEmitter.cpp

Context not available.
void PseudoLoweringEmitter::run(raw_ostream &o) { void PseudoLoweringEmitter::run(raw_ostream &o) {
StringRef Classes[] = {"PseudoInstExpansion", "Instruction"}; StringRef Classes[] = {"PseudoInstExpansion", "Instruction"};
std::vector<Record *> Insts = std::vector<Record *> Insts =
Records.getAllDerivedDefinitions(makeArrayRef(Classes)); Records.getAllDerivedDefinitions(ArrayRef(Classes));
// Process the pseudo expansion definitions, validating them as we do so. // Process the pseudo expansion definitions, validating them as we do so.
Records.startTimer("Process definitions"); Records.startTimer("Process definitions");
Context not available.

llvm/utils/TableGen/RegisterInfoEmitter.cpp

Context not available.
OS << " const MCRegisterClass &MCR = " << Target.getName() OS << " const MCRegisterClass &MCR = " << Target.getName()
<< "MCRegisterClasses[" << RC.getQualifiedName() + "RegClassID];\n" << "MCRegisterClasses[" << RC.getQualifiedName() + "RegClassID];\n"
<< " const ArrayRef<MCPhysReg> Order[] = {\n" << " const ArrayRef<MCPhysReg> Order[] = {\n"
<< " makeArrayRef(MCR.begin(), MCR.getNumRegs()"; << " ArrayRef(MCR.begin(), MCR.getNumRegs()";
for (unsigned oi = 1, oe = RC.getNumOrders(); oi != oe; ++oi) for (unsigned oi = 1, oe = RC.getNumOrders(); oi != oe; ++oi)
if (RC.getOrder(oi).empty()) if (RC.getOrder(oi).empty())
OS << "),\n ArrayRef<MCPhysReg>("; OS << "),\n ArrayRef<MCPhysReg>(";
else else
OS << "),\n makeArrayRef(AltOrder" << oi; OS << "),\n ArrayRef(AltOrder" << oi;
OS << ")\n };\n const unsigned Select = " << RC.getName() OS << ")\n };\n const unsigned Select = " << RC.getName()
<< "AltOrderSelect(MF);\n assert(Select < " << RC.getNumOrders() << "AltOrderSelect(MF);\n assert(Select < " << RC.getNumOrders()
<< ");\n return Order[Select];\n}\n"; << ");\n return Order[Select];\n}\n";
Context not available.
for (Record *CSRSet : CSRSets) for (Record *CSRSet : CSRSets)
OS << " " << CSRSet->getName() << "_RegMask,\n"; OS << " " << CSRSet->getName() << "_RegMask,\n";
OS << " };\n"; OS << " };\n";
OS << " return makeArrayRef(Masks);\n"; OS << " return ArrayRef(Masks);\n";
} else { } else {
OS << " return std::nullopt;\n"; OS << " return std::nullopt;\n";
} }
Context not available.
for (Record *CSRSet : CSRSets) for (Record *CSRSet : CSRSets)
OS << " " << '"' << CSRSet->getName() << '"' << ",\n"; OS << " " << '"' << CSRSet->getName() << '"' << ",\n";
OS << " };\n"; OS << " };\n";
OS << " return makeArrayRef(Names);\n"; OS << " return ArrayRef(Names);\n";
} else { } else {
OS << " return std::nullopt;\n"; OS << " return std::nullopt;\n";
} }
Context not available.

llvm/utils/TableGen/SearchableTableEmitter.cpp

Context not available.
} }
if (IsContiguous) { if (IsContiguous) {
OS << " auto Table = makeArrayRef(" << IndexName << ");\n"; OS << " auto Table = ArrayRef(" << IndexName << ");\n";
OS << " size_t Idx = " << Index.Fields[0].Name << ";\n"; OS << " size_t Idx = " << Index.Fields[0].Name << ";\n";
OS << " return Idx >= Table.size() ? nullptr : "; OS << " return Idx >= Table.size() ? nullptr : ";
if (IsPrimary) if (IsPrimary)
Context not available.
} }
OS << "};\n"; OS << "};\n";
OS << " auto Table = makeArrayRef(" << IndexName << ");\n"; OS << " auto Table = ArrayRef(" << IndexName << ");\n";
OS << " auto Idx = std::lower_bound(Table.begin(), Table.end(), Key,\n"; OS << " auto Idx = std::lower_bound(Table.begin(), Table.end(), Key,\n";
OS << " [](const " << IndexTypeName << " &LHS, const KeyType &RHS) {\n"; OS << " [](const " << IndexTypeName << " &LHS, const KeyType &RHS) {\n";
Context not available.

llvm/utils/TableGen/SubtargetEmitter.cpp

Context not available.
<< "StringRef TuneCPU, StringRef FS)\n" << "StringRef TuneCPU, StringRef FS)\n"
<< " : TargetSubtargetInfo(TT, CPU, TuneCPU, FS, "; << " : TargetSubtargetInfo(TT, CPU, TuneCPU, FS, ";
if (NumFeatures) if (NumFeatures)
OS << "makeArrayRef(" << Target << "FeatureKV, " << NumFeatures << "), "; OS << "ArrayRef(" << Target << "FeatureKV, " << NumFeatures << "), ";
else else
OS << "std::nullopt, "; OS << "std::nullopt, ";
if (NumProcs) if (NumProcs)
OS << "makeArrayRef(" << Target << "SubTypeKV, " << NumProcs << "), "; OS << "ArrayRef(" << Target << "SubTypeKV, " << NumProcs << "), ";
else else
OS << "None, "; OS << "None, ";
OS << '\n'; OS.indent(24); OS << '\n'; OS.indent(24);
Context not available.

mlir/examples/toy/Ch2/mlir/MLIRGen.cpp

Context not available.
using llvm::cast; using llvm::cast;
using llvm::dyn_cast; using llvm::dyn_cast;
using llvm::isa; using llvm::isa;
using llvm::makeArrayRef;
using llvm::ScopedHashTableScope; using llvm::ScopedHashTableScope;
using llvm::SmallVector; using llvm::SmallVector;
using llvm::StringRef; using llvm::StringRef;
Context not available.
} }
// Otherwise, this return operation has zero operands. // Otherwise, this return operation has zero operands.
builder.create<ReturnOp>(location, expr ? makeArrayRef(expr) builder.create<ReturnOp>(location,
: ArrayRef<mlir::Value>()); expr ? ArrayRef(expr) : ArrayRef<mlir::Value>());
return mlir::success(); return mlir::success();
} }
Context not available.
// This is the actual attribute that holds the list of values for this // This is the actual attribute that holds the list of values for this
// tensor literal. // tensor literal.
auto dataAttribute = auto dataAttribute =
mlir::DenseElementsAttr::get(dataType, llvm::makeArrayRef(data)); mlir::DenseElementsAttr::get(dataType, llvm::ArrayRef(data));
// Build the MLIR op `toy.constant`. This invokes the `ConstantOp::build` // Build the MLIR op `toy.constant`. This invokes the `ConstantOp::build`
// method. // method.
Context not available.

mlir/examples/toy/Ch3/mlir/MLIRGen.cpp

Context not available.
using llvm::cast; using llvm::cast;
using llvm::dyn_cast; using llvm::dyn_cast;
using llvm::isa; using llvm::isa;
using llvm::makeArrayRef;
using llvm::ScopedHashTableScope; using llvm::ScopedHashTableScope;
using llvm::SmallVector; using llvm::SmallVector;
using llvm::StringRef; using llvm::StringRef;
Context not available.
} }
// Otherwise, this return operation has zero operands. // Otherwise, this return operation has zero operands.
builder.create<ReturnOp>(location, expr ? makeArrayRef(expr) builder.create<ReturnOp>(location,
: ArrayRef<mlir::Value>()); expr ? ArrayRef(expr) : ArrayRef<mlir::Value>());
return mlir::success(); return mlir::success();
} }
Context not available.
// This is the actual attribute that holds the list of values for this // This is the actual attribute that holds the list of values for this
// tensor literal. // tensor literal.
auto dataAttribute = auto dataAttribute =
mlir::DenseElementsAttr::get(dataType, llvm::makeArrayRef(data)); mlir::DenseElementsAttr::get(dataType, llvm::ArrayRef(data));
// Build the MLIR op `toy.constant`. This invokes the `ConstantOp::build` // Build the MLIR op `toy.constant`. This invokes the `ConstantOp::build`
// method. // method.
Context not available.

mlir/examples/toy/Ch4/mlir/MLIRGen.cpp

Context not available.
using llvm::cast; using llvm::cast;
using llvm::dyn_cast; using llvm::dyn_cast;
using llvm::isa; using llvm::isa;
using llvm::makeArrayRef;
using llvm::ScopedHashTableScope; using llvm::ScopedHashTableScope;
using llvm::SmallVector; using llvm::SmallVector;
using llvm::StringRef; using llvm::StringRef;
Context not available.
} }
// Otherwise, this return operation has zero operands. // Otherwise, this return operation has zero operands.
builder.create<ReturnOp>(location, expr ? makeArrayRef(expr) builder.create<ReturnOp>(location,
: ArrayRef<mlir::Value>()); expr ? ArrayRef(expr) : ArrayRef<mlir::Value>());
return mlir::success(); return mlir::success();
} }
Context not available.
// This is the actual attribute that holds the list of values for this // This is the actual attribute that holds the list of values for this
// tensor literal. // tensor literal.
auto dataAttribute = auto dataAttribute =
mlir::DenseElementsAttr::get(dataType, llvm::makeArrayRef(data)); mlir::DenseElementsAttr::get(dataType, llvm::ArrayRef(data));
// Build the MLIR op `toy.constant`. This invokes the `ConstantOp::build` // Build the MLIR op `toy.constant`. This invokes the `ConstantOp::build`
// method. // method.
Context not available.

mlir/examples/toy/Ch5/mlir/LowerToAffineLoops.cpp

Context not available.
if (dimension == valueShape.size()) { if (dimension == valueShape.size()) {
rewriter.create<AffineStoreOp>( rewriter.create<AffineStoreOp>(
loc, rewriter.create<arith::ConstantOp>(loc, *valueIt++), alloc, loc, rewriter.create<arith::ConstantOp>(loc, *valueIt++), alloc,
llvm::makeArrayRef(indices)); llvm::ArrayRef(indices));
return; return;
} }
Context not available.

mlir/examples/toy/Ch5/mlir/MLIRGen.cpp

Context not available.
using llvm::cast; using llvm::cast;
using llvm::dyn_cast; using llvm::dyn_cast;
using llvm::isa; using llvm::isa;
using llvm::makeArrayRef;
using llvm::ScopedHashTableScope; using llvm::ScopedHashTableScope;
using llvm::SmallVector; using llvm::SmallVector;
using llvm::StringRef; using llvm::StringRef;
Context not available.
} }
// Otherwise, this return operation has zero operands. // Otherwise, this return operation has zero operands.
builder.create<ReturnOp>(location, expr ? makeArrayRef(expr) builder.create<ReturnOp>(location,
: ArrayRef<mlir::Value>()); expr ? ArrayRef(expr) : ArrayRef<mlir::Value>());
return mlir::success(); return mlir::success();
} }
Context not available.
// This is the actual attribute that holds the list of values for this // This is the actual attribute that holds the list of values for this
// tensor literal. // tensor literal.
auto dataAttribute = auto dataAttribute =
mlir::DenseElementsAttr::get(dataType, llvm::makeArrayRef(data)); mlir::DenseElementsAttr::get(dataType, llvm::ArrayRef(data));
// Build the MLIR op `toy.constant`. This invokes the `ConstantOp::build` // Build the MLIR op `toy.constant`. This invokes the `ConstantOp::build`
// method. // method.
Context not available.

mlir/examples/toy/Ch6/mlir/LowerToAffineLoops.cpp

Context not available.
if (dimension == valueShape.size()) { if (dimension == valueShape.size()) {
rewriter.create<AffineStoreOp>( rewriter.create<AffineStoreOp>(
loc, rewriter.create<arith::ConstantOp>(loc, *valueIt++), alloc, loc, rewriter.create<arith::ConstantOp>(loc, *valueIt++), alloc,
llvm::makeArrayRef(indices)); llvm::ArrayRef(indices));
return; return;
} }
Context not available.

mlir/examples/toy/Ch6/mlir/MLIRGen.cpp

Context not available.
using llvm::cast; using llvm::cast;
using llvm::dyn_cast; using llvm::dyn_cast;
using llvm::isa; using llvm::isa;
using llvm::makeArrayRef;
using llvm::ScopedHashTableScope; using llvm::ScopedHashTableScope;
using llvm::SmallVector; using llvm::SmallVector;
using llvm::StringRef; using llvm::StringRef;
Context not available.
} }
// Otherwise, this return operation has zero operands. // Otherwise, this return operation has zero operands.
builder.create<ReturnOp>(location, expr ? makeArrayRef(expr) builder.create<ReturnOp>(location,
: ArrayRef<mlir::Value>()); expr ? ArrayRef(expr) : ArrayRef<mlir::Value>());
return mlir::success(); return mlir::success();
} }
Context not available.
// This is the actual attribute that holds the list of values for this // This is the actual attribute that holds the list of values for this
// tensor literal. // tensor literal.
auto dataAttribute = auto dataAttribute =
mlir::DenseElementsAttr::get(dataType, llvm::makeArrayRef(data)); mlir::DenseElementsAttr::get(dataType, llvm::ArrayRef(data));
// Build the MLIR op `toy.constant`. This invokes the `ConstantOp::build` // Build the MLIR op `toy.constant`. This invokes the `ConstantOp::build`
// method. // method.
Context not available.

mlir/examples/toy/Ch7/mlir/LowerToAffineLoops.cpp

Context not available.
if (dimension == valueShape.size()) { if (dimension == valueShape.size()) {
rewriter.create<AffineStoreOp>( rewriter.create<AffineStoreOp>(
loc, rewriter.create<arith::ConstantOp>(loc, *valueIt++), alloc, loc, rewriter.create<arith::ConstantOp>(loc, *valueIt++), alloc,
llvm::makeArrayRef(indices)); llvm::ArrayRef(indices));
return; return;
} }
Context not available.

mlir/examples/toy/Ch7/mlir/MLIRGen.cpp

Context not available.
using llvm::cast; using llvm::cast;
using llvm::dyn_cast; using llvm::dyn_cast;
using llvm::isa; using llvm::isa;
using llvm::makeArrayRef;
using llvm::ScopedHashTableScope; using llvm::ScopedHashTableScope;
using llvm::SmallVector; using llvm::SmallVector;
using llvm::StringRef; using llvm::StringRef;
Context not available.
} }
// Otherwise, this return operation has zero operands. // Otherwise, this return operation has zero operands.
builder.create<ReturnOp>(location, expr ? makeArrayRef(expr) builder.create<ReturnOp>(location,
: ArrayRef<mlir::Value>()); expr ? ArrayRef(expr) : ArrayRef<mlir::Value>());
return mlir::success(); return mlir::success();
} }
Context not available.
// This is the actual attribute that holds the list of values for this // This is the actual attribute that holds the list of values for this
// tensor literal. // tensor literal.
return mlir::DenseElementsAttr::get(dataType, llvm::makeArrayRef(data)); return mlir::DenseElementsAttr::get(dataType, llvm::ArrayRef(data));
} }
mlir::DenseElementsAttr getConstantAttr(NumberExprAST &lit) { mlir::DenseElementsAttr getConstantAttr(NumberExprAST &lit) {
// The type of this attribute is tensor of 64-bit floating-point with no // The type of this attribute is tensor of 64-bit floating-point with no
Context not available.
// This is the actual attribute that holds the list of values for this // This is the actual attribute that holds the list of values for this
// tensor literal. // tensor literal.
return mlir::DenseElementsAttr::get(dataType, return mlir::DenseElementsAttr::get(dataType,
llvm::makeArrayRef(lit.getValue())); llvm::ArrayRef(lit.getValue()));
} }
/// Emit a constant for a struct literal. It will be emitted as an array of /// Emit a constant for a struct literal. It will be emitted as an array of
/// other literals in an Attribute attached to a `toy.struct_constant` /// other literals in an Attribute attached to a `toy.struct_constant`
Context not available.

mlir/include/mlir/Dialect/Shape/IR/ShapeOps.td

Context not available.
let builders = [OpBuilder<(ins "::mlir::Type":$result, let builders = [OpBuilder<(ins "::mlir::Type":$result,
"::mlir::Value":$lhs, "::mlir::Value":$rhs, "::mlir::Value":$lhs, "::mlir::Value":$rhs,
"/*optional*/ ::mlir::StringAttr":$error), [{ "/*optional*/ ::mlir::StringAttr":$error), [{
build($_builder, $_state, result, ::llvm::makeArrayRef({lhs, rhs}), error); build($_builder, $_state, result, ::llvm::ArrayRef({lhs, rhs}), error);
}]> }]>
]; ];
Context not available.
// Convenience builder alias for the binary version. // Convenience builder alias for the binary version.
let builders = [ let builders = [
OpBuilder<(ins "::mlir::Value":$lhs, "::mlir::Value":$rhs), OpBuilder<(ins "::mlir::Value":$lhs, "::mlir::Value":$rhs),
[{ build($_builder, $_state, ::llvm::makeArrayRef({lhs, rhs})); }]>, [{ build($_builder, $_state, ::llvm::ArrayRef({lhs, rhs})); }]>,
]; ];
let assemblyFormat = "$shapes attr-dict `:` type($shapes)"; let assemblyFormat = "$shapes attr-dict `:` type($shapes)";
Context not available.
let builders = [ let builders = [
OpBuilder<(ins "::mlir::Value":$lhs, "::mlir::Value":$rhs), OpBuilder<(ins "::mlir::Value":$lhs, "::mlir::Value":$rhs),
[{ build($_builder, $_state, ::llvm::makeArrayRef({lhs, rhs})); }]>, [{ build($_builder, $_state, ::llvm::ArrayRef({lhs, rhs})); }]>,
]; ];
let hasFolder = 1; let hasFolder = 1;
Context not available.
let builders = [ let builders = [
OpBuilder<(ins "::mlir::Value":$lhs, "::mlir::Value":$rhs), OpBuilder<(ins "::mlir::Value":$lhs, "::mlir::Value":$rhs),
[{ build($_builder, $_state, ::llvm::makeArrayRef({lhs, rhs})); }]>, [{ build($_builder, $_state, ::llvm::ArrayRef({lhs, rhs})); }]>,
]; ];
let hasCanonicalizer = 1; let hasCanonicalizer = 1;
Context not available.

mlir/include/mlir/Dialect/Tosa/Utils/ShapeUtils.h

Context not available.
Type getType() const { Type getType() const {
if (hasRank) if (hasRank)
return RankedTensorType::get(llvm::makeArrayRef(sizes), dtype); return RankedTensorType::get(llvm::ArrayRef(sizes), dtype);
return UnrankedTensorType::get(dtype); return UnrankedTensorType::get(dtype);
} }
Context not available.

mlir/include/mlir/IR/AsmState.h

Context not available.
/// known to be of the correct type. /// known to be of the correct type.
template <typename T> template <typename T>
ArrayRef<T> getDataAs() const { ArrayRef<T> getDataAs() const {
return llvm::makeArrayRef<T>((const T *)data.data(), return llvm::ArrayRef<T>((const T *)data.data(), data.size() / sizeof(T));
data.size() / sizeof(T));
} }
/// Return a mutable reference to the raw underlying data of this blob. /// Return a mutable reference to the raw underlying data of this blob.
Context not available.

mlir/include/mlir/IR/AttrTypeBase.td

Context not available.
OptionalParameter<"::llvm::ArrayRef<" # arrayOf # ">", desc> { OptionalParameter<"::llvm::ArrayRef<" # arrayOf # ">", desc> {
let allocator = [{$_dst = $_allocator.copyInto($_self);}]; let allocator = [{$_dst = $_allocator.copyInto($_self);}];
let cppStorageType = "::llvm::SmallVector<" # arrayOf # ">"; let cppStorageType = "::llvm::SmallVector<" # arrayOf # ">";
let comparator = "::llvm::makeArrayRef($_lhs) == ::llvm::makeArrayRef($_rhs)"; let comparator = "::llvm::ArrayRef($_lhs) == ::llvm::ArrayRef($_rhs)";
} }
// For classes which require allocation and have their own allocateInto method. // For classes which require allocation and have their own allocateInto method.
Context not available.

mlir/include/mlir/IR/BuiltinAttributes.h

Context not available.
is_valid_cpp_fp_type<T>::value || is_valid_cpp_fp_type<T>::value ||
detail::is_complex_t<T>::value>> detail::is_complex_t<T>::value>>
static DenseElementsAttr get(const ShapedType &type, T value) { static DenseElementsAttr get(const ShapedType &type, T value) {
return get(type, llvm::makeArrayRef(value)); return get(type, llvm::ArrayRef(value));
} }
/// Constructs a dense complex elements attribute from an array of complex /// Constructs a dense complex elements attribute from an array of complex
Context not available.
/// simply wraps the DenseElementsAttr::get calls. /// simply wraps the DenseElementsAttr::get calls.
template <typename Arg> template <typename Arg>
static DenseFPElementsAttr get(const ShapedType &type, Arg &&arg) { static DenseFPElementsAttr get(const ShapedType &type, Arg &&arg) {
return DenseElementsAttr::get(type, llvm::makeArrayRef(arg)) return DenseElementsAttr::get(type, llvm::ArrayRef(arg))
.template cast<DenseFPElementsAttr>(); .template cast<DenseFPElementsAttr>();
} }
template <typename T> template <typename T>
Context not available.
/// simply wraps the DenseElementsAttr::get calls. /// simply wraps the DenseElementsAttr::get calls.
template <typename Arg> template <typename Arg>
static DenseIntElementsAttr get(const ShapedType &type, Arg &&arg) { static DenseIntElementsAttr get(const ShapedType &type, Arg &&arg) {
return DenseElementsAttr::get(type, llvm::makeArrayRef(arg)) return DenseElementsAttr::get(type, llvm::ArrayRef(arg))
.template cast<DenseIntElementsAttr>(); .template cast<DenseIntElementsAttr>();
} }
template <typename T> template <typename T>
Context not available.

mlir/include/mlir/IR/OpBase.td

Context not available.
let constBuilderCall = "::mlir::DenseElementsAttr::get(" let constBuilderCall = "::mlir::DenseElementsAttr::get("
"::mlir::RankedTensorType::get({}, " "::mlir::RankedTensorType::get({}, "
"$_builder.getIntegerType(" # width # ")), " "$_builder.getIntegerType(" # width # ")), "
"::llvm::makeArrayRef($0)).cast<::mlir::DenseIntElementsAttr>()"; "::llvm::ArrayRef($0)).cast<::mlir::DenseIntElementsAttr>()";
} }
def I32ElementsAttr : SignlessIntElementsAttr<32>; def I32ElementsAttr : SignlessIntElementsAttr<32>;
Context not available.
let constBuilderCall = "::mlir::DenseIntElementsAttr::get(" let constBuilderCall = "::mlir::DenseIntElementsAttr::get("
"::mlir::RankedTensorType::get({" # !interleave(dims, ", ") # "::mlir::RankedTensorType::get({" # !interleave(dims, ", ") #
"}, $_builder.getIntegerType(" # width # ")), ::llvm::makeArrayRef($0))"; "}, $_builder.getIntegerType(" # width # ")), ::llvm::ArrayRef($0))";
} }
class RankedI32ElementsAttr<list<int> dims> : class RankedI32ElementsAttr<list<int> dims> :
Context not available.
// Note that this is only constructing scalar elements attribute. // Note that this is only constructing scalar elements attribute.
let constBuilderCall = "::mlir::DenseElementsAttr::get(" let constBuilderCall = "::mlir::DenseElementsAttr::get("
"::mlir::RankedTensorType::get({}, $_builder.getF" # width # "Type())," "::mlir::RankedTensorType::get({}, $_builder.getF" # width # "Type()),"
"::llvm::makeArrayRef($0))"; "::llvm::ArrayRef($0))";
let convertFromStorage = "$_self"; let convertFromStorage = "$_self";
} }
Context not available.
let constBuilderCall = "::mlir::DenseElementsAttr::get(" let constBuilderCall = "::mlir::DenseElementsAttr::get("
"::mlir::RankedTensorType::get({" # !interleave(dims, ", ") # "::mlir::RankedTensorType::get({" # !interleave(dims, ", ") #
"}, $_builder.getF" # width # "Type()), " "}, $_builder.getF" # width # "Type()), "
"::llvm::makeArrayRef($0)).cast<::mlir::DenseFPElementsAttr>()"; "::llvm::ArrayRef($0)).cast<::mlir::DenseFPElementsAttr>()";
let convertFromStorage = "$_self"; let convertFromStorage = "$_self";
} }
Context not available.

mlir/include/mlir/IR/OpDefinition.h

Context not available.
return op->emitOpError() return op->emitOpError()
<< "expects parent op " << "expects parent op "
<< (sizeof...(ParentOpTypes) != 1 ? "to be one of '" : "'") << (sizeof...(ParentOpTypes) != 1 ? "to be one of '" : "'")
<< llvm::makeArrayRef({ParentOpTypes::getOperationName()...}) << llvm::ArrayRef({ParentOpTypes::getOperationName()...}) << "'";
<< "'";
} }
}; };
}; };
Context not available.

mlir/lib/Analysis/Presburger/PresburgerSpace.cpp

Context not available.
"alignment."); "alignment.");
ArrayRef<void *> kindAttachments = ArrayRef<void *> kindAttachments =
makeArrayRef(identifiers) ArrayRef(identifiers).slice(getVarKindOffset(kind), getNumVarKind(kind));
.slice(getVarKindOffset(kind), getNumVarKind(kind));
ArrayRef<void *> otherKindAttachments = ArrayRef<void *> otherKindAttachments =
makeArrayRef(other.identifiers) ArrayRef(other.identifiers)
.slice(other.getVarKindOffset(kind), other.getNumVarKind(kind)); .slice(other.getVarKindOffset(kind), other.getNumVarKind(kind));
return kindAttachments == otherKindAttachments; return kindAttachments == otherKindAttachments;
} }
Context not available.

mlir/lib/AsmParser/AsmParserState.cpp

Context not available.
// Access State // Access State
auto AsmParserState::getBlockDefs() const -> iterator_range<BlockDefIterator> { auto AsmParserState::getBlockDefs() const -> iterator_range<BlockDefIterator> {
return llvm::make_pointee_range(llvm::makeArrayRef(impl->blocks)); return llvm::make_pointee_range(llvm::ArrayRef(impl->blocks));
} }
auto AsmParserState::getBlockDef(Block *block) const auto AsmParserState::getBlockDef(Block *block) const
Context not available.
} }
auto AsmParserState::getOpDefs() const -> iterator_range<OperationDefIterator> { auto AsmParserState::getOpDefs() const -> iterator_range<OperationDefIterator> {
return llvm::make_pointee_range(llvm::makeArrayRef(impl->operations)); return llvm::make_pointee_range(llvm::ArrayRef(impl->operations));
} }
auto AsmParserState::getOpDef(Operation *op) const auto AsmParserState::getOpDef(Operation *op) const
Context not available.

mlir/lib/AsmParser/AttributeParser.cpp

Context not available.
return nullptr; return nullptr;
if (isComplex) { if (isComplex) {
// If this is a complex, treat the parsed values as complex values. // If this is a complex, treat the parsed values as complex values.
auto complexData = llvm::makeArrayRef( auto complexData = llvm::ArrayRef(
reinterpret_cast<std::complex<APInt> *>(intValues.data()), reinterpret_cast<std::complex<APInt> *>(intValues.data()),
intValues.size() / 2); intValues.size() / 2);
return DenseElementsAttr::get(type, complexData); return DenseElementsAttr::get(type, complexData);
Context not available.
return nullptr; return nullptr;
if (isComplex) { if (isComplex) {
// If this is a complex, treat the parsed values as complex values. // If this is a complex, treat the parsed values as complex values.
auto complexData = llvm::makeArrayRef( auto complexData = llvm::ArrayRef(
reinterpret_cast<std::complex<APFloat> *>(floatValues.data()), reinterpret_cast<std::complex<APFloat> *>(floatValues.data()),
floatValues.size() / 2); floatValues.size() / 2);
return DenseElementsAttr::get(type, complexData); return DenseElementsAttr::get(type, complexData);
Context not available.

mlir/lib/Bindings/Python/IRCore.cpp

Context not available.
throw py::value_error("No caller frames provided"); throw py::value_error("No caller frames provided");
MlirLocation caller = frames.back().get(); MlirLocation caller = frames.back().get();
for (const PyLocation &frame : for (const PyLocation &frame :
llvm::reverse(llvm::makeArrayRef(frames).drop_back())) llvm::reverse(llvm::ArrayRef(frames).drop_back()))
caller = mlirLocationCallSiteGet(frame.get(), caller); caller = mlirLocationCallSiteGet(frame.get(), caller);
return PyLocation(context->getRef(), return PyLocation(context->getRef(),
mlirLocationCallSiteGet(callee.get(), caller)); mlirLocationCallSiteGet(callee.get(), caller));
Context not available.

mlir/lib/Bytecode/Reader/BytecodeReader.cpp

Context not available.
if (failed(reader.parseVarInt(dataSize)) || if (failed(reader.parseVarInt(dataSize)) ||
failed(reader.parseBytes(dataSize, data))) failed(reader.parseBytes(dataSize, data)))
return failure(); return failure();
result = llvm::makeArrayRef(reinterpret_cast<const char *>(data.data()), result = llvm::ArrayRef(reinterpret_cast<const char *>(data.data()),
data.size()); data.size());
return success(); return success();
} }
Context not available.

mlir/lib/CAPI/Dialect/Quant.cpp

Context not available.
int64_t storageTypeMax) { int64_t storageTypeMax) {
return wrap(quant::UniformQuantizedPerAxisType::get( return wrap(quant::UniformQuantizedPerAxisType::get(
flags, unwrap(storageType), unwrap(expressedType), flags, unwrap(storageType), unwrap(expressedType),
llvm::makeArrayRef(scales, nDims), llvm::makeArrayRef(zeroPoints, nDims), llvm::ArrayRef(scales, nDims), llvm::ArrayRef(zeroPoints, nDims),
quantizedDimension, storageTypeMin, storageTypeMax)); quantizedDimension, storageTypeMin, storageTypeMax));
} }
Context not available.

mlir/lib/CAPI/IR/AffineMap.cpp

Context not available.
MlirAffineMap mlirAffineMapPermutationGet(MlirContext ctx, intptr_t size, MlirAffineMap mlirAffineMapPermutationGet(MlirContext ctx, intptr_t size,
unsigned *permutation) { unsigned *permutation) {
return wrap(AffineMap::getPermutationMap( return wrap(AffineMap::getPermutationMap(
llvm::makeArrayRef(permutation, static_cast<size_t>(size)), unwrap(ctx))); llvm::ArrayRef(permutation, static_cast<size_t>(size)), unwrap(ctx)));
} }
bool mlirAffineMapIsIdentity(MlirAffineMap affineMap) { bool mlirAffineMapIsIdentity(MlirAffineMap affineMap) {
Context not available.

mlir/lib/CAPI/IR/BuiltinAttributes.cpp

Context not available.
uint64_t *idxs) { uint64_t *idxs) {
return wrap(unwrap(attr) return wrap(unwrap(attr)
.cast<ElementsAttr>() .cast<ElementsAttr>()
.getValues<Attribute>()[llvm::makeArrayRef(idxs, rank)]); .getValues<Attribute>()[llvm::ArrayRef(idxs, rank)]);
} }
bool mlirElementsAttrIsValidIndex(MlirAttribute attr, intptr_t rank, bool mlirElementsAttrIsValidIndex(MlirAttribute attr, intptr_t rank,
uint64_t *idxs) { uint64_t *idxs) {
return unwrap(attr).cast<ElementsAttr>().isValidIndex( return unwrap(attr).cast<ElementsAttr>().isValidIndex(
llvm::makeArrayRef(idxs, rank)); llvm::ArrayRef(idxs, rank));
} }
int64_t mlirElementsAttrGetNumElements(MlirAttribute attr) { int64_t mlirElementsAttrGetNumElements(MlirAttribute attr) {
Context not available.
static MlirAttribute getDenseAttribute(MlirType shapedType, static MlirAttribute getDenseAttribute(MlirType shapedType,
intptr_t numElements, intptr_t numElements,
const T *elements) { const T *elements) {
return wrap( return wrap(DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(),
DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), llvm::ArrayRef(elements, numElements)));
llvm::makeArrayRef(elements, numElements)));
} }
MlirAttribute mlirDenseElementsAttrUInt8Get(MlirType shapedType, MlirAttribute mlirDenseElementsAttrUInt8Get(MlirType shapedType,
Context not available.
intptr_t numElements, const T *elements) { intptr_t numElements, const T *elements) {
return wrap(U::get(unwrap(shapedType).cast<ShapedType>(), unwrap(name), return wrap(U::get(unwrap(shapedType).cast<ShapedType>(), unwrap(name),
UnmanagedAsmResourceBlob::allocateInferAlign( UnmanagedAsmResourceBlob::allocateInferAlign(
llvm::makeArrayRef(elements, numElements)))); llvm::ArrayRef(elements, numElements))));
} }
MLIR_CAPI_EXPORTED MlirAttribute mlirUnmanagedDenseBoolResourceElementsAttrGet( MLIR_CAPI_EXPORTED MlirAttribute mlirUnmanagedDenseBoolResourceElementsAttrGet(
Context not available.

mlir/lib/CAPI/IR/BuiltinTypes.cpp

Context not available.
MlirType mlirVectorTypeGet(intptr_t rank, const int64_t *shape, MlirType mlirVectorTypeGet(intptr_t rank, const int64_t *shape,
MlirType elementType) { MlirType elementType) {
return wrap( return wrap(VectorType::get(llvm::ArrayRef(shape, static_cast<size_t>(rank)),
VectorType::get(llvm::makeArrayRef(shape, static_cast<size_t>(rank)), unwrap(elementType)));
unwrap(elementType)));
} }
MlirType mlirVectorTypeGetChecked(MlirLocation loc, intptr_t rank, MlirType mlirVectorTypeGetChecked(MlirLocation loc, intptr_t rank,
const int64_t *shape, MlirType elementType) { const int64_t *shape, MlirType elementType) {
return wrap(VectorType::getChecked( return wrap(VectorType::getChecked(
unwrap(loc), llvm::makeArrayRef(shape, static_cast<size_t>(rank)), unwrap(loc), llvm::ArrayRef(shape, static_cast<size_t>(rank)),
unwrap(elementType))); unwrap(elementType)));
} }
Context not available.
MlirType mlirRankedTensorTypeGet(intptr_t rank, const int64_t *shape, MlirType mlirRankedTensorTypeGet(intptr_t rank, const int64_t *shape,
MlirType elementType, MlirAttribute encoding) { MlirType elementType, MlirAttribute encoding) {
return wrap(RankedTensorType::get( return wrap(
llvm::makeArrayRef(shape, static_cast<size_t>(rank)), unwrap(elementType), RankedTensorType::get(llvm::ArrayRef(shape, static_cast<size_t>(rank)),
unwrap(encoding))); unwrap(elementType), unwrap(encoding)));
} }
MlirType mlirRankedTensorTypeGetChecked(MlirLocation loc, intptr_t rank, MlirType mlirRankedTensorTypeGetChecked(MlirLocation loc, intptr_t rank,
Context not available.
MlirType elementType, MlirType elementType,
MlirAttribute encoding) { MlirAttribute encoding) {
return wrap(RankedTensorType::getChecked( return wrap(RankedTensorType::getChecked(
unwrap(loc), llvm::makeArrayRef(shape, static_cast<size_t>(rank)), unwrap(loc), llvm::ArrayRef(shape, static_cast<size_t>(rank)),
unwrap(elementType), unwrap(encoding))); unwrap(elementType), unwrap(encoding)));
} }
Context not available.
const int64_t *shape, MlirAttribute layout, const int64_t *shape, MlirAttribute layout,
MlirAttribute memorySpace) { MlirAttribute memorySpace) {
return wrap(MemRefType::get( return wrap(MemRefType::get(
llvm::makeArrayRef(shape, static_cast<size_t>(rank)), unwrap(elementType), llvm::ArrayRef(shape, static_cast<size_t>(rank)), unwrap(elementType),
mlirAttributeIsNull(layout) mlirAttributeIsNull(layout)
? MemRefLayoutAttrInterface() ? MemRefLayoutAttrInterface()
: unwrap(layout).cast<MemRefLayoutAttrInterface>(), : unwrap(layout).cast<MemRefLayoutAttrInterface>(),
Context not available.
MlirAttribute layout, MlirAttribute layout,
MlirAttribute memorySpace) { MlirAttribute memorySpace) {
return wrap(MemRefType::getChecked( return wrap(MemRefType::getChecked(
unwrap(loc), llvm::makeArrayRef(shape, static_cast<size_t>(rank)), unwrap(loc), llvm::ArrayRef(shape, static_cast<size_t>(rank)),
unwrap(elementType), unwrap(elementType),
mlirAttributeIsNull(layout) mlirAttributeIsNull(layout)
? MemRefLayoutAttrInterface() ? MemRefLayoutAttrInterface()
Context not available.
MlirType mlirMemRefTypeContiguousGet(MlirType elementType, intptr_t rank, MlirType mlirMemRefTypeContiguousGet(MlirType elementType, intptr_t rank,
const int64_t *shape, const int64_t *shape,
MlirAttribute memorySpace) { MlirAttribute memorySpace) {
return wrap(MemRefType::get( return wrap(MemRefType::get(llvm::ArrayRef(shape, static_cast<size_t>(rank)),
llvm::makeArrayRef(shape, static_cast<size_t>(rank)), unwrap(elementType), unwrap(elementType), MemRefLayoutAttrInterface(),
MemRefLayoutAttrInterface(), unwrap(memorySpace))); unwrap(memorySpace)));
} }
MlirType mlirMemRefTypeContiguousGetChecked(MlirLocation loc, MlirType mlirMemRefTypeContiguousGetChecked(MlirLocation loc,
Context not available.
const int64_t *shape, const int64_t *shape,
MlirAttribute memorySpace) { MlirAttribute memorySpace) {
return wrap(MemRefType::getChecked( return wrap(MemRefType::getChecked(
unwrap(loc), llvm::makeArrayRef(shape, static_cast<size_t>(rank)), unwrap(loc), llvm::ArrayRef(shape, static_cast<size_t>(rank)),
unwrap(elementType), MemRefLayoutAttrInterface(), unwrap(memorySpace))); unwrap(elementType), MemRefLayoutAttrInterface(), unwrap(memorySpace)));
} }
Context not available.

mlir/lib/CAPI/IR/IntegerSet.cpp

Context not available.
return wrap(IntegerSet::get( return wrap(IntegerSet::get(
static_cast<unsigned>(numDims), static_cast<unsigned>(numSymbols), static_cast<unsigned>(numDims), static_cast<unsigned>(numSymbols),
mlirConstraints, mlirConstraints,
llvm::makeArrayRef(eqFlags, static_cast<size_t>(numConstraints)))); llvm::ArrayRef(eqFlags, static_cast<size_t>(numConstraints))));
} }
MlirIntegerSet MlirIntegerSet
Context not available.

mlir/lib/Conversion/AffineToStandard/AffineToStandard.cpp

Context not available.
auto integerSet = op.getIntegerSet(); auto integerSet = op.getIntegerSet();
Value zeroConstant = rewriter.create<arith::ConstantIndexOp>(loc, 0); Value zeroConstant = rewriter.create<arith::ConstantIndexOp>(loc, 0);
SmallVector<Value, 8> operands(op.getOperands()); SmallVector<Value, 8> operands(op.getOperands());
auto operandsRef = llvm::makeArrayRef(operands); auto operandsRef = llvm::ArrayRef(operands);
// Calculate cond as a conjunction without short-circuiting. // Calculate cond as a conjunction without short-circuiting.
Value cond = nullptr; Value cond = nullptr;
Context not available.
LogicalResult matchAndRewrite(AffineDmaStartOp op, LogicalResult matchAndRewrite(AffineDmaStartOp op,
PatternRewriter &rewriter) const override { PatternRewriter &rewriter) const override {
SmallVector<Value, 8> operands(op.getOperands()); SmallVector<Value, 8> operands(op.getOperands());
auto operandsRef = llvm::makeArrayRef(operands); auto operandsRef = llvm::ArrayRef(operands);
// Expand affine map for DMA source memref. // Expand affine map for DMA source memref.
auto maybeExpandedSrcMap = expandAffineMap( auto maybeExpandedSrcMap = expandAffineMap(
Context not available.

mlir/lib/Conversion/ArithToSPIRV/ArithToSPIRV.cpp

Context not available.
adaptor.getRhs()); adaptor.getRhs());
Value sumResult = rewriter.create<spirv::CompositeExtractOp>( Value sumResult = rewriter.create<spirv::CompositeExtractOp>(
loc, result, llvm::makeArrayRef(0)); loc, result, llvm::ArrayRef(0));
Value carryValue = rewriter.create<spirv::CompositeExtractOp>( Value carryValue = rewriter.create<spirv::CompositeExtractOp>(
loc, result, llvm::makeArrayRef(1)); loc, result, llvm::ArrayRef(1));
// Convert the carry value to boolean. // Convert the carry value to boolean.
Value one = spirv::ConstantOp::getOne(dstElemTy, loc, rewriter); Value one = spirv::ConstantOp::getOne(dstElemTy, loc, rewriter);
Context not available.
rewriter.create<SPIRVMulOp>(loc, adaptor.getLhs(), adaptor.getRhs()); rewriter.create<SPIRVMulOp>(loc, adaptor.getLhs(), adaptor.getRhs());
Value low = rewriter.create<spirv::CompositeExtractOp>(loc, result, Value low = rewriter.create<spirv::CompositeExtractOp>(loc, result,
llvm::makeArrayRef(0)); llvm::ArrayRef(0));
Value high = rewriter.create<spirv::CompositeExtractOp>( Value high = rewriter.create<spirv::CompositeExtractOp>(loc, result,
loc, result, llvm::makeArrayRef(1)); llvm::ArrayRef(1));
rewriter.replaceOp(op, {low, high}); rewriter.replaceOp(op, {low, high});
return success(); return success();
Context not available.

mlir/lib/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.cpp

Context not available.
auto dataAttrType = RankedTensorType::get( auto dataAttrType = RankedTensorType::get(
{static_cast<int64_t>(elementVals.size())}, builder.getI8Type()); {static_cast<int64_t>(elementVals.size())}, builder.getI8Type());
auto dataAttr = auto dataAttr =
DenseElementsAttr::get(dataAttrType, llvm::makeArrayRef(elementVals)); DenseElementsAttr::get(dataAttrType, llvm::ArrayRef(elementVals));
auto arrayTy = auto arrayTy =
LLVM::LLVMArrayType::get(IntegerType::get(ctx, 8), elementVals.size()); LLVM::LLVMArrayType::get(IntegerType::get(ctx, 8), elementVals.size());
std::string symbolName = generateGlobalMsgSymbolName(moduleOp); std::string symbolName = generateGlobalMsgSymbolName(moduleOp);
Context not available.

mlir/lib/Conversion/LLVMCommon/MemRefBuilder.cpp

Context not available.
// Copy size values to stack-allocated memory. // Copy size values to stack-allocated memory.
auto one = createIndexAttrConstant(builder, loc, indexType, 1); auto one = createIndexAttrConstant(builder, loc, indexType, 1);
auto sizes = builder.create<LLVM::ExtractValueOp>( auto sizes = builder.create<LLVM::ExtractValueOp>(
loc, value, llvm::makeArrayRef<int64_t>({kSizePosInMemRefDescriptor})); loc, value, llvm::ArrayRef<int64_t>({kSizePosInMemRefDescriptor}));
auto sizesPtr = auto sizesPtr =
builder.create<LLVM::AllocaOp>(loc, arrayPtrTy, one, /*alignment=*/0); builder.create<LLVM::AllocaOp>(loc, arrayPtrTy, one, /*alignment=*/0);
builder.create<LLVM::StoreOp>(loc, sizes, sizesPtr); builder.create<LLVM::StoreOp>(loc, sizes, sizesPtr);
Context not available.

mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp

Context not available.
for (auto &en : llvm::enumerate(reassociation)) { for (auto &en : llvm::enumerate(reassociation)) {
rewriter.setInsertionPoint(op); rewriter.setInsertionPoint(op);
auto dstIndex = en.index(); auto dstIndex = en.index();
ArrayRef<int64_t> ref = llvm::makeArrayRef(en.value()); ArrayRef<int64_t> ref = llvm::ArrayRef(en.value());
while (srcShape[ref.back()] == 1 && ref.size() > 1) while (srcShape[ref.back()] == 1 && ref.size() > 1)
ref = ref.drop_back(); ref = ref.drop_back();
if (!ShapedType::isDynamic(srcShape[ref.back()]) || ref.size() == 1) { if (!ShapedType::isDynamic(srcShape[ref.back()]) || ref.size() == 1) {
Context not available.

mlir/lib/Conversion/VectorToSPIRV/VectorToSPIRV.cpp

Context not available.
// Reduce them. // Reduce them.
Value result = values.front(); Value result = values.front();
for (Value next : llvm::makeArrayRef(values).drop_front()) { for (Value next : llvm::ArrayRef(values).drop_front()) {
switch (reduceOp.getKind()) { switch (reduceOp.getKind()) {
#define INT_AND_FLOAT_CASE(kind, iop, fop) \ #define INT_AND_FLOAT_CASE(kind, iop, fop) \
Context not available.

mlir/lib/Dialect/Affine/IR/AffineOps.cpp

Context not available.
return failure(); return failure();
result.attributes.erase(tmpAttrStrName); result.attributes.erase(tmpAttrStrName);
llvm::append_range(flatExprs, map.getValue().getResults()); llvm::append_range(flatExprs, map.getValue().getResults());
auto operandsRef = llvm::makeArrayRef(mapOperands); auto operandsRef = llvm::ArrayRef(mapOperands);
auto dimsRef = operandsRef.take_front(map.getValue().getNumDims()); auto dimsRef = operandsRef.take_front(map.getValue().getNumDims());
SmallVector<OpAsmParser::UnresolvedOperand> dims(dimsRef.begin(), SmallVector<OpAsmParser::UnresolvedOperand> dims(dimsRef.begin(),
dimsRef.end()); dimsRef.end());
Context not available.

mlir/lib/Dialect/Affine/Utils/Utils.cpp

Context not available.
parallelReductions, [](const LoopReduction &red) { return red.kind; })); parallelReductions, [](const LoopReduction &red) { return red.kind; }));
AffineParallelOp newPloop = outsideBuilder.create<AffineParallelOp>( AffineParallelOp newPloop = outsideBuilder.create<AffineParallelOp>(
loc, ValueRange(reducedValues).getTypes(), reductionKinds, loc, ValueRange(reducedValues).getTypes(), reductionKinds,
llvm::makeArrayRef(lowerBoundMap), lowerBoundOperands, llvm::ArrayRef(lowerBoundMap), lowerBoundOperands,
llvm::makeArrayRef(upperBoundMap), upperBoundOperands, llvm::ArrayRef(upperBoundMap), upperBoundOperands,
llvm::makeArrayRef(forOp.getStep())); llvm::ArrayRef(forOp.getStep()));
// Steal the body of the old affine for op. // Steal the body of the old affine for op.
newPloop.getRegion().takeBody(forOp.getRegion()); newPloop.getRegion().takeBody(forOp.getRegion());
Operation *yieldOp = &newPloop.getBody()->back(); Operation *yieldOp = &newPloop.getBody()->back();
Context not available.

mlir/lib/Dialect/Func/IR/FuncOps.cpp

Context not available.
FuncOp FuncOp::create(Location location, StringRef name, FunctionType type, FuncOp FuncOp::create(Location location, StringRef name, FunctionType type,
Operation::dialect_attr_range attrs) { Operation::dialect_attr_range attrs) {
SmallVector<NamedAttribute, 8> attrRef(attrs); SmallVector<NamedAttribute, 8> attrRef(attrs);
return create(location, name, type, llvm::makeArrayRef(attrRef)); return create(location, name, type, llvm::ArrayRef(attrRef));
} }
FuncOp FuncOp::create(Location location, StringRef name, FunctionType type, FuncOp FuncOp::create(Location location, StringRef name, FunctionType type,
ArrayRef<NamedAttribute> attrs, ArrayRef<NamedAttribute> attrs,
Context not available.

mlir/lib/Dialect/GPU/Transforms/AllReduceLowering.cpp

Context not available.
return SmallVector<Value, 1>{ return SmallVector<Value, 1>{
accumFactory(value, shuffleOp.getResult(0))}; accumFactory(value, shuffleOp.getResult(0))};
}, },
[&] { return llvm::makeArrayRef(value); }); [&] { return llvm::ArrayRef(value); });
value = rewriter.getInsertionBlock()->getArgument(0); value = rewriter.getInsertionBlock()->getArgument(0);
} }
return SmallVector<Value, 1>{value}; return SmallVector<Value, 1>{value};
Context not available.

mlir/lib/Dialect/GPU/Transforms/MemoryPromotion.cpp

Context not available.
b, b.getLoc(), lbs, ubs, steps, b, b.getLoc(), lbs, ubs, steps,
[&](OpBuilder &b, Location loc, ValueRange loopIvs) { [&](OpBuilder &b, Location loc, ValueRange loopIvs) {
ivs.assign(loopIvs.begin(), loopIvs.end()); ivs.assign(loopIvs.begin(), loopIvs.end());
auto activeIvs = llvm::makeArrayRef(ivs).take_back(rank); auto activeIvs = llvm::ArrayRef(ivs).take_back(rank);
Value loaded = b.create<memref::LoadOp>(loc, from, activeIvs); Value loaded = b.create<memref::LoadOp>(loc, from, activeIvs);
b.create<memref::StoreOp>(loc, loaded, to, activeIvs); b.create<memref::StoreOp>(loc, loaded, to, activeIvs);
}); });
// Map the innermost loops to threads in reverse order. // Map the innermost loops to threads in reverse order.
for (const auto &en : for (const auto &en :
llvm::enumerate(llvm::reverse(llvm::makeArrayRef(ivs).take_back( llvm::enumerate(llvm::reverse(llvm::ArrayRef(ivs).take_back(
GPUDialect::getNumWorkgroupDimensions())))) { GPUDialect::getNumWorkgroupDimensions())))) {
Value v = en.value(); Value v = en.value();
auto loop = cast<scf::ForOp>(v.getParentRegion()->getParentOp()); auto loop = cast<scf::ForOp>(v.getParentRegion()->getParentOp());
Context not available.

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

Context not available.
auto llvmFuncType = LLVM::LLVMFunctionType::get(llvmResultType, argTypes); auto llvmFuncType = LLVM::LLVMFunctionType::get(llvmResultType, argTypes);
auto wrappedFuncType = LLVM::LLVMPointerType::get(llvmFuncType); auto wrappedFuncType = LLVM::LLVMPointerType::get(llvmFuncType);
auto funcArguments = llvm::makeArrayRef(operands).drop_front(); auto funcArguments = llvm::ArrayRef(operands).drop_front();
// Make sure that the first operand (indirect callee) matches the wrapped // Make sure that the first operand (indirect callee) matches the wrapped
// LLVM IR function type, and that the types of the other call operands // LLVM IR function type, and that the types of the other call operands
Context not available.

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

Context not available.
if (payloadOpName.has_value()) { if (payloadOpName.has_value()) {
addBodyWithPayloadOp(parser, result, payloadOpName.value(), payloadOpAttrs, addBodyWithPayloadOp(parser, result, payloadOpName.value(), payloadOpAttrs,
makeArrayRef(result.operands).drop_back()); ArrayRef(result.operands).drop_back());
} else { } else {
SmallVector<OpAsmParser::Argument> regionArgs; SmallVector<OpAsmParser::Argument> regionArgs;
if (parser.parseArgumentList(regionArgs, OpAsmParser::Delimiter::Paren, if (parser.parseArgumentList(regionArgs, OpAsmParser::Delimiter::Paren,
Context not available.
if (payloadOpName.has_value()) { if (payloadOpName.has_value()) {
addBodyWithPayloadOp(parser, result, payloadOpName.value(), payloadOpAttrs, addBodyWithPayloadOp(parser, result, payloadOpName.value(), payloadOpAttrs,
makeArrayRef(result.operands)); ArrayRef(result.operands));
} else { } else {
SmallVector<OpAsmParser::Argument> regionArgs; SmallVector<OpAsmParser::Argument> regionArgs;
if (parser.parseArgumentList(regionArgs, OpAsmParser::Delimiter::Paren, if (parser.parseArgumentList(regionArgs, OpAsmParser::Delimiter::Paren,
Context not available.

mlir/lib/Dialect/Linalg/Utils/Utils.cpp

Context not available.
loc, loc,
/*inputs=*/from, /*inputs=*/from,
/*outputs=*/to, /*outputs=*/to,
/*indexingMaps=*/llvm::makeArrayRef({id, id}), /*indexingMaps=*/llvm::ArrayRef({id, id}),
/*iteratorTypes=*/iteratorTypes, /*iteratorTypes=*/iteratorTypes,
[](OpBuilder &b, Location loc, ValueRange args) { [](OpBuilder &b, Location loc, ValueRange args) {
b.create<linalg::YieldOp>(loc, args.front()); b.create<linalg::YieldOp>(loc, args.front());
Context not available.

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

Context not available.
// If input shape matches target vector width, we can just call the // If input shape matches target vector width, we can just call the
// user-provided compute function with the operands. // user-provided compute function with the operands.
if (inputShape == llvm::makeArrayRef(vectorWidth)) if (inputShape == llvm::ArrayRef(vectorWidth))
return compute(operands); return compute(operands);
// Check if the inner dimension has to be expanded, or we can directly iterate // Check if the inner dimension has to be expanded, or we can directly iterate
Context not available.

mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp

Context not available.
SmallVector<int64_t> resultStrides; SmallVector<int64_t> resultStrides;
resultStrides.reserve(reassociation.size()); resultStrides.reserve(reassociation.size());
for (const ReassociationIndices &reassoc : reassociation) { for (const ReassociationIndices &reassoc : reassociation) {
ArrayRef<int64_t> ref = llvm::makeArrayRef(reassoc); ArrayRef<int64_t> ref = llvm::ArrayRef(reassoc);
while (srcShape[ref.back()] == 1 && ref.size() > 1) while (srcShape[ref.back()] == 1 && ref.size() > 1)
ref = ref.drop_back(); ref = ref.drop_back();
if (!ShapedType::isDynamic(srcShape[ref.back()]) || ref.size() == 1) { if (!ShapedType::isDynamic(srcShape[ref.back()]) || ref.size() == 1) {
Context not available.

mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp

Context not available.
return failure(); return failure();
auto resultType = getElementPtrType( auto resultType = getElementPtrType(
type, llvm::makeArrayRef(result.operands).drop_front(), result.location); type, llvm::ArrayRef(result.operands).drop_front(), result.location);
if (!resultType) { if (!resultType) {
return failure(); return failure();
} }
Context not available.
return failure(); return failure();
auto resultType = getElementPtrType( auto resultType = getElementPtrType(
type, llvm::makeArrayRef(state.operands).drop_front(2), state.location); type, llvm::ArrayRef(state.operands).drop_front(2), state.location);
if (!resultType) if (!resultType)
return failure(); return failure();
Context not available.

mlir/lib/Dialect/SPIRV/Transforms/SPIRVConversion.cpp

Context not available.
loc, integerType, builder.getI32IntegerAttr(offset)); loc, integerType, builder.getI32IntegerAttr(offset));
auto addrOp = builder.create<spirv::AddressOfOp>(loc, varOp); auto addrOp = builder.create<spirv::AddressOfOp>(loc, varOp);
auto acOp = builder.create<spirv::AccessChainOp>( auto acOp = builder.create<spirv::AccessChainOp>(
loc, addrOp, llvm::makeArrayRef({zeroOp, offsetOp})); loc, addrOp, llvm::ArrayRef({zeroOp, offsetOp}));
return builder.create<spirv::LoadOp>(loc, acOp); return builder.create<spirv::LoadOp>(loc, acOp);
} }
Context not available.

mlir/lib/Dialect/Shape/IR/Shape.cpp

Context not available.
FuncOp FuncOp::create(Location location, StringRef name, FunctionType type, FuncOp FuncOp::create(Location location, StringRef name, FunctionType type,
Operation::dialect_attr_range attrs) { Operation::dialect_attr_range attrs) {
SmallVector<NamedAttribute, 8> attrRef(attrs); SmallVector<NamedAttribute, 8> attrRef(attrs);
return create(location, name, type, llvm::makeArrayRef(attrRef)); return create(location, name, type, llvm::ArrayRef(attrRef));
} }
FuncOp FuncOp::create(Location location, StringRef name, FunctionType type, FuncOp FuncOp::create(Location location, StringRef name, FunctionType type,
ArrayRef<NamedAttribute> attrs, ArrayRef<NamedAttribute> attrs,
Context not available.
return failure(); return failure();
auto shapeVec = llvm::to_vector<6>( auto shapeVec = llvm::to_vector<6>(
operands[0].cast<DenseIntElementsAttr>().getValues<int64_t>()); operands[0].cast<DenseIntElementsAttr>().getValues<int64_t>());
auto shape = llvm::makeArrayRef(shapeVec); auto shape = llvm::ArrayRef(shapeVec);
auto splitPoint = operands[1].cast<IntegerAttr>().getInt(); auto splitPoint = operands[1].cast<IntegerAttr>().getInt();
// Verify that the split point is in the correct range. // Verify that the split point is in the correct range.
// TODO: Constant fold to an "error". // TODO: Constant fold to an "error".
Context not available.
return failure(); return failure();
// Resolve operands. // Resolve operands.
auto initVals = llvm::makeArrayRef(operands).drop_front(); auto initVals = llvm::ArrayRef(operands).drop_front();
if (parser.resolveOperand(operands.front(), shapeOrExtentTensorType, if (parser.resolveOperand(operands.front(), shapeOrExtentTensorType,
result.operands) || result.operands) ||
parser.resolveOperands(initVals, result.types, parser.getNameLoc(), parser.resolveOperands(initVals, result.types, parser.getNameLoc(),
Context not available.

mlir/lib/Dialect/Tensor/Transforms/SplitPaddingPatterns.cpp

Context not available.
cstZero)); cstZero));
} }
Value ifCond = eqZeroCmpVals.front(); Value ifCond = eqZeroCmpVals.front();
for (Value cmp : llvm::makeArrayRef(eqZeroCmpVals).drop_front()) for (Value cmp : llvm::ArrayRef(eqZeroCmpVals).drop_front())
ifCond = rewriter.create<arith::AndIOp>(loc, ifCond, cmp); ifCond = rewriter.create<arith::AndIOp>(loc, ifCond, cmp);
// Build the scf.if op itself. For the "then" branch, we can elide the // Build the scf.if op itself. For the "then" branch, we can elide the
Context not available.

mlir/lib/Dialect/Transform/IR/TransformInterfaces.cpp

Context not available.
assert(segments[position].data() == nullptr && "results already set"); assert(segments[position].data() == nullptr && "results already set");
int64_t start = operations.size(); int64_t start = operations.size();
llvm::append_range(operations, ops); llvm::append_range(operations, ops);
segments[position] = makeArrayRef(operations).drop_front(start); segments[position] = ArrayRef(operations).drop_front(start);
} }
ArrayRef<Operation *> ArrayRef<Operation *>
Context not available.

mlir/lib/Dialect/Vector/IR/VectorOps.cpp

Context not available.
/// Folding is only possible in the absence of an internal permutation in the /// Folding is only possible in the absence of an internal permutation in the
/// result vector. /// result vector.
bool canFold() { bool canFold() {
return (sentinels == return (sentinels == ArrayRef(extractPosition).drop_front(extractedRank));
makeArrayRef(extractPosition).drop_front(extractedRank));
} }
// Helper to get the next defining op of interest. // Helper to get the next defining op of interest.
Context not available.
auto permutation = extractVector<unsigned>(nextTransposeOp.getTransp()); auto permutation = extractVector<unsigned>(nextTransposeOp.getTransp());
AffineMap m = inversePermutation( AffineMap m = inversePermutation(
AffineMap::getPermutationMap(permutation, extractOp.getContext())); AffineMap::getPermutationMap(permutation, extractOp.getContext()));
extractPosition = applyPermutationMap(m, makeArrayRef(extractPosition)); extractPosition = applyPermutationMap(m, ArrayRef(extractPosition));
return success(); return success();
} }
Context not available.
ExtractFromInsertTransposeChainState::handleInsertOpWithMatchingPos( ExtractFromInsertTransposeChainState::handleInsertOpWithMatchingPos(
Value &res) { Value &res) {
auto insertedPos = extractVector<int64_t>(nextInsertOp.getPosition()); auto insertedPos = extractVector<int64_t>(nextInsertOp.getPosition());
if (makeArrayRef(insertedPos) != if (ArrayRef(insertedPos) !=
llvm::makeArrayRef(extractPosition).take_front(extractedRank)) llvm::ArrayRef(extractPosition).take_front(extractedRank))
return failure(); return failure();
// Case 2.a. early-exit fold. // Case 2.a. early-exit fold.
res = nextInsertOp.getSource(); res = nextInsertOp.getSource();
Context not available.
OpBuilder b(extractOp.getContext()); OpBuilder b(extractOp.getContext());
extractOp->setAttr( extractOp->setAttr(
extractOp.getPositionAttrName(), extractOp.getPositionAttrName(),
b.getI64ArrayAttr( b.getI64ArrayAttr(ArrayRef(extractPosition).take_front(extractedRank)));
makeArrayRef(extractPosition).take_front(extractedRank)));
extractOp.getVectorMutable().assign(source); extractOp.getVectorMutable().assign(source);
return extractOp.getResult(); return extractOp.getResult();
} }
Context not available.

mlir/lib/ExecutionEngine/RocmRuntimeWrappers.cpp

Context not available.
std::rotate(denseStrides.begin(), denseStrides.begin() + 1, std::rotate(denseStrides.begin(), denseStrides.begin() + 1,
denseStrides.end()); denseStrides.end());
denseStrides.back() = 1; denseStrides.back() = 1;
assert(strides == llvm::makeArrayRef(denseStrides)); assert(strides == llvm::ArrayRef(denseStrides));
auto ptr = descriptor->data + descriptor->offset * elementSizeBytes; auto ptr = descriptor->data + descriptor->offset * elementSizeBytes;
mgpuMemHostRegister(ptr, sizeBytes); mgpuMemHostRegister(ptr, sizeBytes);
Context not available.

mlir/lib/Interfaces/DataLayoutInterfaces.cpp

Context not available.
if (nonNullSpecs.empty()) if (nonNullSpecs.empty())
return {}; return {};
return nonNullSpecs.back().combineWith( return nonNullSpecs.back().combineWith(
llvm::makeArrayRef(nonNullSpecs).drop_back()); llvm::ArrayRef(nonNullSpecs).drop_back());
} }
LogicalResult mlir::detail::verifyDataLayoutOp(Operation *op) { LogicalResult mlir::detail::verifyDataLayoutOp(Operation *op) {
Context not available.

mlir/lib/TableGen/Format.cpp

Context not available.
s << repl.spec << kMarkerForNoSubst; s << repl.spec << kMarkerForNoSubst;
continue; continue;
} }
auto range = llvm::makeArrayRef(adapters); auto range = llvm::ArrayRef(adapters);
range = range.drop_front(repl.index); range = range.drop_front(repl.index);
if (repl.end != FmtReplacement::kUnset) if (repl.end != FmtReplacement::kUnset)
range = range.drop_back(adapters.size() - repl.end); range = range.drop_back(adapters.size() - repl.end);
Context not available.

mlir/lib/Target/SPIRV/Deserialization/Deserializer.cpp

Context not available.
} }
ArrayRef<Type> returnTypes; ArrayRef<Type> returnTypes;
if (!isVoidType(returnType)) { if (!isVoidType(returnType)) {
returnTypes = llvm::makeArrayRef(returnType); returnTypes = llvm::ArrayRef(returnType);
} }
typeMap[operands[0]] = FunctionType::get(context, argTypes, returnTypes); typeMap[operands[0]] = FunctionType::get(context, argTypes, returnTypes);
return success(); return success();
Context not available.

mlir/lib/Target/SPIRV/TranslateRegistration.cpp

Context not available.
return {}; return {};
} }
auto binary = llvm::makeArrayRef(reinterpret_cast<const uint32_t *>(start), auto binary = llvm::ArrayRef(reinterpret_cast<const uint32_t *>(start),
size / sizeof(uint32_t)); size / sizeof(uint32_t));
return spirv::deserialize(binary, context); return spirv::deserialize(binary, context);
} }
Context not available.

mlir/lib/Tools/PDLL/AST/NodePrinter.cpp

Context not available.
if (elementIndentStack.empty()) if (elementIndentStack.empty())
return; return;
for (bool isLastElt : llvm::makeArrayRef(elementIndentStack).drop_back()) for (bool isLastElt : llvm::ArrayRef(elementIndentStack).drop_back())
os << (isLastElt ? " " : " |"); os << (isLastElt ? " " : " |");
os << (elementIndentStack.back() ? " `" : " |"); os << (elementIndentStack.back() ? " `" : " |");
} }
Context not available.

mlir/lib/Tools/PDLL/AST/TypeDetail.h

Context not available.
std::pair<ArrayRef<Type>, ArrayRef<StringRef>> key) { std::pair<ArrayRef<Type>, ArrayRef<StringRef>> key) {
SmallVector<StringRef> names = llvm::to_vector(llvm::map_range( SmallVector<StringRef> names = llvm::to_vector(llvm::map_range(
key.second, [&](StringRef name) { return alloc.copyInto(name); })); key.second, [&](StringRef name) { return alloc.copyInto(name); }));
return new (alloc.allocate<TupleTypeStorage>()) TupleTypeStorage( return new (alloc.allocate<TupleTypeStorage>())
std::make_pair(alloc.copyInto(key.first), TupleTypeStorage(std::make_pair(alloc.copyInto(key.first),
alloc.copyInto(llvm::makeArrayRef(names)))); alloc.copyInto(llvm::ArrayRef(names))));
} }
}; };
Context not available.

mlir/lib/Transforms/Utils/DialectConversion.cpp

Context not available.
mlir::applyPartialConversion(Operation *op, ConversionTarget &target, mlir::applyPartialConversion(Operation *op, ConversionTarget &target,
const FrozenRewritePatternSet &patterns, const FrozenRewritePatternSet &patterns,
DenseSet<Operation *> *unconvertedOps) { DenseSet<Operation *> *unconvertedOps) {
return applyPartialConversion(llvm::makeArrayRef(op), target, patterns, return applyPartialConversion(llvm::ArrayRef(op), target, patterns,
unconvertedOps); unconvertedOps);
} }
Context not available.
LogicalResult LogicalResult
mlir::applyFullConversion(Operation *op, ConversionTarget &target, mlir::applyFullConversion(Operation *op, ConversionTarget &target,
const FrozenRewritePatternSet &patterns) { const FrozenRewritePatternSet &patterns) {
return applyFullConversion(llvm::makeArrayRef(op), target, patterns); return applyFullConversion(llvm::ArrayRef(op), target, patterns);
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
Context not available.
const FrozenRewritePatternSet &patterns, const FrozenRewritePatternSet &patterns,
DenseSet<Operation *> &convertedOps, DenseSet<Operation *> &convertedOps,
function_ref<void(Diagnostic &)> notifyCallback) { function_ref<void(Diagnostic &)> notifyCallback) {
return applyAnalysisConversion(llvm::makeArrayRef(op), target, patterns, return applyAnalysisConversion(llvm::ArrayRef(op), target, patterns,
convertedOps, notifyCallback); convertedOps, notifyCallback);
} }
Context not available.

mlir/test/lib/Dialect/Test/TestDialect.cpp

Context not available.
// test.pretty_printed_region start <inner-op> end : <functional-type> // test.pretty_printed_region start <inner-op> end : <functional-type>
// Else fallback to parsing the "non pretty-printed" version. // Else fallback to parsing the "non pretty-printed" version.
if (!succeeded(parser.parseOptionalKeyword("start"))) if (!succeeded(parser.parseOptionalKeyword("start")))
return parser.parseGenericOperationAfterOpName( return parser.parseGenericOperationAfterOpName(result,
result, llvm::makeArrayRef(operands)); llvm::ArrayRef(operands));
FailureOr<OperationName> parseOpNameInfo = parser.parseCustomOperationName(); FailureOr<OperationName> parseOpNameInfo = parser.parseCustomOperationName();
if (failed(parseOpNameInfo)) if (failed(parseOpNameInfo))
Context not available.

mlir/test/lib/Dialect/Test/TestPatterns.cpp

Context not available.
// Check if these transformations introduce visiting of operations that // Check if these transformations introduce visiting of operations that
// are not in the `ops` set (The new created ops are valid). An invalid // are not in the `ops` set (The new created ops are valid). An invalid
// operation will trigger the assertion while processing. // operation will trigger the assertion while processing.
(void)applyOpPatternsAndFold(makeArrayRef(ops), std::move(patterns), (void)applyOpPatternsAndFold(ArrayRef(ops), std::move(patterns),
/*strict=*/true); /*strict=*/true);
} }
Context not available.
for (auto &op : getOperation().getBody().front()) for (auto &op : getOperation().getBody().front())
ops.push_back(&op); ops.push_back(&op);
// Generate test patterns for each, but skip terminator. // Generate test patterns for each, but skip terminator.
for (auto *op : llvm::makeArrayRef(ops).drop_back()) { for (auto *op : llvm::ArrayRef(ops).drop_back()) {
// Test create method of each of the Op classes below. The resultant // Test create method of each of the Op classes below. The resultant
// output would be in reverse order underneath `op` from which // output would be in reverse order underneath `op` from which
// the attributes and regions are used. // the attributes and regions are used.
Context not available.

mlir/test/mlir-tblgen/op-attribute.td

Context not available.
// DECL: static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() // DECL: static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames()
// DECL-NEXT: static ::llvm::StringRef attrNames[] = // DECL-NEXT: static ::llvm::StringRef attrNames[] =
// DECL-SAME: {::llvm::StringRef("aAttr"), ::llvm::StringRef("bAttr"), ::llvm::StringRef("cAttr"), ::llvm::StringRef("dAttr")}; // DECL-SAME: {::llvm::StringRef("aAttr"), ::llvm::StringRef("bAttr"), ::llvm::StringRef("cAttr"), ::llvm::StringRef("dAttr")};
// DECL-NEXT: return ::llvm::makeArrayRef(attrNames); // DECL-NEXT: return ::llvm::ArrayRef(attrNames);
// DECL: ::mlir::StringAttr getAAttrAttrName() // DECL: ::mlir::StringAttr getAAttrAttrName()
// DECL-NEXT: return getAttributeNameForIndex(0); // DECL-NEXT: return getAttributeNameForIndex(0);
Context not available.
// DECL: static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() // DECL: static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames()
// DECL-NEXT: static ::llvm::StringRef attrNames[] = // DECL-NEXT: static ::llvm::StringRef attrNames[] =
// DECL-SAME: {::llvm::StringRef("aAttr"), ::llvm::StringRef("bAttr"), ::llvm::StringRef("cAttr")}; // DECL-SAME: {::llvm::StringRef("aAttr"), ::llvm::StringRef("bAttr"), ::llvm::StringRef("cAttr")};
// DECL-NEXT: return ::llvm::makeArrayRef(attrNames); // DECL-NEXT: return ::llvm::ArrayRef(attrNames);
// DECL: ::mlir::StringAttr getAAttrAttrName() // DECL: ::mlir::StringAttr getAAttrAttrName()
// DECL-NEXT: return getAttributeNameForIndex(0); // DECL-NEXT: return getAttributeNameForIndex(0);
Context not available.

mlir/tools/mlir-tblgen/AttrOrTypeFormatGen.cpp

Context not available.
os << ") {\n"; os << ") {\n";
} else if (auto *param = dyn_cast<ParameterElement>(first)) { } else if (auto *param = dyn_cast<ParameterElement>(first)) {
genVariableParser(param, ctx, os); genVariableParser(param, ctx, os);
guardOn(llvm::makeArrayRef(param)); guardOn(llvm::ArrayRef(param));
} else if (auto *params = dyn_cast<ParamsDirective>(first)) { } else if (auto *params = dyn_cast<ParamsDirective>(first)) {
genParamsParser(params, ctx, os); genParamsParser(params, ctx, os);
guardOn(params->getParams()); guardOn(params->getParams());
Context not available.
MethodBody &os) { MethodBody &os) {
FormatElement *anchor = el->getAnchor(); FormatElement *anchor = el->getAnchor();
if (auto *param = dyn_cast<ParameterElement>(anchor)) { if (auto *param = dyn_cast<ParameterElement>(anchor)) {
guardOnAny(ctx, os, llvm::makeArrayRef(param), el->isInverted()); guardOnAny(ctx, os, llvm::ArrayRef(param), el->isInverted());
} else if (auto *params = dyn_cast<ParamsDirective>(anchor)) { } else if (auto *params = dyn_cast<ParamsDirective>(anchor)) {
guardOnAny(ctx, os, params->getParams(), el->isInverted()); guardOnAny(ctx, os, params->getParams(), el->isInverted());
} else if (auto *strct = dyn_cast<StructDirective>(anchor)) { } else if (auto *strct = dyn_cast<StructDirective>(anchor)) {
Context not available.

mlir/tools/mlir-tblgen/FormatGen.h

Context not available.
/// Return the `then` elements of the optional group. Drops the first /// Return the `then` elements of the optional group. Drops the first
/// `thenParseStart` whitespace elements if `parseable` is true. /// `thenParseStart` whitespace elements if `parseable` is true.
ArrayRef<FormatElement *> getThenElements(bool parseable = false) const { ArrayRef<FormatElement *> getThenElements(bool parseable = false) const {
return llvm::makeArrayRef(thenElements) return llvm::ArrayRef(thenElements)
.drop_front(parseable ? thenParseStart : 0); .drop_front(parseable ? thenParseStart : 0);
} }
/// Return the `else` elements of the optional group. Drops the first /// Return the `else` elements of the optional group. Drops the first
/// `elseParseStart` whitespace elements if `parseable` is true. /// `elseParseStart` whitespace elements if `parseable` is true.
ArrayRef<FormatElement *> getElseElements(bool parseable = false) const { ArrayRef<FormatElement *> getElseElements(bool parseable = false) const {
return llvm::makeArrayRef(elseElements) return llvm::ArrayRef(elseElements)
.drop_front(parseable ? elseParseStart : 0); .drop_front(parseable ? elseParseStart : 0);
} }
Context not available.

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

Context not available.
[&](StringRef attrName) { [&](StringRef attrName) {
body << "::llvm::StringRef(\"" << attrName << "\")"; body << "::llvm::StringRef(\"" << attrName << "\")";
}); });
body << "};\n return ::llvm::makeArrayRef(attrNames);"; body << "};\n return ::llvm::ArrayRef(attrNames);";
} }
// Emit the getAttributeNameForIndex methods. // Emit the getAttributeNameForIndex methods.
Context not available.

mlir/tools/mlir-tblgen/OpPythonBindingGen.cpp

Context not available.
populateBuilderLinesOperand(op, operandArgNames, builderLines); populateBuilderLinesOperand(op, operandArgNames, builderLines);
populateBuilderLinesAttr( populateBuilderLinesAttr(
op, llvm::makeArrayRef(builderArgs).drop_front(numResultArgs), op, llvm::ArrayRef(builderArgs).drop_front(numResultArgs), builderLines);
builderLines);
populateBuilderLinesResult( populateBuilderLinesResult(
op, llvm::makeArrayRef(builderArgs).take_front(numResultArgs), op, llvm::ArrayRef(builderArgs).take_front(numResultArgs), builderLines);
builderLines);
populateBuilderLinesSuccessors(op, successorArgNames, builderLines); populateBuilderLinesSuccessors(op, successorArgNames, builderLines);
populateBuilderRegions(op, builderArgs, builderLines); populateBuilderRegions(op, builderArgs, builderLines);
Context not available.

mlir/unittests/IR/AttributeTest.cpp

Context not available.
EXPECT_TRUE(splat.isSplat()); EXPECT_TRUE(splat.isSplat());
auto detectedSplat = auto detectedSplat =
DenseElementsAttr::get(shape, llvm::makeArrayRef({splatElt, splatElt})); DenseElementsAttr::get(shape, llvm::ArrayRef({splatElt, splatElt}));
EXPECT_EQ(detectedSplat, splat); EXPECT_EQ(detectedSplat, splat);
for (auto newValue : detectedSplat.template getValues<EltTy>()) for (auto newValue : detectedSplat.template getValues<EltTy>())
Context not available.
Attribute value = IntegerAttr::get(intTy, elementValue); Attribute value = IntegerAttr::get(intTy, elementValue);
RankedTensorType shape = RankedTensorType::get({}, intTy); RankedTensorType shape = RankedTensorType::get({}, intTy);
auto attr = DenseElementsAttr::get(shape, llvm::makeArrayRef({elementValue})); auto attr = DenseElementsAttr::get(shape, llvm::ArrayRef({elementValue}));
EXPECT_TRUE(attr.getValues<Attribute>()[0] == value); EXPECT_TRUE(attr.getValues<Attribute>()[0] == value);
} }
Context not available.
RankedTensorType shape = RankedTensorType::get({4}, intTy); RankedTensorType shape = RankedTensorType::get({4}, intTy);
auto attr = auto attr =
DenseElementsAttr::get(shape, llvm::makeArrayRef({elementValue})) DenseElementsAttr::get(shape, llvm::ArrayRef({elementValue}))
.mapValues(boolTy, [](const APInt &x) { .mapValues(boolTy, [](const APInt &x) {
return x.isZero() ? APInt::getZero(1) : APInt::getAllOnes(1); return x.isZero() ? APInt::getZero(1) : APInt::getAllOnes(1);
}); });
Context not available.
RankedTensorType shape = RankedTensorType::get({4}, intTy); RankedTensorType shape = RankedTensorType::get({4}, intTy);
auto attr = auto attr =
DenseElementsAttr::get(shape, llvm::makeArrayRef({elementValue})) DenseElementsAttr::get(shape, llvm::ArrayRef({elementValue}))
.mapValues(boolTy, [](const APInt &x) { .mapValues(boolTy, [](const APInt &x) {
return x.isZero() ? APInt::getZero(1) : APInt::getAllOnes(1); return x.isZero() ? APInt::getZero(1) : APInt::getAllOnes(1);
}); });
Context not available.
template <typename AttrT, typename T> template <typename AttrT, typename T>
static void checkNativeIntAccess(Builder &builder, size_t intWidth) { static void checkNativeIntAccess(Builder &builder, size_t intWidth) {
T data[] = {0, 1, 2}; T data[] = {0, 1, 2};
checkNativeAccess<AttrT, T>(builder.getContext(), llvm::makeArrayRef(data), checkNativeAccess<AttrT, T>(builder.getContext(), llvm::ArrayRef(data),
builder.getIntegerType(intWidth)); builder.getIntegerType(intWidth));
} }
Context not available.
// Bool // Bool
bool boolData[] = {true, false, true}; bool boolData[] = {true, false, true};
checkNativeAccess<DenseBoolResourceElementsAttr>( checkNativeAccess<DenseBoolResourceElementsAttr>(
&context, llvm::makeArrayRef(boolData), builder.getI1Type()); &context, llvm::ArrayRef(boolData), builder.getI1Type());
// Unsigned integers // Unsigned integers
checkNativeIntAccess<DenseUI8ResourceElementsAttr, uint8_t>(builder, 8); checkNativeIntAccess<DenseUI8ResourceElementsAttr, uint8_t>(builder, 8);
Context not available.
// Float // Float
float floatData[] = {0, 1, 2}; float floatData[] = {0, 1, 2};
checkNativeAccess<DenseF32ResourceElementsAttr>( checkNativeAccess<DenseF32ResourceElementsAttr>(
&context, llvm::makeArrayRef(floatData), builder.getF32Type()); &context, llvm::ArrayRef(floatData), builder.getF32Type());
// Double // Double
double doubleData[] = {0, 1, 2}; double doubleData[] = {0, 1, 2};
checkNativeAccess<DenseF64ResourceElementsAttr>( checkNativeAccess<DenseF64ResourceElementsAttr>(
&context, llvm::makeArrayRef(doubleData), builder.getF64Type()); &context, llvm::ArrayRef(doubleData), builder.getF64Type());
} }
TEST(DenseResourceElementsAttrTest, CheckNoCast) { TEST(DenseResourceElementsAttrTest, CheckNoCast) {
Context not available.

mlir/unittests/IR/SubElementInterfaceTest.cpp

Context not available.
SmallVector<Attribute> subAttrs; SmallVector<Attribute> subAttrs;
dictAttr.walkSubAttrs([&](Attribute attr) { subAttrs.push_back(attr); }); dictAttr.walkSubAttrs([&](Attribute attr) { subAttrs.push_back(attr); });
EXPECT_EQ(llvm::makeArrayRef(subAttrs), EXPECT_EQ(llvm::ArrayRef(subAttrs),
ArrayRef<Attribute>({strAttr, trueAttr, falseAttr, boolArrayAttr})); ArrayRef<Attribute>({strAttr, trueAttr, falseAttr, boolArrayAttr}));
} }
Context not available.