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 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]); } }
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()); }
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; }
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(); }
bool CapturedDiagList::hasDiagnostic(llvm::ArrayRef<unsigned> IDs, SourceRange range) const { if (range.isInvalid()) return false; ListTy::const_iterator I = List.begin(); while (I != List.end()) { FullSourceLoc diagLoc = I->getLocation(); if ((IDs.empty() || // empty means any diagnostic in the range. std::find(IDs.begin(), IDs.end(), I->getID()) != IDs.end()) && !diagLoc.isBeforeInTranslationUnitThan(range.getBegin()) && (diagLoc == range.getEnd() || diagLoc.isBeforeInTranslationUnitThan(range.getEnd()))) { return true; } ++I; } return false; }
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; } } }
// 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; }
unsigned GenericParamKey::findIndexIn( llvm::ArrayRef<GenericTypeParamType *> genericParams) const { // For depth 0, we have random access. We perform the extra checking so that // we can return if (Depth == 0 && Index < genericParams.size() && genericParams[Index] == *this) return Index; // At other depths, perform a binary search. unsigned result = std::lower_bound(genericParams.begin(), genericParams.end(), *this, Ordering()) - genericParams.begin(); if (result < genericParams.size() && genericParams[result] == *this) return result; // We didn't find the parameter we were looking for. return genericParams.size(); }
bool ABISysV_mips::PrepareTrivialCall (Thread &thread, addr_t sp, addr_t func_addr, addr_t return_addr, llvm::ArrayRef<addr_t> args) const { Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); if (log) { StreamString s; s.Printf("ABISysV_mips::PrepareTrivialCall (tid = 0x%" PRIx64 ", sp = 0x%" PRIx64 ", func_addr = 0x%" PRIx64 ", return_addr = 0x%" PRIx64, thread.GetID(), (uint64_t)sp, (uint64_t)func_addr, (uint64_t)return_addr); for (size_t i = 0; i < args.size(); ++i) s.Printf (", arg%zd = 0x%" PRIx64, i + 1, args[i]); s.PutCString (")"); log->PutCString(s.GetString().c_str()); } RegisterContext *reg_ctx = thread.GetRegisterContext().get(); if (!reg_ctx) return false; const RegisterInfo *reg_info = NULL; RegisterValue reg_value; // Argument registers const char *reg_names[] = { "r4", "r5", "r6", "r7" }; llvm::ArrayRef<addr_t>::iterator ai = args.begin(), ae = args.end(); // Write arguments to registers for (size_t i = 0; i < llvm::array_lengthof(reg_names); ++i) { if (ai == ae) break; reg_info = reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + i); if (log) log->Printf("About to write arg%zd (0x%" PRIx64 ") into %s", i + 1, args[i], reg_info->name); if (!reg_ctx->WriteRegisterFromUnsigned(reg_info, args[i])) return false; ++ai; } // If we have more than 4 arguments --Spill onto the stack if (ai != ae) { // No of arguments to go on stack size_t num_stack_regs = args.size(); // Allocate needed space for args on the stack sp -= (num_stack_regs * 4); // Keep the stack 8 byte aligned sp &= ~(8ull-1ull); // just using arg1 to get the right size const RegisterInfo *reg_info = reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1); addr_t arg_pos = sp+16; size_t i = 4; for (; ai != ae; ++ai) { reg_value.SetUInt32(*ai); if (log) log->Printf("About to write arg%zd (0x%" PRIx64 ") at 0x%" PRIx64 "", i+1, args[i], arg_pos); if (reg_ctx->WriteRegisterValueToMemory(reg_info, arg_pos, reg_info->byte_size, reg_value).Fail()) return false; arg_pos += reg_info->byte_size; i++; } } Error error; const RegisterInfo *pc_reg_info = reg_ctx->GetRegisterInfo (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC); const RegisterInfo *sp_reg_info = reg_ctx->GetRegisterInfo (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP); const RegisterInfo *ra_reg_info = reg_ctx->GetRegisterInfo (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_RA); if (log) log->Printf("Writing SP: 0x%" PRIx64, (uint64_t)sp); // Set "sp" to the requested value if (!reg_ctx->WriteRegisterFromUnsigned (sp_reg_info, sp)) return false; if (log) log->Printf("Writing RA: 0x%" PRIx64, (uint64_t)return_addr); // Set "ra" to the return address if (!reg_ctx->WriteRegisterFromUnsigned (ra_reg_info, return_addr)) return false; if (log) log->Printf("Writing PC: 0x%" PRIx64, (uint64_t)func_addr); // Set pc to the address of the called function. if (!reg_ctx->WriteRegisterFromUnsigned (pc_reg_info, func_addr)) return false; return true; }
bool ABIMacOSX_arm::PrepareTrivialCall (Thread &thread, addr_t sp, addr_t function_addr, addr_t return_addr, llvm::ArrayRef<addr_t> args) const { RegisterContext *reg_ctx = thread.GetRegisterContext().get(); if (!reg_ctx) return false; const uint32_t pc_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC); const uint32_t sp_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP); const uint32_t ra_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_RA); RegisterValue reg_value; const char *reg_names[] = { "r0", "r1", "r2", "r3" }; llvm::ArrayRef<addr_t>::iterator ai = args.begin(), ae = args.end(); for (size_t i = 0; i < llvm::array_lengthof(reg_names); ++i) { if (ai == ae) break; reg_value.SetUInt32(*ai); if (!reg_ctx->WriteRegister(reg_ctx->GetRegisterInfoByName(reg_names[i]), reg_value)) return false; ++ai; } if (ai != ae) { // Spill onto the stack size_t num_stack_regs = ae - ai; sp -= (num_stack_regs * 4); // Keep the stack 8 byte aligned, not that we need to sp &= ~(8ull-1ull); // just using arg1 to get the right size const RegisterInfo *reg_info = reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1); addr_t arg_pos = sp; for (; ai != ae; ++ai) { reg_value.SetUInt32(*ai); if (reg_ctx->WriteRegisterValueToMemory(reg_info, arg_pos, reg_info->byte_size, reg_value).Fail()) return false; arg_pos += reg_info->byte_size; } } TargetSP target_sp (thread.CalculateTarget()); Address so_addr; // Figure out if our return address is ARM or Thumb by using the // Address::GetCallableLoadAddress(Target*) which will figure out the ARM // thumb-ness and set the correct address bits for us. so_addr.SetLoadAddress (return_addr, target_sp.get()); return_addr = so_addr.GetCallableLoadAddress (target_sp.get()); // Set "lr" to the return address if (!reg_ctx->WriteRegisterFromUnsigned (ra_reg_num, return_addr)) return false; // Set "sp" to the requested value if (!reg_ctx->WriteRegisterFromUnsigned (sp_reg_num, sp)) return false; // If bit zero or 1 is set, this must be a thumb function, no need to figure // this out from the symbols. so_addr.SetLoadAddress (function_addr, target_sp.get()); function_addr = so_addr.GetCallableLoadAddress (target_sp.get()); const RegisterInfo *cpsr_reg_info = reg_ctx->GetRegisterInfoByName("cpsr"); const uint32_t curr_cpsr = reg_ctx->ReadRegisterAsUnsigned(cpsr_reg_info, 0); // Make a new CPSR and mask out any Thumb IT (if/then) bits uint32_t new_cpsr = curr_cpsr & ~MASK_CPSR_IT_MASK; // If bit zero or 1 is set, this must be thumb... if (function_addr & 1ull) new_cpsr |= MASK_CPSR_T; // Set T bit in CPSR else new_cpsr &= ~MASK_CPSR_T; // Clear T bit in CPSR if (new_cpsr != curr_cpsr) { if (!reg_ctx->WriteRegisterFromUnsigned (cpsr_reg_info, new_cpsr)) return false; } function_addr &= ~1ull; // clear bit zero since the CPSR will take care of the mode for us // Set "pc" to the address requested if (!reg_ctx->WriteRegisterFromUnsigned (pc_reg_num, function_addr)) return false; return true; }