bool CapturedDiagList::clearDiagnostic(llvm::ArrayRef<unsigned> IDs,
SourceRange range) {
if (range.isInvalid())
return false;
bool cleared = false;
ListTy::iterator I = List.begin();
while (I != List.end()) {
FullSourceLoc diagLoc = I->getLocation();
if ((IDs.empty() || // empty means clear all diagnostics in the range.
std::find(IDs.begin(), IDs.end(), I->getID()) != IDs.end()) &&
!diagLoc.isBeforeInTranslationUnitThan(range.getBegin()) &&
(diagLoc == range.getEnd() ||
diagLoc.isBeforeInTranslationUnitThan(range.getEnd()))) {
cleared = true;
ListTy::iterator eraseS = I++;
while (I != List.end() && I->getLevel() == Diagnostic::Note)
++I;
// Clear the diagnostic and any notes following it.
List.erase(eraseS, I);
continue;
}
++I;
}
return cleared;
}
void
PythonBytes::SetBytes(llvm::ArrayRef<uint8_t> bytes)
{
const char *data = reinterpret_cast<const char *>(bytes.data());
PyObject *py_bytes = PyBytes_FromStringAndSize(data, bytes.size());
PythonObject::Reset(PyRefType::Owned, py_bytes);
}
// Minidump string
llvm::Optional<std::string>
lldb_private::minidump::parseMinidumpString(llvm::ArrayRef<uint8_t> &data) {
std::string result;
const uint32_t *source_length;
Status error = consumeObject(data, source_length);
if (error.Fail() || *source_length > data.size() || *source_length % 2 != 0)
return llvm::None;
auto source_start = reinterpret_cast<const llvm::UTF16 *>(data.data());
// source_length is the length of the string in bytes
// we need the length of the string in UTF-16 characters/code points (16 bits
// per char)
// that's why it's divided by 2
const auto source_end = source_start + (*source_length) / 2;
// resize to worst case length
result.resize(UNI_MAX_UTF8_BYTES_PER_CODE_POINT * (*source_length) / 2);
auto result_start = reinterpret_cast<llvm::UTF8 *>(&result[0]);
const auto result_end = result_start + result.size();
llvm::ConvertUTF16toUTF8(&source_start, source_end, &result_start, result_end,
llvm::strictConversion);
const auto result_size =
std::distance(reinterpret_cast<llvm::UTF8 *>(&result[0]), result_start);
result.resize(result_size); // shrink to actual length
return result;
}
NullptrFixer::NullptrFixer(unsigned &AcceptedChanges,
llvm::ArrayRef<llvm::StringRef> UserMacros,
Transform &Owner)
: AcceptedChanges(AcceptedChanges), Owner(Owner) {
UserNullMacros.insert(UserNullMacros.begin(), UserMacros.begin(),
UserMacros.end());
UserNullMacros.insert(UserNullMacros.begin(), llvm::StringRef(NullMacroName));
}
UnknownSyntax
SyntaxFactory::makeUnknownSyntax(llvm::ArrayRef<RC<TokenSyntax>> Tokens) {
RawSyntax::LayoutList Layout;
std::copy(Tokens.begin(), Tokens.end(), std::back_inserter(Layout));
auto Raw = RawSyntax::make(SyntaxKind::Unknown, Layout,
SourcePresence::Present);
auto Data = UnknownSyntaxData::make(Raw);
return { Data, Data.get() };
}
// Returns qualified names of symbols with any of IDs in the index.
std::vector<std::string> lookup(const SymbolIndex &I,
llvm::ArrayRef<SymbolID> IDs) {
LookupRequest Req;
Req.IDs.insert(IDs.begin(), IDs.end());
std::vector<std::string> Results;
I.lookup(Req, [&](const Symbol &Sym) {
Results.push_back(getQualifiedName(Sym));
});
return Results;
}
void printNameList(llvm::raw_ostream &out, llvm::ArrayRef<ObjectPtr> x, llvm::ArrayRef<unsigned> dispatchIndices)
{
for (size_t i = 0; i < x.size(); ++i) {
if (i != 0)
out << ", ";
if (find(dispatchIndices.begin(), dispatchIndices.end(), i) != dispatchIndices.end())
out << "*";
printName(out, x[i]);
}
}
llvm::ArrayRef<MinidumpThread>
MinidumpThread::ParseThreadList(llvm::ArrayRef<uint8_t> &data) {
const llvm::support::ulittle32_t *thread_count;
Status error = consumeObject(data, thread_count);
if (error.Fail() || *thread_count * sizeof(MinidumpThread) > data.size())
return {};
return llvm::ArrayRef<MinidumpThread>(
reinterpret_cast<const MinidumpThread *>(data.data()), *thread_count);
}
int llvm::libDriverMain(llvm::ArrayRef<const char*> ArgsArr) {
SmallVector<const char *, 20> NewArgs(ArgsArr.begin(), ArgsArr.end());
BumpPtrAllocator Alloc;
BumpPtrStringSaver Saver(Alloc);
cl::ExpandResponseFiles(Saver, cl::TokenizeWindowsCommandLine, NewArgs);
ArgsArr = NewArgs;
LibOptTable Table;
unsigned MissingIndex;
unsigned MissingCount;
llvm::opt::InputArgList Args =
Table.ParseArgs(ArgsArr.slice(1), MissingIndex, MissingCount);
if (MissingCount) {
llvm::errs() << "missing arg value for \""
<< Args.getArgString(MissingIndex) << "\", expected "
<< MissingCount
<< (MissingCount == 1 ? " argument.\n" : " arguments.\n");
return 1;
}
for (auto *Arg : Args.filtered(OPT_UNKNOWN))
llvm::errs() << "ignoring unknown argument: " << Arg->getSpelling() << "\n";
if (Args.filtered_begin(OPT_INPUT) == Args.filtered_end()) {
llvm::errs() << "no input files.\n";
return 1;
}
std::vector<StringRef> SearchPaths = getSearchPaths(&Args, Saver);
std::vector<llvm::NewArchiveIterator> Members;
for (auto *Arg : Args.filtered(OPT_INPUT)) {
Optional<std::string> Path = findInputFile(Arg->getValue(), SearchPaths);
if (!Path.hasValue()) {
llvm::errs() << Arg->getValue() << ": no such file or directory\n";
return 1;
}
Members.emplace_back(Saver.save(*Path),
llvm::sys::path::filename(Arg->getValue()));
}
std::pair<StringRef, std::error_code> Result =
llvm::writeArchive(getOutputPath(&Args, Members[0]), Members,
/*WriteSymtab=*/true, object::Archive::K_GNU,
/*Deterministic*/ true, /*Thin*/ false);
if (Result.second) {
if (Result.first.empty())
Result.first = ArgsArr[0];
llvm::errs() << Result.first << ": " << Result.second.message() << "\n";
return 1;
}
return 0;
}
void emitWarning(const char* warning_msg,
llvm::ArrayRef<llvm::Value*> extra_args,
Compiler* compiler)
{
std::vector<llvm::Value*> args;
args.push_back(compiler->emitConstantPointer(warning_msg));
args.insert(args.end(), extra_args.begin(), extra_args.end());
Function* warning = getDeclaration("Rf_warning", compiler);
compiler->emitCallOrInvoke(warning, args);
}
void emitError(const char* error_msg, llvm::ArrayRef<llvm::Value*> extra_args,
Compiler* compiler)
{
std::vector<llvm::Value*> args;
args.push_back(compiler->emitConstantPointer(error_msg));
args.insert(args.end(), extra_args.begin(), extra_args.end());
Function* error = getDeclaration("Rf_error", compiler);
compiler->emitCallOrInvoke(error, args);
compiler->CreateUnreachable();
}
llvm::ArrayRef<MinidumpModule>
MinidumpModule::ParseModuleList(llvm::ArrayRef<uint8_t> &data) {
const llvm::support::ulittle32_t *modules_count;
Status error = consumeObject(data, modules_count);
if (error.Fail() || *modules_count * sizeof(MinidumpModule) > data.size())
return {};
return llvm::ArrayRef<MinidumpModule>(
reinterpret_cast<const MinidumpModule *>(data.data()), *modules_count);
}
llvm::ArrayRef<MinidumpMemoryDescriptor>
MinidumpMemoryDescriptor::ParseMemoryList(llvm::ArrayRef<uint8_t> &data) {
const llvm::support::ulittle32_t *mem_ranges_count;
Status error = consumeObject(data, mem_ranges_count);
if (error.Fail() ||
*mem_ranges_count * sizeof(MinidumpMemoryDescriptor) > data.size())
return {};
return llvm::makeArrayRef(
reinterpret_cast<const MinidumpMemoryDescriptor *>(data.data()),
*mem_ranges_count);
}
static void loadImports(llvm::ArrayRef<ImportPtr> imports)
{
for (size_t i = 0; i < imports.size(); ++i) {
module->imports.push_back(imports[i]);
}
for (size_t i = 0; i < imports.size(); ++i) {
loadDependent(module, NULL, imports[i], false);
}
for (size_t i = 0; i < imports.size(); ++i) {
initModule(imports[i]->module);
}
}
static void jitTopLevel(llvm::ArrayRef<TopLevelItemPtr> toplevels)
{
if (toplevels.empty()) {
return;
}
if (printAST) {
for (size_t i = 0; i < toplevels.size(); ++i) {
llvm::errs() << i << ": " << toplevels[i] << "\n";
}
}
addGlobals(module, toplevels);
}
void addGlobals(ModulePtr m, llvm::ArrayRef<TopLevelItemPtr> toplevels) {
TopLevelItemPtr const *i, *end;
for (i = toplevels.begin(), end = toplevels.end();
i != end; ++i) {
m->topLevelItems.push_back(*i);
TopLevelItem *x = i->ptr();
x->env = m->env;
switch (x->objKind) {
case ENUM_DECL : {
EnumDecl *enumer = (EnumDecl *)x;
TypePtr t = enumType(enumer);
addGlobal(m, enumer->name, enumer->visibility, t.ptr());
for (unsigned i = 0 ; i < enumer->members.size(); ++i) {
EnumMember *member = enumer->members[i].ptr();
member->index = (int)i;
member->type = t;
addGlobal(m, member->name, enumer->visibility, member);
}
break;
}
case PROCEDURE : {
Procedure *proc = (Procedure *)x;
if (proc->interface != NULL)
proc->interface->env = m->env;
// fallthrough
}
default :
if (x->name.ptr())
addGlobal(m, x->name, x->visibility, x);
break;
}
}
llvm::ArrayRef<TopLevelItemPtr> items = m->topLevelItems;
for (size_t i = items.size() - toplevels.size(); i < items.size(); ++i) {
Object *obj = items[i].ptr();
switch (obj->objKind) {
case OVERLOAD :
initOverload((Overload *)obj);
break;
case INSTANCE_DECL :
initVariantInstance((InstanceDecl *)obj);
break;
case STATIC_ASSERT_TOP_LEVEL:
checkStaticAssert((StaticAssertTopLevel *)obj);
break;
default:
break;
}
}
}
static void DumpDWARFExpr(Stream &s, llvm::ArrayRef<uint8_t> expr, Thread *thread) {
if (auto order_and_width = GetByteOrderAndAddrSize(thread)) {
DataExtractor extractor(expr.data(), expr.size(), order_and_width->first,
order_and_width->second);
if (!DWARFExpression::PrintDWARFExpression(s, extractor,
order_and_width->second,
/*dwarf_ref_size*/ 4,
/*location_expression*/ false))
s.PutCString("invalid-dwarf-expr");
} else
s.PutCString("dwarf-expr");
}
static void circularImportsError(llvm::ArrayRef<string> modules) {
string s;
llvm::raw_string_ostream ss(s);
ss << "import loop:\n";
for (string const *it = modules.begin(); it != modules.end(); ++it) {
ss << " " << *it;
if (it + 1 != modules.end()) {
// because error() function adds trailing newline
ss << "\n";
}
}
return error(ss.str());
}
/// \brief Write a block of data, and get the offset that it starts at.
/// \param Bytes the array of bytes to be written.
/// \return the offset that this block was written at.
///
offset_uint write(llvm::ArrayRef<char> Bytes) {
// If the stream doesn't exist, silently ignore the write request.
if (!Out)
return noOffset();
auto const Size = Bytes.size();
Out->write(Bytes.data(), Size);
// Update the current offset and return the original value.
auto const WrittenAt = Offset;
Offset += Size;
return WrittenAt;
}
static bool matchTempness(CodePtr code,
llvm::ArrayRef<ValueTempness> argsTempness,
bool callByName,
vector<ValueTempness> &tempnessKey,
vector<uint8_t> &forwardedRValueFlags)
{
llvm::ArrayRef<FormalArgPtr> fargs = code->formalArgs;
if (code->hasVarArg)
assert(fargs.size()-1 <= argsTempness.size());
else
assert(fargs.size() == argsTempness.size());
tempnessKey.clear();
forwardedRValueFlags.clear();
unsigned varArgSize = argsTempness.size()-fargs.size()+1;
for (unsigned i = 0, j = 0; i < fargs.size(); ++i) {
if (callByName && (fargs[i]->tempness == TEMPNESS_FORWARD)) {
error(fargs[i], "forwarded arguments are not allowed "
"in call-by-name procedures");
}
if (fargs[i]->varArg) {
for (; j < varArgSize; ++j) {
if (!tempnessMatches(argsTempness[i+j], fargs[i]->tempness))
return false;
tempnessKey.push_back(
tempnessKeyItem(fargs[i]->tempness,
argsTempness[i+j]));
bool forwardedRValue =
(fargs[i]->tempness == TEMPNESS_FORWARD) &&
(argsTempness[i+j] == TEMPNESS_RVALUE);
forwardedRValueFlags.push_back(forwardedRValue);
}
--j;
} else {
if (!tempnessMatches(argsTempness[i+j], fargs[i]->tempness))
return false;
tempnessKey.push_back(
tempnessKeyItem(fargs[i]->tempness,
argsTempness[i+j]));
bool forwardedRValue =
(fargs[i]->tempness == TEMPNESS_FORWARD) &&
(argsTempness[i+j] == TEMPNESS_RVALUE);
forwardedRValueFlags.push_back(forwardedRValue);
}
}
return true;
}
void flatten(llvm::ArrayRef<AST_stmt*> roots, std::vector<AST*>& output, bool expand_scopes) {
FlattenVisitor visitor(&output, expand_scopes);
for (int i = 0; i < roots.size(); i++) {
roots[i]->accept(&visitor);
}
}
void getProcedureMonoTypes(ProcedureMono &mono, EnvPtr env,
llvm::ArrayRef<FormalArgPtr> formalArgs, bool hasVarArg)
{
if (mono.monoState == Procedure_NoOverloads && !hasVarArg)
{
assert(mono.monoTypes.empty());
mono.monoState = Procedure_MonoOverload;
for (size_t i = 0; i < formalArgs.size(); ++i) {
if (formalArgs[i]->type == NULL)
goto poly;
LocationContext loc(formalArgs[i]->type->location);
PatternPtr argPattern =
evaluateOnePattern(formalArgs[i]->type, env);
ObjectPtr argTypeObj = derefDeep(argPattern);
if (argTypeObj == NULL)
goto poly;
TypePtr argType;
if (!staticToType(argTypeObj, argType))
error(formalArgs[i], "expecting a type");
mono.monoTypes.push_back(argType);
}
} else
goto poly;
return;
poly:
mono.monoTypes.clear();
mono.monoState = Procedure_PolyOverload;
return;
}
bool TestClient::SetInferior(llvm::ArrayRef<std::string> inferior_args) {
std::stringstream command;
command << "A";
for (size_t i = 0; i < inferior_args.size(); i++) {
if (i > 0)
command << ',';
std::string hex_encoded = toHex(inferior_args[i]);
command << hex_encoded.size() << ',' << i << ',' << hex_encoded;
}
if (!SendMessage(command.str()))
return false;
if (!SendMessage("qLaunchSuccess"))
return false;
std::string response;
if (!SendMessage("qProcessInfo", response))
return false;
auto create_or_error = ProcessInfo::Create(response);
if (auto create_error = create_or_error.takeError()) {
GTEST_LOG_(ERROR) << toString(std::move(create_error));
return false;
}
m_process_info = *create_or_error;
return true;
}
static void constructCompileCommands(
CompileCommandPairs &compileCommands,
const clang::tooling::CompilationDatabase &compilationDatabase,
llvm::ArrayRef<std::string> sourcePaths)
{
for (unsigned pathIndex = 0, pathEnd = sourcePaths.size(); pathIndex != pathEnd; pathIndex++)
{
llvm::SmallString<1024> filePath(clang::tooling::getAbsolutePath(sourcePaths[pathIndex]));
std::vector<clang::tooling::CompileCommand> compileCmdsForFile =
compilationDatabase.getCompileCommands(filePath.str());
if (!compileCmdsForFile.empty())
{
for (int commandsIndex = 0, commandsEnd = compileCmdsForFile.size();
commandsIndex != commandsEnd; commandsIndex++)
{
compileCommands.push_back(
std::make_pair(filePath.str(), compileCmdsForFile[commandsIndex]));
}
}
/* - this needs to be collected and the gathered information will be printed eventually
- not here
else
{
DEBUG({
llvm::dbgs() << "Skipping " << filePath << ". Command line not found.\n";
});
}
*/
}
}
static void jitStatements(llvm::ArrayRef<StatementPtr> statements)
{
if (statements.empty()) {
return;
}
if (printAST) {
for (size_t i = 0; i < statements.size(); ++i) {
llvm::errs() << statements[i] << "\n";
}
}
IdentifierPtr fun = Identifier::get(newFunctionName());
BlockPtr funBody = new Block(statements);
ExternalProcedurePtr entryProc =
new ExternalProcedure(NULL,
fun,
PRIVATE,
vector<ExternalArgPtr>(),
false,
NULL,
funBody.ptr(),
new ExprList());
entryProc->env = module->env;
codegenBeforeRepl(module);
try {
codegenExternalProcedure(entryProc, true);
}
catch (std::exception) {
return;
}
llvm::Function* ctor;
llvm::Function* dtor;
codegenAfterRepl(ctor, dtor);
engine->runFunction(ctor, std::vector<llvm::GenericValue>());
void* dtorLlvmFun = engine->getPointerToFunction(dtor);
typedef void (*PFN)();
atexit((PFN)(uintptr_t)dtorLlvmFun);
engine->runFunction(entryProc->llvmFunc, std::vector<llvm::GenericValue>());
}
void printNameList(llvm::raw_ostream &out, llvm::ArrayRef<ObjectPtr> x)
{
for (unsigned i = 0; i < x.size(); ++i) {
if (i != 0)
out << ", ";
printName(out, x[i]);
}
}
// Some interfaces to LLVM builder require unsigned indices instead of a vector.
// i.e. llvm::IRBuilder::CreateExtractValue()
// This method will do the conversion and inform the caller if not every element was
// a constant integer.
bool ConvertValuesToUnsigned(unsigned* indices, int &count, llvm::ArrayRef<llvm::Value*> chain)
{
llvm::ArrayRef<llvm::Value*>::iterator start = chain.begin();
for (count = 0; start != chain.end(); ++start, ++count) {
if (llvm::Constant* constant = llvm::dyn_cast<llvm::Constant>(*start)) {
if (llvm::ConstantInt *constantInt = llvm::dyn_cast<llvm::ConstantInt>(constant))
indices[count] = constantInt->getValue().getSExtValue();
else
return false;
} else {
return false;
}
}
return true;
}
void printNameList(llvm::raw_ostream &out, llvm::ArrayRef<TypePtr> x)
{
for (size_t i = 0; i < x.size(); ++i) {
if (i != 0)
out << ", ";
printName(out, x[i].ptr());
}
}
void writeRefs(const SymbolID &ID, llvm::ArrayRef<Ref> Refs,
const StringTableOut &Strings, llvm::raw_ostream &OS) {
OS << ID.raw();
writeVar(Refs.size(), OS);
for (const auto &Ref : Refs) {
OS.write(static_cast<unsigned char>(Ref.Kind));
writeLocation(Ref.Location, Strings, OS);
}
}
std::pair<llvm::ArrayRef<MinidumpMemoryDescriptor64>, uint64_t>
MinidumpMemoryDescriptor64::ParseMemory64List(llvm::ArrayRef<uint8_t> &data) {
const llvm::support::ulittle64_t *mem_ranges_count;
Status error = consumeObject(data, mem_ranges_count);
if (error.Fail() ||
*mem_ranges_count * sizeof(MinidumpMemoryDescriptor64) > data.size())
return {};
const llvm::support::ulittle64_t *base_rva;
error = consumeObject(data, base_rva);
if (error.Fail())
return {};
return std::make_pair(
llvm::makeArrayRef(
reinterpret_cast<const MinidumpMemoryDescriptor64 *>(data.data()),
*mem_ranges_count),
*base_rva);
}