This is an archive of the discontinued LLVM Phabricator instance.

Differential D141298

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

Authored by serge-sans-paille on Jan 9 2023, 9:13 AM.

Details

Reviewers
mehdi_amini
antiagainst
rriddle
aartbik
MaskRay
jpienaar
ftynse
awarzynski
bondhugula
rafauler
Amir
maksfb
ThomasRaoux
njames93
nicolasvasilache
herhut
dcaballe
Commits
rG984b800a036f: Move from llvm::makeArrayRef to ArrayRef deduction guides - last part
Summary

This is a follow-up to https://reviews.llvm.org/D140896, split into
several parts as it touches a lot of files.

Diff Detail

Event Timeline

serge-sans-paille created this revision.Jan 9 2023, 9:13 AM
Herald added a reviewer: antiagainst. · View Herald TranscriptJan 9 2023, 9:13 AM
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: njames93. · View Herald Transcript
Herald added projects: Restricted Project, Restricted Project, Restricted Project. · View Herald Transcript
Herald added subscribers: libc-commits, hanchung, kadircet and 68 others. · View Herald Transcript
serge-sans-paille requested review of this revision.Jan 9 2023, 9:13 AM
Herald added a reviewer: nicolasvasilache. · View Herald TranscriptJan 9 2023, 9:13 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. · View Herald Transcript
Herald added subscribers: cfe-commits, llvm-commits, lldb-commits and 5 others. · View Herald Transcript
serge-sans-paille added a comment.Jan 9 2023, 9:13 AM

Once that patch lands, I'll mark makeArrayRef as deprecated.

Herald added subscribers: Michael137, JDevlieghere. · View Herald TranscriptJan 9 2023, 9:13 AM
Harbormaster completed remote builds in B206564: Diff 487469.Jan 9 2023, 9:13 AM
mehdi_amini added a comment.Jan 9 2023, 9:23 AM

Seems mechanical, and if it build everywhere LGTM :)

serge-sans-paille updated this revision to Diff 487484.Jan 9 2023, 9:40 AM
Harbormaster completed remote builds in B206576: Diff 487484.Jan 9 2023, 9:41 AM
MaskRay accepted this revision.Jan 9 2023, 11:24 AM
serge-sans-paille updated this revision to Diff 487685.Jan 9 2023, 10:24 PM

Fix rebase

Harbormaster completed remote builds in B206711: Diff 487685.Jan 9 2023, 10:24 PM
This revision was not accepted when it landed; it landed in state Needs Review.Jan 10 2023, 2:48 AM
This revision was landed with ongoing or failed builds.
Closed by commit rG984b800a036f: Move from llvm::makeArrayRef to ArrayRef deduction guides - last part (authored by serge-sans-paille). · Explain Why
This revision was automatically updated to reflect the committed changes.
serge-sans-paille added a commit: rG984b800a036f: Move from llvm::makeArrayRef to ArrayRef deduction guides - last part.

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
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
2 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
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 487727

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

Show First 20 Lines • Show All 145 Lines • ▼ Show 20 Lines for (uint64_t Address : opts::Translate) {
<< Twine::utohexstr( << Twine::utohexstr(
BAT.translate(FI->first, Address - FI->first, false)) BAT.translate(FI->first, Address - FI->first, false))
<< "\n"; << "\n";
} }
} }
} }
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))
report_error(opts::InputFilename, errc::no_such_file_or_directory); report_error(opts::InputFilename, errc::no_such_file_or_directory);
ToolName = argv[0]; ToolName = argv[0];
std::string ToolPath = GetExecutablePath(argv[0]); std::string ToolPath = GetExecutablePath(argv[0]);
Expected<llvm::object::OwningBinary<llvm::object::Binary>> BinaryOrErr = Expected<llvm::object::OwningBinary<llvm::object::Binary>> BinaryOrErr =
Show All 13 Lines

bolt/tools/driver/llvm-bolt.cpp

Show First 20 Lines • Show All 92 Lines • ▼ Show 20 Linesstatic void report_error(StringRef Message, Error E) {
exit(1); exit(1);
} }
static void printBoltRevision(llvm::raw_ostream &OS) { static void printBoltRevision(llvm::raw_ostream &OS) {
OS << "BOLT revision " << BoltRevision << "\n"; OS << "BOLT revision " << BoltRevision << "\n";
} }
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,
"perf2bolt - BOLT data aggregator\n" "perf2bolt - BOLT data aggregator\n"
"\nEXAMPLE: perf2bolt -p=perf.data executable -o data.fdata\n"); "\nEXAMPLE: perf2bolt -p=perf.data executable -o data.fdata\n");
if (opts::PerfData.empty()) { if (opts::PerfData.empty()) {
errs() << ToolName << ": expected -perfdata=<filename> option.\n"; errs() << ToolName << ": expected -perfdata=<filename> option.\n";
exit(1); exit(1);
Show All 12 Linesvoid perf2boltMode(int argc, char **argv) {
if (opts::OutputFilename.empty()) { if (opts::OutputFilename.empty()) {
errs() << ToolName << ": expected -o=<output file> option.\n"; errs() << ToolName << ": expected -o=<output file> option.\n";
exit(1); exit(1);
} }
opts::AggregateOnly = true; opts::AggregateOnly = true;
} }
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,
"llvm-boltdiff - BOLT binary diff tool\n" "llvm-boltdiff - BOLT binary diff tool\n"
"\nEXAMPLE: llvm-boltdiff -data=a.fdata -data2=b.fdata exec1 exec2\n"); "\nEXAMPLE: llvm-boltdiff -data=a.fdata -data2=b.fdata exec1 exec2\n");
if (opts::InputDataFilename2.empty()) { if (opts::InputDataFilename2.empty()) {
errs() << ToolName << ": expected -data2=<filename> option.\n"; errs() << ToolName << ": expected -data2=<filename> option.\n";
exit(1); exit(1);
Show All 9 Linesvoid boltDiffMode(int argc, char **argv) {
if (opts::InputFilename.empty()) { if (opts::InputFilename.empty()) {
errs() << ToolName << ": expected binary.\n"; errs() << ToolName << ": expected binary.\n";
exit(1); exit(1);
} }
opts::DiffOnly = true; opts::DiffOnly = true;
} }
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);
cl::ParseCommandLineOptions(argc, argv, cl::ParseCommandLineOptions(argc, argv,
"BOLT - Binary Optimization and Layout Tool\n"); "BOLT - Binary Optimization and Layout Tool\n");
if (opts::OutputFilename.empty()) { if (opts::OutputFilename.empty()) {
▲ Show 20 Lines • Show All 149 Lines • Show Last 20 Lines

bolt/tools/heatmap/heatmap.cpp

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Linesstatic std::string GetExecutablePath(const char *Argv0) {
if (!llvm::sys::fs::exists(ExecutablePath)) if (!llvm::sys::fs::exists(ExecutablePath))
if (llvm::ErrorOr<std::string> P = if (llvm::ErrorOr<std::string> P =
llvm::sys::findProgramByName(ExecutablePath)) llvm::sys::findProgramByName(ExecutablePath))
ExecutablePath = *P; ExecutablePath = *P;
return std::string(ExecutablePath.str()); return std::string(ExecutablePath.str());
} }
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()) {
errs() << ToolName << ": expected -perfdata=<filename> option.\n"; errs() << ToolName << ": expected -perfdata=<filename> option.\n";
exit(1); exit(1);
} }
opts::HeatmapMode = true; opts::HeatmapMode = true;
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 85 Lines • ▼ Show 20 Lines
}; };
} // namespace } // namespace
static void printVersion(raw_ostream &OS) { static void printVersion(raw_ostream &OS) {
OS << "clang-apply-replacements version " CLANG_VERSION_STRING << "\n"; OS << "clang-apply-replacements version " CLANG_VERSION_STRING << "\n";
} }
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);
IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts(new DiagnosticOptions()); IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts(new DiagnosticOptions());
DiagnosticsEngine Diagnostics( DiagnosticsEngine Diagnostics(
IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs()), DiagOpts.get()); IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs()), DiagOpts.get());
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 347 Lines • ▼ Show 20 Lines
void ArgumentCommentCheck::check(const MatchFinder::MatchResult &Result) { void ArgumentCommentCheck::check(const MatchFinder::MatchResult &Result) {
const auto *E = Result.Nodes.getNodeAs<Expr>("expr"); const auto *E = Result.Nodes.getNodeAs<Expr>("expr");
if (const auto *Call = dyn_cast<CallExpr>(E)) { if (const auto *Call = dyn_cast<CallExpr>(E)) {
const FunctionDecl *Callee = Call->getDirectCallee(); const FunctionDecl *Callee = Call->getDirectCallee();
if (!Callee) if (!Callee)
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 &&
Construct->getArg(0)->getSourceRange() == Construct->getSourceRange()) { Construct->getArg(0)->getSourceRange() == Construct->getSourceRange()) {
// Ignore implicit construction. // Ignore implicit construction.
return; return;
} }
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()));
} }
} }
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

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

