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 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
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);
}
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";
});
}
*/
}
}
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);
}
}
// 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;
}
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]);
}
}
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);
}
}
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);
}
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]);
}
}
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();
}
// Linux Proc Status
// it's stored as an ascii string in the file
llvm::Optional<LinuxProcStatus>
LinuxProcStatus::Parse(llvm::ArrayRef<uint8_t> &data) {
LinuxProcStatus result;
result.proc_status =
llvm::StringRef(reinterpret_cast<const char *>(data.data()), data.size());
data = data.drop_front(data.size());
llvm::SmallVector<llvm::StringRef, 0> lines;
result.proc_status.split(lines, '\n', 42);
// /proc/$pid/status has 41 lines, but why not use 42?
for (auto line : lines) {
if (line.consume_front("Pid:")) {
line = line.trim();
if (!line.getAsInteger(10, result.pid))
return result;
}
}
return llvm::None;
}
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);
}
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");
}
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);
}
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 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);
}
/// \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 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>());
}
// Callback invoked when a #pragma warning directive is read.
void PPCallbacksTracker::PragmaWarning(clang::SourceLocation Loc,
llvm::StringRef WarningSpec,
llvm::ArrayRef<int> Ids) {
beginCallback("PragmaWarning");
appendArgument("Loc", Loc);
appendArgument("WarningSpec", WarningSpec);
std::string Str;
llvm::raw_string_ostream SS(Str);
SS << "[";
for (int i = 0, e = Ids.size(); i != e; ++i) {
if (i)
SS << ", ";
SS << Ids[i];
}
SS << "]";
appendArgument("Ids", SS.str());
}
static
MatchSuccessPtr findMatchingInvoke(llvm::ArrayRef<OverloadPtr> overloads,
unsigned &overloadIndex,
ObjectPtr callable,
llvm::ArrayRef<TypePtr> argsKey,
MatchFailureError &failures)
{
while (overloadIndex < overloads.size()) {
OverloadPtr x = overloads[overloadIndex++];
MatchResultPtr result = matchInvoke(x, callable, argsKey);
failures.failures.push_back(make_pair(x, result));
if (result->matchCode == MATCH_SUCCESS) {
MatchSuccess *y = (MatchSuccess *)result.ptr();
return y;
}
}
return NULL;
}
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);
}
void initializePatternEnv(EnvPtr patternEnv, llvm::ArrayRef<PatternVar> pvars,
vector<PatternCellPtr> &cells, vector<MultiPatternCellPtr> &multiCells)
{
for (size_t i = 0; i < pvars.size(); ++i) {
if (pvars[i].isMulti) {
MultiPatternCellPtr multiCell = new MultiPatternCell(NULL);
multiCells.push_back(multiCell);
cells.push_back(NULL);
addLocal(patternEnv, pvars[i].name, multiCell.ptr());
}
else {
PatternCellPtr cell = new PatternCell(NULL);
cells.push_back(cell);
multiCells.push_back(NULL);
addLocal(patternEnv, pvars[i].name, cell.ptr());
}
}
}
std::vector<const MinidumpMemoryInfo *>
MinidumpMemoryInfo::ParseMemoryInfoList(llvm::ArrayRef<uint8_t> &data) {
const MinidumpMemoryInfoListHeader *header;
Status error = consumeObject(data, header);
if (error.Fail() ||
header->size_of_header < sizeof(MinidumpMemoryInfoListHeader) ||
header->size_of_entry < sizeof(MinidumpMemoryInfo))
return {};
data = data.drop_front(header->size_of_header -
sizeof(MinidumpMemoryInfoListHeader));
if (header->size_of_entry * header->num_of_entries > data.size())
return {};
std::vector<const MinidumpMemoryInfo *> result;
for (uint64_t i = 0; i < header->num_of_entries; ++i) {
result.push_back(reinterpret_cast<const MinidumpMemoryInfo *>(
data.data() + i * header->size_of_entry));
}
return result;
}
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;
}
void clone(llvm::ArrayRef<CatchPtr> x, vector<CatchPtr> &out)
{
for (unsigned i = 0; i < x.size(); ++i)
out.push_back(clone(x[i]));
}
void clone(llvm::ArrayRef<IdentifierPtr> x, vector<IdentifierPtr> &out)
{
for (unsigned i = 0; i < x.size(); ++i)
out.push_back(x[i]);
}