std::unique_ptr<Directive> Directive::create(bool RegexKind, SourceLocation DirectiveLoc, SourceLocation DiagnosticLoc, bool MatchAnyLine, StringRef Text, unsigned Min, unsigned Max) { if (!RegexKind) return llvm::make_unique<StandardDirective>(DirectiveLoc, DiagnosticLoc, MatchAnyLine, Text, Min, Max); // Parse the directive into a regular expression. std::string RegexStr; StringRef S = Text; while (!S.empty()) { if (S.startswith("{{")) { S = S.drop_front(2); size_t RegexMatchLength = S.find("}}"); assert(RegexMatchLength != StringRef::npos); // Append the regex, enclosed in parentheses. RegexStr += "("; RegexStr.append(S.data(), RegexMatchLength); RegexStr += ")"; S = S.drop_front(RegexMatchLength + 2); } else { size_t VerbatimMatchLength = S.find("{{"); if (VerbatimMatchLength == StringRef::npos) VerbatimMatchLength = S.size(); // Escape and append the fixed string. RegexStr += llvm::Regex::escape(S.substr(0, VerbatimMatchLength)); S = S.drop_front(VerbatimMatchLength); } } return llvm::make_unique<RegexDirective>( DirectiveLoc, DiagnosticLoc, MatchAnyLine, Text, Min, Max, RegexStr); }
ErrorOr<StringRef> ELFLinkingContext::searchLibrary(StringRef libName) const { bool hasColonPrefix = libName[0] == ':'; SmallString<128> path; for (StringRef dir : _inputSearchPaths) { // Search for dynamic library if (!_isStaticExecutable) { buildSearchPath(path, dir, _sysrootPath); llvm::sys::path::append(path, hasColonPrefix ? libName.drop_front() : Twine("lib", libName) + ".so"); if (exists(path.str())) return path.str().copy(_allocator); } // Search for static libraries too buildSearchPath(path, dir, _sysrootPath); llvm::sys::path::append(path, hasColonPrefix ? libName.drop_front() : Twine("lib", libName) + ".a"); if (exists(path.str())) return path.str().copy(_allocator); } if (hasColonPrefix && exists(libName.drop_front())) return libName.drop_front(); return make_error_code(llvm::errc::no_such_file_or_directory); }
Optional<ReplacementItem> formatv_object_base::parseReplacementItem(StringRef Spec) { StringRef RepString = Spec.trim("{}"); // If the replacement sequence does not start with a non-negative integer, // this is an error. char Pad = ' '; std::size_t Align = 0; AlignStyle Where = AlignStyle::Right; StringRef Options; size_t Index = 0; RepString = RepString.trim(); if (RepString.consumeInteger(0, Index)) { assert(false && "Invalid replacement sequence index!"); return ReplacementItem{}; } RepString = RepString.trim(); if (!RepString.empty() && RepString.front() == ',') { RepString = RepString.drop_front(); if (!consumeFieldLayout(RepString, Where, Align, Pad)) assert(false && "Invalid replacement field layout specification!"); } RepString = RepString.trim(); if (!RepString.empty() && RepString.front() == ':') { Options = RepString.drop_front().trim(); RepString = StringRef(); } RepString = RepString.trim(); if (!RepString.empty()) { assert(false && "Unexpected characters found in replacement string!"); } return ReplacementItem{Spec, Index, Align, Where, Pad, Options}; }
bool formatv_object_base::consumeFieldLayout(StringRef &Spec, AlignStyle &Where, size_t &Align, char &Pad) { Where = AlignStyle::Right; Align = 0; Pad = ' '; if (Spec.empty()) return true; if (Spec.size() > 1) { // A maximum of 2 characters at the beginning can be used for something // other // than the width. // If Spec[1] is a loc char, then Spec[0] is a pad char and Spec[2:...] // contains the width. // Otherwise, if Spec[0] is a loc char, then Spec[1:...] contains the width. // Otherwise, Spec[0:...] contains the width. if (auto Loc = translateLocChar(Spec[1])) { Pad = Spec[0]; Where = *Loc; Spec = Spec.drop_front(2); } else if (auto Loc = translateLocChar(Spec[0])) { Where = *Loc; Spec = Spec.drop_front(1); } } bool Failed = Spec.consumeInteger(0, Align); return !Failed; }
std::pair<ReplacementItem, StringRef> formatv_object_base::splitLiteralAndReplacement(StringRef Fmt) { std::size_t From = 0; while (From < Fmt.size() && From != StringRef::npos) { std::size_t BO = Fmt.find_first_of('{', From); // Everything up until the first brace is a literal. if (BO != 0) return std::make_pair(ReplacementItem{Fmt.substr(0, BO)}, Fmt.substr(BO)); StringRef Braces = Fmt.drop_front(BO).take_while([](char C) { return C == '{'; }); // If there is more than one brace, then some of them are escaped. Treat // these as replacements. if (Braces.size() > 1) { size_t NumEscapedBraces = Braces.size() / 2; StringRef Middle = Fmt.substr(BO, NumEscapedBraces); StringRef Right = Fmt.drop_front(BO + NumEscapedBraces * 2); return std::make_pair(ReplacementItem{Middle}, Right); } // An unterminated open brace is undefined. We treat the rest of the string // as a literal replacement, but we assert to indicate that this is // undefined and that we consider it an error. std::size_t BC = Fmt.find_first_of('}', BO); if (BC == StringRef::npos) { assert( false && "Unterminated brace sequence. Escape with {{ for a literal brace."); return std::make_pair(ReplacementItem{Fmt}, StringRef()); } // Even if there is a closing brace, if there is another open brace before // this closing brace, treat this portion as literal, and try again with the // next one. std::size_t BO2 = Fmt.find_first_of('{', BO + 1); if (BO2 < BC) return std::make_pair(ReplacementItem{Fmt.substr(0, BO2)}, Fmt.substr(BO2)); StringRef Spec = Fmt.slice(BO + 1, BC); StringRef Right = Fmt.substr(BC + 1); auto RI = parseReplacementItem(Spec); if (RI.hasValue()) return std::make_pair(*RI, Right); // If there was an error parsing the replacement item, treat it as an // invalid replacement spec, and just continue. From = BC + 1; } return std::make_pair(ReplacementItem{Fmt}, StringRef()); }
bool llvm::consumeSignedInteger(StringRef &Str, unsigned Radix, long long &Result) { unsigned long long ULLVal; // Handle positive strings first. if (Str.empty() || Str.front() != '-') { if (consumeUnsignedInteger(Str, Radix, ULLVal) || // Check for value so large it overflows a signed value. (long long)ULLVal < 0) return true; Result = ULLVal; return false; } // Get the positive part of the value. StringRef Str2 = Str.drop_front(1); if (consumeUnsignedInteger(Str2, Radix, ULLVal) || // Reject values so large they'd overflow as negative signed, but allow // "-0". This negates the unsigned so that the negative isn't undefined // on signed overflow. (long long)-ULLVal > 0) return true; Str = Str2; Result = -ULLVal; return false; }
void printSymbolVersionDefinition(const typename ELFT::Shdr &Shdr, ArrayRef<uint8_t> Contents, StringRef StrTab) { outs() << "Version definitions:\n"; const uint8_t *Buf = Contents.data(); uint32_t VerdefIndex = 1; // sh_info contains the number of entries in the SHT_GNU_verdef section. To // make the index column have consistent width, we should insert blank spaces // according to sh_info. uint16_t VerdefIndexWidth = std::to_string(Shdr.sh_info).size(); while (Buf) { auto *Verdef = reinterpret_cast<const typename ELFT::Verdef *>(Buf); outs() << format_decimal(VerdefIndex++, VerdefIndexWidth) << " " << format("0x%02" PRIx16 " ", (uint16_t)Verdef->vd_flags) << format("0x%08" PRIx32 " ", (uint32_t)Verdef->vd_hash); const uint8_t *BufAux = Buf + Verdef->vd_aux; uint16_t VerdauxIndex = 0; while (BufAux) { auto *Verdaux = reinterpret_cast<const typename ELFT::Verdaux *>(BufAux); if (VerdauxIndex) outs() << std::string(VerdefIndexWidth + 17, ' '); outs() << StringRef(StrTab.drop_front(Verdaux->vda_name).data()) << '\n'; BufAux = Verdaux->vda_next ? BufAux + Verdaux->vda_next : nullptr; ++VerdauxIndex; } Buf = Verdef->vd_next ? Buf + Verdef->vd_next : nullptr; } }
static bool matchesStyle(StringRef Name, IdentifierNamingCheck::NamingStyle Style) { static llvm::Regex Matchers[] = { llvm::Regex("^.*$"), llvm::Regex("^[a-z][a-z0-9_]*$"), llvm::Regex("^[a-z][a-zA-Z0-9]*$"), llvm::Regex("^[A-Z][A-Z0-9_]*$"), llvm::Regex("^[A-Z][a-zA-Z0-9]*$"), llvm::Regex("^[A-Z]([a-z0-9]*(_[A-Z])?)*"), llvm::Regex("^[a-z]([a-z0-9]*(_[A-Z])?)*"), }; bool Matches = true; if (Name.startswith(Style.Prefix)) Name = Name.drop_front(Style.Prefix.size()); else Matches = false; if (Name.endswith(Style.Suffix)) Name = Name.drop_back(Style.Suffix.size()); else Matches = false; // Ensure the name doesn't have any extra underscores beyond those specified // in the prefix and suffix. if (Name.startswith("_") || Name.endswith("_")) Matches = false; if (Style.Case && !Matchers[static_cast<size_t>(*Style.Case)].match(Name)) Matches = false; return Matches; }
void X86AsmPrinter::GenerateExportDirective(const MCSymbol *Sym, bool IsData) { SmallString<128> Directive; raw_svector_ostream OS(Directive); StringRef Name = Sym->getName(); const Triple &TT = TM.getTargetTriple(); if (TT.isKnownWindowsMSVCEnvironment()) OS << " /EXPORT:"; else OS << " -export:"; if ((TT.isWindowsGNUEnvironment() || TT.isWindowsCygwinEnvironment()) && (Name[0] == getDataLayout().getGlobalPrefix())) Name = Name.drop_front(); OS << Name; if (IsData) { if (TT.isKnownWindowsMSVCEnvironment()) OS << ",DATA"; else OS << ",data"; } OS.flush(); OutStreamer->EmitBytes(Directive); }
static bool matchesStyle(StringRef Name, IdentifierNamingCheck::NamingStyle Style) { static llvm::Regex Matchers[] = { llvm::Regex("^.*$"), llvm::Regex("^[a-z][a-z0-9_]*$"), llvm::Regex("^[a-z][a-zA-Z0-9]*$"), llvm::Regex("^[A-Z][A-Z0-9_]*$"), llvm::Regex("^[A-Z][a-zA-Z0-9]*$"), llvm::Regex("^[A-Z]([a-z0-9]*(_[A-Z])?)*"), llvm::Regex("^[a-z]([a-z0-9]*(_[A-Z])?)*"), }; bool Matches = true; if (Name.startswith(Style.Prefix)) Name = Name.drop_front(Style.Prefix.size()); else Matches = false; if (Name.endswith(Style.Suffix)) Name = Name.drop_back(Style.Suffix.size()); else Matches = false; if (!Matchers[static_cast<size_t>(Style.Case)].match(Name)) Matches = false; return Matches; }
void X86AsmPrinter::GenerateExportDirective(const MCSymbol *Sym, bool IsData) { SmallString<128> Directive; raw_svector_ostream OS(Directive); StringRef Name = Sym->getName(); if (Subtarget->isTargetKnownWindowsMSVC()) OS << " /EXPORT:"; else OS << " -export:"; if ((Subtarget->isTargetWindowsGNU() || Subtarget->isTargetWindowsCygwin()) && (Name[0] == getDataLayout().getGlobalPrefix())) Name = Name.drop_front(); OS << Name; if (IsData) { if (Subtarget->isTargetKnownWindowsMSVC()) OS << ",DATA"; else OS << ",data"; } OS.flush(); OutStreamer.EmitBytes(Directive); }
static Check::CheckType FindCheckType(StringRef Buffer, StringRef Prefix) { char NextChar = Buffer[Prefix.size()]; // Verify that the : is present after the prefix. if (NextChar == ':') return Check::CheckPlain; if (NextChar != '-') return Check::CheckNone; StringRef Rest = Buffer.drop_front(Prefix.size() + 1); if (Rest.startswith("NEXT:")) return Check::CheckNext; if (Rest.startswith("SAME:")) return Check::CheckSame; if (Rest.startswith("NOT:")) return Check::CheckNot; if (Rest.startswith("DAG:")) return Check::CheckDAG; if (Rest.startswith("LABEL:")) return Check::CheckLabel; return Check::CheckNone; }
IAMResult IAMInference::inferVar(const clang::VarDecl *varDecl) { auto fail = [varDecl]() -> IAMResult { DEBUG(llvm::dbgs() << "failed to infer variable: "); DEBUG(varDecl->print(llvm::dbgs())); DEBUG(llvm::dbgs() << "\n"); ++FailInferVar; return {}; }; // Try to find a type to add this as a static property to StringRef workingName = varDecl->getName(); if (workingName.empty()) return fail(); // Special pattern: constants of the form "kFooBarBaz", extend "FooBar" with // property "Baz" if (*camel_case::getWords(workingName).begin() == "k") workingName = workingName.drop_front(1); NameBuffer remainingName; if (auto effectiveDC = findTypeAndMatch(workingName, remainingName)) return importAsStaticProperty(remainingName, effectiveDC); return fail(); }
void ModuleInfo::addSymbol(const SymbolRef &Symbol) { SymbolRef::Type SymbolType; if (error(Symbol.getType(SymbolType))) return; if (SymbolType != SymbolRef::ST_Function && SymbolType != SymbolRef::ST_Data) return; uint64_t SymbolAddress; if (error(Symbol.getAddress(SymbolAddress)) || SymbolAddress == UnknownAddressOrSize) return; uint64_t SymbolSize; // Getting symbol size is linear for Mach-O files, so assume that symbol // occupies the memory range up to the following symbol. if (isa<MachOObjectFile>(Module)) SymbolSize = 0; else if (error(Symbol.getSize(SymbolSize)) || SymbolSize == UnknownAddressOrSize) return; StringRef SymbolName; if (error(Symbol.getName(SymbolName))) return; // Mach-O symbol table names have leading underscore, skip it. if (Module->isMachO() && SymbolName.size() > 0 && SymbolName[0] == '_') SymbolName = SymbolName.drop_front(); // FIXME: If a function has alias, there are two entries in symbol table // with same address size. Make sure we choose the correct one. SymbolMapTy &M = SymbolType == SymbolRef::ST_Function ? Functions : Objects; SymbolDesc SD = { SymbolAddress, SymbolSize }; M.insert(std::make_pair(SD, SymbolName)); }
static bool stripPrefix(StringRef &string, const char (&data)[N]) { constexpr size_t prefixLength = N - 1; if (!string.startswith(StringRef(data, prefixLength))) return false; string = string.drop_front(prefixLength); return true; }
// Try to find the first match in buffer for any prefix. If a valid match is // found, return that prefix and set its type and location. If there are almost // matches (e.g. the actual prefix string is found, but is not an actual check // string), but no valid match, return an empty string and set the position to // resume searching from. If no partial matches are found, return an empty // string and the location will be StringRef::npos. If one prefix is a substring // of another, the maximal match should be found. e.g. if "A" and "AA" are // prefixes then AA-CHECK: should match the second one. static StringRef FindFirstCandidateMatch(StringRef &Buffer, Check::CheckType &CheckTy, size_t &CheckLoc) { StringRef FirstPrefix; size_t FirstLoc = StringRef::npos; size_t SearchLoc = StringRef::npos; Check::CheckType FirstTy = Check::CheckNone; CheckTy = Check::CheckNone; CheckLoc = StringRef::npos; for (prefix_iterator I = CheckPrefixes.begin(), E = CheckPrefixes.end(); I != E; ++I) { StringRef Prefix(*I); size_t PrefixLoc = Buffer.find(Prefix); if (PrefixLoc == StringRef::npos) continue; // Track where we are searching for invalid prefixes that look almost right. // We need to only advance to the first partial match on the next attempt // since a partial match could be a substring of a later, valid prefix. // Need to skip to the end of the word, otherwise we could end up // matching a prefix in a substring later. if (PrefixLoc < SearchLoc) SearchLoc = SkipWord(Buffer, PrefixLoc); // We only want to find the first match to avoid skipping some. if (PrefixLoc > FirstLoc) continue; // If one matching check-prefix is a prefix of another, choose the // longer one. if (PrefixLoc == FirstLoc && Prefix.size() < FirstPrefix.size()) continue; StringRef Rest = Buffer.drop_front(PrefixLoc); // Make sure we have actually found the prefix, and not a word containing // it. This should also prevent matching the wrong prefix when one is a // substring of another. if (PrefixLoc != 0 && IsPartOfWord(Buffer[PrefixLoc - 1])) FirstTy = Check::CheckNone; else FirstTy = FindCheckType(Rest, Prefix); FirstLoc = PrefixLoc; FirstPrefix = Prefix; } // If the first prefix is invalid, we should continue the search after it. if (FirstTy == Check::CheckNone) { CheckLoc = SearchLoc; return ""; } CheckTy = FirstTy; CheckLoc = FirstLoc; return FirstPrefix; }
/// Get the function name from the record, removing the filename prefix if /// necessary. static StringRef getFuncNameWithoutPrefix(const CoverageMappingRecord &Record) { StringRef FunctionName = Record.FunctionName; if (Record.Filenames.empty()) return FunctionName; StringRef Filename = sys::path::filename(Record.Filenames[0]); if (FunctionName.startswith(Filename)) FunctionName = FunctionName.drop_front(Filename.size() + 1); return FunctionName; }
size_t StringRef::find_lower(StringRef Str, size_t From) const { StringRef This = substr(From); while (This.size() >= Str.size()) { if (This.startswith_lower(Str)) return From; This = This.drop_front(); ++From; } return npos; }
ID types::lookupTypeForExtension(StringRef Ext) { if (Ext.empty()) return TY_INVALID; assert(Ext.front() == '.' && "not a file extension"); return llvm::StringSwitch<types::ID>(Ext.drop_front()) #define TYPE(NAME, ID, SUFFIX, FLAGS) \ .Case(SUFFIX, TY_##ID) #include "swift/Driver/Types.def" .Default(TY_INVALID); }
bool HSAILELFMCAsmInfo::isValidUnquotedName(StringRef Name) const { char First = Name.front(); assert((First == '%' || First == '&' || First == '@') && "Missing valid prefix character"); Name = Name.drop_front(1); if (!Name.empty()) { if (!isValidFirstChar(Name.front())) return false; Name = Name.drop_front(); } for (char C : Name) { if (!isValidChar(C)) return false; } return true; }
void ELFObjectWriter::writeSectionData(const MCAssembler &Asm, MCSection &Sec, const MCAsmLayout &Layout) { MCSectionELF &Section = static_cast<MCSectionELF &>(Sec); StringRef SectionName = Section.getSectionName(); auto &MC = Asm.getContext(); const auto &MAI = MC.getAsmInfo(); // Compressing debug_frame requires handling alignment fragments which is // more work (possibly generalizing MCAssembler.cpp:writeFragment to allow // for writing to arbitrary buffers) for little benefit. bool CompressionEnabled = MAI->compressDebugSections() != DebugCompressionType::None; if (!CompressionEnabled || !SectionName.startswith(".debug_") || SectionName == ".debug_frame") { Asm.writeSectionData(&Section, Layout); return; } assert((MAI->compressDebugSections() == DebugCompressionType::Z || MAI->compressDebugSections() == DebugCompressionType::GNU) && "expected zlib or zlib-gnu style compression"); SmallVector<char, 128> UncompressedData; raw_svector_ostream VecOS(UncompressedData); raw_pwrite_stream &OldStream = getStream(); setStream(VecOS); Asm.writeSectionData(&Section, Layout); setStream(OldStream); SmallVector<char, 128> CompressedContents; if (Error E = zlib::compress( StringRef(UncompressedData.data(), UncompressedData.size()), CompressedContents)) { consumeError(std::move(E)); getStream() << UncompressedData; return; } bool ZlibStyle = MAI->compressDebugSections() == DebugCompressionType::Z; if (!maybeWriteCompression(UncompressedData.size(), CompressedContents, ZlibStyle, Sec.getAlignment())) { getStream() << UncompressedData; return; } if (ZlibStyle) // Set the compressed flag. That is zlib style. Section.setFlags(Section.getFlags() | ELF::SHF_COMPRESSED); else // Add "z" prefix to section name. This is zlib-gnu style. MC.renameELFSection(&Section, (".z" + SectionName.drop_front(1)).str()); getStream() << CompressedContents; }
Optional<EditorPlaceholderData> swift::parseEditorPlaceholder(StringRef PlaceholderText) { if (!PlaceholderText.startswith("<#") || !PlaceholderText.endswith("#>")) return None; PlaceholderText = PlaceholderText.drop_front(2).drop_back(2); EditorPlaceholderData PHDataBasic; PHDataBasic.Kind = EditorPlaceholderKind::Basic; PHDataBasic.Display = PlaceholderText; if (!PlaceholderText.startswith("T##")) { // Basic. return PHDataBasic; } // Typed. EditorPlaceholderData PHDataTyped; PHDataTyped.Kind = EditorPlaceholderKind::Typed; assert(PlaceholderText.startswith("T##")); PlaceholderText = PlaceholderText.drop_front(3); size_t Pos = PlaceholderText.find("##"); if (Pos == StringRef::npos) { PHDataTyped.Display = PHDataTyped.Type = PHDataTyped.TypeForExpansion = PlaceholderText; return PHDataTyped; } PHDataTyped.Display = PlaceholderText.substr(0, Pos); PlaceholderText = PlaceholderText.substr(Pos+2); Pos = PlaceholderText.find("##"); if (Pos == StringRef::npos) { PHDataTyped.Type = PHDataTyped.TypeForExpansion = PlaceholderText; } else { PHDataTyped.Type = PlaceholderText.substr(0, Pos); PHDataTyped.TypeForExpansion = PlaceholderText.substr(Pos+2); } return PHDataTyped; }
void CommentASTToXMLConverter::appendToResultWithCDATAEscaping(StringRef S) { if (S.empty()) return; Result << "<![CDATA["; while (!S.empty()) { size_t Pos = S.find("]]>"); if (Pos == 0) { Result << "]]]]><![CDATA[>"; S = S.drop_front(3); continue; } if (Pos == StringRef::npos) Pos = S.size(); Result << S.substr(0, Pos); S = S.drop_front(Pos); } Result << "]]>"; }
void ArrayOrderPass::perform(std::unique_ptr<MutableFile> &f) { auto definedAtoms = f->definedAtoms(); // Move sections need to be sorted into the separate continious group. // That reduces a number of sorting elements and simplifies conditions // in the sorting predicate. auto last = std::stable_partition(definedAtoms.begin(), definedAtoms.end(), [](const DefinedAtom *atom) { if (atom->sectionChoice() != DefinedAtom::sectionCustomRequired) return false; StringRef name = atom->customSectionName(); return name.startswith(".init_array") || name.startswith(".fini_array"); }); std::stable_sort(definedAtoms.begin(), last, [](const DefinedAtom *left, const DefinedAtom *right) { StringRef leftSec = left->customSectionName(); StringRef rightSec = right->customSectionName(); // Drop the front dot from the section name and get // an optional section's number starting after the second dot. StringRef leftNum = leftSec.drop_front().rsplit('.').second; StringRef rightNum = rightSec.drop_front().rsplit('.').second; // Sort {.init_array, .fini_array}[.<num>] sections // according to their number. Sections without optional // numer suffix should go last. uint32_t leftPriority = std::numeric_limits<uint32_t>::max(); if (!leftNum.empty()) leftNum.getAsInteger(10, leftPriority); uint32_t rightPriority = std::numeric_limits<uint32_t>::max(); if (!rightNum.empty()) rightNum.getAsInteger(10, rightPriority); return leftPriority < rightPriority; }); }
static std::string fixupWithStyle(StringRef Name, const IdentifierNamingCheck::NamingStyle &Style) { if (Name.find('_') != StringRef::npos && Name.startswith(Style.Prefix)) Name = Name.drop_front(Style.Prefix.size()); const std::string Fixed = fixupWithCase( Name, Style.Case.getValueOr(IdentifierNamingCheck::CaseType::CT_AnyCase)); StringRef Mid = StringRef(Fixed).trim("_"); if (Mid.empty()) Mid = "_"; return (Style.Prefix + Mid + Style.Suffix).str(); }
void swift::trimLeadingWhitespaceFromLines(StringRef RawText, unsigned WhitespaceToTrim, SmallVectorImpl<StringRef> &OutLines) { SmallVector<StringRef, 8> Lines; bool IsFirstLine = true; while (!RawText.empty()) { size_t Pos = RawText.find_first_of("\n\r"); if (Pos == StringRef::npos) Pos = RawText.size(); StringRef Line = RawText.substr(0, Pos); Lines.push_back(Line); if (!IsFirstLine) { size_t NonWhitespacePos = RawText.find_first_not_of(' '); if (NonWhitespacePos != StringRef::npos) WhitespaceToTrim = std::min(WhitespaceToTrim, static_cast<unsigned>(NonWhitespacePos)); } IsFirstLine = false; RawText = RawText.drop_front(Pos); unsigned NewlineBytes = measureNewline(RawText); RawText = RawText.drop_front(NewlineBytes); } IsFirstLine = true; for (auto &Line : Lines) { if (!IsFirstLine) { Line = Line.drop_front(WhitespaceToTrim); } IsFirstLine = false; } OutLines.append(Lines.begin(), Lines.end()); }
Error loadNaiveFormatLog(StringRef Data, XRayFileHeader &FileHeader, std::vector<XRayRecord> &Records) { // Check that there is at least a header if (Data.size() < 32) return make_error<StringError>( "Not enough bytes for an XRay log.", std::make_error_code(std::errc::invalid_argument)); if (Data.size() - 32 == 0 || Data.size() % 32 != 0) return make_error<StringError>( "Invalid-sized XRay data.", std::make_error_code(std::errc::invalid_argument)); if (auto E = readBinaryFormatHeader(Data, FileHeader)) return E; // Each record after the header will be 32 bytes, in the following format: // // (2) uint16 : record type // (1) uint8 : cpu id // (1) uint8 : type // (4) sint32 : function id // (8) uint64 : tsc // (4) uint32 : thread id // (12) - : padding for (auto S = Data.drop_front(32); !S.empty(); S = S.drop_front(32)) { DataExtractor RecordExtractor(S, true, 8); uint32_t OffsetPtr = 0; Records.emplace_back(); auto &Record = Records.back(); Record.RecordType = RecordExtractor.getU16(&OffsetPtr); Record.CPU = RecordExtractor.getU8(&OffsetPtr); auto Type = RecordExtractor.getU8(&OffsetPtr); switch (Type) { case 0: Record.Type = RecordTypes::ENTER; break; case 1: Record.Type = RecordTypes::EXIT; break; default: return make_error<StringError>( Twine("Unknown record type '") + Twine(int{Type}) + "'", std::make_error_code(std::errc::executable_format_error)); } Record.FuncId = RecordExtractor.getSigned(&OffsetPtr, sizeof(int32_t)); Record.TSC = RecordExtractor.getU64(&OffsetPtr); Record.TId = RecordExtractor.getU32(&OffsetPtr); } return Error::success(); }
void printSymbolVersionDependency(ArrayRef<uint8_t> Contents, StringRef StrTab) { outs() << "Version References:\n"; const uint8_t *Buf = Contents.data(); while (Buf) { auto *Verneed = reinterpret_cast<const typename ELFT::Verneed *>(Buf); outs() << " required from " << StringRef(StrTab.drop_front(Verneed->vn_file).data()) << ":\n"; const uint8_t *BufAux = Buf + Verneed->vn_aux; while (BufAux) { auto *Vernaux = reinterpret_cast<const typename ELFT::Vernaux *>(BufAux); outs() << " " << format("0x%08" PRIx32 " ", (uint32_t)Vernaux->vna_hash) << format("0x%02" PRIx16 " ", (uint16_t)Vernaux->vna_flags) << format("%02" PRIu16 " ", (uint16_t)Vernaux->vna_other) << StringRef(StrTab.drop_front(Vernaux->vna_name).data()) << '\n'; BufAux = Vernaux->vna_next ? BufAux + Vernaux->vna_next : nullptr; } Buf = Verneed->vn_next ? Buf + Verneed->vn_next : nullptr; } }
std::unique_ptr<Acceptor> Acceptor::Create(StringRef name, const bool child_processes_inherit, Error &error) { error.Clear(); Socket::SocketProtocol socket_protocol = Socket::ProtocolUnixDomain; int port; std::string scheme, host, path; // Try to match socket name as URL - e.g., tcp://localhost:5555 if (UriParser::Parse(name.str(), scheme, host, port, path)) { if (!FindProtocolByScheme(scheme.c_str(), socket_protocol)) error.SetErrorStringWithFormat("Unknown protocol scheme \"%s\"", scheme.c_str()); else name = name.drop_front(scheme.size() + strlen("://")); } else { std::string host_str; std::string port_str; int32_t port = INT32_MIN; // Try to match socket name as $host:port - e.g., localhost:5555 if (Socket::DecodeHostAndPort(name, host_str, port_str, port, nullptr)) socket_protocol = Socket::ProtocolTcp; } if (error.Fail()) return std::unique_ptr<Acceptor>(); std::unique_ptr<Socket> listener_socket_up = Socket::Create(socket_protocol, child_processes_inherit, error); LocalSocketIdFunc local_socket_id; if (error.Success()) { if (listener_socket_up->GetSocketProtocol() == Socket::ProtocolTcp) { TCPSocket *tcp_socket = static_cast<TCPSocket *>(listener_socket_up.get()); local_socket_id = [tcp_socket]() { auto local_port = tcp_socket->GetLocalPortNumber(); return (local_port != 0) ? llvm::to_string(local_port) : ""; }; } else { const std::string socket_name = name; local_socket_id = [socket_name]() { return socket_name; }; } return std::unique_ptr<Acceptor>( new Acceptor(std::move(listener_socket_up), name, local_socket_id)); } return std::unique_ptr<Acceptor>(); }
static UTF32 chopOneUTF32(StringRef &Buffer) { UTF32 C; const UTF8 *const Begin8Const = reinterpret_cast<const UTF8 *>(Buffer.begin()); const UTF8 *Begin8 = Begin8Const; UTF32 *Begin32 = &C; // In lenient mode we will always end up with a "reasonable" value in C for // non-empty input. assert(!Buffer.empty()); ConvertUTF8toUTF32(&Begin8, reinterpret_cast<const UTF8 *>(Buffer.end()), &Begin32, &C + 1, lenientConversion); Buffer = Buffer.drop_front(Begin8 - Begin8Const); return C; }