Show First 20 Lines • Show All 230 Lines • ▼ Show 20 Lines getEnumMapping() {
static constexpr std::pair< static constexpr std::pair<
bugprone::SignalHandlerCheck::AsyncSafeFunctionSetKind, StringRef> bugprone::SignalHandlerCheck::AsyncSafeFunctionSetKind, StringRef>
Mapping[] = { Mapping[] = {
{bugprone::SignalHandlerCheck::AsyncSafeFunctionSetKind::Minimal, {bugprone::SignalHandlerCheck::AsyncSafeFunctionSetKind::Minimal,
"minimal"}, "minimal"},
{bugprone::SignalHandlerCheck::AsyncSafeFunctionSetKind::POSIX, {bugprone::SignalHandlerCheck::AsyncSafeFunctionSetKind::POSIX,
"POSIX"}, "POSIX"},
}; };
return makeArrayRef(Mapping); return ArrayRef(Mapping);
} }
}; };
namespace bugprone { namespace bugprone {
namespace { namespace {
/// Returns if a function is declared inside a system header. /// Returns if a function is declared inside a system header.
▲ Show 20 Lines • Show All 317 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 264 Lines • ▼ Show 20 Linestemplate <> struct OptionEnumMapping<concurrency::MtUnsafeCheck::FunctionSet> {
static llvm::ArrayRef< static llvm::ArrayRef<
std::pair<concurrency::MtUnsafeCheck::FunctionSet, StringRef>> std::pair<concurrency::MtUnsafeCheck::FunctionSet, StringRef>>
getEnumMapping() { getEnumMapping() {
static constexpr std::pair<concurrency::MtUnsafeCheck::FunctionSet, static constexpr std::pair<concurrency::MtUnsafeCheck::FunctionSet,
StringRef> StringRef>
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);
} }
}; };
namespace concurrency { namespace concurrency {
static ast_matchers::internal::Matcher<clang::NamedDecl> static ast_matchers::internal::Matcher<clang::NamedDecl>
hasAnyMtUnsafeNames(MtUnsafeCheck::FunctionSet Libc) { hasAnyMtUnsafeNames(MtUnsafeCheck::FunctionSet Libc) {
switch (Libc) { switch (Libc) {
Show All 35 Lines

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

Show First 20 Lines • Show All 621 Lines • ▼ Show 20 Lines for (const BindArgument &B : LP.BindArguments) {
if (emitCapture(CaptureSet, Delimiter, B.CM, B.CE, B.CaptureIdentifier, if (emitCapture(CaptureSet, Delimiter, B.CM, B.CE, B.CaptureIdentifier,
B.SourceTokens, Stream)) B.SourceTokens, Stream))
AnyCapturesEmitted = true; AnyCapturesEmitted = true;
} }
} }
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;
return Args.drop_front(); return Args.drop_front();
} }
AvoidBindCheck::AvoidBindCheck(StringRef Name, ClangTidyContext *Context) AvoidBindCheck::AvoidBindCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
PermissiveParameterList(Options.get("PermissiveParameterList", false)) {} PermissiveParameterList(Options.get("PermissiveParameterList", false)) {}
Show All 28 Linesvoid AvoidBindCheck::check(const MatchFinder::MatchResult &Result) {
std::string Buffer; std::string Buffer;
llvm::raw_string_ostream Stream(Buffer); llvm::raw_string_ostream Stream(Buffer);
Stream << "["; Stream << "[";
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);
if (LP.Callable.Type == CT_Function) { if (LP.Callable.Type == CT_Function) {
StringRef SourceTokens = LP.Callable.SourceTokens; StringRef SourceTokens = LP.Callable.SourceTokens;
SourceTokens.consume_front("&"); SourceTokens.consume_front("&");
Stream << " { return " << SourceTokens; Stream << " { return " << SourceTokens;
} else if (LP.Callable.Type == CT_MemberFunction) { } else if (LP.Callable.Type == CT_MemberFunction) {
Show All 39 Lines

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

Show All 31 Lines
template <> struct OptionEnumMapping<modernize::Confidence::Level> { template <> struct OptionEnumMapping<modernize::Confidence::Level> {
static llvm::ArrayRef<std::pair<modernize::Confidence::Level, StringRef>> static llvm::ArrayRef<std::pair<modernize::Confidence::Level, StringRef>>
getEnumMapping() { getEnumMapping() {
static constexpr std::pair<modernize::Confidence::Level, StringRef> static constexpr std::pair<modernize::Confidence::Level, StringRef>
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);
} }
}; };
template <> struct OptionEnumMapping<modernize::VariableNamer::NamingStyle> { template <> struct OptionEnumMapping<modernize::VariableNamer::NamingStyle> {
static llvm::ArrayRef< static llvm::ArrayRef<
std::pair<modernize::VariableNamer::NamingStyle, StringRef>> std::pair<modernize::VariableNamer::NamingStyle, StringRef>>
getEnumMapping() { getEnumMapping() {
static constexpr std::pair<modernize::VariableNamer::NamingStyle, StringRef> static constexpr std::pair<modernize::VariableNamer::NamingStyle, StringRef>
Mapping[] = {{modernize::VariableNamer::NS_CamelCase, "CamelCase"}, Mapping[] = {{modernize::VariableNamer::NS_CamelCase, "CamelCase"},
{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);
} }
}; };
namespace modernize { namespace modernize {
static const char LoopNameArray[] = "forLoopArray"; static const char LoopNameArray[] = "forLoopArray";
static const char LoopNameIterator[] = "forLoopIterator"; static const char LoopNameIterator[] = "forLoopIterator";
static const char LoopNameReverseIterator[] = "forLoopReverseIterator"; static const char LoopNameReverseIterator[] = "forLoopReverseIterator";
▲ Show 20 Lines • Show All 912 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines static constexpr std::pair<readability::IdentifierNamingCheck::CaseType,
{readability::IdentifierNamingCheck::CT_LowerCase, "lower_case"}, {readability::IdentifierNamingCheck::CT_LowerCase, "lower_case"},
{readability::IdentifierNamingCheck::CT_UpperCase, "UPPER_CASE"}, {readability::IdentifierNamingCheck::CT_UpperCase, "UPPER_CASE"},
{readability::IdentifierNamingCheck::CT_CamelBack, "camelBack"}, {readability::IdentifierNamingCheck::CT_CamelBack, "camelBack"},
{readability::IdentifierNamingCheck::CT_CamelCase, "CamelCase"}, {readability::IdentifierNamingCheck::CT_CamelCase, "CamelCase"},
{readability::IdentifierNamingCheck::CT_CamelSnakeCase, {readability::IdentifierNamingCheck::CT_CamelSnakeCase,
"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 <>
struct OptionEnumMapping< struct OptionEnumMapping<
readability::IdentifierNamingCheck::HungarianPrefixType> { readability::IdentifierNamingCheck::HungarianPrefixType> {
using HungarianPrefixType = using HungarianPrefixType =
readability::IdentifierNamingCheck::HungarianPrefixType; readability::IdentifierNamingCheck::HungarianPrefixType;
static llvm::ArrayRef<std::pair<HungarianPrefixType, StringRef>> static llvm::ArrayRef<std::pair<HungarianPrefixType, StringRef>>
getEnumMapping() { getEnumMapping() {
static constexpr std::pair<HungarianPrefixType, StringRef> Mapping[] = { static constexpr std::pair<HungarianPrefixType, StringRef> Mapping[] = {
{HungarianPrefixType::HPT_Off, "Off"}, {HungarianPrefixType::HPT_Off, "Off"},
{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);
} }
}; };
namespace readability { namespace readability {
// clang-format off // clang-format off
#define NAMING_KEYS(m) \ #define NAMING_KEYS(m) \
m(Namespace) \ m(Namespace) \
▲ Show 20 Lines • Show All 1,382 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 225 Lines • ▼ Show 20 Lines
} // namespace utils } // namespace utils
llvm::ArrayRef<std::pair<utils::IncludeSorter::IncludeStyle, StringRef>> llvm::ArrayRef<std::pair<utils::IncludeSorter::IncludeStyle, StringRef>>
OptionEnumMapping<utils::IncludeSorter::IncludeStyle>::getEnumMapping() { OptionEnumMapping<utils::IncludeSorter::IncludeStyle>::getEnumMapping() {
static constexpr std::pair<utils::IncludeSorter::IncludeStyle, StringRef> static constexpr std::pair<utils::IncludeSorter::IncludeStyle, StringRef>
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

clang-tools-extra/clangd/ClangdLSPServer.cpp

Show First 20 Lines • Show All 499 Lines • ▼ Show 20 Lines if (Opts.UseDirBasedCDB) {
if (const auto &Dir = Params.initializationOptions.compilationDatabasePath) if (const auto &Dir = Params.initializationOptions.compilationDatabasePath)
CDBOpts.CompileCommandsDir = Dir; CDBOpts.CompileCommandsDir = Dir;
CDBOpts.ContextProvider = Opts.ContextProvider; CDBOpts.ContextProvider = Opts.ContextProvider;
BaseCDB = BaseCDB =
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;
CDB.emplace(BaseCDB.get(), Params.initializationOptions.fallbackFlags, CDB.emplace(BaseCDB.get(), Params.initializationOptions.fallbackFlags,
std::move(Mangler)); std::move(Mangler));
{ {
// Switch caller's context with LSPServer's background context. Since we // Switch caller's context with LSPServer's background context. Since we
// rather want to propagate information from LSPServer's context into the // rather want to propagate information from LSPServer's context into the
// Server, CDB, etc. // Server, CDB, etc.
▲ Show 20 Lines • Show All 1,306 Lines • Show Last 20 Lines

clang-tools-extra/clangd/CompileCommands.cpp

Show First 20 Lines • Show All 205 Lines • ▼ Show 20 Lines if (Cmd.empty())
return; return;
auto &OptTable = clang::driver::getDriverOptTable(); auto &OptTable = clang::driver::getDriverOptTable();
// OriginalArgs needs to outlive ArgList. // OriginalArgs needs to outlive ArgList.
llvm::SmallVector<const char *, 16> OriginalArgs; llvm::SmallVector<const char *, 16> OriginalArgs;
OriginalArgs.reserve(Cmd.size()); OriginalArgs.reserve(Cmd.size());
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;
// Drop the executable name, as ParseArgs doesn't expect it. This means // Drop the executable name, as ParseArgs doesn't expect it. This means
// 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)
: /*everything*/ 0, : /*everything*/ 0,
/*FlagsToExclude=*/driver::options::NoDriverOption | /*FlagsToExclude=*/driver::options::NoDriverOption |
(IsCLMode (IsCLMode
? 0 ? 0
: (driver::options::CLOption | driver::options::CLDXCOption))); : (driver::options::CLOption | driver::options::CLDXCOption)));
▲ Show 20 Lines • Show All 436 Lines • Show Last 20 Lines

clang-tools-extra/clangd/FindSymbols.cpp

Show First 20 Lines • Show All 638 Lines • ▼ Show 20 Linesstd::vector<DocumentSymbol> collectDocSymbols(ParsedAST &AST) {
for (const auto &P : PragmaMarks) for (const auto &P : PragmaMarks)
Pragmas.push_back(markToSymbol(P)); Pragmas.push_back(markToSymbol(P));
Range EntireFile = { Range EntireFile = {
{0, 0}, {0, 0},
{std::numeric_limits<int>::max(), std::numeric_limits<int>::max()}}; {std::numeric_limits<int>::max(), std::numeric_limits<int>::max()}};
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;
} }
} // namespace } // namespace
llvm::Expected<std::vector<DocumentSymbol>> getDocumentSymbols(ParsedAST &AST) { llvm::Expected<std::vector<DocumentSymbol>> getDocumentSymbols(ParsedAST &AST) {
return collectDocSymbols(AST); return collectDocSymbols(AST);
} }
} // namespace clangd } // namespace clangd
} // namespace clang } // namespace clang

clang-tools-extra/clangd/Preamble.cpp

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Lines
namespace clangd { namespace clangd {
namespace { namespace {
constexpr llvm::StringLiteral PreamblePatchHeaderName = "__preamble_patch__.h"; constexpr llvm::StringLiteral PreamblePatchHeaderName = "__preamble_patch__.h";
bool compileCommandsAreEqual(const tooling::CompileCommand &LHS, bool compileCommandsAreEqual(const tooling::CompileCommand &LHS,
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 {
public: public:
CppFilePreambleCallbacks( CppFilePreambleCallbacks(
PathRef File, PreambleParsedCallback ParsedCallback, PathRef File, PreambleParsedCallback ParsedCallback,
PreambleBuildStats *Stats, bool ParseForwardingFunctions, PreambleBuildStats *Stats, bool ParseForwardingFunctions,
std::function<void(CompilerInstance &)> BeforeExecuteCallback) std::function<void(CompilerInstance &)> BeforeExecuteCallback)
▲ Show 20 Lines • Show All 705 Lines • Show Last 20 Lines

clang-tools-extra/clangd/Selection.cpp

Show First 20 Lines • Show All 256 Lines • ▼ Show 20 Lines SelectionTester(const syntax::TokenBuffer &Buf, FileID SelFile,
const syntax::Token *SelFirst = const syntax::Token *SelFirst =
llvm::partition_point(AllSpelledTokens, [&](const syntax::Token &Tok) { llvm::partition_point(AllSpelledTokens, [&](const syntax::Token &Tok) {
return SM.getFileOffset(Tok.endLocation()) <= SelBegin; return SM.getFileOffset(Tok.endLocation()) <= SelBegin;
}); });
const syntax::Token *SelLimit = std::partition_point( const syntax::Token *SelLimit = std::partition_point(
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 :
Buf.expansionsOverlapping(Sel)) { Buf.expansionsOverlapping(Sel)) {
if (X.Expanded.empty()) { if (X.Expanded.empty()) {
for (const syntax::Token &Tok : X.Spelled) { for (const syntax::Token &Tok : X.Spelled) {
if (&Tok >= SelFirst && &Tok < SelLimit) if (&Tok >= SelFirst && &Tok < SelLimit)
PPIgnored[&Tok - SelFirst] = true; PPIgnored[&Tok - SelFirst] = true;
▲ Show 20 Lines • Show All 140 Lines • ▼ Show 20 Lines const syntax::Token *End = std::partition_point(
// file, there shouldn't be any more implicit inclusions. // file, there shouldn't be any more implicit inclusions.
assert(false && "Expanded token could not be resolved to main file!"); assert(false && "Expanded token could not be resolved to main file!");
EndInvalid = true; EndInvalid = true;
return true; // conservatively assume this token can overlap return true; // conservatively assume this token can overlap
}); });
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.
SelectionTree::Selection SelectionTree::Selection
testChunk(FileID FID, llvm::ArrayRef<syntax::Token> Batch) const { testChunk(FileID FID, llvm::ArrayRef<syntax::Token> Batch) const {
assert(!Batch.empty()); assert(!Batch.empty());
SourceLocation StartLoc = Batch.front().location(); SourceLocation StartLoc = Batch.front().location();
// There are several possible categories of FileID depending on how the // There are several possible categories of FileID depending on how the
▲ Show 20 Lines • Show All 697 Lines • Show Last 20 Lines

clang-tools-extra/clangd/XRefs.cpp

Show First 20 Lines • Show All 720 Lines • ▼ Show 20 Linesconst syntax::Token *findNearbyIdentifier(const SpelledWord &Word,
}; };
auto SpelledTokens = TB.spelledTokens(File); auto SpelledTokens = TB.spelledTokens(File);
// Find where the word occurred in the token stream, to search forward & back. // Find where the word occurred in the token stream, to search forward & back.
auto *I = llvm::partition_point(SpelledTokens, [&](const syntax::Token &T) { auto *I = llvm::partition_point(SpelledTokens, [&](const syntax::Token &T) {
assert(SM.getFileID(T.location()) == SM.getFileID(Word.Location)); assert(SM.getFileID(T.location()) == SM.getFileID(Word.Location));
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;
if (BestTok) if (BestTok)
vlog( vlog(
"Word {0} under cursor {1} isn't a token (after PP), trying nearby {2}", "Word {0} under cursor {1} isn't a token (after PP), trying nearby {2}",
Word.Text, Word.Location.printToString(SM), Word.Text, Word.Location.printToString(SM),
BestTok->location().printToString(SM)); BestTok->location().printToString(SM));
▲ Show 20 Lines • Show All 1,513 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 236 Lines • ▼ Show 20 LinesgetFunctionSourceCode(const FunctionDecl *FD, llvm::StringRef TargetNamespace,
DelAttr(FD->getAttr<FinalAttr>()); DelAttr(FD->getAttr<FinalAttr>());
auto DelKeyword = [&](tok::TokenKind Kind, SourceRange FromRange) { auto DelKeyword = [&](tok::TokenKind Kind, SourceRange FromRange) {
bool FoundAny = false; bool FoundAny = false;
for (const auto &Tok : TokBuf.expandedTokens(FromRange)) { for (const auto &Tok : TokBuf.expandedTokens(FromRange)) {
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),
error("define outline: couldn't remove `{0}` keyword.", error("define outline: couldn't remove `{0}` keyword.",
tok::getKeywordSpelling(Kind))); tok::getKeywordSpelling(Kind)));
break; break;
} }
CharSourceRange DelRange = CharSourceRange DelRange =
▲ Show 20 Lines • Show All 212 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 139 Lines • ▼ Show 20 Lines bool buildCommand(const ThreadsafeFS &TFS) {
log("Loading compilation database..."); log("Loading compilation database...");
DirectoryBasedGlobalCompilationDatabase::Options CDBOpts(TFS); DirectoryBasedGlobalCompilationDatabase::Options CDBOpts(TFS);
CDBOpts.CompileCommandsDir = CDBOpts.CompileCommandsDir =
Config::current().CompileFlags.CDBSearch.FixedCDBPath; Config::current().CompileFlags.CDBSearch.FixedCDBPath;
std::unique_ptr<GlobalCompilationDatabase> BaseCDB = std::unique_ptr<GlobalCompilationDatabase> BaseCDB =
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>(
BaseCDB.get(), std::vector<std::string>{}, std::move(Mangler)); BaseCDB.get(), std::vector<std::string>{}, std::move(Mangler));
if (auto TrueCmd = CDB->getCompileCommand(File)) { if (auto TrueCmd = CDB->getCompileCommand(File)) {
Cmd = std::move(*TrueCmd); Cmd = std::move(*TrueCmd);
log("Compile command {0} is: {1}", log("Compile command {0} is: {1}",
▲ Show 20 Lines • Show All 66 Lines • ▼ Show 20 Lines bool buildAST() {
log("Building AST..."); log("Building AST...");
AST = ParsedAST::build(File, Inputs, std::move(Invocation), AST = ParsedAST::build(File, Inputs, std::move(Invocation),
/*InvocationDiags=*/std::vector<Diag>{}, Preamble); /*InvocationDiags=*/std::vector<Diag>{}, Preamble);
if (!AST) { if (!AST) {
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) {
log("Indexing AST..."); log("Indexing AST...");
Index.updateMain(File, *AST); Index.updateMain(File, *AST);
} }
if (!CheckTidyTime.empty()) { if (!CheckTidyTime.empty()) {
▲ Show 20 Lines • Show All 236 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 369 Lines • ▼ Show 20 Lines
} }
TEST(CommandMangler, InputsAfterDashDash) { TEST(CommandMangler, InputsAfterDashDash) {
const auto Mangler = CommandMangler::forTests(); const auto Mangler = CommandMangler::forTests();
{ {
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
// be interpreted as a file. // be interpreted as a file.
{ {
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.
{ {
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"))));
} }
} }
TEST(CommandMangler, StripsMultipleArch) { TEST(CommandMangler, StripsMultipleArch) {
const auto Mangler = CommandMangler::forTests(); const auto Mangler = CommandMangler::forTests();
tooling::CompileCommand Cmd; tooling::CompileCommand Cmd;
Cmd.CommandLine = {"clang", "-arch", "foo", "-arch", "bar", "/Users/foo.cc"}; Cmd.CommandLine = {"clang", "-arch", "foo", "-arch", "bar", "/Users/foo.cc"};
Show All 37 Lines

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

Show First 20 Lines • Show All 454 Lines • ▼ Show 20 Lines void writeCode() {
}; };
std::vector<unsigned> RefOrder(Refs.size()); std::vector<unsigned> RefOrder(Refs.size());
std::iota(RefOrder.begin(), RefOrder.end(), 0); std::iota(RefOrder.begin(), RefOrder.end(), 0);
llvm::stable_sort(RefOrder, [&](unsigned A, unsigned B) { llvm::stable_sort(RefOrder, [&](unsigned A, unsigned B) {
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) {
// Finish refs early at EOL to avoid dealing with splitting the span. // Finish refs early at EOL to avoid dealing with splitting the span.
if (End && (End == I || Code[I] == '\n')) { if (End && (End == I || Code[I] == '\n')) {
OS << "</span>"; OS << "</span>";
End = 0; End = 0;
} }
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 133 Lines • ▼ Show 20 Linesprivate:
} }
static uint16_t static uint16_t
ambiguousData(llvm::ArrayRef<const ForestNode *> Alternatives) { ambiguousData(llvm::ArrayRef<const ForestNode *> Alternatives) {
return Alternatives.size(); return Alternatives.size();
} }
// 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),
Num); Num);
} }
Token::Index StartIndex; Token::Index StartIndex;
Kind K : 4; Kind K : 4;
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 77 Lines • ▼ Show 20 Lines struct alignas(struct Node *) Node {
// this node is reduced. // this node is reduced.
unsigned ParentCount; unsigned ParentCount;
// The parse node for the last parsed symbol. // The parse node for the last parsed symbol.
// This symbol appears on the left of the dot in the parse state's items. // This symbol appears on the left of the dot in the parse state's items.
// (In the literature, the node is attached to the *edge* to the parent). // (In the literature, the node is attached to the *edge* to the parent).
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*.
}; };
// Allocates a new node in the graph. // Allocates a new node in the graph.
const Node *addNode(LRTable::StateID State, const ForestNode *Symbol, const Node *addNode(LRTable::StateID State, const ForestNode *Symbol,
llvm::ArrayRef<const Node *> Parents); llvm::ArrayRef<const Node *> Parents);
// Frees all nodes not reachable as ancestors of Roots, and returns the count. // Frees all nodes not reachable as ancestors of Roots, and returns the count.
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 92 Lines • ▼ Show 20 Linespublic:
// check whether a reduction should apply in the current context: // check whether a reduction should apply in the current context:
// for (RuleID R : LR.getReduceRules(S)) { // for (RuleID R : LR.getReduceRules(S)) {
// if (!LR.canFollow(G.lookupRule(R).Target, NextToken)) // if (!LR.canFollow(G.lookupRule(R).Target, NextToken))
// continue; // continue;
// // ...apply reduce... // // ...apply reduce...
// } // }
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 {
assert(isToken(Terminal)); assert(isToken(Terminal));
assert(isNonterminal(Nonterminal)); assert(isNonterminal(Nonterminal));
// tok::unknown is a sentinel value used in recovery: can follow anything. // tok::unknown is a sentinel value used in recovery: can follow anything.
return Terminal == tokenSymbol(tok::unknown) || return Terminal == tokenSymbol(tok::unknown) ||
FollowSets.test(tok::NUM_TOKENS * Nonterminal + FollowSets.test(tok::NUM_TOKENS * Nonterminal +
symbolToToken(Terminal)); symbolToToken(Terminal));
} }
// 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
// tokens as the given StartSymbol. // tokens as the given StartSymbol.
// //
// In LR parsing, the start state of `translation-unit` corresponds to // In LR parsing, the start state of `translation-unit` corresponds to
// `_ := • translation-unit`. // `_ := • translation-unit`.
// //
▲ Show 20 Lines • Show All 153 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 186 Lines • ▼ Show 20 LinesForestArena::createTerminals(const TokenStream &Code) {
} }
// Include an `eof` terminal. // Include an `eof` terminal.
// This is important to drive the final shift/recover/reduce loop. // This is important to drive the final shift/recover/reduce loop.
new (&Terminals[Index]) new (&Terminals[Index])
ForestNode(ForestNode::Terminal, tokenSymbol(tok::eof), ForestNode(ForestNode::Terminal, tokenSymbol(tok::eof),
/*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
} // namespace clang } // namespace clang

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

Show First 20 Lines • Show All 231 Lines • ▼ Show 20 Linesvoid glrShift(llvm::ArrayRef<const GSS::Node *> OldHeads,
// We group pending shifts by their target state so we can merge them. // We group pending shifts by their target state so we can merge them.
llvm::SmallVector<std::pair<StateID, const GSS::Node *>, 8> Shifts; llvm::SmallVector<std::pair<StateID, const GSS::Node *>, 8> Shifts;
for (const auto *H : OldHeads) for (const auto *H : OldHeads)
if (auto S = Lang.Table.getShiftState(H->State, NewTok.symbol())) if (auto S = Lang.Table.getShiftState(H->State, NewTok.symbol()))
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.
// Their heads become TempParents, the parents of the new GSS node. // Their heads become TempParents, the parents of the new GSS node.
StateID NextState = Rest.front().first; StateID NextState = Rest.front().first;
Parents.clear(); Parents.clear();
for (const auto &Base : Rest) { for (const auto &Base : Rest) {
▲ Show 20 Lines • Show All 524 Lines • Show Last 20 Lines

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

Show All 26 Lines
Grammar::Grammar(std::unique_ptr<GrammarTable> Table) : T(std::move(Table)) { Grammar::Grammar(std::unique_ptr<GrammarTable> Table) : T(std::move(Table)) {
Underscore = *findNonterminal("_"); Underscore = *findNonterminal("_");
} }
llvm::ArrayRef<Rule> Grammar::rulesFor(SymbolID SID) const { llvm::ArrayRef<Rule> Grammar::rulesFor(SymbolID SID) const {
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 {
assert(RID < T->Rules.size()); assert(RID < T->Rules.size());
return T->Rules[RID]; return T->Rules[RID];
} }
llvm::StringRef Grammar::symbolName(SymbolID SID) const { llvm::StringRef Grammar::symbolName(SymbolID SID) const {
▲ Show 20 Lines • Show All 131 Lines • ▼ Show 20 Lines
static llvm::ArrayRef<std::string> getTerminalNames() { static llvm::ArrayRef<std::string> getTerminalNames() {
static const auto &TerminalNames = []() { static const auto &TerminalNames = []() {
auto TerminalNames = new std::string[NumTerminals]; auto TerminalNames = new std::string[NumTerminals];
#define PUNCTUATOR(Tok, Spelling) TerminalNames[tok::Tok] = Spelling; #define PUNCTUATOR(Tok, Spelling) TerminalNames[tok::Tok] = Spelling;
#define KEYWORD(Keyword, Condition) \ #define KEYWORD(Keyword, Condition) \
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;
} }
GrammarTable::GrammarTable() : Terminals(getTerminalNames()) {} GrammarTable::GrammarTable() : Terminals(getTerminalNames()) {}
} // namespace pseudo } // namespace pseudo
} // namespace clang } // namespace clang

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

Show All 14 Lines
template <> struct OptionEnumMapping<Colours> { template <> struct OptionEnumMapping<Colours> {
static llvm::ArrayRef<std::pair<Colours, StringRef>> getEnumMapping() { static llvm::ArrayRef<std::pair<Colours, StringRef>> getEnumMapping() {
static constexpr std::pair<Colours, StringRef> Mapping[] = { static constexpr std::pair<Colours, StringRef> Mapping[] = {
{Colours::Red, "Red"}, {Colours::Orange, "Orange"}, {Colours::Red, "Red"}, {Colours::Orange, "Orange"},
{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);
} }
}; };
namespace test { namespace test {
TEST(ParseLineFilter, EmptyFilter) { TEST(ParseLineFilter, EmptyFilter) {
ClangTidyGlobalOptions Options; ClangTidyGlobalOptions Options;
EXPECT_FALSE(parseLineFilter("", Options)); EXPECT_FALSE(parseLineFilter("", Options));
▲ Show 20 Lines • Show All 406 Lines • Show Last 20 Lines

flang/lib/Lower/ConvertVariable.cpp

Show First 20 Lines • Show All 1,008 Lines • ▼ Show 20 Lines if (!commonBlockHasInit(cmnBlkMems)) {
// temporarily, force a zero size COMMON block to have one byte. // temporarily, force a zero size COMMON block to have one byte.
const auto sz = const auto sz =
static_cast<fir::SequenceType::Extent>(commonSize > 0 ? commonSize : 1); static_cast<fir::SequenceType::Extent>(commonSize > 0 ? commonSize : 1);
fir::SequenceType::Shape shape = {sz}; fir::SequenceType::Shape shape = {sz};
mlir::IntegerType i8Ty = builder.getIntegerType(8); mlir::IntegerType i8Ty = builder.getIntegerType(8);
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;
} }
// COMMON block with initializer (note that initialized blank common are // COMMON block with initializer (note that initialized blank common are
// accepted as an extension by semantics). Sort members by offset before // accepted as an extension by semantics). Sort members by offset before
// generating the type and initializer. // generating the type and initializer.
std::sort(cmnBlkMems.begin(), cmnBlkMems.end(), std::sort(cmnBlkMems.begin(), cmnBlkMems.end(),
▲ Show 20 Lines • Show All 856 Lines • Show Last 20 Lines

flang/tools/flang-driver/driver.cpp

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 LinescreateAndPopulateDiagOpts(llvm::ArrayRef<const char *> argv) {
(void)Fortran::frontend::parseDiagnosticArgs(*diagOpts, args); (void)Fortran::frontend::parseDiagnosticArgs(*diagOpts, args);
return diagOpts; return diagOpts;
} }
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.
llvm::errs() << "error: unknown integrated tool '" << tool << "'. " llvm::errs() << "error: unknown integrated tool '" << tool << "'. "
<< "Valid tools include '-fc1'.\n"; << "Valid tools include '-fc1'.\n";
return 1; return 1;
} }
▲ Show 20 Lines • Show All 94 Lines • Show Last 20 Lines

libc/benchmarks/LibcDefaultImplementations.cpp

Show All 18 Lines
using llvm::libc_benchmarks::MemcmpOrBcmpConfiguration; using llvm::libc_benchmarks::MemcmpOrBcmpConfiguration;
using llvm::libc_benchmarks::MemcpyConfiguration; using llvm::libc_benchmarks::MemcpyConfiguration;
using llvm::libc_benchmarks::MemmoveConfiguration; using llvm::libc_benchmarks::MemmoveConfiguration;
using llvm::libc_benchmarks::MemsetConfiguration; using llvm::libc_benchmarks::MemsetConfiguration;
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);
} }

libc/benchmarks/LibcMemoryBenchmarkMain.cpp

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Linesstruct MemfunctionBenchmarkBase : public BenchmarkSetup {
MemfunctionBenchmarkBase() : ReportProgress(isatty(fileno(stdout))) {} MemfunctionBenchmarkBase() : ReportProgress(isatty(fileno(stdout))) {}
virtual ~MemfunctionBenchmarkBase() {} virtual ~MemfunctionBenchmarkBase() {}
virtual Study run() = 0; virtual Study run() = 0;
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:
Study createStudy() { Study createStudy() {
Study Study; Study Study;
// Setup study. // Setup study.
Study.StudyName = StudyName; Study.StudyName = StudyName;
Runtime &RI = Study.Runtime; Runtime &RI = Study.Runtime;
▲ Show 20 Lines • Show All 173 Lines • Show Last 20 Lines

libc/benchmarks/automemcpy/lib/CodeGen.cpp

Show First 20 Lines • Show All 308 Lines • ▼ Show 20 Lines
// ------------------------------------------------------------- // -------------------------------------------------------------
// e.g. // e.g.
// ArrayRef<NamedFunctionDescriptor> getFunctionDescriptors() { // ArrayRef<NamedFunctionDescriptor> getFunctionDescriptors() {
// static constexpr NamedFunctionDescriptor kDescriptors[] = { // static constexpr NamedFunctionDescriptor kDescriptors[] = {
// {"memcpy_0xE00E29EE73994E2B",{FunctionType::MEMCPY,std::nullopt,std::nullopt,std::nullopt,std::nullopt,Accelerator{{0,kMaxSize}},ElementTypeClass::NATIVE}}, // {"memcpy_0xE00E29EE73994E2B",{FunctionType::MEMCPY,std::nullopt,std::nullopt,std::nullopt,std::nullopt,Accelerator{{0,kMaxSize}},ElementTypeClass::NATIVE}},
// {"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) {
Stream << "{" << SS.Begin << ','; Stream << "{" << SS.Begin << ',';
if (SS.End == kMaxSize) if (SS.End == kMaxSize)
Stream << "kMaxSize"; Stream << "kMaxSize";
else else
Stream << SS.End; Stream << SS.End;
▲ Show 20 Lines • Show All 84 Lines • ▼ Show 20 Linesstatic void Serialize(raw_ostream &Stream,
ArrayRef<NamedFunctionDescriptor> Descriptors) { ArrayRef<NamedFunctionDescriptor> Descriptors) {
Stream << R"(ArrayRef<NamedFunctionDescriptor> getFunctionDescriptors() { Stream << R"(ArrayRef<NamedFunctionDescriptor> getFunctionDescriptors() {
static constexpr NamedFunctionDescriptor kDescriptors[] = { static constexpr NamedFunctionDescriptor kDescriptors[] = {
)"; )";
for (size_t I = 0, E = Descriptors.size(); I < E; ++I) { for (size_t I = 0, E = Descriptors.size(); I < E; ++I) {
Stream << kIndent << kIndent << Descriptors[I] << ",\n"; Stream << kIndent << kIndent << Descriptors[I] << ",\n";
} }
Stream << R"( }; Stream << R"( };
return makeArrayRef(kDescriptors); return ArrayRef(kDescriptors);
} }
)"; )";
} }
} // namespace descriptors } // namespace descriptors
namespace configurations { namespace configurations {
// This namespace generates the getXXXConfigurations functions: // This namespace generates the getXXXConfigurations functions:
// ------------------------------------------------------------ // ------------------------------------------------------------
// e.g. // e.g.
// llvm::ArrayRef<MemcpyConfiguration> getMemcpyConfigurations() { // llvm::ArrayRef<MemcpyConfiguration> getMemcpyConfigurations() {
// using namespace __llvm_libc; // using namespace __llvm_libc;
// static constexpr MemcpyConfiguration kConfigurations[] = { // static constexpr MemcpyConfiguration kConfigurations[] = {
// {Wrap<memcpy_0xE00E29EE73994E2B>, "memcpy_0xE00E29EE73994E2B"}, // {Wrap<memcpy_0xE00E29EE73994E2B>, "memcpy_0xE00E29EE73994E2B"},
// {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.
// It is used to adapt the gnerated code to the prototype of the C function. // It is used to adapt the gnerated code to the prototype of the C function.
// For instance, the generated code for a `memcpy` takes `char*` pointers and // For instance, the generated code for a `memcpy` takes `char*` pointers and
// returns nothing but the original C `memcpy` function take and returns `void*` // returns nothing but the original C `memcpy` function take and returns `void*`
// pointers. // pointers.
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Linesstatic raw_ostream &operator<<(raw_ostream &Stream, const Configuration &C) {
if (C.Descriptors.empty()) if (C.Descriptors.empty())
Stream << kIndent << "return {};\n"; Stream << kIndent << "return {};\n";
else { else {
Stream << kIndent << "using namespace __llvm_libc;\n"; Stream << kIndent << "using namespace __llvm_libc;\n";
Stream << kIndent << "static constexpr " << C.Type Stream << kIndent << "static constexpr " << C.Type
<< " 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;
} }
static void Serialize(raw_ostream &Stream, FunctionType FT, static void Serialize(raw_ostream &Stream, FunctionType FT,
ArrayRef<NamedFunctionDescriptor> Descriptors) { ArrayRef<NamedFunctionDescriptor> Descriptors) {
Configuration Conf; Configuration Conf;
▲ Show 20 Lines • Show All 123 Lines • Show Last 20 Lines

libc/benchmarks/automemcpy/unittests/CodeGenTest.cpp

Show First 20 Lines • Show All 142 Lines • ▼ Show 20 LinesArrayRef<NamedFunctionDescriptor> getFunctionDescriptors() {
static constexpr NamedFunctionDescriptor kDescriptors[] = { static constexpr NamedFunctionDescriptor kDescriptors[] = {
{"memcpy_0xE00E29EE73994E2B",{FunctionType::MEMCPY,std::nullopt,std::nullopt,std::nullopt,std::nullopt,Accelerator{{0,kMaxSize}},ElementTypeClass::NATIVE}}, {"memcpy_0xE00E29EE73994E2B",{FunctionType::MEMCPY,std::nullopt,std::nullopt,std::nullopt,std::nullopt,Accelerator{{0,kMaxSize}},ElementTypeClass::NATIVE}},
{"memcpy_0x7381B60C7BE75EF9",{FunctionType::MEMCPY,Contiguous{{0,4}},Overlap{{4,256}},Loop{{256,kMaxSize},64},std::nullopt,std::nullopt,ElementTypeClass::NATIVE}}, {"memcpy_0x7381B60C7BE75EF9",{FunctionType::MEMCPY,Contiguous{{0,4}},Overlap{{4,256}},Loop{{256,kMaxSize},64},std::nullopt,std::nullopt,ElementTypeClass::NATIVE}},
{"memcmp_0x348D7BA6DB0EE033",{FunctionType::MEMCMP,Contiguous{{0,2}},Overlap{{2,64}},std::nullopt,AlignedLoop{Loop{{64,kMaxSize},16},16,AlignArg::_1},std::nullopt,ElementTypeClass::NATIVE}}, {"memcmp_0x348D7BA6DB0EE033",{FunctionType::MEMCMP,Contiguous{{0,2}},Overlap{{2,64}},std::nullopt,AlignedLoop{Loop{{64,kMaxSize},16},16,AlignArg::_1},std::nullopt,ElementTypeClass::NATIVE}},
{"memset_0x71E761699B999863",{FunctionType::MEMSET,Contiguous{{0,2}},Overlap{{2,256}},std::nullopt,AlignedLoop{Loop{{256,kMaxSize},32},16,AlignArg::_1},std::nullopt,ElementTypeClass::NATIVE}}, {"memset_0x71E761699B999863",{FunctionType::MEMSET,Contiguous{{0,2}},Overlap{{2,256}},std::nullopt,AlignedLoop{Loop{{256,kMaxSize},32},16,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}}, {"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
} // namespace llvm } // namespace llvm
using MemcpyStub = void (*)(char *__restrict, const char *__restrict, size_t); using MemcpyStub = void (*)(char *__restrict, const char *__restrict, size_t);
template <MemcpyStub Foo> template <MemcpyStub Foo>
void *Wrap(void *__restrict dst, const void *__restrict src, size_t size) { void *Wrap(void *__restrict dst, const void *__restrict src, size_t size) {
Foo(reinterpret_cast<char *__restrict>(dst), Foo(reinterpret_cast<char *__restrict>(dst),
reinterpret_cast<const char *__restrict>(src), size); reinterpret_cast<const char *__restrict>(src), size);
return dst; return dst;
} }
llvm::ArrayRef<MemcpyConfiguration> getMemcpyConfigurations() { llvm::ArrayRef<MemcpyConfiguration> getMemcpyConfigurations() {
using namespace __llvm_libc; using namespace __llvm_libc;
static constexpr MemcpyConfiguration kConfigurations[] = { static constexpr MemcpyConfiguration kConfigurations[] = {
{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);
template <MemcmpStub Foo> template <MemcmpStub Foo>
int Wrap(const void *lhs, const void *rhs, size_t size) { int Wrap(const void *lhs, const void *rhs, size_t size) {
return Foo(reinterpret_cast<const char *>(lhs), return Foo(reinterpret_cast<const char *>(lhs),
reinterpret_cast<const char *>(rhs), size); reinterpret_cast<const char *>(rhs), size);
} }
llvm::ArrayRef<MemcmpOrBcmpConfiguration> getMemcmpConfigurations() { llvm::ArrayRef<MemcmpOrBcmpConfiguration> getMemcmpConfigurations() {
using namespace __llvm_libc; using namespace __llvm_libc;
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 {};
} }
using MemsetStub = void (*)(char *, int, size_t); using MemsetStub = void (*)(char *, int, size_t);
template <MemsetStub Foo> void *Wrap(void *dst, int value, size_t size) { template <MemsetStub Foo> void *Wrap(void *dst, int value, size_t size) {
Foo(reinterpret_cast<char *>(dst), value, size); Foo(reinterpret_cast<char *>(dst), value, size);
return dst; return dst;
} }
llvm::ArrayRef<MemsetConfiguration> getMemsetConfigurations() { llvm::ArrayRef<MemsetConfiguration> getMemsetConfigurations() {
using namespace __llvm_libc; using namespace __llvm_libc;
static constexpr MemsetConfiguration kConfigurations[] = { static constexpr MemsetConfiguration kConfigurations[] = {
{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);
template <BzeroStub Foo> void Wrap(void *dst, size_t size) { template <BzeroStub Foo> void Wrap(void *dst, size_t size) {
Foo(reinterpret_cast<char *>(dst), size); Foo(reinterpret_cast<char *>(dst), size);
} }
llvm::ArrayRef<BzeroConfiguration> getBzeroConfigurations() { llvm::ArrayRef<BzeroConfiguration> getBzeroConfigurations() {
using namespace __llvm_libc; using namespace __llvm_libc;
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() {
return {}; return {};
} }
// Functions : 6 // Functions : 6
)"); )");
} }
} // namespace } // namespace
} // namespace automemcpy } // namespace automemcpy
} // namespace llvm } // namespace llvm

lld/COFF/Chunks.h

Show First 20 Lines • Show All 270 Lines • ▼ Show 20 Linespublic:
// Allow iteration over the bodies of this chunk's relocated symbols. // Allow iteration over the bodies of this chunk's relocated symbols.
llvm::iterator_range<symbol_iterator> symbols() const { llvm::iterator_range<symbol_iterator> symbols() const {
return llvm::make_range(symbol_iterator(file, relocsData), return llvm::make_range(symbol_iterator(file, relocsData),
symbol_iterator(file, relocsData + relocsSize)); symbol_iterator(file, relocsData + relocsSize));
} }
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.
void setRelocs(ArrayRef<coff_relocation> newRelocs) { void setRelocs(ArrayRef<coff_relocation> newRelocs) {
relocsData = newRelocs.data(); relocsData = newRelocs.data();
relocsSize = newRelocs.size(); relocsSize = newRelocs.size();
assert(relocsSize == newRelocs.size() && "reloc size truncation"); assert(relocsSize == newRelocs.size() && "reloc size truncation");
} }
▲ Show 20 Lines • Show All 454 Lines • Show Last 20 Lines

lld/COFF/DebugTypes.cpp

Show First 20 Lines • Show All 597 Lines • ▼ Show 20 Lines
// worth the time to copy these into an appropriately sized vector to reduce // worth the time to copy these into an appropriately sized vector to reduce
// memory usage. // memory usage.
void TpiSource::assignGHashesFromVector( void TpiSource::assignGHashesFromVector(
std::vector<GloballyHashedType> &&hashVec) { std::vector<GloballyHashedType> &&hashVec) {
if (hashVec.empty()) if (hashVec.empty())
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;
} }
// Faster way to iterate type records. forEachTypeChecked is faster than // Faster way to iterate type records. forEachTypeChecked is faster than
// iterating CVTypeArray. It avoids virtual readBytes calls in inner loops. // iterating CVTypeArray. It avoids virtual readBytes calls in inner loops.
static void forEachTypeChecked(ArrayRef<uint8_t> types, static void forEachTypeChecked(ArrayRef<uint8_t> types,
function_ref<void(const CVType &)> fn) { function_ref<void(const CVType &)> fn) {
checkError( checkError(
▲ Show 20 Lines • Show All 507 Lines • ▼ Show 20 Linesvoid TypeMerger::mergeTypesWithGHash() {
// item records. It arranges types in this order: // item records. It arranges types in this order:
// - type records // - type records
// - source 0, type 0... // - source 0, type 0...
// - source 1, type 1... // - source 1, type 1...
// - item records // - item records
// - 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);
} }
parallelSort(entries, std::less<GHashCell>()); parallelSort(entries, std::less<GHashCell>());
log(formatv("ghash table load factor: {0:p} (size {1} / capacity {2})\n", log(formatv("ghash table load factor: {0:p} (size {1} / capacity {2})\n",
tableSize ? double(entries.size()) / tableSize : 0, tableSize ? double(entries.size()) / tableSize : 0,
entries.size(), tableSize)); entries.size(), tableSize));
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Linesvoid TypeMerger::sortDependencies() {
for (TpiSource *s : ctx.tpiSourceList) for (TpiSource *s : ctx.tpiSourceList)
(s->isDependency() ? deps : objs).push_back(s); (s->isDependency() ? deps : objs).push_back(s);
uint32_t numDeps = deps.size(); uint32_t numDeps = deps.size();
uint32_t numObjs = objs.size(); uint32_t numObjs = objs.size();
ctx.tpiSourceList = std::move(deps); ctx.tpiSourceList = std::move(deps);
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
/// index for that type in the output PDB. /// index for that type in the output PDB.
static TypeIndex loadPdbTypeIndexFromCell(GHashState *g, static TypeIndex loadPdbTypeIndexFromCell(GHashState *g,
uint32_t ghashCellIdx) { uint32_t ghashCellIdx) {
GHashCell cell = g->table.table[ghashCellIdx]; GHashCell cell = g->table.table[ghashCellIdx];
return TypeIndex::fromArrayIndex(cell.getGHashIdx()); return TypeIndex::fromArrayIndex(cell.getGHashIdx());
Show All 25 Lines

lld/COFF/DriverUtils.cpp

Show First 20 Lines • Show All 847 Lines • ▼ Show 20 Linesopt::InputArgList ArgParser::parse(ArrayRef<const char *> argv) {
// Expand response files (arguments in the form of @<filename>) and insert // Expand response files (arguments in the form of @<filename>) and insert
// flags from %LINK% and %_LINK_%, and then parse the argument again. // flags from %LINK% and %_LINK_%, and then parse the argument again.
SmallVector<const char *, 256> expandedArgv(argv.data(), SmallVector<const char *, 256> expandedArgv(argv.data(),
argv.data() + argv.size()); argv.data() + argv.size());
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 = ctx.optTable.ParseArgs(makeArrayRef(expandedArgv).drop_front(), args = ctx.optTable.ParseArgs(ArrayRef(expandedArgv).drop_front(),
missingIndex, missingCount); missingIndex, 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()) {
std::string msg = "Command line:"; std::string msg = "Command line:";
for (const char *s : expandedArgv) for (const char *s : expandedArgv)
msg += " " + std::string(s); msg += " " + std::string(s);
message(msg); message(msg);
▲ Show 20 Lines • Show All 104 Lines • Show Last 20 Lines

lld/COFF/PDB.cpp

Show First 20 Lines • Show All 488 Lines • ▼ Show 20 Linesstatic bool symbolGoesInGlobalsStream(const CVSymbol &sym,
default: default:
return false; return false;
} }
} }
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:
case SymbolKind::S_GDATA32: case SymbolKind::S_GDATA32:
case SymbolKind::S_GTHREAD32: case SymbolKind::S_GTHREAD32:
case SymbolKind::S_LTHREAD32: case SymbolKind::S_LTHREAD32:
case SymbolKind::S_LDATA32: case SymbolKind::S_LDATA32:
case SymbolKind::S_PROCREF: case SymbolKind::S_PROCREF:
case SymbolKind::S_LPROCREF: { case SymbolKind::S_LPROCREF: {
// sym is a temporary object, so we have to copy and reallocate the record // sym is a temporary object, so we have to copy and reallocate the record
// 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:
case SymbolKind::S_LPROC32: { case SymbolKind::S_LPROC32: {
SymbolRecordKind k = SymbolRecordKind::ProcRefSym; SymbolRecordKind k = SymbolRecordKind::ProcRefSym;
if (sym.kind() == SymbolKind::S_LPROC32) if (sym.kind() == SymbolKind::S_LPROC32)
k = SymbolRecordKind::LocalProcRef; k = SymbolRecordKind::LocalProcRef;
ProcRefSym ps(k); ProcRefSym ps(k);
▲ Show 20 Lines • Show All 496 Lines • ▼ Show 20 Lines
} }
// Allocate memory for a .debug$S / .debug$F section and relocate it. // Allocate memory for a .debug$S / .debug$F section and relocate it.
static ArrayRef<uint8_t> relocateDebugChunk(SectionChunk &debugChunk) { static ArrayRef<uint8_t> relocateDebugChunk(SectionChunk &debugChunk) {
uint8_t *buffer = bAlloc().Allocate<uint8_t>(debugChunk.getSize()); uint8_t *buffer = bAlloc().Allocate<uint8_t>(debugChunk.getSize());
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) {
// If this TpiSource doesn't have an object file, it must be from a type // If this TpiSource doesn't have an object file, it must be from a type
// server PDB. Type server PDBs do not contain symbols, so stop here. // server PDB. Type server PDBs do not contain symbols, so stop here.
if (!source->file) if (!source->file)
return; return;
▲ Show 20 Lines • Show All 384 Lines • ▼ Show 20 Linesvoid PDBLinker::addCommonLinkerModuleSymbols(
ObjNameSym ons(SymbolRecordKind::ObjNameSym); ObjNameSym ons(SymbolRecordKind::ObjNameSym);
EnvBlockSym ebs(SymbolRecordKind::EnvBlockSym); EnvBlockSym ebs(SymbolRecordKind::EnvBlockSym);
Compile3Sym cs(SymbolRecordKind::Compile3Sym); Compile3Sym cs(SymbolRecordKind::Compile3Sym);
fillLinkerVerRecord(cs, ctx.config.machine); fillLinkerVerRecord(cs, ctx.config.machine);
ons.Name = "* Linker *"; ons.Name = "* Linker *";
ons.Signature = 0; ons.Signature = 0;
ArrayRef<StringRef> args = makeArrayRef(ctx.config.argv).drop_front(); ArrayRef<StringRef> args = ArrayRef(ctx.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;
if (ctx.config.pdbSourcePath.empty()) if (ctx.config.pdbSourcePath.empty())
sys::fs::current_path(cwd); sys::fs::current_path(cwd);
else else
cwd = ctx.config.pdbSourcePath; cwd = ctx.config.pdbSourcePath;
ebs.Fields.push_back(cwd); ebs.Fields.push_back(cwd);
▲ Show 20 Lines • Show All 398 Lines • Show Last 20 Lines

lld/ELF/Arch/AMDGPU.cpp

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
static uint32_t getEFlags(InputFile *file) { static uint32_t getEFlags(InputFile *file) {
return cast<ObjFile<ELF64LE>>(file)->getObj().getHeader().e_flags; return cast<ObjFile<ELF64LE>>(file)->getObj().getHeader().e_flags;
} }
uint32_t AMDGPU::calcEFlagsV3() const { uint32_t AMDGPU::calcEFlagsV3() const {
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));
return 0; return 0;
} }
return ret; return ret;
} }
uint32_t AMDGPU::calcEFlagsV4() const { uint32_t AMDGPU::calcEFlagsV4() const {
uint32_t retMach = getEFlags(ctx.objectFiles[0]) & EF_AMDGPU_MACH; uint32_t retMach = getEFlags(ctx.objectFiles[0]) & EF_AMDGPU_MACH;
uint32_t retXnack = uint32_t retXnack =
getEFlags(ctx.objectFiles[0]) & EF_AMDGPU_FEATURE_XNACK_V4; getEFlags(ctx.objectFiles[0]) & EF_AMDGPU_FEATURE_XNACK_V4;
uint32_t retSramEcc = uint32_t retSramEcc =
getEFlags(ctx.objectFiles[0]) & EF_AMDGPU_FEATURE_SRAMECC_V4; getEFlags(ctx.objectFiles[0]) & EF_AMDGPU_FEATURE_SRAMECC_V4;
// 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;
} }
if (retXnack == EF_AMDGPU_FEATURE_XNACK_UNSUPPORTED_V4 || if (retXnack == EF_AMDGPU_FEATURE_XNACK_UNSUPPORTED_V4 ||
(retXnack != EF_AMDGPU_FEATURE_XNACK_ANY_V4 && (retXnack != EF_AMDGPU_FEATURE_XNACK_ANY_V4 &&
(getEFlags(f) & EF_AMDGPU_FEATURE_XNACK_V4) (getEFlags(f) & EF_AMDGPU_FEATURE_XNACK_V4)
▲ Show 20 Lines • Show All 109 Lines • Show Last 20 Lines

lld/ELF/Arch/AVR.cpp

Show First 20 Lines • Show All 234 Lines • ▼ Show 20 Lines
} }
uint32_t AVR::calcEFlags() const { uint32_t AVR::calcEFlags() const {
assert(!ctx.objectFiles.empty()); assert(!ctx.objectFiles.empty());
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) +
": cannot link object files with incompatible target ISA"); ": cannot link object files with incompatible target ISA");
if (!(objFlags & EF_AVR_LINKRELAX_PREPARED)) if (!(objFlags & EF_AVR_LINKRELAX_PREPARED))
hasLinkRelaxFlag = false; hasLinkRelaxFlag = false;
} }
if (!hasLinkRelaxFlag) if (!hasLinkRelaxFlag)
flags &= ~EF_AVR_LINKRELAX_PREPARED; flags &= ~EF_AVR_LINKRELAX_PREPARED;
return flags; return flags;
} }

lld/ELF/Arch/PPC64.cpp

Show First 20 Lines • Show All 265 Lines • ▼ Show 20 Linesstatic void writeSequence(MutableArrayRef<uint32_t> buf, const char *prefix,
assert(ptr == &*buf.end()); assert(ptr == &*buf.end());
if (defined.empty()) if (defined.empty())
return; return;
// The full section content has the extent of [begin, end). We drop unused // The full section content has the extent of [begin, end). We drop unused
// 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) {
sym->section = sec; sym->section = sec;
sym->value -= 4 * first; sym->value -= 4 * first;
} }
} }
▲ Show 20 Lines • Show All 1,424 Lines • Show Last 20 Lines

lld/ELF/Arch/RISCV.cpp

Show First 20 Lines • Show All 614 Lines • ▼ Show 20 Lines
static bool relax(InputSection &sec) { static bool relax(InputSection &sec) {
const uint64_t secAddr = sec.getVA(); const uint64_t secAddr = sec.getVA();
auto &aux = *sec.relaxAux; auto &aux = *sec.relaxAux;
bool changed = false; bool changed = false;
// 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))
if (!sa[0].end) if (!sa[0].end)
valueDelta[sa[0].d] = delta; valueDelta[sa[0].d] = delta;
delta = aux.relocDeltas[i]; delta = aux.relocDeltas[i];
} }
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);
aux.writes.clear(); aux.writes.clear();
for (auto [i, r] : llvm::enumerate(sec.relocs())) { for (auto [i, r] : llvm::enumerate(sec.relocs())) {
const uint64_t loc = secAddr + r.offset - delta; const uint64_t loc = secAddr + r.offset - delta;
uint32_t &cur = aux.relocDeltas[i], remove = 0; uint32_t &cur = aux.relocDeltas[i], remove = 0;
switch (r.type) { switch (r.type) {
▲ Show 20 Lines • Show All 384 Lines • Show Last 20 Lines

lld/ELF/Config.h

Show First 20 Lines • Show All 444 Lines • ▼ Show 20 Linesstruct Ctx {
void reset(); void reset();
}; };
LLVM_LIBRARY_VISIBILITY extern Ctx ctx; LLVM_LIBRARY_VISIBILITY extern Ctx ctx;
// 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);
static inline void internalLinkerError(StringRef loc, const Twine &msg) { static inline void internalLinkerError(StringRef loc, const Twine &msg) {
errorOrWarn(loc + "internal linker error: " + msg + "\n" + errorOrWarn(loc + "internal linker error: " + msg + "\n" +
llvm::getBugReportMsg()); llvm::getBugReportMsg());
} }
} // namespace lld::elf } // namespace lld::elf
#endif #endif

lld/ELF/Driver.cpp

Show First 20 Lines • Show All 2,682 Lines • ▼ Show 20 Lines if (errorCount())
return; return;
// Bail out if normal linked output is skipped due to LTO. // Bail out if normal linked output is skipped due to LTO.
if (skipLinkedOutput) if (skipLinkedOutput)
return; return;
// 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);
}); });
parallelForEach(newObjectFiles, postParseObjectFile); parallelForEach(newObjectFiles, postParseObjectFile);
for (const DuplicateSymbol &d : ctx.duplicates) for (const DuplicateSymbol &d : ctx.duplicates)
reportDuplicate(*d.sym, d.file, d.section, d.value); reportDuplicate(*d.sym, d.file, d.section, d.value);
// Handle --exclude-libs again because lto.tmp may reference additional // Handle --exclude-libs again because lto.tmp may reference additional
▲ Show 20 Lines • Show All 162 Lines • Show Last 20 Lines

lld/ELF/InputFiles.h

Show First 20 Lines • Show All 168 Lines • ▼ Show 20 Lines template <typename ELFT> llvm::object::ELFFile<ELFT> getObj() const {
return check(llvm::object::ELFFile<ELFT>::create(mb.getBuffer())); return check(llvm::object::ELFFile<ELFT>::create(mb.getBuffer()));
} }
StringRef getStringTable() const { return stringTable; } StringRef getStringTable() const { return stringTable; }
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,
numSymbols - firstGlobal); numSymbols - firstGlobal);
} }
template <typename ELFT> typename ELFT::ShdrRange getELFShdrs() const { template <typename ELFT> typename ELFT::ShdrRange getELFShdrs() const {
return typename ELFT::ShdrRange( return typename ELFT::ShdrRange(
▲ Show 20 Lines • Show All 193 Lines • Show Last 20 Lines

lld/ELF/InputSection.h

Show First 20 Lines • Show All 235 Lines • ▼ Show 20 Linespublic:
// information. // information.
template <typename ELFT> template <typename ELFT>
void adjustSplitStackFunctionPrologues(uint8_t *buf, uint8_t *end); void adjustSplitStackFunctionPrologues(uint8_t *buf, uint8_t *end);
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:
template <typename ELFT> template <typename ELFT>
void parseCompressedHeader(); void parseCompressedHeader();
void decompress() const; void decompress() const;
}; };
▲ Show 20 Lines • Show All 190 Lines • Show Last 20 Lines

lld/ELF/InputSection.cpp

Show All 38 Lines
std::string lld::toString(const InputSectionBase *sec) { std::string lld::toString(const InputSectionBase *sec) {
return (toString(sec->file) + ":(" + sec->name + ")").str(); return (toString(sec->file) + ":(" + sec->name + ")").str();
} }
template <class ELFT> template <class ELFT>
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));
} }
InputSectionBase::InputSectionBase(InputFile *file, uint64_t flags, InputSectionBase::InputSectionBase(InputFile *file, uint64_t flags,
uint32_t type, uint64_t entsize, uint32_t type, uint64_t entsize,
uint32_t link, uint32_t info, uint32_t link, uint32_t info,
uint32_t addralign, ArrayRef<uint8_t> data, uint32_t addralign, ArrayRef<uint8_t> data,
StringRef name, Kind sectionKind) StringRef name, Kind sectionKind)
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Lines
template <class ELFT> RelsOrRelas<ELFT> InputSectionBase::relsOrRelas() const { template <class ELFT> RelsOrRelas<ELFT> InputSectionBase::relsOrRelas() const {
if (relSecIdx == 0) if (relSecIdx == 0)
return {}; return {};
RelsOrRelas<ELFT> ret; RelsOrRelas<ELFT> ret;
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;
} }
uint64_t SectionBase::getOffset(uint64_t offset) const { uint64_t SectionBase::getOffset(uint64_t offset) const {
switch (kind()) { switch (kind()) {
case Output: { case Output: {
auto *os = cast<OutputSection>(this); auto *os = cast<OutputSection>(this);
▲ Show 20 Lines • Show All 1,191 Lines • Show Last 20 Lines

lld/ELF/OutputSections.cpp

Show First 20 Lines • Show All 391 Lines • ▼ Show 20 Lines#if LLVM_ENABLE_ZLIB
// the fastest. If -O2 is given, we use level 6 to compress debug info more by // the fastest. If -O2 is given, we use level 6 to compress debug info more by
// ~15%. We found that level 7 to 9 doesn't make much difference (~1% more // ~15%. We found that level 7 to 9 doesn't make much difference (~1% more
// compression) while they take significant amount of time (~2x), so level 6 // compression) while they take significant amount of time (~2x), so level 6
// seems enough. // seems enough.
const int level = config->optimize >= 2 ? 6 : Z_BEST_SPEED; const int level = config->optimize >= 2 ? 6 : Z_BEST_SPEED;
// 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
// shards but the last to flush the output to a byte boundary to be // shards but the last to flush the output to a byte boundary to be
// concatenated with the next shard. // concatenated with the next shard.
auto shardsOut = std::make_unique<SmallVector<uint8_t, 0>[]>(numShards); auto shardsOut = std::make_unique<SmallVector<uint8_t, 0>[]>(numShards);
auto shardsAdler = std::make_unique<uint32_t[]>(numShards); auto shardsAdler = std::make_unique<uint32_t[]>(numShards);
parallelFor(0, numShards, [&](size_t i) { parallelFor(0, numShards, [&](size_t i) {
▲ Show 20 Lines • Show All 283 Lines • ▼ Show 20 Lines for (SectionCommand *cmd : os.commands) {
if (ret.empty()) { if (ret.empty()) {
ret = isd->sections; ret = isd->sections;
} else { } else {
if (storage.empty()) if (storage.empty())
storage.assign(ret.begin(), ret.end()); storage.assign(ret.begin(), ret.end());
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
// before .foo.M if N < M. Used to sort .{init,fini}_array.N sections. // before .foo.M if N < M. Used to sort .{init,fini}_array.N sections.
// We want to keep the original order if the priorities are the same // We want to keep the original order if the priorities are the same
// because the compiler keeps the original initialization order in a // because the compiler keeps the original initialization order in a
// translation unit and we need to respect that. // translation unit and we need to respect that.
// For more detail, read the section of the GCC's manual about init_priority. // For more detail, read the section of the GCC's manual about init_priority.
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

lld/ELF/SyntheticSections.cpp

Show First 20 Lines • Show All 2,804 Lines • ▼ Show 20 Lines for (ArrayRef<NameAttrEntry> entries : nameAttrs) {
idx = symbols[shardId].size() + 1; idx = symbols[shardId].size() + 1;
symbols[shardId].push_back({ent.name, {v}, 0, 0}); symbols[shardId].push_back({ent.name, {v}, 0, 0});
} }
++i; ++i;
} }
}); });
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
// contents to Ret. // contents to Ret.
SmallVector<GdbSymbol, 0> ret; SmallVector<GdbSymbol, 0> ret;
ret.reserve(numSymbols); ret.reserve(numSymbols);
for (SmallVector<GdbSymbol, 0> &vec : for (SmallVector<GdbSymbol, 0> &vec :
makeMutableArrayRef(symbols.get(), numShards)) makeMutableArrayRef(symbols.get(), numShards))
▲ Show 20 Lines • Show All 871 Lines • ▼ Show 20 Lines if (config->emachine == EM_MIPS) {
if (!config->isPic && !config->relocatable && if (!config->isPic && !config->relocatable &&
(config->eflags & (EF_MIPS_PIC | EF_MIPS_CPIC)) == EF_MIPS_CPIC) (config->eflags & (EF_MIPS_PIC | EF_MIPS_CPIC)) == EF_MIPS_CPIC)
return 1; return 1;
return 0; return 0;
} }
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;
} }
return 0; return 0;
} }
▲ Show 20 Lines • Show All 258 Lines • Show Last 20 Lines

lld/ELF/Writer.cpp

Show First 20 Lines • Show All 1,354 Lines • ▼ Show 20 Lines if (executableOutputSection && !orderedSections.empty() &&
for (; insPt != unorderedSections.size(); ++insPt) { for (; insPt != unorderedSections.size(); ++insPt) {
unorderedPos += unorderedSections[insPt]->getSize(); unorderedPos += unorderedSections[insPt]->getSize();
if (unorderedPos > unorderedSize / 2) if (unorderedPos > unorderedSize / 2)
break; break;
} }
} }
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);
} }
static void sortSection(OutputSection &osec, static void sortSection(OutputSection &osec,
const DenseMap<const InputSectionBase *, int> &order) { const DenseMap<const InputSectionBase *, int> &order) {
StringRef name = osec.name; StringRef name = osec.name;
// Never sort these. // Never sort these.
▲ Show 20 Lines • Show All 1,538 Lines • ▼ Show 20 LinescomputeHash(llvm::MutableArrayRef<uint8_t> hashBuf,
std::unique_ptr<uint8_t[]> hashes(new uint8_t[hashesSize]); std::unique_ptr<uint8_t[]> hashes(new uint8_t[hashesSize]);
// Compute hash values. // Compute hash values.
parallelFor(0, chunks.size(), [&](size_t i) { parallelFor(0, chunks.size(), [&](size_t i) {
hashFn(hashes.get() + i * hashBuf.size(), chunks[i]); hashFn(hashes.get() + i * hashBuf.size(), chunks[i]);
}); });
// 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() {
if (!mainPart->buildId || !mainPart->buildId->getParent()) if (!mainPart->buildId || !mainPart->buildId->getParent())
return; return;
if (config->buildId == BuildIdKind::Hexstring) { if (config->buildId == BuildIdKind::Hexstring) {
for (Partition &part : partitions) for (Partition &part : partitions)
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

lldb/include/lldb/Utility/AnsiTerminal.h

Show First 20 Lines • Show All 131 Lines • ▼ Show 20 Lines#define _TO_STR(_val) _TO_STR2(_val)
{"fast-blink}", ANSI_ESC_START _TO_STR(ANSI_CTRL_FAST_BLINK) ANSI_ESC_END}, {"fast-blink}", ANSI_ESC_START _TO_STR(ANSI_CTRL_FAST_BLINK) ANSI_ESC_END},
{"negative}", ANSI_ESC_START _TO_STR(ANSI_CTRL_IMAGE_NEGATIVE) ANSI_ESC_END}, {"negative}", ANSI_ESC_START _TO_STR(ANSI_CTRL_IMAGE_NEGATIVE) ANSI_ESC_END},
{"conceal}", ANSI_ESC_START _TO_STR(ANSI_CTRL_CONCEAL) ANSI_ESC_END}, {"conceal}", ANSI_ESC_START _TO_STR(ANSI_CTRL_CONCEAL) ANSI_ESC_END},
{"crossed-out}", ANSI_ESC_START _TO_STR(ANSI_CTRL_CROSSED_OUT) ANSI_ESC_END}, {"crossed-out}", ANSI_ESC_START _TO_STR(ANSI_CTRL_CROSSED_OUT) ANSI_ESC_END},
#undef _TO_STR #undef _TO_STR
#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.";
std::string fmt; std::string fmt;
while (!format.empty()) { while (!format.empty()) {
llvm::StringRef left, right; llvm::StringRef left, right;
std::tie(left, right) = format.split(tok_hdr); std::tie(left, right) = format.split(tok_hdr);
Show All 29 Lines

lldb/include/lldb/Utility/Args.h

Show First 20 Lines • Show All 161 Lines • ▼ Show 20 Linespublic:
/// An array of NULL terminate C string argument pointers that /// An array of NULL terminate C string argument pointers that
/// also has a terminating NULL C string pointer /// also has a terminating NULL C string pointer
const char **GetConstArgumentVector() const; const char **GetConstArgumentVector() const;
/// Gets the argument as an ArrayRef. Note that the return value does *not* /// Gets the argument as an ArrayRef. Note that the return value does *not*
/// 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.
/// ///
/// \param[in] arg_str /// \param[in] arg_str
/// The new argument. /// The new argument.
/// ///
/// \param[in] quote_char /// \param[in] quote_char
▲ Show 20 Lines • Show All 204 Lines • Show Last 20 Lines

lldb/source/API/SBDebugger.cpp

Show First 20 Lines • Show All 1,639 Lines • ▼ Show 20 Lines
} }
static llvm::ArrayRef<const char *> GetCategoryArray(const char **categories) { static llvm::ArrayRef<const char *> GetCategoryArray(const char **categories) {
if (categories == nullptr) if (categories == nullptr)
return {}; return {};
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) {
LLDB_INSTRUMENT_VA(this, channel, categories); LLDB_INSTRUMENT_VA(this, channel, categories);
if (m_opaque_sp) { if (m_opaque_sp) {
uint32_t log_options = uint32_t log_options =
LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME; LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME;
Show All 24 Lines

lldb/source/Breakpoint/BreakpointID.cpp

Show All 32 Linesbool BreakpointID::IsRangeIdentifier(llvm::StringRef str) {
return llvm::is_contained(g_range_specifiers, str); return llvm::is_contained(g_range_specifiers, str);
} }
bool BreakpointID::IsValidIDExpression(llvm::StringRef str) { bool BreakpointID::IsValidIDExpression(llvm::StringRef str) {
return BreakpointID::ParseCanonicalReference(str).has_value(); return BreakpointID::ParseCanonicalReference(str).has_value();
} }
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) {
if (level == eDescriptionLevelVerbose) if (level == eDescriptionLevelVerbose)
s->Printf("%p BreakpointID:", static_cast<void *>(this)); s->Printf("%p BreakpointID:", static_cast<void *>(this));
if (m_break_id == LLDB_INVALID_BREAK_ID) if (m_break_id == LLDB_INVALID_BREAK_ID)
s->PutCString("<invalid>"); s->PutCString("<invalid>");
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

lldb/source/Commands/CommandObjectBreakpoint.cpp

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Lines
class lldb_private::BreakpointOptionGroup : public OptionGroup { class lldb_private::BreakpointOptionGroup : public OptionGroup {
public: public:
BreakpointOptionGroup() : m_bp_opts(false) {} BreakpointOptionGroup() : m_bp_opts(false) {}
~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,
ExecutionContext *execution_context) override { ExecutionContext *execution_context) override {
Status error; Status error;
const int short_option = const int short_option =
g_breakpoint_modify_options[option_idx].short_option; g_breakpoint_modify_options[option_idx].short_option;
▲ Show 20 Lines • Show All 113 Lines • ▼ Show 20 Lines
class BreakpointDummyOptionGroup : public OptionGroup { class BreakpointDummyOptionGroup : public OptionGroup {
public: public:
BreakpointDummyOptionGroup() = default; BreakpointDummyOptionGroup() = default;
~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,
ExecutionContext *execution_context) override { ExecutionContext *execution_context) override {
Status error; Status error;
const int short_option = const int short_option =
g_breakpoint_dummy_options[option_idx].short_option; g_breakpoint_dummy_options[option_idx].short_option;
▲ Show 20 Lines • Show All 294 Lines • ▼ Show 20 Lines void OptionParsingStarting(ExecutionContext *execution_context) override {
m_all_files = false; m_all_files = false;
m_exception_extra_args.Clear(); m_exception_extra_args.Clear();
m_move_to_nearest_code = eLazyBoolCalculate; m_move_to_nearest_code = eLazyBoolCalculate;
m_source_regex_func_names.clear(); m_source_regex_func_names.clear();
m_current_key.clear(); m_current_key.clear();
} }
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.
std::string m_condition; std::string m_condition;
FileSpecList m_filenames; FileSpecList m_filenames;
uint32_t m_line_num = 0; uint32_t m_line_num = 0;
uint32_t m_column = 0; uint32_t m_column = 0;
▲ Show 20 Lines • Show All 645 Lines • ▼ Show 20 Lines public:
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_level = lldb::eDescriptionLevelFull; m_level = lldb::eDescriptionLevelFull;
m_internal = false; m_internal = false;
m_use_dummy = false; m_use_dummy = false;
} }
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.
lldb::DescriptionLevel m_level = lldb::eDescriptionLevelBrief; lldb::DescriptionLevel m_level = lldb::eDescriptionLevelBrief;
bool m_internal; bool m_internal;
bool m_use_dummy = false; bool m_use_dummy = false;
▲ Show 20 Lines • Show All 106 Lines • ▼ Show 20 Lines public:
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_filename.clear(); m_filename.clear();
m_line_num = 0; m_line_num = 0;
} }
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.
std::string m_filename; std::string m_filename;
uint32_t m_line_num = 0; uint32_t m_line_num = 0;
}; };
▲ Show 20 Lines • Show All 140 Lines • ▼ Show 20 Lines public:
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_use_dummy = false; m_use_dummy = false;
m_force = false; m_force = false;
m_delete_disabled = false; m_delete_disabled = false;
} }
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.
bool m_use_dummy = false; bool m_use_dummy = false;
bool m_force = false; bool m_force = false;
bool m_delete_disabled = false; bool m_delete_disabled = false;
}; };
▲ Show 20 Lines • Show All 109 Lines • ▼ Show 20 Lines
class BreakpointNameOptionGroup : public OptionGroup { class BreakpointNameOptionGroup : public OptionGroup {
public: public:
BreakpointNameOptionGroup() BreakpointNameOptionGroup()
: m_breakpoint(LLDB_INVALID_BREAK_ID), m_use_dummy(false) {} : m_breakpoint(LLDB_INVALID_BREAK_ID), m_use_dummy(false) {}
~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,
ExecutionContext *execution_context) override { ExecutionContext *execution_context) override {
Status error; Status error;
const int short_option = g_breakpoint_name_options[option_idx].short_option; const int short_option = g_breakpoint_name_options[option_idx].short_option;
switch (short_option) { switch (short_option) {
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
class BreakpointAccessOptionGroup : public OptionGroup { class BreakpointAccessOptionGroup : public OptionGroup {
public: public:
BreakpointAccessOptionGroup() = default; BreakpointAccessOptionGroup() = default;
~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 {
Status error; Status error;
const int short_option = const int short_option =
g_breakpoint_access_options[option_idx].short_option; g_breakpoint_access_options[option_idx].short_option;
switch (short_option) { switch (short_option) {
▲ Show 20 Lines • Show All 546 Lines • ▼ Show 20 Lines public:
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_filename.clear(); m_filename.clear();
m_names.clear(); m_names.clear();
} }
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(
CompletionRequest &request, OptionElementVector &opt_element_vector, CompletionRequest &request, OptionElementVector &opt_element_vector,
int opt_element_index, CommandInterpreter &interpreter) override { int opt_element_index, CommandInterpreter &interpreter) override {
int opt_arg_pos = opt_element_vector[opt_element_index].opt_arg_pos; int opt_arg_pos = opt_element_vector[opt_element_index].opt_arg_pos;
int opt_defs_index = opt_element_vector[opt_element_index].opt_defs_index; int opt_defs_index = opt_element_vector[opt_element_index].opt_defs_index;
▲ Show 20 Lines • Show All 172 Lines • ▼ Show 20 Lines public:
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_filename.clear(); m_filename.clear();
m_append = false; m_append = false;
} }
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.
std::string m_filename; std::string m_filename;
bool m_append = false; bool m_append = false;
}; };
▲ Show 20 Lines • Show All 168 Lines • Show Last 20 Lines

lldb/source/Commands/CommandObjectBreakpointCommand.cpp

Show First 20 Lines • Show All 311 Lines • ▼ Show 20 Lines void OptionParsingStarting(ExecutionContext *execution_context) override {
m_use_one_liner = false; m_use_one_liner = false;
m_stop_on_error = true; m_stop_on_error = true;
m_one_liner.clear(); m_one_liner.clear();
m_use_dummy = false; m_use_dummy = false;
} }
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.
bool m_use_commands = false; bool m_use_commands = false;
bool m_use_script_language = false; bool m_use_script_language = false;
lldb::ScriptLanguage m_script_language = eScriptLanguageNone; lldb::ScriptLanguage m_script_language = eScriptLanguageNone;
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
return error; return error;
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_use_dummy = false; m_use_dummy = false;
} }
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.
bool m_use_dummy = false; bool m_use_dummy = false;
}; };
protected: protected:
bool DoExecute(Args &command, CommandReturnObject &result) override { bool DoExecute(Args &command, CommandReturnObject &result) override {
▲ Show 20 Lines • Show All 186 Lines • Show Last 20 Lines

lldb/source/Commands/CommandObjectCommands.cpp

Show First 20 Lines • Show All 113 Lines • ▼ Show 20 Lines public:
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_stop_on_error.Clear(); m_stop_on_error.Clear();
m_silent_run.Clear(); m_silent_run.Clear();
m_stop_on_continue.Clear(); m_stop_on_continue.Clear();
m_cmd_relative_to_command_file.Clear(); m_cmd_relative_to_command_file.Clear();
} }
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.
OptionValueBoolean m_stop_on_error; OptionValueBoolean m_stop_on_error;
OptionValueBoolean m_silent_run; OptionValueBoolean m_silent_run;
OptionValueBoolean m_stop_on_continue; OptionValueBoolean m_stop_on_continue;
OptionValueBoolean m_cmd_relative_to_command_file; OptionValueBoolean m_cmd_relative_to_command_file;
▲ Show 20 Lines • Show All 77 Lines • ▼ Show 20 Lines
protected: protected:
class CommandOptions : public OptionGroup { class CommandOptions : public OptionGroup {
public: public:
CommandOptions() = default; CommandOptions() = default;
~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,
ExecutionContext *execution_context) override { ExecutionContext *execution_context) override {
Status error; Status error;
const int short_option = GetDefinitions()[option_idx].short_option; const int short_option = GetDefinitions()[option_idx].short_option;
std::string option_str(option_value); std::string option_str(option_value);
▲ Show 20 Lines • Show All 827 Lines • ▼ Show 20 Lines public:
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_help.clear(); m_help.clear();
m_syntax.clear(); m_syntax.clear();
} }
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; }
llvm::StringRef GetSyntax() { return m_syntax; } llvm::StringRef GetSyntax() { return m_syntax; }
protected: protected:
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
▲ Show 20 Lines • Show All 230 Lines • ▼ Show 20 Lines Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
return error; return error;
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
relative_to_command_file = false; relative_to_command_file = false;
} }
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;
}; };
bool DoExecute(Args &command, CommandReturnObject &result) override { bool DoExecute(Args &command, CommandReturnObject &result) override {
if (command.empty()) { if (command.empty()) {
result.AppendError("command script import needs one or more arguments"); result.AppendError("command script import needs one or more arguments");
▲ Show 20 Lines • Show All 134 Lines • ▼ Show 20 Lines void OptionParsingStarting(ExecutionContext *execution_context) override {
m_class_name.clear(); m_class_name.clear();
m_funct_name.clear(); m_funct_name.clear();
m_short_help.clear(); m_short_help.clear();
m_overwrite_lazy = eLazyBoolCalculate; m_overwrite_lazy = eLazyBoolCalculate;
m_synchronicity = eScriptedCommandSynchronicitySynchronous; m_synchronicity = eScriptedCommandSynchronicitySynchronous;
} }
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.
std::string m_class_name; std::string m_class_name;
std::string m_funct_name; std::string m_funct_name;
std::string m_short_help; std::string m_short_help;
LazyBool m_overwrite_lazy = eLazyBoolCalculate; LazyBool m_overwrite_lazy = eLazyBoolCalculate;
▲ Show 20 Lines • Show All 426 Lines • ▼ Show 20 Lines public:
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_short_help.clear(); m_short_help.clear();
m_long_help.clear(); m_long_help.clear();
m_overwrite = false; m_overwrite = false;
} }
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.
std::string m_short_help; std::string m_short_help;
std::string m_long_help; std::string m_long_help;
bool m_overwrite = false; bool m_overwrite = false;
}; };
▲ Show 20 Lines • Show All 206 Lines • Show Last 20 Lines

lldb/source/Commands/CommandObjectDiagnostics.cpp

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Lines Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
return error; return error;
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
directory.Clear(); directory.Clear();
} }
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;
}; };
Options *GetOptions() override { return &m_options; } Options *GetOptions() override { return &m_options; }
protected: protected:
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

lldb/source/Commands/CommandObjectDisassemble.cpp

Show First 20 Lines • Show All 198 Lines • ▼ Show 20 LinesStatus CommandObjectDisassemble::CommandOptions::OptionParsingFinished(
ExecutionContext *execution_context) { ExecutionContext *execution_context) {
if (!some_location_specified) if (!some_location_specified)
current_function = true; current_function = true;
return Status(); return Status();
} }
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
CommandObjectDisassemble::CommandObjectDisassemble( CommandObjectDisassemble::CommandObjectDisassemble(
CommandInterpreter &interpreter) CommandInterpreter &interpreter)
: CommandObjectParsed( : CommandObjectParsed(
interpreter, "disassemble", interpreter, "disassemble",
▲ Show 20 Lines • Show All 331 Lines • Show Last 20 Lines

lldb/source/Commands/CommandObjectExpression.cpp

Show First 20 Lines • Show All 166 Lines • ▼ Show 20 Linesvoid CommandObjectExpression::CommandOptions::OptionParsingStarting(
m_verbosity = eLanguageRuntimeDescriptionDisplayVerbosityCompact; m_verbosity = eLanguageRuntimeDescriptionDisplayVerbosityCompact;
auto_apply_fixits = eLazyBoolCalculate; auto_apply_fixits = eLazyBoolCalculate;
top_level = false; top_level = false;
allow_jit = true; allow_jit = true;
} }
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(
CommandInterpreter &interpreter) CommandInterpreter &interpreter)
: CommandObjectRaw(interpreter, "expression", : CommandObjectRaw(interpreter, "expression",
"Evaluate an expression on the current " "Evaluate an expression on the current "
"thread. Displays any returned value " "thread. Displays any returned value "
"with LLDB's default formatting.", "with LLDB's default formatting.",
▲ Show 20 Lines • Show All 466 Lines • Show Last 20 Lines

lldb/source/Commands/CommandObjectFrame.cpp

Show First 20 Lines • Show All 90 Lines • ▼ Show 20 Lines public:
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
address.reset(); address.reset();
reg.reset(); reg.reset();
offset.reset(); offset.reset();
} }
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.
std::optional<lldb::addr_t> address; std::optional<lldb::addr_t> address;
std::optional<ConstString> reg; std::optional<ConstString> reg;
std::optional<int64_t> offset; std::optional<int64_t> offset;
}; };
▲ Show 20 Lines • Show All 141 Lines • ▼ Show 20 Lines Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
return error; return error;
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
relative_frame_offset.reset(); relative_frame_offset.reset();
} }
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_frame_select_options); return llvm::ArrayRef(g_frame_select_options);
} }
std::optional<int32_t> relative_frame_offset; std::optional<int32_t> relative_frame_offset;
}; };
CommandObjectFrameSelect(CommandInterpreter &interpreter) CommandObjectFrameSelect(CommandInterpreter &interpreter)
: CommandObjectParsed(interpreter, "frame select", : CommandObjectParsed(interpreter, "frame select",
"Select the current stack frame by " "Select the current stack frame by "
▲ Show 20 Lines • Show All 507 Lines • ▼ Show 20 Lines void OptionParsingStarting(ExecutionContext *execution_context) override {
m_module = ""; m_module = "";
m_symbols.clear(); m_symbols.clear();
m_class_name = ""; m_class_name = "";
m_regex = false; m_regex = false;
m_first_instruction_only = true; m_first_instruction_only = true;
} }
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.
std::string m_class_name; std::string m_class_name;
std::string m_module; std::string m_module;
std::vector<std::string> m_symbols; std::vector<std::string> m_symbols;
bool m_regex; bool m_regex;
bool m_first_instruction_only; bool m_first_instruction_only;
▲ Show 20 Lines • Show All 392 Lines • Show Last 20 Lines

lldb/source/Commands/CommandObjectHelp.cpp

Show First 20 Lines • Show All 65 Lines • ▼ Show 20 Lines
CommandObjectHelp::~CommandObjectHelp() = default; CommandObjectHelp::~CommandObjectHelp() = default;
#define LLDB_OPTIONS_help #define LLDB_OPTIONS_help
#include "CommandOptions.inc" #include "CommandOptions.inc"
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) {
CommandObject::CommandMap::iterator pos; CommandObject::CommandMap::iterator pos;
CommandObject *cmd_obj; CommandObject *cmd_obj;
const size_t argc = command.GetArgumentCount(); const size_t argc = command.GetArgumentCount();
// 'help' doesn't take any arguments, other than command names. If argc is // 'help' doesn't take any arguments, other than command names. If argc is
▲ Show 20 Lines • Show All 141 Lines • Show Last 20 Lines

lldb/source/Commands/CommandObjectLog.cpp

Show First 20 Lines • Show All 140 Lines • ▼ Show 20 Lines public:
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
log_file.Clear(); log_file.Clear();
buffer_size.Clear(); buffer_size.Clear();
handler = eLogHandlerStream; handler = eLogHandlerStream;
log_options = 0; log_options = 0;
} }
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;
OptionValueUInt64 buffer_size; OptionValueUInt64 buffer_size;
LogHandlerKind handler = eLogHandlerStream; LogHandlerKind handler = eLogHandlerStream;
uint32_t log_options = 0; uint32_t log_options = 0;
}; };
▲ Show 20 Lines • Show All 208 Lines • ▼ Show 20 Lines Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
return error; return error;
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
log_file.Clear(); log_file.Clear();
} }
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;
}; };
void void
HandleArgumentCompletion(CompletionRequest &request, HandleArgumentCompletion(CompletionRequest &request,
OptionElementVector &opt_element_vector) override { OptionElementVector &opt_element_vector) override {
▲ Show 20 Lines • Show All 263 Lines • Show Last 20 Lines

lldb/source/Commands/CommandObjectMemory.cpp

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Lines
public: public:
OptionGroupReadMemory() OptionGroupReadMemory()
: m_num_per_line(1, 1), m_offset(0, 0), : m_num_per_line(1, 1), m_offset(0, 0),
m_language_for_type(eLanguageTypeUnknown) {} m_language_for_type(eLanguageTypeUnknown) {}
~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,
ExecutionContext *execution_context) override { ExecutionContext *execution_context) override {
Status error; Status error;
const int short_option = g_memory_read_options[option_idx].short_option; const int short_option = g_memory_read_options[option_idx].short_option;
switch (short_option) { switch (short_option) {
▲ Show 20 Lines • Show All 831 Lines • ▼ Show 20 Lines
public: public:
class OptionGroupFindMemory : public OptionGroup { class OptionGroupFindMemory : public OptionGroup {
public: public:
OptionGroupFindMemory() : m_count(1), m_offset(0) {} OptionGroupFindMemory() : m_count(1), m_offset(0) {}
~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,
ExecutionContext *execution_context) override { ExecutionContext *execution_context) override {
Status error; Status error;
const int short_option = g_memory_find_options[option_idx].short_option; const int short_option = g_memory_find_options[option_idx].short_option;
switch (short_option) { switch (short_option) {
▲ Show 20 Lines • Show All 286 Lines • ▼ Show 20 Lines
public: public:
class OptionGroupWriteMemory : public OptionGroup { class OptionGroupWriteMemory : public OptionGroup {
public: public:
OptionGroupWriteMemory() = default; OptionGroupWriteMemory() = default;
~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,
ExecutionContext *execution_context) override { ExecutionContext *execution_context) override {
Status error; Status error;
const int short_option = g_memory_write_options[option_idx].short_option; const int short_option = g_memory_write_options[option_idx].short_option;
switch (short_option) { switch (short_option) {
▲ Show 20 Lines • Show All 441 Lines • ▼ Show 20 Lines
public: public:
class OptionGroupMemoryRegion : public OptionGroup { class OptionGroupMemoryRegion : public OptionGroup {
public: public:
OptionGroupMemoryRegion() : m_all(false, false) {} OptionGroupMemoryRegion() : m_all(false, false) {}
~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,
ExecutionContext *execution_context) override { ExecutionContext *execution_context) override {
Status status; Status status;
const int short_option = g_memory_region_options[option_idx].short_option; const int short_option = g_memory_region_options[option_idx].short_option;
switch (short_option) { switch (short_option) {
▲ Show 20 Lines • Show All 213 Lines • Show Last 20 Lines

lldb/source/Commands/CommandObjectMemoryTag.cpp

Show First 20 Lines • Show All 138 Lines • ▼ Show 20 Lines
public: public:
class OptionGroupTagWrite : public OptionGroup { class OptionGroupTagWrite : public OptionGroup {
public: public:
OptionGroupTagWrite() = default; OptionGroupTagWrite() = default;
~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,
ExecutionContext *execution_context) override { ExecutionContext *execution_context) override {
Status status; Status status;
const int short_option = const int short_option =
g_memory_tag_write_options[option_idx].short_option; g_memory_tag_write_options[option_idx].short_option;
▲ Show 20 Lines • Show All 166 Lines • Show Last 20 Lines

lldb/source/Commands/CommandObjectPlatform.cpp

Show First 20 Lines • Show All 120 Lines • ▼ Show 20 Lines SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
return error; return error;
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_permissions = 0; m_permissions = 0;
} }
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.
uint32_t m_permissions; uint32_t m_permissions;
private: private:
OptionPermissions(const OptionPermissions &) = delete; OptionPermissions(const OptionPermissions &) = delete;
▲ Show 20 Lines • Show All 510 Lines • ▼ Show 20 Lines public:
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_offset = 0; m_offset = 0;
m_count = 1; m_count = 1;
} }
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.
uint32_t m_offset; uint32_t m_offset;
uint32_t m_count; uint32_t m_count;
}; };
▲ Show 20 Lines • Show All 76 Lines • ▼ Show 20 Lines public:
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_offset = 0; m_offset = 0;
m_data.clear(); m_data.clear();
} }
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.
uint32_t m_offset; uint32_t m_offset;
std::string m_data; std::string m_data;
}; };
▲ Show 20 Lines • Show All 705 Lines • ▼ Show 20 Lines public:
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
match_info.Clear(); match_info.Clear();
show_args = false; show_args = false;
verbose = false; verbose = false;
} }
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.
ProcessInstanceInfoMatch match_info; ProcessInstanceInfoMatch match_info;
bool show_args = false; bool show_args = false;
bool verbose = false; bool verbose = false;
}; };
▲ Show 20 Lines • Show All 137 Lines • ▼ Show 20 Lines Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
return error; return error;
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
attach_info.Clear(); attach_info.Clear();
} }
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.
static OptionDefinition g_option_table[]; static OptionDefinition g_option_table[];
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
▲ Show 20 Lines • Show All 69 Lines • ▼ Show 20 Lines
public: public:
class CommandOptions : public Options { class CommandOptions : public Options {
public: public:
CommandOptions() = default; CommandOptions() = default;
~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,
ExecutionContext *execution_context) override { ExecutionContext *execution_context) override {
Status error; Status error;
const char short_option = (char)GetDefinitions()[option_idx].short_option; const char short_option = (char)GetDefinitions()[option_idx].short_option;
▲ Show 20 Lines • Show All 224 Lines • Show Last 20 Lines

lldb/source/Commands/CommandObjectProcess.cpp

Show First 20 Lines • Show All 355 Lines • ▼ Show 20 Lines Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
return error; return error;
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
attach_info.Clear(); attach_info.Clear();
} }
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;
}; };
CommandObjectProcessAttach(CommandInterpreter &interpreter) CommandObjectProcessAttach(CommandInterpreter &interpreter)
: CommandObjectProcessLaunchOrAttach( : CommandObjectProcessLaunchOrAttach(
interpreter, "process attach", "Attach to a process.", interpreter, "process attach", "Attach to a process.",
▲ Show 20 Lines • Show All 166 Lines • ▼ Show 20 Lines public:
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_ignore = 0; m_ignore = 0;
m_run_to_bkpt_args.Clear(); m_run_to_bkpt_args.Clear();
m_any_bkpts_specified = false; m_any_bkpts_specified = false;
} }
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;
Args m_run_to_bkpt_args; Args m_run_to_bkpt_args;
bool m_any_bkpts_specified = false; bool m_any_bkpts_specified = false;
}; };
▲ Show 20 Lines • Show All 277 Lines • ▼ Show 20 Lines Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
return error; return error;
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_keep_stopped = eLazyBoolCalculate; m_keep_stopped = eLazyBoolCalculate;
} }
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.
LazyBool m_keep_stopped; LazyBool m_keep_stopped;
}; };
CommandObjectProcessDetach(CommandInterpreter &interpreter) CommandObjectProcessDetach(CommandInterpreter &interpreter)
: CommandObjectParsed(interpreter, "process detach", : CommandObjectParsed(interpreter, "process detach",
▲ Show 20 Lines • Show All 66 Lines • ▼ Show 20 Lines Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
return error; return error;
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
plugin_name.clear(); plugin_name.clear();
} }
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.
std::string plugin_name; std::string plugin_name;
}; };
CommandObjectProcessConnect(CommandInterpreter &interpreter) CommandObjectProcessConnect(CommandInterpreter &interpreter)
▲ Show 20 Lines • Show All 108 Lines • ▼ Show 20 Lines public:
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
do_install = false; do_install = false;
install_path.Clear(); install_path.Clear();
} }
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.
bool do_install; bool do_install;
FileSpec install_path; FileSpec install_path;
}; };
CommandObjectProcessLoad(CommandInterpreter &interpreter) CommandObjectProcessLoad(CommandInterpreter &interpreter)
▲ Show 20 Lines • Show All 299 Lines • ▼ Show 20 Linespublic:
class CommandOptions : public Options { class CommandOptions : public Options {
public: public:
CommandOptions() = default; CommandOptions() = default;
~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,
ExecutionContext *execution_context) override { ExecutionContext *execution_context) override {
const int short_option = m_getopt_table[option_idx].val; const int short_option = m_getopt_table[option_idx].val;
Status error; Status error;
switch (short_option) { switch (short_option) {
▲ Show 20 Lines • Show All 105 Lines • ▼ Show 20 Lines Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
return {}; return {};
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_verbose = false; m_verbose = false;
} }
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.
bool m_verbose = false; bool m_verbose = false;
}; };
protected: protected:
bool DoExecute(Args &command, CommandReturnObject &result) override { bool DoExecute(Args &command, CommandReturnObject &result) override {
▲ Show 20 Lines • Show All 104 Lines • ▼ Show 20 Lines void OptionParsingStarting(ExecutionContext *execution_context) override {
notify.clear(); notify.clear();
pass.clear(); pass.clear();
only_target_values = false; only_target_values = false;
do_clear = false; do_clear = false;
dummy = false; dummy = false;
} }
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.
std::string stop; std::string stop;
std::string notify; std::string notify;
std::string pass; std::string pass;
bool only_target_values = false; bool only_target_values = false;
▲ Show 20 Lines • Show All 372 Lines • Show Last 20 Lines

lldb/source/Commands/CommandObjectRegister.cpp

Show First 20 Lines • Show All 234 Lines • ▼ Show 20 Lines public:
CommandOptions() CommandOptions()
: set_indexes(OptionValue::ConvertTypeToMask(OptionValue::eTypeUInt64)), : set_indexes(OptionValue::ConvertTypeToMask(OptionValue::eTypeUInt64)),
dump_all_sets(false, false), // Initial and default values are false dump_all_sets(false, false), // Initial and default values are false
alternate_name(false, false) {} alternate_name(false, false) {}
~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 {
set_indexes.Clear(); set_indexes.Clear();
dump_all_sets.Clear(); dump_all_sets.Clear();
alternate_name.Clear(); alternate_name.Clear();
} }
▲ Show 20 Lines • Show All 158 Lines • Show Last 20 Lines

lldb/source/Commands/CommandObjectScript.cpp

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines
void CommandObjectScript::CommandOptions::OptionParsingStarting( void CommandObjectScript::CommandOptions::OptionParsingStarting(
ExecutionContext *execution_context) { ExecutionContext *execution_context) {
language = lldb::eScriptLanguageNone; language = lldb::eScriptLanguageNone;
} }
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)
: CommandObjectRaw( : CommandObjectRaw(
interpreter, "script", interpreter, "script",
"Invoke the script interpreter with provided code and display any " "Invoke the script interpreter with provided code and display any "
"results. Start the interactive interpreter if no code is supplied.", "results. Start the interactive interpreter if no code is supplied.",
"script [--language <scripting-language> --] [<script-code>]") {} "script [--language <scripting-language> --] [<script-code>]") {}
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

lldb/source/Commands/CommandObjectSession.cpp

Show First 20 Lines • Show All 111 Lines • ▼ Show 20 Lines public:
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_start_idx.Clear(); m_start_idx.Clear();
m_stop_idx.Clear(); m_stop_idx.Clear();
m_count.Clear(); m_count.Clear();
m_clear.Clear(); m_clear.Clear();
} }
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.
OptionValueUInt64 m_start_idx; OptionValueUInt64 m_start_idx;
OptionValueUInt64 m_stop_idx; OptionValueUInt64 m_stop_idx;
OptionValueUInt64 m_count; OptionValueUInt64 m_count;
OptionValueBoolean m_clear; OptionValueBoolean m_clear;
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

lldb/source/Commands/CommandObjectSettings.cpp

Show First 20 Lines • Show All 114 Lines • ▼ Show 20 Lines public:
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_global = false; m_global = false;
m_force = false; m_force = false;
m_exists = false; m_exists = false;
} }
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.
bool m_global = false; bool m_global = false;
bool m_force = false; bool m_force = false;
bool m_exists = false; bool m_exists = false;
}; };
▲ Show 20 Lines • Show All 222 Lines • ▼ Show 20 Lines public:
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_filename.clear(); m_filename.clear();
m_append = false; m_append = false;
} }
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.
std::string m_filename; std::string m_filename;
bool m_append = false; bool m_append = false;
}; };
protected: protected:
▲ Show 20 Lines • Show All 77 Lines • ▼ Show 20 Lines Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
return error; return error;
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_filename.clear(); m_filename.clear();
} }
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.
std::string m_filename; std::string m_filename;
}; };
protected: protected:
bool DoExecute(Args &command, CommandReturnObject &result) override { bool DoExecute(Args &command, CommandReturnObject &result) override {
▲ Show 20 Lines • Show All 613 Lines • ▼ Show 20 Lines Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
return Status(); return Status();
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_clear_all = false; m_clear_all = false;
} }
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;
}; };
protected: protected:
bool DoExecute(Args &command, CommandReturnObject &result) override { bool DoExecute(Args &command, CommandReturnObject &result) override {
result.SetStatus(eReturnStatusSuccessFinishNoResult); result.SetStatus(eReturnStatusSuccessFinishNoResult);
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

lldb/source/Commands/CommandObjectSource.cpp

Show First 20 Lines • Show All 93 Lines • ▼ Show 20 Lines void OptionParsingStarting(ExecutionContext *execution_context) override {
address = LLDB_INVALID_ADDRESS; address = LLDB_INVALID_ADDRESS;
start_line = 0; start_line = 0;
end_line = 0; end_line = 0;
num_lines = 0; num_lines = 0;
modules.clear(); modules.clear();
} }
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.
FileSpec file_spec; FileSpec file_spec;
std::string file_name; std::string file_name;
std::string symbol_name; std::string symbol_name;
lldb::addr_t address; lldb::addr_t address;
uint32_t start_line; uint32_t start_line;
▲ Show 20 Lines • Show All 580 Lines • ▼ Show 20 Lines void OptionParsingStarting(ExecutionContext *execution_context) override {
start_line = 0; start_line = 0;
num_lines = 0; num_lines = 0;
show_bp_locs = false; show_bp_locs = false;
reverse = false; reverse = false;
modules.clear(); modules.clear();
} }
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.
FileSpec file_spec; FileSpec file_spec;
std::string file_name; std::string file_name;
std::string symbol_name; std::string symbol_name;
lldb::addr_t address; lldb::addr_t address;
uint32_t start_line; uint32_t start_line;
▲ Show 20 Lines • Show All 551 Lines • Show Last 20 Lines

lldb/source/Commands/CommandObjectStats.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
return error; return error;
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_all_targets = false; m_all_targets = false;
} }
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;
}; };
public: public:
CommandObjectStatsDump(CommandInterpreter &interpreter) CommandObjectStatsDump(CommandInterpreter &interpreter)
: CommandObjectParsed( : CommandObjectParsed(
Show All 35 Lines

lldb/source/Commands/CommandObjectTarget.cpp

Show First 20 Lines • Show All 147 Lines • ▼ Show 20 Lines
class OptionGroupDependents : public OptionGroup { class OptionGroupDependents : public OptionGroup {
public: public:
OptionGroupDependents() = default; OptionGroupDependents() = default;
~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,
ExecutionContext *execution_context) override { ExecutionContext *execution_context) override {
Status error; Status error;
// For compatibility no value means don't load dependents. // For compatibility no value means don't load dependents.
if (option_value.empty()) { if (option_value.empty()) {
▲ Show 20 Lines • Show All 1,800 Lines • ▼ Show 20 Lines public:
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_sort_order = eSortOrderNone; m_sort_order = eSortOrderNone;
m_prefer_mangled.Clear(); m_prefer_mangled.Clear();
} }
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;
OptionValueBoolean m_prefer_mangled = {false, false}; OptionValueBoolean m_prefer_mangled = {false, false};
}; };
protected: protected:
bool DoExecute(Args &command, CommandReturnObject &result) override { bool DoExecute(Args &command, CommandReturnObject &result) override {
▲ Show 20 Lines • Show All 435 Lines • ▼ Show 20 Lines Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
return Status(); return Status();
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_verbose = false; m_verbose = false;
} }
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;
}; };
CommandOptions m_options; CommandOptions m_options;
}; };
▲ Show 20 Lines • Show All 493 Lines • ▼ Show 20 Lines public:
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_format_array.clear(); m_format_array.clear();
m_use_global_module_list = false; m_use_global_module_list = false;
m_module_addr = LLDB_INVALID_ADDRESS; m_module_addr = LLDB_INVALID_ADDRESS;
} }
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.
typedef std::vector<std::pair<char, uint32_t>> FormatWidthCollection; typedef std::vector<std::pair<char, uint32_t>> FormatWidthCollection;
FormatWidthCollection m_format_array; FormatWidthCollection m_format_array;
bool m_use_global_module_list = false; bool m_use_global_module_list = false;
lldb::addr_t m_module_addr = LLDB_INVALID_ADDRESS; lldb::addr_t m_module_addr = LLDB_INVALID_ADDRESS;
}; };
▲ Show 20 Lines • Show All 339 Lines • ▼ Show 20 Lines public:
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_type = eLookupTypeInvalid; m_type = eLookupTypeInvalid;
m_str.clear(); m_str.clear();
m_addr = LLDB_INVALID_ADDRESS; m_addr = LLDB_INVALID_ADDRESS;
} }
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.
int m_type = eLookupTypeInvalid; // Should be a eLookupTypeXXX enum after int m_type = eLookupTypeInvalid; // Should be a eLookupTypeXXX enum after
// parsing options // parsing options
std::string m_str; // Holds name lookup std::string m_str; // Holds name lookup
lldb::addr_t m_addr = LLDB_INVALID_ADDRESS; // Holds the address to lookup lldb::addr_t m_addr = LLDB_INVALID_ADDRESS; // Holds the address to lookup
▲ Show 20 Lines • Show All 395 Lines • ▼ Show 20 Lines Status OptionParsingFinished(ExecutionContext *execution_context) override {
if (m_all_ranges && !m_verbose) { if (m_all_ranges && !m_verbose) {
status.SetErrorString("--show-variable-ranges must be used in " status.SetErrorString("--show-variable-ranges must be used in "
"conjunction with --verbose."); "conjunction with --verbose.");
} }
return status; return status;
} }
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
std::string m_str; // Holds name lookup std::string m_str; // Holds name lookup
FileSpec m_file; // Files for file lookups FileSpec m_file; // Files for file lookups
lldb::addr_t m_addr; // Holds the address to lookup lldb::addr_t m_addr; // Holds the address to lookup
lldb::addr_t lldb::addr_t
m_offset; // Subtract this offset from m_addr before doing lookups. m_offset; // Subtract this offset from m_addr before doing lookups.
▲ Show 20 Lines • Show All 812 Lines • ▼ Show 20 Lines
public: public:
class CommandOptions : public OptionGroup { class CommandOptions : public OptionGroup {
public: public:
CommandOptions() : m_line_end(UINT_MAX) {} CommandOptions() : m_line_end(UINT_MAX) {}
~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,
ExecutionContext *execution_context) override { ExecutionContext *execution_context) override {
Status error; Status error;
const int short_option = const int short_option =
g_target_stop_hook_add_options[option_idx].short_option; g_target_stop_hook_add_options[option_idx].short_option;
▲ Show 20 Lines • Show All 617 Lines • Show Last 20 Lines

lldb/source/Commands/CommandObjectThread.cpp

Show First 20 Lines • Show All 90 Lines • ▼ Show 20 Lines public:
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_count = UINT32_MAX; m_count = UINT32_MAX;
m_start = 0; m_start = 0;
m_extended_backtrace = false; m_extended_backtrace = false;
} }
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.
uint32_t m_count; uint32_t m_count;
uint32_t m_start; uint32_t m_start;
bool m_extended_backtrace; bool m_extended_backtrace;
}; };
▲ Show 20 Lines • Show All 141 Lines • ▼ Show 20 Lines ThreadStepScopeOptionGroup() {
// Keep default values of all options in one place: OptionParsingStarting // Keep default values of all options in one place: OptionParsingStarting
// () // ()
OptionParsingStarting(nullptr); OptionParsingStarting(nullptr);
} }
~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,
ExecutionContext *execution_context) override { ExecutionContext *execution_context) override {
Status error; Status error;
const int short_option = const int short_option =
g_thread_step_scope_options[option_idx].short_option; g_thread_step_scope_options[option_idx].short_option;
▲ Show 20 Lines • Show All 603 Lines • ▼ Show 20 Lines public:
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_thread_idx = LLDB_INVALID_THREAD_ID; m_thread_idx = LLDB_INVALID_THREAD_ID;
m_frame_idx = 0; m_frame_idx = 0;
m_stop_others = false; m_stop_others = false;
m_until_addrs.clear(); m_until_addrs.clear();
} }
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;
bool m_stop_others = false; bool m_stop_others = false;
std::vector<lldb::addr_t> m_until_addrs; std::vector<lldb::addr_t> m_until_addrs;
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
}; };
▲ Show 20 Lines • Show All 379 Lines • ▼ Show 20 Lines Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
default: default:
llvm_unreachable("Unimplemented option"); llvm_unreachable("Unimplemented option");
} }
return error; return error;
} }
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;
bool m_json_stopinfo; bool m_json_stopinfo;
}; };
CommandObjectThreadInfo(CommandInterpreter &interpreter) CommandObjectThreadInfo(CommandInterpreter &interpreter)
: CommandObjectIterateOverThreads( : CommandObjectIterateOverThreads(
▲ Show 20 Lines • Show All 181 Lines • ▼ Show 20 Lines Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
return error; return error;
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_from_expression = false; m_from_expression = false;
} }
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;
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
}; };
CommandObjectThreadReturn(CommandInterpreter &interpreter) CommandObjectThreadReturn(CommandInterpreter &interpreter)
▲ Show 20 Lines • Show All 155 Lines • ▼ Show 20 Lines Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
break; break;
default: default:
llvm_unreachable("Unimplemented option"); llvm_unreachable("Unimplemented option");
} }
return error; return error;
} }
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;
uint32_t m_line_num; uint32_t m_line_num;
int32_t m_line_offset; int32_t m_line_offset;
lldb::addr_t m_load_addr; lldb::addr_t m_load_addr;
bool m_force; bool m_force;
}; };
▲ Show 20 Lines • Show All 117 Lines • ▼ Show 20 Lines void OptionParsingStarting(ExecutionContext *execution_context) override {
m_verbose = false; m_verbose = false;
m_internal = false; m_internal = false;
m_unreported = true; // The variable is "skip unreported" and we want to m_unreported = true; // The variable is "skip unreported" and we want to
// skip unreported by default. // skip unreported by default.
m_tids.clear(); m_tids.clear();
} }
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.
bool m_verbose; bool m_verbose;
bool m_internal; bool m_internal;
bool m_unreported; bool m_unreported;
std::vector<lldb::tid_t> m_tids; std::vector<lldb::tid_t> m_tids;
}; };
▲ Show 20 Lines • Show All 363 Lines • ▼ Show 20 Lines public:
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_dumper_options = {}; m_dumper_options = {};
m_output_file = std::nullopt; m_output_file = std::nullopt;
} }
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;
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
TraceDumperOptions m_dumper_options; TraceDumperOptions m_dumper_options;
std::optional<FileSpec> m_output_file; std::optional<FileSpec> m_output_file;
}; };
▲ Show 20 Lines • Show All 156 Lines • ▼ Show 20 Lines public:
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_count = kDefaultCount; m_count = kDefaultCount;
m_continue = false; m_continue = false;
m_output_file = std::nullopt; m_output_file = std::nullopt;
m_dumper_options = {}; m_dumper_options = {};
} }
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;
// Instance variables to hold the values for command options. // Instance variables to hold the values for command options.
size_t m_count; size_t m_count;
size_t m_continue; size_t m_continue;
std::optional<FileSpec> m_output_file; std::optional<FileSpec> m_output_file;
▲ Show 20 Lines • Show All 117 Lines • ▼ Show 20 Lines public:
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_verbose = false; m_verbose = false;
m_json = false; m_json = false;
} }
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.
bool m_verbose; bool m_verbose;
bool m_json; bool m_json;
}; };
CommandObjectTraceDumpInfo(CommandInterpreter &interpreter) CommandObjectTraceDumpInfo(CommandInterpreter &interpreter)
▲ Show 20 Lines • Show All 152 Lines • Show Last 20 Lines

lldb/source/Commands/CommandObjectTrace.cpp

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Lines Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
return error; return error;
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_compact = false; m_compact = false;
}; };
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;
}; };
Options *GetOptions() override { return &m_options; } Options *GetOptions() override { return &m_options; }
CommandObjectTraceSave(CommandInterpreter &interpreter) CommandObjectTraceSave(CommandInterpreter &interpreter)
▲ Show 20 Lines • Show All 87 Lines • ▼ Show 20 Lines Status SetOptionValue(uint32_t option_idx, StringRef option_arg,
return error; return error;
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_verbose = false; m_verbose = false;
} }
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.
}; };
CommandObjectTraceLoad(CommandInterpreter &interpreter) CommandObjectTraceLoad(CommandInterpreter &interpreter)
: CommandObjectParsed( : CommandObjectParsed(
interpreter, "trace load", interpreter, "trace load",
▲ Show 20 Lines • Show All 77 Lines • ▼ Show 20 Lines Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
return error; return error;
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_verbose = false; m_verbose = false;
} }
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.
}; };
CommandObjectTraceDump(CommandInterpreter &interpreter) CommandObjectTraceDump(CommandInterpreter &interpreter)
: CommandObjectParsed(interpreter, "trace dump", : CommandObjectParsed(interpreter, "trace dump",
"Dump the loaded processor trace data.", "Dump the loaded processor trace data.",
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
return error; return error;
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_verbose = false; m_verbose = false;
} }
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.
}; };
CommandObjectTraceSchema(CommandInterpreter &interpreter) CommandObjectTraceSchema(CommandInterpreter &interpreter)
: CommandObjectParsed(interpreter, "trace schema", : CommandObjectParsed(interpreter, "trace schema",
"Show the schema of the given trace plugin.", "Show the schema of the given trace plugin.",
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

lldb/source/Commands/CommandObjectType.cpp

Show First 20 Lines • Show All 112 Lines • ▼ Show 20 Lines public:
~CommandOptions() override = default; ~CommandOptions() override = default;
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;
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.
TypeSummaryImpl::Flags m_flags; TypeSummaryImpl::Flags m_flags;
FormatterMatchType m_match_type = eFormatterMatchExact; FormatterMatchType m_match_type = eFormatterMatchExact;
std::string m_format_string; std::string m_format_string;
ConstString m_name; ConstString m_name;
▲ Show 20 Lines • Show All 216 Lines • ▼ Show 20 Lines void OptionParsingStarting(ExecutionContext *execution_context) override {
m_skip_references = false; m_skip_references = false;
m_category = "default"; m_category = "default";
is_class_based = false; is_class_based = false;
handwrite_python = false; handwrite_python = false;
m_match_type = eFormatterMatchExact; m_match_type = eFormatterMatchExact;
} }
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.
bool m_cascade; bool m_cascade;
bool m_skip_references; bool m_skip_references;
bool m_skip_pointers; bool m_skip_pointers;
std::string m_class_name; std::string m_class_name;
▲ Show 20 Lines • Show All 140 Lines • ▼ Show 20 Lines
private: private:
class CommandOptions : public OptionGroup { class CommandOptions : public OptionGroup {
public: public:
CommandOptions() = default; CommandOptions() = default;
~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 {
m_cascade = true; m_cascade = true;
m_skip_pointers = false; m_skip_pointers = false;
m_skip_references = false; m_skip_references = false;
m_regex = false; m_regex = false;
m_category.assign("default"); m_category.assign("default");
▲ Show 20 Lines • Show All 218 Lines • ▼ Show 20 Lines public:
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_delete_all = false; m_delete_all = false;
m_category = "default"; m_category = "default";
m_language = lldb::eLanguageTypeUnknown; m_language = lldb::eLanguageTypeUnknown;
} }
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.
bool m_delete_all; bool m_delete_all;
std::string m_category; std::string m_category;
lldb::LanguageType m_language; lldb::LanguageType m_language;
}; };
▲ Show 20 Lines • Show All 120 Lines • ▼ Show 20 Lines Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
return error; return error;
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_delete_all = false; m_delete_all = false;
} }
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.
bool m_delete_all; bool m_delete_all;
}; };
CommandOptions m_options; CommandOptions m_options;
uint32_t m_formatter_kind_mask; uint32_t m_formatter_kind_mask;
▲ Show 20 Lines • Show All 102 Lines • ▼ Show 20 Lines public:
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_category_regex.Clear(); m_category_regex.Clear();
m_category_language.Clear(); m_category_language.Clear();
} }
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.
OptionValueString m_category_regex; OptionValueString m_category_regex;
OptionValueLanguage m_category_language; OptionValueLanguage m_category_language;
}; };
▲ Show 20 Lines • Show All 684 Lines • ▼ Show 20 Lines public:
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_define_enabled.Clear(); m_define_enabled.Clear();
m_cate_language.Clear(); m_cate_language.Clear();
} }
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.
OptionValueBoolean m_define_enabled; OptionValueBoolean m_define_enabled;
OptionValueLanguage m_cate_language; OptionValueLanguage m_cate_language;
}; };
▲ Show 20 Lines • Show All 86 Lines • ▼ Show 20 Lines Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
return error; return error;
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_language = lldb::eLanguageTypeUnknown; m_language = lldb::eLanguageTypeUnknown;
} }
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.
lldb::LanguageType m_language; lldb::LanguageType m_language;
}; };
CommandOptions m_options; CommandOptions m_options;
▲ Show 20 Lines • Show All 160 Lines • ▼ Show 20 Lines Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
return error; return error;
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_language = lldb::eLanguageTypeUnknown; m_language = lldb::eLanguageTypeUnknown;
} }
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.
lldb::LanguageType m_language; lldb::LanguageType m_language;
}; };
CommandOptions m_options; CommandOptions m_options;
▲ Show 20 Lines • Show All 426 Lines • ▼ Show 20 Lines void OptionParsingStarting(ExecutionContext *execution_context) override {
m_skip_references = false; m_skip_references = false;
m_category = "default"; m_category = "default";
m_expr_paths.clear(); m_expr_paths.clear();
has_child_list = false; has_child_list = false;
m_regex = false; m_regex = false;
} }
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.
bool m_cascade; bool m_cascade;
bool m_skip_references; bool m_skip_references;
bool m_skip_pointers; bool m_skip_pointers;
bool m_input_python; bool m_input_python;
▲ Show 20 Lines • Show All 199 Lines • ▼ Show 20 Linesprotected:
class CommandOptions : public OptionGroup { class CommandOptions : public OptionGroup {
public: public:
CommandOptions() = default; CommandOptions() = default;
~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,
ExecutionContext *execution_context) override { ExecutionContext *execution_context) override {
Status error; Status error;
const int short_option = g_type_lookup_options[option_idx].short_option; const int short_option = g_type_lookup_options[option_idx].short_option;
▲ Show 20 Lines • Show All 385 Lines • Show Last 20 Lines

lldb/source/Commands/CommandObjectWatchpoint.cpp

Show First 20 Lines • Show All 190 Lines • ▼ Show 20 Lines Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
return error; return error;
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_level = lldb::eDescriptionLevelFull; m_level = lldb::eDescriptionLevelFull;
} }
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.
lldb::DescriptionLevel m_level = lldb::eDescriptionLevelBrief; lldb::DescriptionLevel m_level = lldb::eDescriptionLevelBrief;
}; };
protected: protected:
▲ Show 20 Lines • Show All 266 Lines • ▼ Show 20 Lines Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
return {}; return {};
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_force = false; m_force = false;
} }
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.
bool m_force = false; bool m_force = false;
}; };
protected: protected:
bool DoExecute(Args &command, CommandReturnObject &result) override { bool DoExecute(Args &command, CommandReturnObject &result) override {
▲ Show 20 Lines • Show All 109 Lines • ▼ Show 20 Lines Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
return error; return error;
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_ignore_count = 0; m_ignore_count = 0;
} }
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.
uint32_t m_ignore_count = 0; uint32_t m_ignore_count = 0;
}; };
protected: protected:
▲ Show 20 Lines • Show All 108 Lines • ▼ Show 20 Lines public:
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_condition.clear(); m_condition.clear();
m_condition_passed = false; m_condition_passed = false;
} }
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.
std::string m_condition; std::string m_condition;
bool m_condition_passed = false; bool m_condition_passed = false;
}; };
▲ Show 20 Lines • Show All 469 Lines • Show Last 20 Lines

lldb/source/Commands/CommandObjectWatchpointCommand.cpp

Show First 20 Lines • Show All 343 Lines • ▼ Show 20 Lines void OptionParsingStarting(ExecutionContext *execution_context) override {
m_use_one_liner = false; m_use_one_liner = false;
m_stop_on_error = true; m_stop_on_error = true;
m_one_liner.clear(); m_one_liner.clear();
m_function_name.clear(); m_function_name.clear();
} }
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.
bool m_use_commands = false; bool m_use_commands = false;
bool m_use_script_language = false; bool m_use_script_language = false;
lldb::ScriptLanguage m_script_language = eScriptLanguageNone; lldb::ScriptLanguage m_script_language = eScriptLanguageNone;
▲ Show 20 Lines • Show All 270 Lines • Show Last 20 Lines

lldb/source/Commands/CommandOptionsProcessLaunch.cpp

Show First 20 Lines • Show All 139 Lines • ▼ Show 20 Lines default:
error.SetErrorStringWithFormat("unrecognized short option character '%c'", error.SetErrorStringWithFormat("unrecognized short option character '%c'",
short_option); short_option);
break; break;
} }
return error; return error;
} }
llvm::ArrayRef<OptionDefinition> CommandOptionsProcessLaunch::GetDefinitions() { llvm::ArrayRef<OptionDefinition> CommandOptionsProcessLaunch::GetDefinitions() {
return llvm::makeArrayRef(g_process_launch_options); return llvm::ArrayRef(g_process_launch_options);
} }

lldb/source/Host/common/NativeProcessProtocol.cpp

Show First 20 Lines • Show All 377 Lines • ▼ Show 20 Lines error =
ReadMemory(addr, curr_break_op.data(), curr_break_op.size(), bytes_read); ReadMemory(addr, curr_break_op.data(), curr_break_op.size(), bytes_read);
if (error.Fail() || bytes_read < curr_break_op.size()) { if (error.Fail() || bytes_read < curr_break_op.size()) {
return Status("addr=0x%" PRIx64 return Status("addr=0x%" PRIx64
": tried to read %zu bytes but only read %zu", ": tried to read %zu bytes but only read %zu",
addr, curr_break_op.size(), bytes_read); addr, curr_break_op.size(), bytes_read);
} }
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,
"Saved opcodes ({0:@[x]}) have already been restored at {1:x}.", "Saved opcodes ({0:@[x]}) have already been restored at {1:x}.",
llvm::make_range(saved.begin(), saved.end()), addr); llvm::make_range(saved.begin(), saved.end()), addr);
} else { } else {
// We found a valid breakpoint opcode at this address, now restore the // We found a valid breakpoint opcode at this address, now restore the
// saved opcode. // saved opcode.
▲ Show 20 Lines • Show All 83 Lines • ▼ Show 20 Lines if (verify_bytes_read != verify_bp_opcode_bytes.size()) {
return llvm::createStringError( return llvm::createStringError(
llvm::inconvertibleErrorCode(), llvm::inconvertibleErrorCode(),
"Failed to read memory while " "Failed to read memory while "
"attempting to verify breakpoint: attempted to read {0} bytes " "attempting to verify breakpoint: attempted to read {0} bytes "
"but only read {1}", "but only read {1}",
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(),
"Verification of software breakpoint " "Verification of software breakpoint "
"writing failed - trap opcodes not successfully read back " "writing failed - trap opcodes not successfully read back "
"after writing when setting breakpoint at {0:x}", "after writing when setting breakpoint at {0:x}",
addr); addr);
} }
Show All 14 LinesNativeProcessProtocol::GetSoftwareBreakpointTrapOpcode(size_t size_hint) {
static const uint8_t g_riscv_opcode[] = {0x73, 0x00, 0x10, 0x00}; // ebreak static const uint8_t g_riscv_opcode[] = {0x73, 0x00, 0x10, 0x00}; // ebreak
static const uint8_t g_riscv_opcode_c[] = {0x02, 0x90}; // c.ebreak static const uint8_t g_riscv_opcode_c[] = {0x02, 0x90}; // c.ebreak
static const uint8_t g_loongarch_opcode[] = {0x05, 0x00, 0x2a, static const uint8_t g_loongarch_opcode[] = {0x05, 0x00, 0x2a,
0x00}; // break 0x5 0x00}; // break 0x5
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(),
"CPU type not supported!"); "CPU type not supported!");
} }
} }
size_t NativeProcessProtocol::GetSoftwareBreakpointPCOffset() { size_t NativeProcessProtocol::GetSoftwareBreakpointPCOffset() {
▲ Show 20 Lines • Show All 90 Lines • ▼ Show 20 LinesStatus NativeProcessProtocol::ReadMemoryWithoutTrap(lldb::addr_t addr,
Status error = ReadMemory(addr, buf, size, bytes_read); Status error = ReadMemory(addr, buf, size, bytes_read);
if (error.Fail()) if (error.Fail())
return error; return error;
auto data = auto data =
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
if (bp_addr < addr) { if (bp_addr < addr) {
saved_opcodes = saved_opcodes.drop_front(addr - bp_addr); saved_opcodes = saved_opcodes.drop_front(addr - bp_addr);
bp_addr = addr; bp_addr = addr;
} }
▲ Show 20 Lines • Show All 99 Lines • Show Last 20 Lines

lldb/source/Interpreter/OptionGroupArchitecture.cpp

Show All 14 Lines
static constexpr OptionDefinition g_option_table[] = { static constexpr OptionDefinition g_option_table[] = {
{LLDB_OPT_SET_1, false, "arch", 'a', OptionParser::eRequiredArgument, {LLDB_OPT_SET_1, false, "arch", 'a', OptionParser::eRequiredArgument,
nullptr, {}, 0, eArgTypeArchitecture, nullptr, {}, 0, eArgTypeArchitecture,
"Specify the architecture for the target."}, "Specify the architecture for the target."},
}; };
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,
ArchSpec &arch) { ArchSpec &arch) {
arch = Platform::GetAugmentedArchSpec(platform, m_arch_str); arch = Platform::GetAugmentedArchSpec(platform, m_arch_str);
return arch.IsValid(); return arch.IsValid();
} }
Show All 23 Lines

lldb/source/Interpreter/OptionGroupFormat.cpp

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Lines case eArgTypeByteSize:
break; break;
default: default:
llvm_unreachable("Unimplemented option"); llvm_unreachable("Unimplemented option");
} }
} }
} }
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;
else else
return result.take_front(3); return result.take_front(3);
} }
return result.take_front(2); return result.take_front(2);
} }
▲ Show 20 Lines • Show All 214 Lines • Show Last 20 Lines

lldb/source/Interpreter/OptionGroupMemoryTag.cpp

Show All 26 Lines : m_show_tags(false, false), m_option_definition{
0, 0,
eArgTypeNone, eArgTypeNone,
note_binary note_binary
? "Include memory tags in output " ? "Include memory tags in output "
"(does not apply to binary output)." "(does not apply to binary output)."
: "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
OptionGroupMemoryTag::SetOptionValue(uint32_t option_idx, OptionGroupMemoryTag::SetOptionValue(uint32_t option_idx,
llvm::StringRef option_arg, llvm::StringRef option_arg,
ExecutionContext *execution_context) { ExecutionContext *execution_context) {
assert(option_idx == 0 && "Only one option in memory tag group!"); assert(option_idx == 0 && "Only one option in memory tag group!");
Show All 17 Lines

lldb/source/Interpreter/OptionGroupOutputFile.cpp

Show All 21 Linesstatic constexpr OptionDefinition g_option_table[] = {
nullptr, {}, 0, eArgTypeFilename, nullptr, {}, 0, eArgTypeFilename,
"Specify a path for capturing command output."}, "Specify a path for capturing command output."},
{LLDB_OPT_SET_1, false, "append-outfile", SHORT_OPTION_APND, {LLDB_OPT_SET_1, false, "append-outfile", SHORT_OPTION_APND,
OptionParser::eNoArgument, nullptr, {}, 0, eArgTypeNone, OptionParser::eNoArgument, nullptr, {}, 0, eArgTypeNone,
"Append to the file specified with '--outfile <path>'."}, "Append to the file specified with '--outfile <path>'."},
}; };
llvm::ArrayRef<OptionDefinition> OptionGroupOutputFile::GetDefinitions() { llvm::ArrayRef<OptionDefinition> OptionGroupOutputFile::GetDefinitions() {
return llvm::makeArrayRef(g_option_table); return llvm::ArrayRef(g_option_table);
} }
Status Status
OptionGroupOutputFile::SetOptionValue(uint32_t option_idx, OptionGroupOutputFile::SetOptionValue(uint32_t option_idx,
llvm::StringRef option_arg, llvm::StringRef option_arg,
ExecutionContext *execution_context) { ExecutionContext *execution_context) {
Status error; Status error;
const int short_option = g_option_table[option_idx].short_option; const int short_option = g_option_table[option_idx].short_option;
Show All 22 Lines

lldb/source/Interpreter/OptionGroupUUID.cpp

Show All 13 Lines
using namespace lldb_private; using namespace lldb_private;
static constexpr OptionDefinition g_option_table[] = { static constexpr OptionDefinition g_option_table[] = {
{LLDB_OPT_SET_1, false, "uuid", 'u', OptionParser::eRequiredArgument, {LLDB_OPT_SET_1, false, "uuid", 'u', OptionParser::eRequiredArgument,
nullptr, {}, 0, eArgTypeModuleUUID, "A module UUID value."}, nullptr, {}, 0, eArgTypeModuleUUID, "A module UUID value."},
}; };
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,
llvm::StringRef option_arg, llvm::StringRef option_arg,
ExecutionContext *execution_context) { ExecutionContext *execution_context) {
Status error; Status error;
const int short_option = g_option_table[option_idx].short_option; const int short_option = g_option_table[option_idx].short_option;
Show All 18 Lines

lldb/source/Interpreter/OptionGroupValueObjectDisplay.cpp

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Linesstatic const OptionDefinition g_option_table[] = {
nullptr, {}, 0, eArgTypeBoolean, "Show results of type validators."}, nullptr, {}, 0, eArgTypeBoolean, "Show results of type validators."},
{LLDB_OPT_SET_1, false, "element-count", 'Z', {LLDB_OPT_SET_1, false, "element-count", 'Z',
OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeCount, OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeCount,
"Treat the result of the expression as if its type is an array of this " "Treat the result of the expression as if its type is an array of this "
"many values."}}; "many values."}};
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(
uint32_t option_idx, llvm::StringRef option_arg, uint32_t option_idx, llvm::StringRef option_arg,
ExecutionContext *execution_context) { ExecutionContext *execution_context) {
Status error; Status error;
const int short_option = g_option_table[option_idx].short_option; const int short_option = g_option_table[option_idx].short_option;
bool success = false; bool success = false;
▲ Show 20 Lines • Show All 150 Lines • Show Last 20 Lines

lldb/source/Interpreter/OptionGroupVariable.cpp

Show First 20 Lines • Show All 125 Lines • ▼ Show 20 Linesvoid OptionGroupVariable::OptionParsingStarting(
show_scope = false; show_scope = false;
summary.Clear(); summary.Clear();
summary_string.Clear(); summary_string.Clear();
} }
#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)
return result; return result;
// Skip the "--no-args", "--no-locals" and "--show-globals" options if we are // Skip the "--no-args", "--no-locals" and "--show-globals" options if we are
// not showing frame specific options (globals only) // not showing frame specific options (globals only)
return result.drop_front(NUM_FRAME_OPTS); return result.drop_front(NUM_FRAME_OPTS);
} }

lldb/source/Interpreter/OptionGroupWatchpoint.cpp

Show First 20 Lines • Show All 105 Lines • ▼ Show 20 Lines
void OptionGroupWatchpoint::OptionParsingStarting( void OptionGroupWatchpoint::OptionParsingStarting(
ExecutionContext *execution_context) { ExecutionContext *execution_context) {
watch_type_specified = false; watch_type_specified = false;
watch_type = eWatchInvalid; watch_type = eWatchInvalid;
watch_size = 0; watch_size = 0;
} }
llvm::ArrayRef<OptionDefinition> OptionGroupWatchpoint::GetDefinitions() { llvm::ArrayRef<OptionDefinition> OptionGroupWatchpoint::GetDefinitions() {
return llvm::makeArrayRef(g_option_table); return llvm::ArrayRef(g_option_table);
} }

lldb/source/Interpreter/OptionValueBoolean.cpp

Show First 20 Lines • Show All 66 Lines • ▼ Show 20 LinesStatus OptionValueBoolean::SetValueFromString(llvm::StringRef value_str,
return error; return error;
} }
void OptionValueBoolean::AutoComplete(CommandInterpreter &interpreter, void OptionValueBoolean::AutoComplete(CommandInterpreter &interpreter,
CompletionRequest &request) { CompletionRequest &request) {
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())
entries = entries.take_front(2); entries = entries.take_front(2);
for (auto entry : entries) for (auto entry : entries)
request.TryCompleteCurrentArg(entry); request.TryCompleteCurrentArg(entry);
} }

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

Show First 20 Lines • Show All 265 Lines • ▼ Show 20 Lines while (size > 0 && reg_index < regs_for_args_count) {
reg_value[byte_index++] = *(value++); reg_value[byte_index++] = *(value++);
--size; --size;
} }
while (byte_index < reg_size) { while (byte_index < reg_size) {
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),
reg_val_obj)) reg_val_obj))
return false; return false;
// NOTE: It's unsafe to iterate through LLDB_REGNUM_GENERICs. // NOTE: It's unsafe to iterate through LLDB_REGNUM_GENERICs.
++reg_index; ++reg_index;
▲ Show 20 Lines • Show All 319 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 862 Lines • ▼ Show 20 Lines Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
return error; return error;
} }
void OptionParsingStarting(ExecutionContext *execution_context) override { void OptionParsingStarting(ExecutionContext *execution_context) override {
m_verbose.Clear(); m_verbose.Clear();
} }
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;
}; };
CommandObjectObjC_ClassTable_Dump(CommandInterpreter &interpreter) CommandObjectObjC_ClassTable_Dump(CommandInterpreter &interpreter)
: CommandObjectParsed(interpreter, "dump", : CommandObjectParsed(interpreter, "dump",
"Dump information on Objective-C classes " "Dump information on Objective-C classes "
▲ Show 20 Lines • Show All 2,432 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 4,107 Lines • ▼ Show 20 Lines Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
return err; return err;
} }
void OptionParsingStarting(ExecutionContext *exe_ctx) override { void OptionParsingStarting(ExecutionContext *exe_ctx) override {
m_have_coord = false; m_have_coord = false;
} }
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,
StreamString &err_str) { StreamString &err_str) {
m_kernel_types = RSReduceBreakpointResolver::eKernelTypeNone; m_kernel_types = RSReduceBreakpointResolver::eKernelTypeNone;
const auto reduce_name_to_type = [](llvm::StringRef name) -> int { const auto reduce_name_to_type = [](llvm::StringRef name) -> int {
return llvm::StringSwitch<int>(name) return llvm::StringSwitch<int>(name)
.Case("accumulator", RSReduceBreakpointResolver::eKernelTypeAccum) .Case("accumulator", RSReduceBreakpointResolver::eKernelTypeAccum)
▲ Show 20 Lines • Show All 135 Lines • ▼ Show 20 Lines Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
return err; return err;
} }
void OptionParsingStarting(ExecutionContext *exe_ctx) override { void OptionParsingStarting(ExecutionContext *exe_ctx) override {
m_have_coord = false; m_have_coord = false;
} }
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;
bool m_have_coord = false; bool m_have_coord = false;
}; };
bool DoExecute(Args &command, CommandReturnObject &result) override { bool DoExecute(Args &command, CommandReturnObject &result) override {
const size_t argc = command.GetArgumentCount(); const size_t argc = command.GetArgumentCount();
▲ Show 20 Lines • Show All 263 Lines • ▼ Show 20 Lines Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
return err; return err;
} }
void OptionParsingStarting(ExecutionContext *exe_ctx) override { void OptionParsingStarting(ExecutionContext *exe_ctx) override {
m_outfile.Clear(); m_outfile.Clear();
} }
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;
}; };
bool DoExecute(Args &command, CommandReturnObject &result) override { bool DoExecute(Args &command, CommandReturnObject &result) override {
const size_t argc = command.GetArgumentCount(); const size_t argc = command.GetArgumentCount();
if (argc < 1) { if (argc < 1) {
▲ Show 20 Lines • Show All 101 Lines • ▼ Show 20 Lines Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
break; break;
} }
return err; return err;
} }
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;
}; };
bool DoExecute(Args &command, CommandReturnObject &result) override { bool DoExecute(Args &command, CommandReturnObject &result) override {
RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>( RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
m_exe_ctx.GetProcessPtr()->GetLanguageRuntime( m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
▲ Show 20 Lines • Show All 263 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 441 Lines • ▼ Show 20 Lines if (data_sp &&
data_sp->GetByteSize() > (llvm::ELF::EI_NIDENT + data_offset)) { data_sp->GetByteSize() > (llvm::ELF::EI_NIDENT + data_offset)) {
const uint8_t *magic = data_sp->GetBytes() + data_offset; const uint8_t *magic = data_sp->GetBytes() + data_offset;
return ELFHeader::MagicBytesMatch(magic); return ELFHeader::MagicBytesMatch(magic);
} }
return false; return false;
} }
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(
const ProgramHeaderColl &program_headers, DataExtractor &object_data) { const ProgramHeaderColl &program_headers, DataExtractor &object_data) {
uint32_t core_notes_crc = 0; uint32_t core_notes_crc = 0;
for (const ELFProgramHeader &H : program_headers) { for (const ELFProgramHeader &H : program_headers) {
▲ Show 20 Lines • Show All 3,007 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 66 Lines • ▼ Show 20 LinesGetWasmString(llvm::DataExtractor &data, llvm::DataExtractor::Cursor &c) {
llvm::SmallVector<uint8_t, 32> str_storage; llvm::SmallVector<uint8_t, 32> str_storage;
data.getU8(c, str_storage, len); data.getU8(c, str_storage, len);
if (!c) { if (!c) {
consumeError(c.takeError()); consumeError(c.takeError());
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);
} }
char ObjectFileWasm::ID; char ObjectFileWasm::ID;
void ObjectFileWasm::Initialize() { void ObjectFileWasm::Initialize() {
PluginManager::RegisterPlugin(GetPluginNameStatic(), PluginManager::RegisterPlugin(GetPluginNameStatic(),
GetPluginDescriptionStatic(), CreateInstance, GetPluginDescriptionStatic(), CreateInstance,
▲ Show 20 Lines • Show All 395 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 411 Lines • ▼ Show 20 Lines
NativeProcessFreeBSD::GetSoftwareBreakpointTrapOpcode(size_t size_hint) { NativeProcessFreeBSD::GetSoftwareBreakpointTrapOpcode(size_t size_hint) {
static const uint8_t g_arm_opcode[] = {0xfe, 0xde, 0xff, 0xe7}; static const uint8_t g_arm_opcode[] = {0xfe, 0xde, 0xff, 0xe7};
static const uint8_t g_thumb_opcode[] = {0x01, 0xde}; static const uint8_t g_thumb_opcode[] = {0x01, 0xde};
switch (GetArchitecture().GetMachine()) { switch (GetArchitecture().GetMachine()) {
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!");
} }
default: default:
return NativeProcessProtocol::GetSoftwareBreakpointTrapOpcode(size_hint); return NativeProcessProtocol::GetSoftwareBreakpointTrapOpcode(size_hint);
} }
} }
▲ Show 20 Lines • Show All 631 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 1,507 Lines • ▼ Show 20 LinesNativeProcessLinux::GetSoftwareBreakpointTrapOpcode(size_t size_hint) {
// linux kernel does otherwise. // linux kernel does otherwise.
static const uint8_t g_arm_opcode[] = {0xf0, 0x01, 0xf0, 0xe7}; static const uint8_t g_arm_opcode[] = {0xf0, 0x01, 0xf0, 0xe7};
static const uint8_t g_thumb_opcode[] = {0x01, 0xde}; static const uint8_t g_thumb_opcode[] = {0x01, 0xde};
switch (GetArchitecture().GetMachine()) { switch (GetArchitecture().GetMachine()) {
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!");
} }
default: default:
return NativeProcessProtocol::GetSoftwareBreakpointTrapOpcode(size_hint); return NativeProcessProtocol::GetSoftwareBreakpointTrapOpcode(size_hint);
} }
} }
▲ Show 20 Lines • Show All 481 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 211 Lines • ▼ Show 20 Lines if (m_opt_regsets.AllSet(eRegsetMaskSVE)) {
std::make_pair(sve_vg, sve_ffr + 1); std::make_pair(sve_vg, sve_ffr + 1);
} else { } else {
m_register_info_p = g_register_infos_arm64_le; m_register_info_p = g_register_infos_arm64_le;
m_register_info_count = fpu_fpcr + 1; m_register_info_count = fpu_fpcr + 1;
} }
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));
if (m_opt_regsets.AllSet(eRegsetMaskPAuth)) if (m_opt_regsets.AllSet(eRegsetMaskPAuth))
AddRegSetPAuth(); AddRegSetPAuth();
if (m_opt_regsets.AllSet(eRegsetMaskMTE)) if (m_opt_regsets.AllSet(eRegsetMaskMTE))
AddRegSetMTE(); AddRegSetMTE();
▲ Show 20 Lines • Show All 97 Lines • ▼ Show 20 Linesuint32_t RegisterInfoPOSIX_arm64::ConfigureVectorLength(uint32_t sve_vq) {
m_vector_reg_vq = sve_vq; m_vector_reg_vq = sve_vq;
if (sve_vq == eVectorQuadwordAArch64) if (sve_vq == eVectorQuadwordAArch64)
return m_vector_reg_vq; return m_vector_reg_vq;
std::vector<lldb_private::RegisterInfo> &reg_info_ref = std::vector<lldb_private::RegisterInfo> &reg_info_ref =
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;
reg_info_ref[fpu_fpcr].byte_offset = offset + 4; reg_info_ref[fpu_fpcr].byte_offset = offset + 4;
reg_info_ref[sve_vg].byte_offset = offset + 8; reg_info_ref[sve_vg].byte_offset = offset + 8;
offset += 16; offset += 16;
// Update Z registers size and offset // Update Z registers size and offset
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 289 Lines • ▼ Show 20 Lines
llvm::Expected<llvm::ArrayRef<uint8_t>> llvm::Expected<llvm::ArrayRef<uint8_t>>
NativeProcessWindows::GetSoftwareBreakpointTrapOpcode(size_t size_hint) { NativeProcessWindows::GetSoftwareBreakpointTrapOpcode(size_t size_hint) {
static const uint8_t g_aarch64_opcode[] = {0x00, 0x00, 0x3e, 0xd4}; // brk #0xf000 static const uint8_t g_aarch64_opcode[] = {0x00, 0x00, 0x3e, 0xd4}; // brk #0xf000
static const uint8_t g_thumb_opcode[] = {0xfe, 0xde}; // udf #0xfe static const uint8_t g_thumb_opcode[] = {0xfe, 0xde}; // udf #0xfe
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);
} }
} }
size_t NativeProcessWindows::GetSoftwareBreakpointPCOffset() { size_t NativeProcessWindows::GetSoftwareBreakpointPCOffset() {
// Windows always reports an incremented PC after a breakpoint is hit, // Windows always reports an incremented PC after a breakpoint is hit,
▲ Show 20 Lines • Show All 320 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 2,301 Lines • ▼ Show 20 LinesGDBRemoteCommunicationServerLLGS::Handle_P(StringExtractorGDBRemote &packet) {
} }
if (reg_size != reg_info->byte_size) if (reg_size != reg_info->byte_size)
return SendIllFormedResponse(packet, "P packet register size is incorrect"); return SendIllFormedResponse(packet, "P packet register size is incorrect");
// 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()) {
LLDB_LOGF(log, LLDB_LOGF(log,
"GDBRemoteCommunicationServerLLGS::%s failed, write of " "GDBRemoteCommunicationServerLLGS::%s failed, write of "
"requested register %" PRIu32 " (%s) failed: %s", "requested register %" PRIu32 " (%s) failed: %s",
__FUNCTION__, reg_index, reg_info->name, error.AsCString()); __FUNCTION__, reg_index, reg_info->name, error.AsCString());
return SendErrorResponse(0x32); return SendErrorResponse(0x32);
▲ Show 20 Lines • Show All 1,993 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 66 Lines • ▼ Show 20 Lines if (error.Fail() ||
return {}; return {};
const llvm::support::ulittle64_t *base_rva; const llvm::support::ulittle64_t *base_rva;
error = consumeObject(data, base_rva); error = consumeObject(data, base_rva);
if (error.Fail()) if (error.Fail())
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);
} }

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

Show All 34 Lines
} }
static constexpr lldb::ScriptLanguage g_supported_script_languages[] = { static constexpr lldb::ScriptLanguage g_supported_script_languages[] = {
ScriptLanguage::eScriptLanguagePython, ScriptLanguage::eScriptLanguagePython,
}; };
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);
} }
void ScriptedProcess::CheckInterpreterAndScriptObject() const { void ScriptedProcess::CheckInterpreterAndScriptObject() const {
lldbassert(m_interpreter && "Invalid Script Interpreter."); lldbassert(m_interpreter && "Invalid Script Interpreter.");
lldbassert(m_script_object_sp && "Invalid Script Object."); lldbassert(m_script_object_sp && "Invalid Script Object.");
} }
▲ Show 20 Lines • Show All 452 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 551 Lines • ▼ Show 20 Lines Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
default: default:
error.SetErrorStringWithFormat("unsupported option '%c'", short_option); error.SetErrorStringWithFormat("unsupported option '%c'", short_option);
} }
return error; return error;
} }
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) {
StructuredData::DictionarySP config_sp(new StructuredData::Dictionary()); StructuredData::DictionarySP config_sp(new StructuredData::Dictionary());
// Set the basic enabled state. // Set the basic enabled state.
config_sp->AddBooleanItem("enabled", enabled); config_sp->AddBooleanItem("enabled", enabled);
▲ Show 20 Lines • Show All 1,292 Lines • Show Last 20 Lines

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

Show All 16 Lines
} }
dw_offset_t dw_offset_t
DWARFDataExtractor::GetDWARFOffset(lldb::offset_t *offset_ptr) const { DWARFDataExtractor::GetDWARFOffset(lldb::offset_t *offset_ptr) const {
return GetMaxU64(offset_ptr, GetDWARFSizeOfOffset()); return GetMaxU64(offset_ptr, GetDWARFSizeOfOffset());
} }
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

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

Show First 20 Lines • Show All 243 Lines • ▼ Show 20 LinesDWARFExpression lldb_private::npdb::MakeConstantLocationExpression(
llvm::ArrayRef<uint8_t> bytes; llvm::ArrayRef<uint8_t> bytes;
if (is_signed) { if (is_signed) {
Value.I = constant.getSExtValue(); Value.I = constant.getSExtValue();
} else { } else {
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);
DWARFExpression result(extractor); DWARFExpression result(extractor);
return result; return result;
} }
DWARFExpression DWARFExpression
Show All 40 Lines

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

Show First 20 Lines • Show All 1,183 Lines • ▼ Show 20 Lines SymbolFileNativePDB *pdb = static_cast<SymbolFileNativePDB *>(
m_clang.GetSymbolFile()->GetBackingSymbolFile()); m_clang.GetSymbolFile()->GetBackingSymbolFile());
PdbIndex &index = pdb->GetIndex(); PdbIndex &index = pdb->GetIndex();
TpiStream &stream = index.tpi(); TpiStream &stream = index.tpi();
CVType args_cvt = stream.getType(args_type_idx); CVType args_cvt = stream.getType(args_type_idx);
ArgListRecord args; ArgListRecord args;
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();
std::vector<CompilerType> arg_types; std::vector<CompilerType> arg_types;
arg_types.reserve(arg_indices.size()); arg_types.reserve(arg_indices.size());
for (TypeIndex arg_index : arg_indices) { for (TypeIndex arg_index : arg_indices) {
▲ Show 20 Lines • Show All 252 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 64 Lines • ▼ Show 20 Linesvoid CommandObjectThreadTraceStartIntelPT::CommandOptions::
OptionParsingStarting(ExecutionContext *execution_context) { OptionParsingStarting(ExecutionContext *execution_context) {
m_ipt_trace_size = kDefaultIptTraceSize; m_ipt_trace_size = kDefaultIptTraceSize;
m_enable_tsc = kDefaultEnableTscValue; m_enable_tsc = kDefaultEnableTscValue;
m_psb_period = kDefaultPsbPeriod; m_psb_period = kDefaultPsbPeriod;
} }
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(
Args &command, CommandReturnObject &result, Args &command, CommandReturnObject &result,
llvm::ArrayRef<lldb::tid_t> tids) { llvm::ArrayRef<lldb::tid_t> tids) {
if (Error err = m_trace.Start(tids, m_options.m_ipt_trace_size, if (Error err = m_trace.Start(tids, m_options.m_ipt_trace_size,
m_options.m_enable_tsc, m_options.m_psb_period)) m_options.m_enable_tsc, m_options.m_psb_period))
result.SetError(Status(std::move(err))); result.SetError(Status(std::move(err)));
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Linesvoid CommandObjectProcessTraceStartIntelPT::CommandOptions::
m_enable_tsc = kDefaultEnableTscValue; m_enable_tsc = kDefaultEnableTscValue;
m_psb_period = kDefaultPsbPeriod; m_psb_period = kDefaultPsbPeriod;
m_per_cpu_tracing = kDefaultPerCpuTracing; m_per_cpu_tracing = kDefaultPerCpuTracing;
m_disable_cgroup_filtering = kDefaultDisableCgroupFiltering; m_disable_cgroup_filtering = kDefaultDisableCgroupFiltering;
} }
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(
Args &command, CommandReturnObject &result) { Args &command, CommandReturnObject &result) {
if (Error err = m_trace.Start( if (Error err = m_trace.Start(
m_options.m_ipt_trace_size, m_options.m_process_buffer_size_limit, m_options.m_ipt_trace_size, m_options.m_process_buffer_size_limit,
m_options.m_enable_tsc, m_options.m_psb_period, m_options.m_enable_tsc, m_options.m_psb_period,
m_options.m_per_cpu_tracing, m_options.m_disable_cgroup_filtering)) m_options.m_per_cpu_tracing, m_options.m_disable_cgroup_filtering))
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines
void CommandObjectThreadTraceExportCTF::CommandOptions::OptionParsingStarting( void CommandObjectThreadTraceExportCTF::CommandOptions::OptionParsingStarting(
ExecutionContext *execution_context) { ExecutionContext *execution_context) {
m_file.clear(); m_file.clear();
m_thread_index = std::nullopt; m_thread_index = std::nullopt;
} }
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,
CommandReturnObject &result) { CommandReturnObject &result) {
const TraceSP &trace_sp = m_exe_ctx.GetTargetSP()->GetTrace(); const TraceSP &trace_sp = m_exe_ctx.GetTargetSP()->GetTrace();
Process *process = m_exe_ctx.GetProcessPtr(); Process *process = m_exe_ctx.GetProcessPtr();
Thread *thread = m_options.m_thread_index Thread *thread = m_options.m_thread_index
? process->GetThreadList() ? process->GetThreadList()
Show All 29 Lines

lldb/source/Symbol/UnwindPlan.cpp

Show First 20 Lines • Show All 142 Lines • ▼ Show 20 Linesvoid UnwindPlan::Row::RegisterLocation::Dump(Stream &s,
} break; } break;
case atDWARFExpression: case atDWARFExpression:
case isDWARFExpression: { case isDWARFExpression: {
s.PutChar('='); s.PutChar('=');
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(']');
} break; } break;
} }
} }
static void DumpRegisterName(Stream &s, const UnwindPlan *unwind_plan, static void DumpRegisterName(Stream &s, const UnwindPlan *unwind_plan,
Show All 37 Lines case isRegisterPlusOffset:
s.Printf("%+3d", m_value.reg.offset); s.Printf("%+3d", m_value.reg.offset);
break; break;
case isRegisterDereferenced: case isRegisterDereferenced:
s.PutChar('['); s.PutChar('[');
DumpRegisterName(s, unwind_plan, thread, m_value.reg.reg_num); DumpRegisterName(s, unwind_plan, thread, m_value.reg.reg_num);
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:
s.PutCString("unspecified"); s.PutCString("unspecified");
break; break;
case isRaSearch: case isRaSearch:
s.Printf("RaSearch@SP%+d", m_value.ra_search_offset); s.Printf("RaSearch@SP%+d", m_value.ra_search_offset);
break; break;
▲ Show 20 Lines • Show All 373 Lines • Show Last 20 Lines

lldb/source/Target/Platform.cpp

Show First 20 Lines • Show All 1,352 Lines • ▼ Show 20 Lines
static constexpr OptionDefinition g_caching_option_table[] = { static constexpr OptionDefinition g_caching_option_table[] = {
{LLDB_OPT_SET_ALL, false, "local-cache-dir", 'c', {LLDB_OPT_SET_ALL, false, "local-cache-dir", 'c',
OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypePath, OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypePath,
"Path in which to store local copies of files."}, "Path in which to store local copies of files."},
}; };
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(
ExecutionContext *execution_context) { ExecutionContext *execution_context) {
m_rsync = false; m_rsync = false;
m_rsync_opts.clear(); m_rsync_opts.clear();
m_rsync_prefix.clear(); m_rsync_prefix.clear();
m_ignores_remote_hostname = false; m_ignores_remote_hostname = false;
Show All 31 Lines
} }
lldb::BreakpointSP lldb::BreakpointSP
Platform::SetThreadCreationBreakpoint(lldb_private::Target &target) { Platform::SetThreadCreationBreakpoint(lldb_private::Target &target) {
return lldb::BreakpointSP(); return lldb::BreakpointSP();
} }
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(
ExecutionContext *execution_context) { ExecutionContext *execution_context) {
m_ssh = false; m_ssh = false;
m_ssh_opts.clear(); m_ssh_opts.clear();
} }
Show All 16 Lines default:
error.SetErrorStringWithFormat("unrecognized option '%c'", short_option); error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
break; break;
} }
return error; return error;
} }
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(
ExecutionContext *execution_context) { ExecutionContext *execution_context) {
m_cache_dir.clear(); m_cache_dir.clear();
} }
lldb_private::Status OptionGroupPlatformCaching::SetOptionValue( lldb_private::Status OptionGroupPlatformCaching::SetOptionValue(
▲ Show 20 Lines • Show All 664 Lines • Show Last 20 Lines

lldb/source/Target/StackFrameRecognizer.cpp

Show First 20 Lines • Show All 71 Lines • ▼ Show 20 Lines if (entry.is_regexp) {
std::string symbol_name; std::string symbol_name;
if (entry.module_regexp) if (entry.module_regexp)
module_name = entry.module_regexp->GetText().str(); module_name = entry.module_regexp->GetText().str();
if (entry.symbol_regexp) if (entry.symbol_regexp)
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(),
entry.module.GetCString(), entry.symbols, false); entry.module.GetCString(), entry.symbols, false);
} }
} }
} }
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

lldb/source/Utility/Args.cpp

Show First 20 Lines • Show All 306 Lines • ▼ Show 20 Lines
} }
void Args::AppendArguments(const char **argv) { void Args::AppendArguments(const char **argv) {
size_t argc = ArgvToArgc(argv); size_t argc = ArgvToArgc(argv);
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());
} }
m_argv.push_back(nullptr); m_argv.push_back(nullptr);
} }
void Args::AppendArgument(llvm::StringRef arg_str, char quote_char) { void Args::AppendArgument(llvm::StringRef arg_str, char quote_char) {
Show All 29 Linesvoid Args::DeleteArgumentAtIndex(size_t idx) {
m_argv.erase(m_argv.begin() + idx); m_argv.erase(m_argv.begin() + idx);
m_entries.erase(m_entries.begin() + idx); m_entries.erase(m_entries.begin() + idx);
} }
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) {
char quote = char quote =
((args[i][0] == '\'') || (args[i][0] == '"') || (args[i][0] == '`')) ((args[i][0] == '\'') || (args[i][0] == '"') || (args[i][0] == '`'))
? args[i][0] ? args[i][0]
: '\0'; : '\0';
▲ Show 20 Lines • Show All 320 Lines • Show Last 20 Lines

lldb/source/Utility/StringList.cpp

Show First 20 Lines • Show All 102 Lines • ▼ Show 20 Lines
} }
void StringList::Clear() { m_strings.clear(); } void StringList::Clear() { m_strings.clear(); }
std::string StringList::LongestCommonPrefix() { std::string StringList::LongestCommonPrefix() {
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;
for (count = 0; count < std::min(prefix.size(), arg.size()); ++count) { for (count = 0; count < std::min(prefix.size(), arg.size()); ++count) {
if (prefix[count] != arg[count]) if (prefix[count] != arg[count])
break; break;
} }
prefix = prefix.take_front(count); prefix = prefix.take_front(count);
▲ Show 20 Lines • Show All 128 Lines • Show Last 20 Lines

lldb/tools/driver/Driver.cpp

Show First 20 Lines • Show All 751 Lines • ▼ Show 20 Linesint main(int argc, char const *argv[]) {
// Setup LLVM signal handlers and make sure we call llvm_shutdown() on // Setup LLVM signal handlers and make sure we call llvm_shutdown() on
// destruction. // destruction.
llvm::InitLLVM IL(argc, argv, /*InstallPipeSignalExitHandler=*/false); llvm::InitLLVM IL(argc, argv, /*InstallPipeSignalExitHandler=*/false);
// Parse arguments. // Parse arguments.
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]);
if (input_args.hasArg(OPT_help)) { if (input_args.hasArg(OPT_help)) {
printHelp(T, argv0); printHelp(T, argv0);
return 0; return 0;
} }
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 3,221 Lines • ▼ Show 20 Linesint main(int argc, char *argv[]) {
llvm::PrettyStackTraceProgram X(argc, argv); llvm::PrettyStackTraceProgram X(argc, argv);
llvm::SmallString<256> program_path(argv[0]); llvm::SmallString<256> program_path(argv[0]);
llvm::sys::fs::make_absolute(program_path); llvm::sys::fs::make_absolute(program_path);
g_vsc.debug_adaptor_path = program_path.str().str(); g_vsc.debug_adaptor_path = program_path.str().str();
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)) {
printHelp(T, llvm::sys::path::filename(argv[0])); printHelp(T, llvm::sys::path::filename(argv[0]));
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }
if (llvm::opt::Arg *target_arg = input_args.getLastArg(OPT_launch_target)) { if (llvm::opt::Arg *target_arg = input_args.getLastArg(OPT_launch_target)) {
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

lldb/unittests/TestingSupport/Host/NativeProcessTestUtils.h

Show First 20 Lines • Show All 80 Lines • ▼ Show 20 Lines Status ReadMemory(addr_t Addr, void *Buf, size_t Size,
assert(BytesRead <= Size); assert(BytesRead <= Size);
std::memcpy(Buf, ExpectedMemory->data(), BytesRead); std::memcpy(Buf, ExpectedMemory->data(), BytesRead);
return Status(); return Status();
} }
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());
} }
BytesWritten = *ExpectedBytes; BytesWritten = *ExpectedBytes;
return Status(); return Status();
} }
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

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

Show All 28 Lines
using namespace mlir::toy; using namespace mlir::toy;
using namespace toy; using namespace toy;
using llvm::ArrayRef; using llvm::ArrayRef;
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;
using llvm::Twine; using llvm::Twine;
namespace { namespace {
/// Implementation of a simple MLIR emission from the Toy AST. /// Implementation of a simple MLIR emission from the Toy AST.
▲ Show 20 Lines • Show All 175 Lines • ▼ Show 20 Lines mlir::LogicalResult mlirGen(ReturnExprAST &ret) {
// 'return' takes an optional expression, handle that case here. // 'return' takes an optional expression, handle that case here.
mlir::Value expr = nullptr; mlir::Value expr = nullptr;
if (ret.getExpr().has_value()) { if (ret.getExpr().has_value()) {
if (!(expr = mlirGen(**ret.getExpr()))) if (!(expr = mlirGen(**ret.getExpr())))
return mlir::failure(); return mlir::failure();
} }
// 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();
} }
/// Emit a literal/constant array. It will be emitted as a flattened array of /// Emit a literal/constant array. It will be emitted as a flattened array of
/// data in an Attribute attached to a `toy.constant` operation. /// data in an Attribute attached to a `toy.constant` operation.
/// See documentation on [Attributes](LangRef.md#attributes) for more details. /// See documentation on [Attributes](LangRef.md#attributes) for more details.
/// Here is an excerpt: /// Here is an excerpt:
/// ///
Show All 23 Lines mlir::Value mlirGen(LiteralExprAST &lit) {
// The type of this attribute is tensor of 64-bit floating-point with the // The type of this attribute is tensor of 64-bit floating-point with the
// shape of the literal. // shape of the literal.
mlir::Type elementType = builder.getF64Type(); mlir::Type elementType = builder.getF64Type();
auto dataType = mlir::RankedTensorType::get(lit.getDims(), elementType); auto dataType = mlir::RankedTensorType::get(lit.getDims(), elementType);
// 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.
return builder.create<ConstantOp>(loc(lit.loc()), type, dataAttribute); return builder.create<ConstantOp>(loc(lit.loc()), type, dataAttribute);
} }
/// Recursive helper function to accumulate the data that compose an array /// Recursive helper function to accumulate the data that compose an array
/// literal. It flattens the nested structure in the supplied vector. For /// literal. It flattens the nested structure in the supplied vector. For
▲ Show 20 Lines • Show All 169 Lines • Show Last 20 Lines

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

Show All 28 Lines
using namespace mlir::toy; using namespace mlir::toy;
using namespace toy; using namespace toy;
using llvm::ArrayRef; using llvm::ArrayRef;
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;
using llvm::Twine; using llvm::Twine;
namespace { namespace {
/// Implementation of a simple MLIR emission from the Toy AST. /// Implementation of a simple MLIR emission from the Toy AST.
▲ Show 20 Lines • Show All 175 Lines • ▼ Show 20 Lines mlir::LogicalResult mlirGen(ReturnExprAST &ret) {
// 'return' takes an optional expression, handle that case here. // 'return' takes an optional expression, handle that case here.
mlir::Value expr = nullptr; mlir::Value expr = nullptr;
if (ret.getExpr().has_value()) { if (ret.getExpr().has_value()) {
if (!(expr = mlirGen(**ret.getExpr()))) if (!(expr = mlirGen(**ret.getExpr())))
return mlir::failure(); return mlir::failure();
} }
// 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();
} }
/// Emit a literal/constant array. It will be emitted as a flattened array of /// Emit a literal/constant array. It will be emitted as a flattened array of
/// data in an Attribute attached to a `toy.constant` operation. /// data in an Attribute attached to a `toy.constant` operation.
/// See documentation on [Attributes](LangRef.md#attributes) for more details. /// See documentation on [Attributes](LangRef.md#attributes) for more details.
/// Here is an excerpt: /// Here is an excerpt:
/// ///
Show All 23 Lines mlir::Value mlirGen(LiteralExprAST &lit) {
// The type of this attribute is tensor of 64-bit floating-point with the // The type of this attribute is tensor of 64-bit floating-point with the
// shape of the literal. // shape of the literal.
mlir::Type elementType = builder.getF64Type(); mlir::Type elementType = builder.getF64Type();
auto dataType = mlir::RankedTensorType::get(lit.getDims(), elementType); auto dataType = mlir::RankedTensorType::get(lit.getDims(), elementType);
// 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.
return builder.create<ConstantOp>(loc(lit.loc()), type, dataAttribute); return builder.create<ConstantOp>(loc(lit.loc()), type, dataAttribute);
} }
/// Recursive helper function to accumulate the data that compose an array /// Recursive helper function to accumulate the data that compose an array
/// literal. It flattens the nested structure in the supplied vector. For /// literal. It flattens the nested structure in the supplied vector. For
▲ Show 20 Lines • Show All 169 Lines • Show Last 20 Lines

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

Show All 28 Lines
using namespace mlir::toy; using namespace mlir::toy;
using namespace toy; using namespace toy;
using llvm::ArrayRef; using llvm::ArrayRef;
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;
using llvm::Twine; using llvm::Twine;
namespace { namespace {
/// Implementation of a simple MLIR emission from the Toy AST. /// Implementation of a simple MLIR emission from the Toy AST.
▲ Show 20 Lines • Show All 179 Lines • ▼ Show 20 Lines mlir::LogicalResult mlirGen(ReturnExprAST &ret) {
// 'return' takes an optional expression, handle that case here. // 'return' takes an optional expression, handle that case here.
mlir::Value expr = nullptr; mlir::Value expr = nullptr;
if (ret.getExpr().has_value()) { if (ret.getExpr().has_value()) {
if (!(expr = mlirGen(**ret.getExpr()))) if (!(expr = mlirGen(**ret.getExpr())))
return mlir::failure(); return mlir::failure();
} }
// 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();
} }
/// Emit a literal/constant array. It will be emitted as a flattened array of /// Emit a literal/constant array. It will be emitted as a flattened array of
/// data in an Attribute attached to a `toy.constant` operation. /// data in an Attribute attached to a `toy.constant` operation.
/// See documentation on [Attributes](LangRef.md#attributes) for more details. /// See documentation on [Attributes](LangRef.md#attributes) for more details.
/// Here is an excerpt: /// Here is an excerpt:
/// ///
Show All 23 Lines mlir::Value mlirGen(LiteralExprAST &lit) {
// The type of this attribute is tensor of 64-bit floating-point with the // The type of this attribute is tensor of 64-bit floating-point with the
// shape of the literal. // shape of the literal.
mlir::Type elementType = builder.getF64Type(); mlir::Type elementType = builder.getF64Type();
auto dataType = mlir::RankedTensorType::get(lit.getDims(), elementType); auto dataType = mlir::RankedTensorType::get(lit.getDims(), elementType);
// 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.
return builder.create<ConstantOp>(loc(lit.loc()), type, dataAttribute); return builder.create<ConstantOp>(loc(lit.loc()), type, dataAttribute);
} }
/// Recursive helper function to accumulate the data that compose an array /// Recursive helper function to accumulate the data that compose an array
/// literal. It flattens the nested structure in the supplied vector. For /// literal. It flattens the nested structure in the supplied vector. For
▲ Show 20 Lines • Show All 169 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 171 Lines • ▼ Show 20 Lines LogicalResult matchAndRewrite(toy::ConstantOp op,
SmallVector<Value, 2> indices; SmallVector<Value, 2> indices;
auto valueIt = constantValue.value_begin<FloatAttr>(); auto valueIt = constantValue.value_begin<FloatAttr>();
std::function<void(uint64_t)> storeElements = [&](uint64_t dimension) { std::function<void(uint64_t)> storeElements = [&](uint64_t dimension) {
// The last dimension is the base case of the recursion, at this point // The last dimension is the base case of the recursion, at this point
// we store the element at the given index. // we store the element at the given index.
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;
} }
// Otherwise, iterate over the current dimension and add the indices to // Otherwise, iterate over the current dimension and add the indices to
// the list. // the list.
for (uint64_t i = 0, e = valueShape[dimension]; i != e; ++i) { for (uint64_t i = 0, e = valueShape[dimension]; i != e; ++i) {
indices.push_back(constantIndices[i]); indices.push_back(constantIndices[i]);
storeElements(dimension + 1); storeElements(dimension + 1);
▲ Show 20 Lines • Show All 177 Lines • Show Last 20 Lines

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

Show All 28 Lines
using namespace mlir::toy; using namespace mlir::toy;
using namespace toy; using namespace toy;
using llvm::ArrayRef; using llvm::ArrayRef;
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;
using llvm::Twine; using llvm::Twine;
namespace { namespace {
/// Implementation of a simple MLIR emission from the Toy AST. /// Implementation of a simple MLIR emission from the Toy AST.
▲ Show 20 Lines • Show All 179 Lines • ▼ Show 20 Lines mlir::LogicalResult mlirGen(ReturnExprAST &ret) {
// 'return' takes an optional expression, handle that case here. // 'return' takes an optional expression, handle that case here.
mlir::Value expr = nullptr; mlir::Value expr = nullptr;
if (ret.getExpr().has_value()) { if (ret.getExpr().has_value()) {
if (!(expr = mlirGen(**ret.getExpr()))) if (!(expr = mlirGen(**ret.getExpr())))
return mlir::failure(); return mlir::failure();
} }
// 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();
} }
/// Emit a literal/constant array. It will be emitted as a flattened array of /// Emit a literal/constant array. It will be emitted as a flattened array of
/// data in an Attribute attached to a `toy.constant` operation. /// data in an Attribute attached to a `toy.constant` operation.
/// See documentation on [Attributes](LangRef.md#attributes) for more details. /// See documentation on [Attributes](LangRef.md#attributes) for more details.
/// Here is an excerpt: /// Here is an excerpt:
/// ///
Show All 23 Lines mlir::Value mlirGen(LiteralExprAST &lit) {
// The type of this attribute is tensor of 64-bit floating-point with the // The type of this attribute is tensor of 64-bit floating-point with the
// shape of the literal. // shape of the literal.
mlir::Type elementType = builder.getF64Type(); mlir::Type elementType = builder.getF64Type();
auto dataType = mlir::RankedTensorType::get(lit.getDims(), elementType); auto dataType = mlir::RankedTensorType::get(lit.getDims(), elementType);
// 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.
return builder.create<ConstantOp>(loc(lit.loc()), type, dataAttribute); return builder.create<ConstantOp>(loc(lit.loc()), type, dataAttribute);
} }
/// Recursive helper function to accumulate the data that compose an array /// Recursive helper function to accumulate the data that compose an array
/// literal. It flattens the nested structure in the supplied vector. For /// literal. It flattens the nested structure in the supplied vector. For
▲ Show 20 Lines • Show All 169 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 171 Lines • ▼ Show 20 Lines LogicalResult matchAndRewrite(toy::ConstantOp op,
SmallVector<Value, 2> indices; SmallVector<Value, 2> indices;
auto valueIt = constantValue.value_begin<FloatAttr>(); auto valueIt = constantValue.value_begin<FloatAttr>();
std::function<void(uint64_t)> storeElements = [&](uint64_t dimension) { std::function<void(uint64_t)> storeElements = [&](uint64_t dimension) {
// The last dimension is the base case of the recursion, at this point // The last dimension is the base case of the recursion, at this point
// we store the element at the given index. // we store the element at the given index.
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;
} }
// Otherwise, iterate over the current dimension and add the indices to // Otherwise, iterate over the current dimension and add the indices to
// the list. // the list.
for (uint64_t i = 0, e = valueShape[dimension]; i != e; ++i) { for (uint64_t i = 0, e = valueShape[dimension]; i != e; ++i) {
indices.push_back(constantIndices[i]); indices.push_back(constantIndices[i]);
storeElements(dimension + 1); storeElements(dimension + 1);
▲ Show 20 Lines • Show All 177 Lines • Show Last 20 Lines

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

Show All 28 Lines
using namespace mlir::toy; using namespace mlir::toy;
using namespace toy; using namespace toy;
using llvm::ArrayRef; using llvm::ArrayRef;
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;
using llvm::Twine; using llvm::Twine;
namespace { namespace {
/// Implementation of a simple MLIR emission from the Toy AST. /// Implementation of a simple MLIR emission from the Toy AST.
▲ Show 20 Lines • Show All 179 Lines • ▼ Show 20 Lines mlir::LogicalResult mlirGen(ReturnExprAST &ret) {
// 'return' takes an optional expression, handle that case here. // 'return' takes an optional expression, handle that case here.
mlir::Value expr = nullptr; mlir::Value expr = nullptr;
if (ret.getExpr().has_value()) { if (ret.getExpr().has_value()) {
if (!(expr = mlirGen(**ret.getExpr()))) if (!(expr = mlirGen(**ret.getExpr())))
return mlir::failure(); return mlir::failure();
} }
// 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();
} }
/// Emit a literal/constant array. It will be emitted as a flattened array of /// Emit a literal/constant array. It will be emitted as a flattened array of
/// data in an Attribute attached to a `toy.constant` operation. /// data in an Attribute attached to a `toy.constant` operation.
/// See documentation on [Attributes](LangRef.md#attributes) for more details. /// See documentation on [Attributes](LangRef.md#attributes) for more details.
/// Here is an excerpt: /// Here is an excerpt:
/// ///
Show All 23 Lines mlir::Value mlirGen(LiteralExprAST &lit) {
// The type of this attribute is tensor of 64-bit floating-point with the // The type of this attribute is tensor of 64-bit floating-point with the
// shape of the literal. // shape of the literal.
mlir::Type elementType = builder.getF64Type(); mlir::Type elementType = builder.getF64Type();
auto dataType = mlir::RankedTensorType::get(lit.getDims(), elementType); auto dataType = mlir::RankedTensorType::get(lit.getDims(), elementType);
// 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.
return builder.create<ConstantOp>(loc(lit.loc()), type, dataAttribute); return builder.create<ConstantOp>(loc(lit.loc()), type, dataAttribute);
} }
/// Recursive helper function to accumulate the data that compose an array /// Recursive helper function to accumulate the data that compose an array
/// literal. It flattens the nested structure in the supplied vector. For /// literal. It flattens the nested structure in the supplied vector. For
▲ Show 20 Lines • Show All 169 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 171 Lines • ▼ Show 20 Lines LogicalResult matchAndRewrite(toy::ConstantOp op,
SmallVector<Value, 2> indices; SmallVector<Value, 2> indices;
auto valueIt = constantValue.value_begin<FloatAttr>(); auto valueIt = constantValue.value_begin<FloatAttr>();
std::function<void(uint64_t)> storeElements = [&](uint64_t dimension) { std::function<void(uint64_t)> storeElements = [&](uint64_t dimension) {
// The last dimension is the base case of the recursion, at this point // The last dimension is the base case of the recursion, at this point
// we store the element at the given index. // we store the element at the given index.
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;
} }
// Otherwise, iterate over the current dimension and add the indices to // Otherwise, iterate over the current dimension and add the indices to
// the list. // the list.
for (uint64_t i = 0, e = valueShape[dimension]; i != e; ++i) { for (uint64_t i = 0, e = valueShape[dimension]; i != e; ++i) {
indices.push_back(constantIndices[i]); indices.push_back(constantIndices[i]);
storeElements(dimension + 1); storeElements(dimension + 1);
▲ Show 20 Lines • Show All 177 Lines • Show Last 20 Lines

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

Show All 28 Lines
using namespace mlir::toy; using namespace mlir::toy;
using namespace toy; using namespace toy;
using llvm::ArrayRef; using llvm::ArrayRef;
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;
using llvm::Twine; using llvm::Twine;
namespace { namespace {
/// Implementation of a simple MLIR emission from the Toy AST. /// Implementation of a simple MLIR emission from the Toy AST.
▲ Show 20 Lines • Show All 312 Lines • ▼ Show 20 Lines mlir::LogicalResult mlirGen(ReturnExprAST &ret) {
// 'return' takes an optional expression, handle that case here. // 'return' takes an optional expression, handle that case here.
mlir::Value expr = nullptr; mlir::Value expr = nullptr;
if (ret.getExpr().has_value()) { if (ret.getExpr().has_value()) {
if (!(expr = mlirGen(**ret.getExpr()))) if (!(expr = mlirGen(**ret.getExpr())))
return mlir::failure(); return mlir::failure();
} }
// 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();
} }
/// Emit a constant for a literal/constant array. It will be emitted as a /// Emit a constant for a literal/constant array. It will be emitted as a
/// flattened array of data in an Attribute attached to a `toy.constant` /// flattened array of data in an Attribute attached to a `toy.constant`
/// operation. See documentation on [Attributes](LangRef.md#attributes) for /// operation. See documentation on [Attributes](LangRef.md#attributes) for
/// more details. Here is an excerpt: /// more details. Here is an excerpt:
/// ///
Show All 20 Lines mlir::DenseElementsAttr getConstantAttr(LiteralExprAST &lit) {
// The type of this attribute is tensor of 64-bit floating-point with the // The type of this attribute is tensor of 64-bit floating-point with the
// shape of the literal. // shape of the literal.
mlir::Type elementType = builder.getF64Type(); mlir::Type elementType = builder.getF64Type();
auto dataType = mlir::RankedTensorType::get(lit.getDims(), elementType); auto dataType = mlir::RankedTensorType::get(lit.getDims(), elementType);
// 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
// shape. // shape.
mlir::Type elementType = builder.getF64Type(); mlir::Type elementType = builder.getF64Type();
auto dataType = mlir::RankedTensorType::get({}, elementType); auto dataType = mlir::RankedTensorType::get({}, elementType);
// 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`
/// operation. This function returns the generated constant, along with the /// operation. This function returns the generated constant, along with the
/// corresponding struct type. /// corresponding struct type.
std::pair<mlir::ArrayAttr, mlir::Type> std::pair<mlir::ArrayAttr, mlir::Type>
getConstantAttr(StructLiteralExprAST &lit) { getConstantAttr(StructLiteralExprAST &lit) {
std::vector<mlir::Attribute> attrElements; std::vector<mlir::Attribute> attrElements;
▲ Show 20 Lines • Show All 253 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 92 Lines • ▼ Show 20 Linesdef Shape_BroadcastOp : Shape_Op<"broadcast", [Commutative, Pure]> {
let assemblyFormat = [{ let assemblyFormat = [{
$shapes attr-dict `:` type($shapes) `->` type($result) $shapes attr-dict `:` type($shapes) `->` type($result)
}]; }];
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}), build($_builder, $_state, result, ::llvm::ArrayRef({lhs, rhs}),
error); error);
}]> }]>
]; ];
let hasFolder = 1; let hasFolder = 1;
let hasCanonicalizer = 1; let hasCanonicalizer = 1;
let hasVerifier = 1; let hasVerifier = 1;
} }
▲ Show 20 Lines • Show All 96 Lines • ▼ Show 20 Linesdef Shape_ShapeEqOp : Shape_Op<"shape_eq", [Pure, Commutative]> {
}]; }];
let arguments = (ins Variadic<Shape_ShapeOrExtentTensorType>:$shapes); let arguments = (ins Variadic<Shape_ShapeOrExtentTensorType>:$shapes);
let results = (outs I1:$result); let results = (outs I1:$result);
// 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)";
let hasFolder = 1; let hasFolder = 1;
} }
def Shape_FromExtentsOp : Shape_Op<"from_extents", [Pure]> { def Shape_FromExtentsOp : Shape_Op<"from_extents", [Pure]> {
let summary = "Creates a shape from extents"; let summary = "Creates a shape from extents";
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines let description = [{
``` ```
}]; }];
let arguments = (ins Variadic<Shape_ShapeOrExtentTensorType>:$shapes); let arguments = (ins Variadic<Shape_ShapeOrExtentTensorType>:$shapes);
let results = (outs I1:$result); let results = (outs I1:$result);
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;
let hasCanonicalizer = 1; let hasCanonicalizer = 1;
let assemblyFormat = "$shapes attr-dict `:` type($shapes)"; let assemblyFormat = "$shapes attr-dict `:` type($shapes)";
} }
▲ Show 20 Lines • Show All 678 Lines • ▼ Show 20 Linesdef Shape_CstrBroadcastableOp : Shape_Op<"cstr_broadcastable", [Commutative]> {
let arguments = (ins Variadic<Shape_ShapeOrExtentTensorType>:$shapes); let arguments = (ins Variadic<Shape_ShapeOrExtentTensorType>:$shapes);
let results = (outs Shape_WitnessType:$result); let results = (outs Shape_WitnessType:$result);
let assemblyFormat = "$shapes attr-dict `:` type($shapes)"; let assemblyFormat = "$shapes attr-dict `:` type($shapes)";
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;
let hasFolder = 1; let hasFolder = 1;
let hasVerifier = 1; let hasVerifier = 1;
} }
def Shape_CstrEqOp : Shape_Op<"cstr_eq", [Commutative]> { def Shape_CstrEqOp : Shape_Op<"cstr_eq", [Commutative]> {
▲ Show 20 Lines • Show All 212 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 62 Lines • ▼ Show 20 Linesstruct ValueKnowledge {
} }
ShapedTypeComponents getShapedTypeComponents() const { ShapedTypeComponents getShapedTypeComponents() const {
return hasRank ? ShapedTypeComponents(sizes) : ShapedTypeComponents(); return hasRank ? ShapedTypeComponents(sizes) : ShapedTypeComponents();
} }
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);
} }
bool operator==(const ValueKnowledge &rhs) const { bool operator==(const ValueKnowledge &rhs) const {
return hasRank == rhs.hasRank && sizes == rhs.sizes && dtype == rhs.dtype; return hasRank == rhs.hasRank && sizes == rhs.sizes && dtype == rhs.dtype;
} }
// Given two pieces of static knowledge, calculate conservatively the // Given two pieces of static knowledge, calculate conservatively the
▲ Show 20 Lines • Show All 104 Lines • Show Last 20 Lines

mlir/include/mlir/IR/AsmState.h

Show First 20 Lines • Show All 138 Lines • ▼ Show 20 Linespublic:
/// Return the raw underlying data of this blob. /// Return the raw underlying data of this blob.
ArrayRef<char> getData() const { return data; } ArrayRef<char> getData() const { return data; }
/// Return the underlying data as an array of the given type. This is an /// Return the underlying data as an array of the given type. This is an
/// inherrently unsafe operation, and should only be used when the data is /// inherrently unsafe operation, and should only be used when the data is
/// 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.
/// Asserts that the blob `isMutable`. /// Asserts that the blob `isMutable`.
MutableArrayRef<char> getMutableData() { MutableArrayRef<char> getMutableData() {
assert(isMutable() && assert(isMutable() &&
"cannot access mutable reference to non-mutable data"); "cannot access mutable reference to non-mutable data");
return MutableArrayRef<char>(const_cast<char *>(data.data()), data.size()); return MutableArrayRef<char>(const_cast<char *>(data.data()), data.size());
▲ Show 20 Lines • Show All 443 Lines • Show Last 20 Lines

mlir/include/mlir/IR/AttrTypeBase.td

Show First 20 Lines • Show All 362 Lines • ▼ Show 20 Lines
} }
// Regular array parameters cannot be parsed when empty. This optional array // Regular array parameters cannot be parsed when empty. This optional array
// parameter can be used with optional groups to be parsed when empty. // parameter can be used with optional groups to be parsed when empty.
class OptionalArrayRefParameter<string arrayOf, string desc = ""> : class OptionalArrayRefParameter<string arrayOf, string desc = ""> :
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.
class SelfAllocationParameter<string type, string desc> : class SelfAllocationParameter<string type, string desc> :
AttrOrTypeParameter<type, desc> { AttrOrTypeParameter<type, desc> {
let allocator = [{$_dst = $_self.allocateInto($_allocator);}]; let allocator = [{$_dst = $_self.allocateInto($_allocator);}];
} }
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

mlir/include/mlir/IR/BuiltinAttributes.h

Show First 20 Lines • Show All 119 Lines • ▼ Show 20 Linespublic:
} }
/// Constructs a dense integer elements attribute from a single element. /// Constructs a dense integer elements attribute from a single element.
template <typename T, template <typename T,
typename = std::enable_if_t<std::numeric_limits<T>::is_integer || typename = std::enable_if_t<std::numeric_limits<T>::is_integer ||
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
/// values. Each value is expected to be the same bitwidth of the element type /// values. Each value is expected to be the same bitwidth of the element type
/// of 'type'. 'type' must be a vector or tensor with static shape. /// of 'type'. 'type' must be a vector or tensor with static shape.
template < template <
typename T, typename ElementT = typename T::value_type, typename T, typename ElementT = typename T::value_type,
typename = std::enable_if_t<detail::is_complex_t<T>::value && typename = std::enable_if_t<detail::is_complex_t<T>::value &&
▲ Show 20 Lines • Show All 769 Lines • ▼ Show 20 Linespublic:
using iterator = DenseElementsAttr::FloatElementIterator; using iterator = DenseElementsAttr::FloatElementIterator;
using DenseIntOrFPElementsAttr::DenseIntOrFPElementsAttr; using DenseIntOrFPElementsAttr::DenseIntOrFPElementsAttr;
/// Get an instance of a DenseFPElementsAttr with the given arguments. This /// Get an instance of a DenseFPElementsAttr with the given arguments. This
/// 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>
static DenseFPElementsAttr get(const ShapedType &type, static DenseFPElementsAttr get(const ShapedType &type,
const std::initializer_list<T> &list) { const std::initializer_list<T> &list) {
return DenseElementsAttr::get(type, list) return DenseElementsAttr::get(type, list)
.template cast<DenseFPElementsAttr>(); .template cast<DenseFPElementsAttr>();
} }
Show All 25 Linespublic:
using iterator = DenseElementsAttr::IntElementIterator; using iterator = DenseElementsAttr::IntElementIterator;
using DenseIntOrFPElementsAttr::DenseIntOrFPElementsAttr; using DenseIntOrFPElementsAttr::DenseIntOrFPElementsAttr;
/// Get an instance of a DenseIntElementsAttr with the given arguments. This /// Get an instance of a DenseIntElementsAttr with the given arguments. This
/// 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>
static DenseIntElementsAttr get(const ShapedType &type, static DenseIntElementsAttr get(const ShapedType &type,
const std::initializer_list<T> &list) { const std::initializer_list<T> &list) {
return DenseElementsAttr::get(type, list) return DenseElementsAttr::get(type, list)
.template cast<DenseIntElementsAttr>(); .template cast<DenseIntElementsAttr>();
} }
▲ Show 20 Lines • Show All 134 Lines • Show Last 20 Lines

mlir/include/mlir/IR/OpBase.td

Show First 20 Lines • Show All 1,357 Lines • ▼ Show 20 Linesclass SignlessIntElementsAttr<int width> : IntElementsAttrBase<
CPred<"$_self.cast<::mlir::DenseIntElementsAttr>().getType()." CPred<"$_self.cast<::mlir::DenseIntElementsAttr>().getType()."
"getElementType().isSignlessInteger(" # width # ")">, "getElementType().isSignlessInteger(" # width # ")">,
width # "-bit signless integer elements attribute"> { width # "-bit signless integer elements attribute"> {
// 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({}, " "::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>;
def I64ElementsAttr : SignlessIntElementsAttr<64>; def I64ElementsAttr : SignlessIntElementsAttr<64>;
// A `width`-bit signless integer elements attribute. The attribute should be // A `width`-bit signless integer elements attribute. The attribute should be
// ranked and has a shape as specified in `dims`. // ranked and has a shape as specified in `dims`.
class RankedSignlessIntElementsAttr<int width, list<int> dims> : class RankedSignlessIntElementsAttr<int width, list<int> dims> :
SignlessIntElementsAttr<width> { SignlessIntElementsAttr<width> {
// Check that this has the specified shape. // Check that this has the specified shape.
let predicate = And<[ let predicate = And<[
SignlessIntElementsAttr<width>.predicate, SignlessIntElementsAttr<width>.predicate,
CPred<"$_self.cast<::mlir::DenseIntElementsAttr>().getType().getShape() == " CPred<"$_self.cast<::mlir::DenseIntElementsAttr>().getType().getShape() == "
"::mlir::ArrayRef<int64_t>({" # !interleave(dims, ", ") # "})">]>; "::mlir::ArrayRef<int64_t>({" # !interleave(dims, ", ") # "})">]>;
let summary = width # "-bit signless int elements attribute of shape [" # let summary = width # "-bit signless int elements attribute of shape [" #
!interleave(dims, ", ") # "]"; !interleave(dims, ", ") # "]";
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> :
RankedSignlessIntElementsAttr<32, dims>; RankedSignlessIntElementsAttr<32, dims>;
class RankedI64ElementsAttr<list<int> dims> : class RankedI64ElementsAttr<list<int> dims> :
RankedSignlessIntElementsAttr<64, dims>; RankedSignlessIntElementsAttr<64, dims>;
class FloatElementsAttr<int width> : ElementsAttrBase< class FloatElementsAttr<int width> : ElementsAttrBase<
CPred<"$_self.isa<::mlir::DenseFPElementsAttr>() &&" CPred<"$_self.isa<::mlir::DenseFPElementsAttr>() &&"
"$_self.cast<::mlir::DenseElementsAttr>().getType()." "$_self.cast<::mlir::DenseElementsAttr>().getType()."
"getElementType().isF" # width # "()">, "getElementType().isF" # width # "()">,
width # "-bit float elements attribute"> { width # "-bit float elements attribute"> {
let storageType = [{ ::mlir::DenseElementsAttr }]; let storageType = [{ ::mlir::DenseElementsAttr }];
let returnType = [{ ::mlir::DenseElementsAttr }]; let returnType = [{ ::mlir::DenseElementsAttr }];
// 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";
} }
def F64ElementsAttr : FloatElementsAttr<64>; def F64ElementsAttr : FloatElementsAttr<64>;
// A `width`-bit floating point elements attribute. The attribute should be // A `width`-bit floating point elements attribute. The attribute should be
// ranked and has a shape as specified in `dims`. // ranked and has a shape as specified in `dims`.
class RankedFloatElementsAttr<int width, list<int> dims> : ElementsAttrBase< class RankedFloatElementsAttr<int width, list<int> dims> : ElementsAttrBase<
CPred<"$_self.isa<::mlir::DenseFPElementsAttr>() &&" CPred<"$_self.isa<::mlir::DenseFPElementsAttr>() &&"
"$_self.cast<::mlir::DenseFPElementsAttr>().getType()." "$_self.cast<::mlir::DenseFPElementsAttr>().getType()."
"getElementType().isF" # width # "() && " "getElementType().isF" # width # "() && "
// Check that this is ranked and has the specified shape. // Check that this is ranked and has the specified shape.
"$_self.cast<::mlir::DenseFPElementsAttr>().getType().hasRank() && " "$_self.cast<::mlir::DenseFPElementsAttr>().getType().hasRank() && "
"$_self.cast<::mlir::DenseFPElementsAttr>().getType().getShape() == " "$_self.cast<::mlir::DenseFPElementsAttr>().getType().getShape() == "
"::mlir::ArrayRef<int64_t>({" # !interleave(dims, ", ") # "})">, "::mlir::ArrayRef<int64_t>({" # !interleave(dims, ", ") # "})">,
width # "-bit float elements attribute of shape [" # width # "-bit float elements attribute of shape [" #
!interleave(dims, ", ") # "]"> { !interleave(dims, ", ") # "]"> {
let storageType = [{ ::mlir::DenseFPElementsAttr }]; let storageType = [{ ::mlir::DenseFPElementsAttr }];
let returnType = [{ ::mlir::DenseFPElementsAttr }]; let returnType = [{ ::mlir::DenseFPElementsAttr }];
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";
} }
class RankedF32ElementsAttr<list<int> dims> : RankedFloatElementsAttr<32, dims>; class RankedF32ElementsAttr<list<int> dims> : RankedFloatElementsAttr<32, dims>;
class RankedF64ElementsAttr<list<int> dims> : RankedFloatElementsAttr<64, dims>; class RankedF64ElementsAttr<list<int> dims> : RankedFloatElementsAttr<64, dims>;
def StringElementsAttr : ElementsAttrBase< def StringElementsAttr : ElementsAttrBase<
CPred<"$_self.isa<::mlir::DenseStringElementsAttr>()" >, CPred<"$_self.isa<::mlir::DenseStringElementsAttr>()" >,
▲ Show 20 Lines • Show All 1,055 Lines • Show Last 20 Lines

mlir/include/mlir/IR/OpDefinition.h

Show First 20 Lines • Show All 1,245 Lines • ▼ Show 20 Linesstruct HasParent {
public: public:
static LogicalResult verifyTrait(Operation *op) { static LogicalResult verifyTrait(Operation *op) {
if (llvm::isa_and_nonnull<ParentOpTypes...>(op->getParentOp())) if (llvm::isa_and_nonnull<ParentOpTypes...>(op->getParentOp()))
return success(); return success();
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()...}) << "'";
<< "'";
} }
}; };
}; };
/// A trait for operations that have an attribute specifying operand segments. /// A trait for operations that have an attribute specifying operand segments.
/// ///
/// Certain operations can have multiple variadic operands and their size /// Certain operations can have multiple variadic operands and their size
/// relationship is not always known statically. For such cases, we need /// relationship is not always known statically. For such cases, we need
▲ Show 20 Lines • Show All 684 Lines • Show Last 20 Lines

mlir/lib/Analysis/Presburger/PresburgerSpace.cpp

Show First 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
bool PresburgerSpace::isAligned(const PresburgerSpace &other, bool PresburgerSpace::isAligned(const PresburgerSpace &other,
VarKind kind) const { VarKind kind) const {
assert(isUsingIds() && other.isUsingIds() && assert(isUsingIds() && other.isUsingIds() &&
"Both spaces should be using identifiers to check for " "Both spaces should be using identifiers to check for "
"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;
} }
void PresburgerSpace::setVarSymbolSeperation(unsigned newSymbolCount) { void PresburgerSpace::setVarSymbolSeperation(unsigned newSymbolCount) {
assert(newSymbolCount <= getNumDimAndSymbolVars() && assert(newSymbolCount <= getNumDimAndSymbolVars() &&
"invalid separation position"); "invalid separation position");
numRange = numRange + numSymbols - newSymbolCount; numRange = numRange + numSymbols - newSymbolCount;
Show All 24 Lines

mlir/lib/AsmParser/AsmParserState.cpp

Show First 20 Lines • Show All 96 Lines • ▼ Show 20 LinesAsmParserState &AsmParserState::operator=(AsmParserState &&other) {
impl = std::move(other.impl); impl = std::move(other.impl);
return *this; return *this;
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// 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
-> const BlockDefinition * { -> const BlockDefinition * {
auto it = impl->blocksToIdx.find(block); auto it = impl->blocksToIdx.find(block);
return it == impl->blocksToIdx.end() ? nullptr : &*impl->blocks[it->second]; return it == impl->blocksToIdx.end() ? nullptr : &*impl->blocks[it->second];
} }
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
-> const OperationDefinition * { -> const OperationDefinition * {
auto it = impl->operationToIdx.find(op); auto it = impl->operationToIdx.find(op);
return it == impl->operationToIdx.end() ? nullptr return it == impl->operationToIdx.end() ? nullptr
: &*impl->operations[it->second]; : &*impl->operations[it->second];
} }
▲ Show 20 Lines • Show All 221 Lines • Show Last 20 Lines

mlir/lib/AsmParser/AttributeParser.cpp

Show First 20 Lines • Show All 569 Lines • ▼ Show 20 LinesDenseElementsAttr TensorLiteralParser::getAttr(SMLoc loc, ShapedType type) {
// Handle integer and index types. // Handle integer and index types.
if (eltType.isIntOrIndex()) { if (eltType.isIntOrIndex()) {
std::vector<APInt> intValues; std::vector<APInt> intValues;
if (failed(getIntAttrElements(loc, eltType, intValues))) if (failed(getIntAttrElements(loc, eltType, intValues)))
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);
} }
return DenseElementsAttr::get(type, intValues); return DenseElementsAttr::get(type, intValues);
} }
// Handle floating point types. // Handle floating point types.
if (FloatType floatTy = eltType.dyn_cast<FloatType>()) { if (FloatType floatTy = eltType.dyn_cast<FloatType>()) {
std::vector<APFloat> floatValues; std::vector<APFloat> floatValues;
if (failed(getFloatAttrElements(loc, floatTy, floatValues))) if (failed(getFloatAttrElements(loc, floatTy, floatValues)))
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);
} }
return DenseElementsAttr::get(type, floatValues); return DenseElementsAttr::get(type, floatValues);
} }
// Other types are assumed to be string representations. // Other types are assumed to be string representations.
▲ Show 20 Lines • Show All 616 Lines • Show Last 20 Lines

mlir/lib/Bindings/Python/IRCore.cpp

Show First 20 Lines • Show All 2,490 Lines • ▼ Show 20 Lines py::class_<PyLocation>(m, "Location", py::module_local())
.def_static( .def_static(
"callsite", "callsite",
[](PyLocation callee, const std::vector<PyLocation> &frames, [](PyLocation callee, const std::vector<PyLocation> &frames,
DefaultingPyMlirContext context) { DefaultingPyMlirContext context) {
if (frames.empty()) if (frames.empty())
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));
}, },
py::arg("callee"), py::arg("frames"), py::arg("context") = py::none(), py::arg("callee"), py::arg("frames"), py::arg("context") = py::none(),
kContextGetCallSiteLocationDocstring) kContextGetCallSiteLocationDocstring)
.def_static( .def_static(
"file", "file",
▲ Show 20 Lines • Show All 805 Lines • Show Last 20 Lines

mlir/lib/Bytecode/Reader/BytecodeReader.cpp

Show First 20 Lines • Show All 913 Lines • ▼ Show 20 Linespublic:
} }
LogicalResult readBlob(ArrayRef<char> &result) override { LogicalResult readBlob(ArrayRef<char> &result) override {
uint64_t dataSize; uint64_t dataSize;
ArrayRef<uint8_t> data; ArrayRef<uint8_t> data;
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();
} }
private: private:
AttrTypeReader &attrTypeReader; AttrTypeReader &attrTypeReader;
StringSectionReader &stringReader; StringSectionReader &stringReader;
ResourceSectionReader &resourceReader; ResourceSectionReader &resourceReader;
EncodingReader &reader; EncodingReader &reader;
▲ Show 20 Lines • Show All 845 Lines • Show Last 20 Lines

mlir/lib/CAPI/Dialect/Quant.cpp

Show First 20 Lines • Show All 161 Lines • ▼ Show 20 Lines
MlirType mlirUniformQuantizedPerAxisTypeGet( MlirType mlirUniformQuantizedPerAxisTypeGet(
unsigned flags, MlirType storageType, MlirType expressedType, unsigned flags, MlirType storageType, MlirType expressedType,
intptr_t nDims, double *scales, int64_t *zeroPoints, intptr_t nDims, double *scales, int64_t *zeroPoints,
int32_t quantizedDimension, int64_t storageTypeMin, int32_t quantizedDimension, int64_t storageTypeMin,
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));
} }
intptr_t mlirUniformQuantizedPerAxisTypeGetNumDims(MlirType type) { intptr_t mlirUniformQuantizedPerAxisTypeGetNumDims(MlirType type) {
return unwrap(type) return unwrap(type)
.cast<quant::UniformQuantizedPerAxisType>() .cast<quant::UniformQuantizedPerAxisType>()
.getScales() .getScales()
.size(); .size();
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

mlir/lib/CAPI/IR/AffineMap.cpp

Show First 20 Lines • Show All 62 Lines • ▼ Show 20 Lines
MlirAffineMap mlirAffineMapMinorIdentityGet(MlirContext ctx, intptr_t dims, MlirAffineMap mlirAffineMapMinorIdentityGet(MlirContext ctx, intptr_t dims,
intptr_t results) { intptr_t results) {
return wrap(AffineMap::getMinorIdentityMap(dims, results, unwrap(ctx))); return wrap(AffineMap::getMinorIdentityMap(dims, results, unwrap(ctx)));
} }
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) {
return unwrap(affineMap).isIdentity(); return unwrap(affineMap).isIdentity();
} }
bool mlirAffineMapIsMinorIdentity(MlirAffineMap affineMap) { bool mlirAffineMapIsMinorIdentity(MlirAffineMap affineMap) {
return unwrap(affineMap).isMinorIdentity(); return unwrap(affineMap).isMinorIdentity();
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

mlir/lib/CAPI/IR/BuiltinAttributes.cpp

Show First 20 Lines • Show All 295 Lines • ▼ Show 20 Lines
bool mlirAttributeIsAElements(MlirAttribute attr) { bool mlirAttributeIsAElements(MlirAttribute attr) {
return unwrap(attr).isa<ElementsAttr>(); return unwrap(attr).isa<ElementsAttr>();
} }
MlirAttribute mlirElementsAttrGetValue(MlirAttribute attr, intptr_t rank, MlirAttribute mlirElementsAttrGetValue(MlirAttribute attr, intptr_t rank,
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) {
return unwrap(attr).cast<ElementsAttr>().getNumElements(); return unwrap(attr).cast<ElementsAttr>().getNumElements();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Dense array attribute. // Dense array attribute.
▲ Show 20 Lines • Show All 196 Lines • ▼ Show 20 Lines return wrap(
DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), values)); DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), values));
} }
/// Creates a dense attribute with elements of the type deduced by templates. /// Creates a dense attribute with elements of the type deduced by templates.
template <typename T> template <typename T>
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,
intptr_t numElements, intptr_t numElements,
const uint8_t *elements) { const uint8_t *elements) {
return getDenseAttribute(shapedType, numElements, elements); return getDenseAttribute(shapedType, numElements, elements);
} }
MlirAttribute mlirDenseElementsAttrInt8Get(MlirType shapedType, MlirAttribute mlirDenseElementsAttrInt8Get(MlirType shapedType,
▲ Show 20 Lines • Show All 171 Lines • ▼ Show 20 Lines
// Resource blob attributes. // Resource blob attributes.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
template <typename U, typename T> template <typename U, typename T>
static MlirAttribute getDenseResource(MlirType shapedType, MlirStringRef name, static MlirAttribute getDenseResource(MlirType shapedType, MlirStringRef name,
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(
MlirType shapedType, MlirStringRef name, intptr_t numElements, MlirType shapedType, MlirStringRef name, intptr_t numElements,
const int *elements) { const int *elements) {
return getDenseResource<DenseBoolResourceElementsAttr>(shapedType, name, return getDenseResource<DenseBoolResourceElementsAttr>(shapedType, name,
numElements, elements); numElements, elements);
} }
▲ Show 20 Lines • Show All 174 Lines • Show Last 20 Lines

mlir/lib/CAPI/IR/BuiltinTypes.cpp

Show First 20 Lines • Show All 181 Lines • ▼ Show 20 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Vector type. // Vector type.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
bool mlirTypeIsAVector(MlirType type) { return unwrap(type).isa<VectorType>(); } bool mlirTypeIsAVector(MlirType type) { return unwrap(type).isa<VectorType>(); }
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)));
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Ranked / Unranked tensor type. // Ranked / Unranked tensor type.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
bool mlirTypeIsATensor(MlirType type) { return unwrap(type).isa<TensorType>(); } bool mlirTypeIsATensor(MlirType type) { return unwrap(type).isa<TensorType>(); }
bool mlirTypeIsARankedTensor(MlirType type) { bool mlirTypeIsARankedTensor(MlirType type) {
return unwrap(type).isa<RankedTensorType>(); return unwrap(type).isa<RankedTensorType>();
} }
bool mlirTypeIsAUnrankedTensor(MlirType type) { bool mlirTypeIsAUnrankedTensor(MlirType type) {
return unwrap(type).isa<UnrankedTensorType>(); return unwrap(type).isa<UnrankedTensorType>();
} }
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,
const int64_t *shape, const int64_t *shape,
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)));
} }
MlirAttribute mlirRankedTensorTypeGetEncoding(MlirType type) { MlirAttribute mlirRankedTensorTypeGetEncoding(MlirType type) {
return wrap(unwrap(type).cast<RankedTensorType>().getEncoding()); return wrap(unwrap(type).cast<RankedTensorType>().getEncoding());
} }
MlirType mlirUnrankedTensorTypeGet(MlirType elementType) { MlirType mlirUnrankedTensorTypeGet(MlirType elementType) {
Show All 10 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
bool mlirTypeIsAMemRef(MlirType type) { return unwrap(type).isa<MemRefType>(); } bool mlirTypeIsAMemRef(MlirType type) { return unwrap(type).isa<MemRefType>(); }
MlirType mlirMemRefTypeGet(MlirType elementType, intptr_t rank, MlirType mlirMemRefTypeGet(MlirType elementType, intptr_t rank,
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>(),
unwrap(memorySpace))); unwrap(memorySpace)));
} }
MlirType mlirMemRefTypeGetChecked(MlirLocation loc, MlirType elementType, MlirType mlirMemRefTypeGetChecked(MlirLocation loc, MlirType elementType,
intptr_t rank, const int64_t *shape, intptr_t rank, const int64_t *shape,
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()
: unwrap(layout).cast<MemRefLayoutAttrInterface>(), : unwrap(layout).cast<MemRefLayoutAttrInterface>(),
unwrap(memorySpace))); unwrap(memorySpace)));
} }
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,
MlirType elementType, intptr_t rank, MlirType elementType, intptr_t rank,
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)));
} }
MlirAttribute mlirMemRefTypeGetLayout(MlirType type) { MlirAttribute mlirMemRefTypeGetLayout(MlirType type) {
return wrap(unwrap(type).cast<MemRefType>().getLayout()); return wrap(unwrap(type).cast<MemRefType>().getLayout());
} }
MlirAffineMap mlirMemRefTypeGetAffineMap(MlirType type) { MlirAffineMap mlirMemRefTypeGetAffineMap(MlirType type) {
▲ Show 20 Lines • Show All 107 Lines • Show Last 20 Lines

mlir/lib/CAPI/IR/IntegerSet.cpp

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 LinesMlirIntegerSet mlirIntegerSetGet(MlirContext context, intptr_t numDims,
const MlirAffineExpr *constraints, const MlirAffineExpr *constraints,
const bool *eqFlags) { const bool *eqFlags) {
SmallVector<AffineExpr> mlirConstraints; SmallVector<AffineExpr> mlirConstraints;
(void)unwrapList(static_cast<size_t>(numConstraints), constraints, (void)unwrapList(static_cast<size_t>(numConstraints), constraints,
mlirConstraints); mlirConstraints);
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
mlirIntegerSetReplaceGet(MlirIntegerSet set, mlirIntegerSetReplaceGet(MlirIntegerSet set,
const MlirAffineExpr *dimReplacements, const MlirAffineExpr *dimReplacements,
const MlirAffineExpr *symbolReplacements, const MlirAffineExpr *symbolReplacements,
intptr_t numResultDims, intptr_t numResultSymbols) { intptr_t numResultDims, intptr_t numResultSymbols) {
SmallVector<AffineExpr> mlirDims, mlirSymbols; SmallVector<AffineExpr> mlirDims, mlirSymbols;
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

mlir/lib/Conversion/AffineToStandard/AffineToStandard.cpp

Show First 20 Lines • Show All 269 Lines • ▼ Show 20 Linespublic:
LogicalResult matchAndRewrite(AffineIfOp op, LogicalResult matchAndRewrite(AffineIfOp op,
PatternRewriter &rewriter) const override { PatternRewriter &rewriter) const override {
auto loc = op.getLoc(); auto loc = op.getLoc();
// Now we just have to handle the condition logic. // Now we just have to handle the condition logic.
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;
for (unsigned i = 0, e = integerSet.getNumConstraints(); i < e; ++i) { for (unsigned i = 0, e = integerSet.getNumConstraints(); i < e; ++i) {
AffineExpr constraintExpr = integerSet.getConstraint(i); AffineExpr constraintExpr = integerSet.getConstraint(i);
bool isEquality = integerSet.isEq(i); bool isEquality = integerSet.isEq(i);
// Build and apply an affine expression // Build and apply an affine expression
▲ Show 20 Lines • Show All 127 Lines • ▼ Show 20 Lines
/// 'affine.dma_start'). /// 'affine.dma_start').
class AffineDmaStartLowering : public OpRewritePattern<AffineDmaStartOp> { class AffineDmaStartLowering : public OpRewritePattern<AffineDmaStartOp> {
public: public:
using OpRewritePattern<AffineDmaStartOp>::OpRewritePattern; using OpRewritePattern<AffineDmaStartOp>::OpRewritePattern;
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(
rewriter, op.getLoc(), op.getSrcMap(), rewriter, op.getLoc(), op.getSrcMap(),
operandsRef.drop_front(op.getSrcMemRefOperandIndex() + 1)); operandsRef.drop_front(op.getSrcMemRefOperandIndex() + 1));
if (!maybeExpandedSrcMap) if (!maybeExpandedSrcMap)
return failure(); return failure();
// Expand affine map for DMA destination memref. // Expand affine map for DMA destination memref.
▲ Show 20 Lines • Show All 140 Lines • Show Last 20 Lines

mlir/lib/Conversion/ArithToSPIRV/ArithToSPIRV.cpp

Show First 20 Lines • Show All 971 Lines • ▼ Show 20 LinesLogicalResult AddUIExtendedOpPattern::matchAndRewrite(
arith::AddUIExtendedOp op, OpAdaptor adaptor, arith::AddUIExtendedOp op, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const { ConversionPatternRewriter &rewriter) const {
Type dstElemTy = adaptor.getLhs().getType(); Type dstElemTy = adaptor.getLhs().getType();
Location loc = op->getLoc(); Location loc = op->getLoc();
Value result = rewriter.create<spirv::IAddCarryOp>(loc, adaptor.getLhs(), Value result = rewriter.create<spirv::IAddCarryOp>(loc, adaptor.getLhs(),
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);
Value carryResult = rewriter.create<spirv::IEqualOp>(loc, carryValue, one); Value carryResult = rewriter.create<spirv::IEqualOp>(loc, carryValue, one);
rewriter.replaceOp(op, {sumResult, carryResult}); rewriter.replaceOp(op, {sumResult, carryResult});
return success(); return success();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// MulIExtendedOpPattern // MulIExtendedOpPattern
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
template <typename ArithMulOp, typename SPIRVMulOp> template <typename ArithMulOp, typename SPIRVMulOp>
LogicalResult MulIExtendedOpPattern<ArithMulOp, SPIRVMulOp>::matchAndRewrite( LogicalResult MulIExtendedOpPattern<ArithMulOp, SPIRVMulOp>::matchAndRewrite(
ArithMulOp op, typename ArithMulOp::Adaptor adaptor, ArithMulOp op, typename ArithMulOp::Adaptor adaptor,
ConversionPatternRewriter &rewriter) const { ConversionPatternRewriter &rewriter) const {
Location loc = op->getLoc(); Location loc = op->getLoc();
Value result = Value result =
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();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// SelectOpPattern // SelectOpPattern
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 164 Lines • Show Last 20 Lines

mlir/lib/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.cpp

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Linesstatic void createPrintMsg(OpBuilder &builder, Location loc, ModuleOp moduleOp,
// Create a zero-terminated byte representation and allocate global symbol. // Create a zero-terminated byte representation and allocate global symbol.
SmallVector<uint8_t> elementVals; SmallVector<uint8_t> elementVals;
elementVals.append(msg.begin(), msg.end()); elementVals.append(msg.begin(), msg.end());
elementVals.push_back(0); elementVals.push_back(0);
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);
auto globalOp = builder.create<LLVM::GlobalOp>( auto globalOp = builder.create<LLVM::GlobalOp>(
loc, arrayTy, /*constant=*/true, LLVM::Linkage::Private, symbolName, loc, arrayTy, /*constant=*/true, LLVM::Linkage::Private, symbolName,
dataAttr); dataAttr);
// Emit call to `printStr` in runtime library. // Emit call to `printStr` in runtime library.
▲ Show 20 Lines • Show All 221 Lines • Show Last 20 Lines

mlir/lib/Conversion/LLVMCommon/MemRefBuilder.cpp

Show First 20 Lines • Show All 133 Lines • ▼ Show 20 LinesValue MemRefDescriptor::size(OpBuilder &builder, Location loc, Value pos,
int64_t rank) { int64_t rank) {
auto indexPtrTy = LLVM::LLVMPointerType::get(indexType); auto indexPtrTy = LLVM::LLVMPointerType::get(indexType);
auto arrayTy = LLVM::LLVMArrayType::get(indexType, rank); auto arrayTy = LLVM::LLVMArrayType::get(indexType, rank);
auto arrayPtrTy = LLVM::LLVMPointerType::get(arrayTy); auto arrayPtrTy = LLVM::LLVMPointerType::get(arrayTy);
// 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);
// Load an return size value of interest. // Load an return size value of interest.
auto resultPtr = builder.create<LLVM::GEPOp>(loc, indexPtrTy, sizesPtr, auto resultPtr = builder.create<LLVM::GEPOp>(loc, indexPtrTy, sizesPtr,
ArrayRef<LLVM::GEPArg>{0, pos}); ArrayRef<LLVM::GEPArg>{0, pos});
return builder.create<LLVM::LoadOp>(loc, resultPtr); return builder.create<LLVM::LoadOp>(loc, resultPtr);
▲ Show 20 Lines • Show All 355 Lines • Show Last 20 Lines

mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp

Show First 20 Lines • Show All 1,528 Lines • ▼ Show 20 Linesstatic void fillInStridesForCollapsedMemDescriptor(
MemRefDescriptor &dstDesc, ArrayRef<ReassociationIndices> reassociation) { MemRefDescriptor &dstDesc, ArrayRef<ReassociationIndices> reassociation) {
auto llvmIndexType = typeConverter->convertType(rewriter.getIndexType()); auto llvmIndexType = typeConverter->convertType(rewriter.getIndexType());
// See comments for computeCollapsedLayoutMap for details on how the strides // See comments for computeCollapsedLayoutMap for details on how the strides
// are calculated. // are calculated.
auto srcShape = srcType.getShape(); auto srcShape = srcType.getShape();
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) {
dstDesc.setStride(rewriter, loc, dstIndex, dstDesc.setStride(rewriter, loc, dstIndex,
srcDesc.stride(rewriter, loc, ref.back())); srcDesc.stride(rewriter, loc, ref.back()));
} else { } else {
// Iterate over the source strides in reverse order. Skip over the // Iterate over the source strides in reverse order. Skip over the
// dimensions whose size is 1. // dimensions whose size is 1.
▲ Show 20 Lines • Show All 522 Lines • Show Last 20 Lines

mlir/lib/Conversion/VectorToSPIRV/VectorToSPIRV.cpp

Show First 20 Lines • Show All 329 Lines • ▼ Show 20 Lines for (int i = 0; i < numElements; ++i) {
loc, srcVectorType.getElementType(), adaptor.getVector(), loc, srcVectorType.getElementType(), adaptor.getVector(),
rewriter.getI32ArrayAttr({i}))); rewriter.getI32ArrayAttr({i})));
} }
if (Value acc = adaptor.getAcc()) if (Value acc = adaptor.getAcc())
values.push_back(acc); values.push_back(acc);
// 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) \
case vector::CombiningKind::kind: \ case vector::CombiningKind::kind: \
if (resultType.isa<IntegerType>()) { \ if (resultType.isa<IntegerType>()) { \
result = rewriter.create<spirv::iop>(loc, resultType, result, next); \ result = rewriter.create<spirv::iop>(loc, resultType, result, next); \
} else { \ } else { \
assert(resultType.isa<FloatType>()); \ assert(resultType.isa<FloatType>()); \
▲ Show 20 Lines • Show All 112 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 3,862 Lines • ▼ Show 20 Lines if (succeeded(parser.parseOptionalKeyword(
mapOperands.clear(); mapOperands.clear();
AffineMapAttr map; AffineMapAttr map;
if (failed(parser.parseAffineMapOfSSAIds(mapOperands, map, tmpAttrStrName, if (failed(parser.parseAffineMapOfSSAIds(mapOperands, map, tmpAttrStrName,
result.attributes, result.attributes,
OpAsmParser::Delimiter::Paren))) OpAsmParser::Delimiter::Paren)))
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());
auto symsRef = operandsRef.drop_front(map.getValue().getNumDims()); auto symsRef = operandsRef.drop_front(map.getValue().getNumDims());
SmallVector<OpAsmParser::UnresolvedOperand> syms(symsRef.begin(), SmallVector<OpAsmParser::UnresolvedOperand> syms(symsRef.begin(),
symsRef.end()); symsRef.end());
flatDimOperands.append(map.getValue().getNumResults(), dims); flatDimOperands.append(map.getValue().getNumResults(), dims);
flatSymOperands.append(map.getValue().getNumResults(), syms); flatSymOperands.append(map.getValue().getNumResults(), syms);
▲ Show 20 Lines • Show All 378 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 356 Lines • ▼ Show 20 Linesmlir::affineParallelize(AffineForOp forOp,
// Creating empty 1-D affine.parallel op. // Creating empty 1-D affine.parallel op.
auto reducedValues = llvm::to_vector<4>(llvm::map_range( auto reducedValues = llvm::to_vector<4>(llvm::map_range(
parallelReductions, [](const LoopReduction &red) { return red.value; })); parallelReductions, [](const LoopReduction &red) { return red.value; }));
auto reductionKinds = llvm::to_vector<4>(llvm::map_range( auto reductionKinds = llvm::to_vector<4>(llvm::map_range(
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();
// Handle the initial values of reductions because the parallel loop always // Handle the initial values of reductions because the parallel loop always
// starts from the neutral value. // starts from the neutral value.
SmallVector<Value> newResults; SmallVector<Value> newResults;
newResults.reserve(numReductions); newResults.reserve(numReductions);
▲ Show 20 Lines • Show All 1,490 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 223 Lines • ▼ Show 20 LinesFuncOp FuncOp::create(Location location, StringRef name, FunctionType type,
OpBuilder builder(location->getContext()); OpBuilder builder(location->getContext());
OperationState state(location, getOperationName()); OperationState state(location, getOperationName());
FuncOp::build(builder, state, name, type, attrs); FuncOp::build(builder, state, name, type, attrs);
return cast<FuncOp>(Operation::create(state)); return cast<FuncOp>(Operation::create(state));
} }
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,
ArrayRef<DictionaryAttr> argAttrs) { ArrayRef<DictionaryAttr> argAttrs) {
FuncOp func = create(location, name, type, attrs); FuncOp func = create(location, name, type, attrs);
func.setAllArgAttrs(argAttrs); func.setAllArgAttrs(argAttrs);
return func; return func;
} }
▲ Show 20 Lines • Show All 135 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 341 Lines • ▼ Show 20 Lines createIf(
// Skip the accumulation if the shuffle op read from a lane outside // Skip the accumulation if the shuffle op read from a lane outside
// of the active range. // of the active range.
createIf( createIf(
shuffleOp.getResult(1), shuffleOp.getResult(1),
[&] { [&] {
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};
}, },
// Generate a reduction over the entire subgroup. This is a // Generate a reduction over the entire subgroup. This is a
// specialization of the above reduction with unconditional // specialization of the above reduction with unconditional
// accumulation. // accumulation.
[&] { [&] {
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 64 Lines • ▼ Show 20 Linesstatic void insertCopyLoops(ImplicitLocOpBuilder &b, Value from, Value to) {
} }
// Produce the loop nest with copies. // Produce the loop nest with copies.
SmallVector<Value, 8> ivs(lbs.size()); SmallVector<Value, 8> ivs(lbs.size());
mlir::scf::buildLoopNest( mlir::scf::buildLoopNest(
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());
mapLoopToProcessorIds(loop, {threadIds[en.index()]}, mapLoopToProcessorIds(loop, {threadIds[en.index()]},
{blockDims[en.index()]}); {blockDims[en.index()]});
} }
} }
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 1,027 Lines • ▼ Show 20 Lines for (Type ty : funcType.getInputs()) {
else else
return parser.emitError(trailingTypeLoc, return parser.emitError(trailingTypeLoc,
"expected LLVM types as inputs"); "expected LLVM types as inputs");
} }
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
// match the types of the function arguments. // match the types of the function arguments.
if (parser.resolveOperand(operands[0], wrappedFuncType, result.operands) || if (parser.resolveOperand(operands[0], wrappedFuncType, result.operands) ||
parser.resolveOperands(funcArguments, funcType.getInputs(), parser.resolveOperands(funcArguments, funcType.getInputs(),
parser.getNameLoc(), result.operands)) parser.getNameLoc(), result.operands))
return failure(); return failure();
▲ Show 20 Lines • Show All 2,127 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 1,091 Lines • ▼ Show 20 Lines if (parser.parseRBrace())
return failure(); return failure();
} }
if (parseDstStyleOp(parser, result)) if (parseDstStyleOp(parser, result))
return failure(); return failure();
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,
/*allowType=*/true, /*allowAttrs=*/true)) { /*allowType=*/true, /*allowAttrs=*/true)) {
return failure(); return failure();
} }
Region *body = result.addRegion(); Region *body = result.addRegion();
if (parser.parseRegion(*body, regionArgs)) if (parser.parseRegion(*body, regionArgs))
▲ Show 20 Lines • Show All 224 Lines • ▼ Show 20 LinesParseResult ReduceOp::parse(OpAsmParser &parser, OperationState &result) {
if (parseDstStyleOp( if (parseDstStyleOp(
parser, result, [&](OpAsmParser &parser, NamedAttrList &attributes) { parser, result, [&](OpAsmParser &parser, NamedAttrList &attributes) {
return parseDenseI64ArrayAttr(parser, attributes, "dimensions"); return parseDenseI64ArrayAttr(parser, attributes, "dimensions");
})) }))
return failure(); return failure();
if (payloadOpName.has_value()) { if (payloadOpName.has_value()) {
addBodyWithPayloadOp(parser, result, payloadOpName.value(), payloadOpAttrs, addBodyWithPayloadOp(parser, result, payloadOpName.value(), payloadOpAttrs,
makeArrayRef(result.operands), /*initFirst=*/true); ArrayRef(result.operands), /*initFirst=*/true);
} else { } else {
SmallVector<OpAsmParser::Argument> regionArgs; SmallVector<OpAsmParser::Argument> regionArgs;
if (parser.parseArgumentList(regionArgs, OpAsmParser::Delimiter::Paren, if (parser.parseArgumentList(regionArgs, OpAsmParser::Delimiter::Paren,
/*allowType=*/true, /*allowAttrs=*/true)) { /*allowType=*/true, /*allowAttrs=*/true)) {
return failure(); return failure();
} }
Region *body = result.addRegion(); Region *body = result.addRegion();
▲ Show 20 Lines • Show All 770 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 451 Lines • ▼ Show 20 Lines#endif // NDEBUG
AffineMap id = AffineMap id =
AffineMap::getMultiDimIdentityMap(memrefTypeTo.getRank(), b.getContext()); AffineMap::getMultiDimIdentityMap(memrefTypeTo.getRank(), b.getContext());
SmallVector<utils::IteratorType> iteratorTypes(memrefTypeTo.getRank(), SmallVector<utils::IteratorType> iteratorTypes(memrefTypeTo.getRank(),
utils::IteratorType::parallel); utils::IteratorType::parallel);
return b.create<linalg::GenericOp>( return b.create<linalg::GenericOp>(
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());
}); });
} }
/// Specialization to build an scf "for" nest. /// Specialization to build an scf "for" nest.
template <> template <>
▲ Show 20 Lines • Show All 627 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 LineshandleMultidimensionalVectors(ImplicitLocOpBuilder &builder,
assert(!operands.empty() && "operands must be not empty"); assert(!operands.empty() && "operands must be not empty");
assert(vectorWidth > 0 && "vector width must be larger than 0"); assert(vectorWidth > 0 && "vector width must be larger than 0");
VectorType inputType = operands[0].getType().cast<VectorType>(); VectorType inputType = operands[0].getType().cast<VectorType>();
ArrayRef<int64_t> inputShape = inputType.getShape(); ArrayRef<int64_t> inputShape = inputType.getShape();
// 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
// over the outer dimensions of the vector. // over the outer dimensions of the vector.
int64_t innerDim = inputShape.back(); int64_t innerDim = inputShape.back();
int64_t expansionDim = innerDim / vectorWidth; int64_t expansionDim = innerDim / vectorWidth;
assert((innerDim % vectorWidth == 0) && "invalid inner dimension size"); assert((innerDim % vectorWidth == 0) && "invalid inner dimension size");
▲ Show 20 Lines • Show All 1,192 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 2,284 Lines • ▼ Show 20 LinescomputeCollapsedLayoutMap(MemRefType srcType,
// The result stride of a reassociation group is the stride of the last entry // The result stride of a reassociation group is the stride of the last entry
// of the reassociation. (TODO: Should be the minimum stride in the // of the reassociation. (TODO: Should be the minimum stride in the
// reassociation because strides are not necessarily sorted. E.g., when using // reassociation because strides are not necessarily sorted. E.g., when using
// memref.transpose.) Dimensions of size 1 should be skipped, because their // memref.transpose.) Dimensions of size 1 should be skipped, because their
// strides are meaningless and could have any arbitrary value. // strides are meaningless and could have any arbitrary value.
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) {
resultStrides.push_back(srcStrides[ref.back()]); resultStrides.push_back(srcStrides[ref.back()]);
} else { } else {
// Dynamically-sized dims may turn out to be dims of size 1 at runtime, so // Dynamically-sized dims may turn out to be dims of size 1 at runtime, so
// the corresponding stride may have to be skipped. (See above comment.) // the corresponding stride may have to be skipped. (See above comment.)
// Therefore, the result stride cannot be statically determined and must // Therefore, the result stride cannot be statically determined and must
▲ Show 20 Lines • Show All 1,107 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 1,123 Lines • ▼ Show 20 Lines return mlir::emitError(
result.location, "'spirv.AccessChain' op indices types' count must be " result.location, "'spirv.AccessChain' op indices types' count must be "
"equal to indices info count"); "equal to indices info count");
} }
if (parser.resolveOperands(indicesInfo, indicesTypes, loc, result.operands)) if (parser.resolveOperands(indicesInfo, indicesTypes, loc, result.operands))
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();
} }
result.addTypes(resultType); result.addTypes(resultType);
return success(); return success();
} }
▲ Show 20 Lines • Show All 3,531 Lines • ▼ Show 20 Lines if (indicesTypes.size() != indicesInfo.size())
return emitError(state.location) return emitError(state.location)
<< opName << opName
<< " indices types' count must be equal to indices info count"; << " indices types' count must be equal to indices info count";
if (parser.resolveOperands(indicesInfo, indicesTypes, loc, state.operands)) if (parser.resolveOperands(indicesInfo, indicesTypes, loc, state.operands))
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();
state.addTypes(resultType); state.addTypes(resultType);
return success(); return success();
} }
template <typename Op> template <typename Op>
▲ Show 20 Lines • Show All 254 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 705 Lines • ▼ Show 20 LinesValue spirv::getPushConstantValue(Operation *op, unsigned elementCount,
spirv::GlobalVariableOp varOp = getOrInsertPushConstantVariable( spirv::GlobalVariableOp varOp = getOrInsertPushConstantVariable(
loc, parent->getRegion(0).front(), elementCount, builder, integerType); loc, parent->getRegion(0).front(), elementCount, builder, integerType);
Value zeroOp = spirv::ConstantOp::getZero(integerType, loc, builder); Value zeroOp = spirv::ConstantOp::getZero(integerType, loc, builder);
Value offsetOp = builder.create<spirv::ConstantOp>( Value offsetOp = builder.create<spirv::ConstantOp>(
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);
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Index calculation // Index calculation
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
Value mlir::spirv::linearizeIndex(ValueRange indices, ArrayRef<int64_t> strides, Value mlir::spirv::linearizeIndex(ValueRange indices, ArrayRef<int64_t> strides,
▲ Show 20 Lines • Show All 196 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 1,271 Lines • ▼ Show 20 LinesFuncOp FuncOp::create(Location location, StringRef name, FunctionType type,
OpBuilder builder(location->getContext()); OpBuilder builder(location->getContext());
OperationState state(location, getOperationName()); OperationState state(location, getOperationName());
FuncOp::build(builder, state, name, type, attrs); FuncOp::build(builder, state, name, type, attrs);
return cast<FuncOp>(Operation::create(state)); return cast<FuncOp>(Operation::create(state));
} }
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,
ArrayRef<DictionaryAttr> argAttrs) { ArrayRef<DictionaryAttr> argAttrs) {
FuncOp func = create(location, name, type, attrs); FuncOp func = create(location, name, type, attrs);
func.setAllArgAttrs(argAttrs); func.setAllArgAttrs(argAttrs);
return func; return func;
} }
▲ Show 20 Lines • Show All 559 Lines • ▼ Show 20 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
LogicalResult SplitAtOp::fold(ArrayRef<Attribute> operands, LogicalResult SplitAtOp::fold(ArrayRef<Attribute> operands,
SmallVectorImpl<OpFoldResult> &results) { SmallVectorImpl<OpFoldResult> &results) {
if (!operands[0] || !operands[1]) if (!operands[0] || !operands[1])
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".
int64_t rank = shape.size(); int64_t rank = shape.size();
if (-rank > splitPoint || splitPoint > rank) if (-rank > splitPoint || splitPoint > rank)
return failure(); return failure();
if (splitPoint < 0) if (splitPoint < 0)
splitPoint += shape.size(); splitPoint += shape.size();
▲ Show 20 Lines • Show All 105 Lines • ▼ Show 20 LinesParseResult ReduceOp::parse(OpAsmParser &parser, OperationState &result) {
Type shapeOrExtentTensorType; Type shapeOrExtentTensorType;
if (parser.parseOperandList(operands, /*requiredOperandCount=*/-1, if (parser.parseOperandList(operands, /*requiredOperandCount=*/-1,
OpAsmParser::Delimiter::Paren) || OpAsmParser::Delimiter::Paren) ||
parser.parseColonType(shapeOrExtentTensorType) || parser.parseColonType(shapeOrExtentTensorType) ||
parser.parseOptionalArrowTypeList(result.types)) parser.parseOptionalArrowTypeList(result.types))
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(),
result.operands)) result.operands))
return failure(); return failure();
// Parse the body. // Parse the body.
Region *body = result.addRegion(); Region *body = result.addRegion();
Show All 24 Lines

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

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Lines LogicalResult matchAndRewrite(tensor::PadOp padOp,
SmallVector<Value> eqZeroCmpVals; SmallVector<Value> eqZeroCmpVals;
for (OpFoldResult pad : llvm::concat<OpFoldResult>(lowPads, highPads)) { for (OpFoldResult pad : llvm::concat<OpFoldResult>(lowPads, highPads)) {
if (!isZero(pad)) if (!isZero(pad))
eqZeroCmpVals.push_back(rewriter.create<arith::CmpIOp>( eqZeroCmpVals.push_back(rewriter.create<arith::CmpIOp>(
loc, arith::CmpIPredicate::eq, getAsValue(pad, rewriter, loc), loc, arith::CmpIPredicate::eq, getAsValue(pad, rewriter, loc),
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
// padding. For the "else" branch, we retain the clone op. // padding. For the "else" branch, we retain the clone op.
auto thenBuilder = [&padOp](OpBuilder &builder, Location loc) { auto thenBuilder = [&padOp](OpBuilder &builder, Location loc) {
builder.create<scf::YieldOp>(loc, padOp.getSource()); builder.create<scf::YieldOp>(loc, padOp.getSource());
}; };
auto elseBuilder = [&padOp](OpBuilder &builder, Location loc) { auto elseBuilder = [&padOp](OpBuilder &builder, Location loc) {
Show All 15 Lines

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

Show First 20 Lines • Show All 377 Lines • ▼ Show 20 Lines
void transform::TransformResults::set(OpResult value, void transform::TransformResults::set(OpResult value,
ArrayRef<Operation *> ops) { ArrayRef<Operation *> ops) {
int64_t position = value.getResultNumber(); int64_t position = value.getResultNumber();
assert(position < static_cast<int64_t>(segments.size()) && assert(position < static_cast<int64_t>(segments.size()) &&
"setting results for a non-existent handle"); "setting results for a non-existent handle");
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);
} }
void transform::TransformResults::setParams( void transform::TransformResults::setParams(
OpResult value, ArrayRef<transform::TransformState::Param> params) { OpResult value, ArrayRef<transform::TransformState::Param> params) {
int64_t position = value.getResultNumber(); int64_t position = value.getResultNumber();
assert(position < static_cast<int64_t>(paramSegments.size()) && assert(position < static_cast<int64_t>(paramSegments.size()) &&
"setting params for a non-existent handle"); "setting params for a non-existent handle");
assert(paramSegments[position].data() == nullptr && "params already set"); assert(paramSegments[position].data() == nullptr && "params already set");
▲ Show 20 Lines • Show All 298 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 1,198 Lines • ▼ Show 20 Lines for (auto [elemA, elemB] : llvm::zip(a, b)) {
return false; return false;
} }
return true; return true;
} }
/// 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.
void updateStateForNextIteration(Value v) { void updateStateForNextIteration(Value v) {
nextInsertOp = v.getDefiningOp<vector::InsertOp>(); nextInsertOp = v.getDefiningOp<vector::InsertOp>();
nextTransposeOp = v.getDefiningOp<vector::TransposeOp>(); nextTransposeOp = v.getDefiningOp<vector::TransposeOp>();
}; };
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Lines
// Case 1. If we hit a transpose, just compose the map and iterate. // Case 1. If we hit a transpose, just compose the map and iterate.
// Invariant: insert + transpose do not change rank, we can always compose. // Invariant: insert + transpose do not change rank, we can always compose.
LogicalResult ExtractFromInsertTransposeChainState::handleTransposeOp() { LogicalResult ExtractFromInsertTransposeChainState::handleTransposeOp() {
if (!nextTransposeOp) if (!nextTransposeOp)
return failure(); return failure();
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();
} }
// Case 2: the insert position matches extractPosition exactly, early return. // Case 2: the insert position matches extractPosition exactly, early return.
LogicalResult LogicalResult
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();
// Case 2.b. if internal transposition is present, canFold will be false. // Case 2.b. if internal transposition is present, canFold will be false.
return success(canFold()); return success(canFold());
} }
/// Case 3: if inserted position is a prefix of extractPosition, /// Case 3: if inserted position is a prefix of extractPosition,
Show All 24 LinesValue ExtractFromInsertTransposeChainState::tryToFoldExtractOpInPlace(
// If we can't fold (either internal transposition, or nothing to fold), bail. // If we can't fold (either internal transposition, or nothing to fold), bail.
bool nothingToFold = (source == extractOp.getVector()); bool nothingToFold = (source == extractOp.getVector());
if (nothingToFold || !canFold()) if (nothingToFold || !canFold())
return Value(); return Value();
// Otherwise, fold by updating the op inplace and return its result. // Otherwise, fold by updating the op inplace and return its result.
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();
} }
/// Iterate over producing insert and transpose ops until we find a fold. /// Iterate over producing insert and transpose ops until we find a fold.
Value ExtractFromInsertTransposeChainState::fold() { Value ExtractFromInsertTransposeChainState::fold() {
Value valueToExtractFrom = extractOp.getVector(); Value valueToExtractFrom = extractOp.getVector();
updateStateForNextIteration(valueToExtractFrom); updateStateForNextIteration(valueToExtractFrom);
▲ Show 20 Lines • Show All 4,402 Lines • Show Last 20 Lines

mlir/lib/ExecutionEngine/RocmRuntimeWrappers.cpp

Show First 20 Lines • Show All 140 Lines • ▼ Show 20 LinesmgpuMemHostRegisterMemRef(int64_t rank, StridedMemRefType<char, 1> *descriptor,
std::partial_sum(sizes.rbegin(), sizes.rend(), denseStrides.rbegin(), std::partial_sum(sizes.rbegin(), sizes.rend(), denseStrides.rbegin(),
std::multiplies<int64_t>()); std::multiplies<int64_t>());
auto sizeBytes = denseStrides.front() * elementSizeBytes; auto sizeBytes = denseStrides.front() * elementSizeBytes;
// Only densely packed tensors are currently supported. // Only densely packed tensors are currently supported.
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);
} }
template <typename T> template <typename T>
void mgpuMemGetDevicePointer(T *hostPtr, T **devicePtr) { void mgpuMemGetDevicePointer(T *hostPtr, T **devicePtr) {
HIP_REPORT_IF_ERROR(hipSetDevice(0)); HIP_REPORT_IF_ERROR(hipSetDevice(0));
Show All 24 Lines

mlir/lib/Interfaces/DataLayoutInterfaces.cpp

Show First 20 Lines • Show All 299 Lines • ▼ Show 20 Lines auto nonNullSpecs = llvm::to_vector<2>(llvm::make_filter_range(
[](DataLayoutSpecInterface iface) { return iface != nullptr; })); [](DataLayoutSpecInterface iface) { return iface != nullptr; }));
// Combine the specs using the innermost as anchor. // Combine the specs using the innermost as anchor.
if (DataLayoutSpecInterface current = getSpec(leaf)) if (DataLayoutSpecInterface current = getSpec(leaf))
return current.combineWith(nonNullSpecs); return current.combineWith(nonNullSpecs);
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) {
DataLayoutSpecInterface spec = getSpec(op); DataLayoutSpecInterface spec = getSpec(op);
// The layout specification may be missing and it's fine. // The layout specification may be missing and it's fine.
if (!spec) if (!spec)
return success(); return success();
▲ Show 20 Lines • Show All 249 Lines • Show Last 20 Lines

mlir/lib/TableGen/Format.cpp

Show First 20 Lines • Show All 179 Lines • ▼ Show 20 Lines if (repl.type == FmtReplacement::Type::SpecialPH) {
continue; continue;
} }
if (repl.type == FmtReplacement::Type::PositionalRangePH) { if (repl.type == FmtReplacement::Type::PositionalRangePH) {
if (repl.index >= adapters.size()) { if (repl.index >= adapters.size()) {
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);
llvm::interleaveComma(range, s, llvm::interleaveComma(range, s,
[&](auto &x) { x->format(s, /*Options=*/""); }); [&](auto &x) { x->format(s, /*Options=*/""); });
continue; continue;
} }
Show All 28 Lines

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

Show First 20 Lines • Show All 850 Lines • ▼ Show 20 Lines for (size_t i = 2, e = operands.size(); i < e; ++i) {
auto ty = getType(operands[i]); auto ty = getType(operands[i]);
if (!ty) { if (!ty) {
return emitError(unknownLoc, "unknown argument type in OpTypeFunction"); return emitError(unknownLoc, "unknown argument type in OpTypeFunction");
} }
argTypes.push_back(ty); argTypes.push_back(ty);
} }
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();
} }
LogicalResult LogicalResult
spirv::Deserializer::processCooperativeMatrixType(ArrayRef<uint32_t> operands) { spirv::Deserializer::processCooperativeMatrixType(ArrayRef<uint32_t> operands) {
if (operands.size() != 5) { if (operands.size() != 5) {
▲ Show 20 Lines • Show All 1,258 Lines • Show Last 20 Lines

mlir/lib/Target/SPIRV/TranslateRegistration.cpp

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 LinesdeserializeModule(const llvm::MemoryBuffer *input, MLIRContext *context) {
auto *start = input->getBufferStart(); auto *start = input->getBufferStart();
auto size = input->getBufferSize(); auto size = input->getBufferSize();
if (size % sizeof(uint32_t) != 0) { if (size % sizeof(uint32_t) != 0) {
emitError(UnknownLoc::get(context)) emitError(UnknownLoc::get(context))
<< "SPIR-V binary module must contain integral number of 32-bit words"; << "SPIR-V binary module must contain integral number of 32-bit words";
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);
} }
namespace mlir { namespace mlir {
void registerFromSPIRVTranslation() { void registerFromSPIRVTranslation() {
TranslateToMLIRRegistration fromBinary( TranslateToMLIRRegistration fromBinary(
"deserialize-spirv", "deserializes the SPIR-V module", "deserialize-spirv", "deserializes the SPIR-V module",
[](llvm::SourceMgr &sourceMgr, MLIRContext *context) { [](llvm::SourceMgr &sourceMgr, MLIRContext *context) {
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 101 Lines • ▼ Show 20 Linesprivate:
void printImpl(const VariableDecl *decl); void printImpl(const VariableDecl *decl);
void printImpl(const Module *module); void printImpl(const Module *module);
/// Print the current indent stack. /// Print the current indent stack.
void printIndent() { void printIndent() {
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() ? " `" : " |");
} }
/// The raw output stream. /// The raw output stream.
raw_ostream &os; raw_ostream &os;
/// A stack of indents and a flag indicating if the current element being /// A stack of indents and a flag indicating if the current element being
▲ Show 20 Lines • Show All 272 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 109 Lines • ▼ Show 20 Lines : public TypeStorageBase<TupleTypeStorage,
std::pair<ArrayRef<Type>, ArrayRef<StringRef>>> { std::pair<ArrayRef<Type>, ArrayRef<StringRef>>> {
using Base::Base; using Base::Base;
static TupleTypeStorage * static TupleTypeStorage *
construct(StorageUniquer::StorageAllocator &alloc, construct(StorageUniquer::StorageAllocator &alloc,
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))));
} }
}; };
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// TypeType // TypeType
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
struct TypeTypeStorage : public TypeStorageBase<TypeTypeStorage> {}; struct TypeTypeStorage : public TypeStorageBase<TypeTypeStorage> {};
Show All 13 Lines

mlir/lib/Transforms/Utils/DialectConversion.cpp

Show First 20 Lines • Show All 3,358 Lines • ▼ Show 20 Linesmlir::applyPartialConversion(ArrayRef<Operation *> ops,
OperationConverter opConverter(target, patterns, OpConversionMode::Partial, OperationConverter opConverter(target, patterns, OpConversionMode::Partial,
unconvertedOps); unconvertedOps);
return opConverter.convertOperations(ops); return opConverter.convertOperations(ops);
} }
LogicalResult LogicalResult
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);
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Full Conversion // Full Conversion
LogicalResult LogicalResult
mlir::applyFullConversion(ArrayRef<Operation *> ops, ConversionTarget &target, mlir::applyFullConversion(ArrayRef<Operation *> ops, ConversionTarget &target,
const FrozenRewritePatternSet &patterns) { const FrozenRewritePatternSet &patterns) {
OperationConverter opConverter(target, patterns, OpConversionMode::Full); OperationConverter opConverter(target, patterns, OpConversionMode::Full);
return opConverter.convertOperations(ops); return opConverter.convertOperations(ops);
} }
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);
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Analysis Conversion // Analysis Conversion
LogicalResult LogicalResult
mlir::applyAnalysisConversion(ArrayRef<Operation *> ops, mlir::applyAnalysisConversion(ArrayRef<Operation *> ops,
ConversionTarget &target, ConversionTarget &target,
const FrozenRewritePatternSet &patterns, const FrozenRewritePatternSet &patterns,
DenseSet<Operation *> &convertedOps, DenseSet<Operation *> &convertedOps,
function_ref<void(Diagnostic &)> notifyCallback) { function_ref<void(Diagnostic &)> notifyCallback) {
OperationConverter opConverter(target, patterns, OpConversionMode::Analysis, OperationConverter opConverter(target, patterns, OpConversionMode::Analysis,
&convertedOps); &convertedOps);
return opConverter.convertOperations(ops, notifyCallback); return opConverter.convertOperations(ops, notifyCallback);
} }
LogicalResult LogicalResult
mlir::applyAnalysisConversion(Operation *op, ConversionTarget &target, mlir::applyAnalysisConversion(Operation *op, ConversionTarget &target,
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);
} }

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

Show First 20 Lines • Show All 939 Lines • ▼ Show 20 LinesParseResult PrettyPrintedRegionOp::parse(OpAsmParser &parser,
SmallVector<OpAsmParser::UnresolvedOperand, 2> operands; SmallVector<OpAsmParser::UnresolvedOperand, 2> operands;
if (parser.parseOperandList(operands)) if (parser.parseOperandList(operands))
return failure(); return failure();
// Check if we are parsing the pretty-printed version // Check if we are parsing the pretty-printed version
// 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))
return failure(); return failure();
StringAttr innerOpName = parseOpNameInfo->getIdentifier(); StringAttr innerOpName = parseOpNameInfo->getIdentifier();
FunctionType opFntype; FunctionType opFntype;
▲ Show 20 Lines • Show All 666 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 227 Lines • ▼ Show 20 Lines getOperation()->walk([&](Operation *op) {
opName == "test.replace_with_same_op" || opName == "test.erase_op") { opName == "test.replace_with_same_op" || opName == "test.erase_op") {
ops.push_back(op); ops.push_back(op);
} }
}); });
// 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);
} }
private: private:
// New inserted operation is valid for further transformation. // New inserted operation is valid for further transformation.
class InsertSameOp : public RewritePattern { class InsertSameOp : public RewritePattern {
public: public:
InsertSameOp(MLIRContext *context) InsertSameOp(MLIRContext *context)
▲ Show 20 Lines • Show All 104 Lines • ▼ Show 20 Linesstruct TestReturnTypeDriver
void runOnOperation() override { void runOnOperation() override {
if (getOperation().getName() == "testCreateFunctions") { if (getOperation().getName() == "testCreateFunctions") {
std::vector<Operation *> ops; std::vector<Operation *> ops;
// Collect ops to avoid triggering on inserted ops. // Collect ops to avoid triggering on inserted ops.
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.
invokeCreateWithInferredReturnType<OpWithInferTypeInterfaceOp>(op); invokeCreateWithInferredReturnType<OpWithInferTypeInterfaceOp>(op);
invokeCreateWithInferredReturnType< invokeCreateWithInferredReturnType<
OpWithShapedTypeInferTypeInterfaceOp>(op); OpWithShapedTypeInferTypeInterfaceOp>(op);
}; };
return; return;
▲ Show 20 Lines • Show All 1,241 Lines • Show Last 20 Lines

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

Show All 38 Lines
// DECL-LABEL: AOp declarations // DECL-LABEL: AOp declarations
// Test attribute name methods // Test attribute name methods
// --- // ---
// 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);
// DECL: ::mlir::StringAttr getAAttrAttrName(::mlir::OperationName name) // DECL: ::mlir::StringAttr getAAttrAttrName(::mlir::OperationName name)
// DECL-NEXT: return getAttributeNameForIndex(name, 0); // DECL-NEXT: return getAttributeNameForIndex(name, 0);
// DECL: ::mlir::StringAttr getBAttrAttrName() // DECL: ::mlir::StringAttr getBAttrAttrName()
// DECL-NEXT: return getAttributeNameForIndex(1); // DECL-NEXT: return getAttributeNameForIndex(1);
▲ Show 20 Lines • Show All 132 Lines • ▼ Show 20 Lines
// DECL-LABEL: AgetOp declarations // DECL-LABEL: AgetOp declarations
// Test attribute name methods // Test attribute name methods
// --- // ---
// 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);
// DECL: ::mlir::StringAttr getAAttrAttrName(::mlir::OperationName name) // DECL: ::mlir::StringAttr getAAttrAttrName(::mlir::OperationName name)
// DECL-NEXT: return getAttributeNameForIndex(name, 0); // DECL-NEXT: return getAttributeNameForIndex(name, 0);
// DECL: ::mlir::StringAttr getBAttrAttrName() // DECL: ::mlir::StringAttr getBAttrAttrName()
// DECL-NEXT: return getAttributeNameForIndex(1); // DECL-NEXT: return getAttributeNameForIndex(1);
▲ Show 20 Lines • Show All 329 Lines • Show Last 20 Lines

mlir/tools/mlir-tblgen/AttrOrTypeFormatGen.cpp

Show First 20 Lines • Show All 652 Lines • ▼ Show 20 Lines llvm::interleave(
" || "); " || ");
os << ")) {\n"; os << ")) {\n";
}; };
if (auto *literal = dyn_cast<LiteralElement>(first)) { if (auto *literal = dyn_cast<LiteralElement>(first)) {
genLiteralParser(literal->getSpelling(), ctx, os, /*isOptional=*/true); genLiteralParser(literal->getSpelling(), ctx, os, /*isOptional=*/true);
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());
} else { } else {
auto *strct = cast<StructDirective>(first); auto *strct = cast<StructDirective>(first);
genStructParser(strct, ctx, os); genStructParser(strct, ctx, os);
guardOn(params->getParams()); guardOn(params->getParams());
} }
▲ Show 20 Lines • Show All 177 Lines • ▼ Show 20 Linesvoid DefFormat::genCustomPrinter(CustomDirective *el, FmtContext &ctx,
} }
os.unindent() << ");\n"; os.unindent() << ");\n";
} }
void DefFormat::genOptionalGroupPrinter(OptionalElement *el, FmtContext &ctx, void DefFormat::genOptionalGroupPrinter(OptionalElement *el, FmtContext &ctx,
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)) {
guardOnAny(ctx, os, strct->getParams(), el->isInverted()); guardOnAny(ctx, os, strct->getParams(), el->isInverted());
} else { } else {
auto *custom = cast<CustomDirective>(anchor); auto *custom = cast<CustomDirective>(anchor);
guardOnAny(ctx, os, guardOnAny(ctx, os,
llvm::make_filter_range( llvm::make_filter_range(
▲ Show 20 Lines • Show All 362 Lines • Show Last 20 Lines

mlir/tools/mlir-tblgen/FormatGen.h

Show First 20 Lines • Show All 381 Lines • ▼ Show 20 Lines OptionalElement(std::vector<FormatElement *> &&thenElements,
FormatElement *anchor, bool inverted) FormatElement *anchor, bool inverted)
: thenElements(std::move(thenElements)), : thenElements(std::move(thenElements)),
elseElements(std::move(elseElements)), thenParseStart(thenParseStart), elseElements(std::move(elseElements)), thenParseStart(thenParseStart),
elseParseStart(elseParseStart), anchor(anchor), inverted(inverted) {} elseParseStart(elseParseStart), anchor(anchor), inverted(inverted) {}
/// 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);
} }
/// Return the anchor of the optional group. /// Return the anchor of the optional group.
FormatElement *getAnchor() const { return anchor; } FormatElement *getAnchor() const { return anchor; }
/// Return true if the optional group is inverted. /// Return true if the optional group is inverted.
bool isInverted() const { return inverted; } bool isInverted() const { return inverted; }
▲ Show 20 Lines • Show All 182 Lines • Show Last 20 Lines

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

Show First 20 Lines • Show All 896 Lines • ▼ Show 20 Lines if (attributes.empty()) {
// Nothing else to do if there are no registered attributes. Exit early. // Nothing else to do if there are no registered attributes. Exit early.
return; return;
} }
body << " static ::llvm::StringRef attrNames[] = {"; body << " static ::llvm::StringRef attrNames[] = {";
llvm::interleaveComma(llvm::make_first_range(attributes), body, llvm::interleaveComma(llvm::make_first_range(attributes), body,
[&](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.
{ {
auto *method = opClass.addInlineMethod<Method::Private>( auto *method = opClass.addInlineMethod<Method::Private>(
"::mlir::StringAttr", "getAttributeNameForIndex", "::mlir::StringAttr", "getAttributeNameForIndex",
MethodParameter("unsigned", "index")); MethodParameter("unsigned", "index"));
ERROR_IF_PRUNED(method, "getAttributeNameForIndex", op); ERROR_IF_PRUNED(method, "getAttributeNameForIndex", op);
▲ Show 20 Lines • Show All 2,286 Lines • Show Last 20 Lines

mlir/tools/mlir-tblgen/OpPythonBindingGen.cpp

Show First 20 Lines • Show All 887 Lines • ▼ Show 20 Linesstatic void emitDefaultOpBuilder(const Operator &op, raw_ostream &os) {
populateBuilderArgsResults(op, builderArgs); populateBuilderArgsResults(op, builderArgs);
size_t numResultArgs = builderArgs.size(); size_t numResultArgs = builderArgs.size();
populateBuilderArgs(op, builderArgs, operandArgNames, successorArgNames); populateBuilderArgs(op, builderArgs, operandArgNames, successorArgNames);
size_t numOperandAttrArgs = builderArgs.size() - numResultArgs; size_t numOperandAttrArgs = builderArgs.size() - numResultArgs;
populateBuilderArgsSuccessors(op, builderArgs, successorArgNames); populateBuilderArgsSuccessors(op, builderArgs, successorArgNames);
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);
// Layout of builderArgs vector elements: // Layout of builderArgs vector elements:
// [ result_args operand_attr_args successor_args regions ] // [ result_args operand_attr_args successor_args regions ]
// Determine whether the argument corresponding to a given index into the // Determine whether the argument corresponding to a given index into the
// builderArgs vector is a python keyword argument or not. // builderArgs vector is a python keyword argument or not.
▲ Show 20 Lines • Show All 151 Lines • Show Last 20 Lines

mlir/unittests/IR/AttributeTest.cpp

Show All 22 Lines
static void testSplat(Type eltType, const EltTy &splatElt) { static void testSplat(Type eltType, const EltTy &splatElt) {
RankedTensorType shape = RankedTensorType::get({2, 1}, eltType); RankedTensorType shape = RankedTensorType::get({2, 1}, eltType);
// Check that the generated splat is the same for 1 element and N elements. // Check that the generated splat is the same for 1 element and N elements.
DenseElementsAttr splat = DenseElementsAttr::get(shape, splatElt); DenseElementsAttr splat = DenseElementsAttr::get(shape, splatElt);
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>())
EXPECT_TRUE(newValue == splatElt); EXPECT_TRUE(newValue == splatElt);
} }
namespace { namespace {
TEST(DenseSplatTest, BoolSplat) { TEST(DenseSplatTest, BoolSplat) {
▲ Show 20 Lines • Show All 175 Lines • ▼ Show 20 Lines
TEST(DenseScalarTest, ExtractZeroRankElement) { TEST(DenseScalarTest, ExtractZeroRankElement) {
MLIRContext context; MLIRContext context;
const int elementValue = 12; const int elementValue = 12;
IntegerType intTy = IntegerType::get(&context, 32); IntegerType intTy = IntegerType::get(&context, 32);
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);
} }
TEST(DenseSplatMapValuesTest, I32ToTrue) { TEST(DenseSplatMapValuesTest, I32ToTrue) {
MLIRContext context; MLIRContext context;
const int elementValue = 12; const int elementValue = 12;
IntegerType boolTy = IntegerType::get(&context, 1); IntegerType boolTy = IntegerType::get(&context, 1);
IntegerType intTy = IntegerType::get(&context, 32); IntegerType intTy = IntegerType::get(&context, 32);
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);
}); });
EXPECT_EQ(attr.getNumElements(), 4); EXPECT_EQ(attr.getNumElements(), 4);
EXPECT_TRUE(attr.isSplat()); EXPECT_TRUE(attr.isSplat());
EXPECT_TRUE(attr.getSplatValue<BoolAttr>().getValue()); EXPECT_TRUE(attr.getSplatValue<BoolAttr>().getValue());
} }
TEST(DenseSplatMapValuesTest, I32ToFalse) { TEST(DenseSplatMapValuesTest, I32ToFalse) {
MLIRContext context; MLIRContext context;
const int elementValue = 0; const int elementValue = 0;
IntegerType boolTy = IntegerType::get(&context, 1); IntegerType boolTy = IntegerType::get(&context, 1);
IntegerType intTy = IntegerType::get(&context, 32); IntegerType intTy = IntegerType::get(&context, 32);
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);
}); });
EXPECT_EQ(attr.getNumElements(), 4); EXPECT_EQ(attr.getNumElements(), 4);
EXPECT_TRUE(attr.isSplat()); EXPECT_TRUE(attr.isSplat());
EXPECT_FALSE(attr.getSplatValue<BoolAttr>().getValue()); EXPECT_FALSE(attr.getSplatValue<BoolAttr>().getValue());
} }
} // namespace } // namespace
Show All 16 Linesstatic void checkNativeAccess(MLIRContext *ctx, ArrayRef<T> data,
// Check that we cast to this attribute when possible. // Check that we cast to this attribute when possible.
Attribute genericAttr = attr; Attribute genericAttr = attr;
EXPECT_TRUE(genericAttr.template isa<AttrT>()); EXPECT_TRUE(genericAttr.template isa<AttrT>());
} }
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));
} }
namespace { namespace {
TEST(DenseResourceElementsAttrTest, CheckNativeAccess) { TEST(DenseResourceElementsAttrTest, CheckNativeAccess) {
MLIRContext context; MLIRContext context;
Builder builder(&context); Builder builder(&context);
// 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);
checkNativeIntAccess<DenseUI16ResourceElementsAttr, uint16_t>(builder, 16); checkNativeIntAccess<DenseUI16ResourceElementsAttr, uint16_t>(builder, 16);
checkNativeIntAccess<DenseUI32ResourceElementsAttr, uint32_t>(builder, 32); checkNativeIntAccess<DenseUI32ResourceElementsAttr, uint32_t>(builder, 32);
checkNativeIntAccess<DenseUI64ResourceElementsAttr, uint64_t>(builder, 64); checkNativeIntAccess<DenseUI64ResourceElementsAttr, uint64_t>(builder, 64);
// Signed integers // Signed integers
checkNativeIntAccess<DenseI8ResourceElementsAttr, int8_t>(builder, 8); checkNativeIntAccess<DenseI8ResourceElementsAttr, int8_t>(builder, 8);
checkNativeIntAccess<DenseI16ResourceElementsAttr, int16_t>(builder, 16); checkNativeIntAccess<DenseI16ResourceElementsAttr, int16_t>(builder, 16);
checkNativeIntAccess<DenseI32ResourceElementsAttr, int32_t>(builder, 32); checkNativeIntAccess<DenseI32ResourceElementsAttr, int32_t>(builder, 32);
checkNativeIntAccess<DenseI64ResourceElementsAttr, int64_t>(builder, 64); checkNativeIntAccess<DenseI64ResourceElementsAttr, int64_t>(builder, 64);
// 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) {
MLIRContext context; MLIRContext context;
Builder builder(&context); Builder builder(&context);
// Create a i32 attribute. // Create a i32 attribute.
ArrayRef<uint32_t> data; ArrayRef<uint32_t> data;
▲ Show 20 Lines • Show All 97 Lines • Show Last 20 Lines

mlir/unittests/IR/SubElementInterfaceTest.cpp

Show All 23 LinesTEST(SubElementInterfaceTest, Nested) {
BoolAttr falseAttr = builder.getBoolAttr(false); BoolAttr falseAttr = builder.getBoolAttr(false);
ArrayAttr boolArrayAttr = builder.getArrayAttr({trueAttr, falseAttr}); ArrayAttr boolArrayAttr = builder.getArrayAttr({trueAttr, falseAttr});
StringAttr strAttr = builder.getStringAttr("array"); StringAttr strAttr = builder.getStringAttr("array");
DictionaryAttr dictAttr = DictionaryAttr dictAttr =
builder.getDictionaryAttr(builder.getNamedAttr(strAttr, boolArrayAttr)); builder.getDictionaryAttr(builder.getNamedAttr(strAttr, boolArrayAttr));
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}));
} }
} // namespace } // namespace