void MetaSema::actOnICommand(llvm::StringRef path) const {
if (path.empty())
m_Interpreter.DumpIncludePath();
else
m_Interpreter.AddIncludePath(path.str());
}
PythonModule PythonModule::AddModule(llvm::StringRef module) {
std::string str = module.str();
return PythonModule(PyRefType::Borrowed, PyImport_AddModule(str.c_str()));
}
bool Breakpoint::AddName(llvm::StringRef new_name) {
m_name_list.insert(new_name.str().c_str());
return true;
}
static llvm::Optional<std::string> createOptionalString(const llvm::StringRef &value)
{
const std::string &string = value.str();
return string.size() ? llvm::Optional<std::string>(string) : llvm::Optional<std::string>();
}
static void verifyFormat(
llvm::StringRef Code,
const FormatStyle &Style = getGoogleStyle(FormatStyle::LK_JavaScript)) {
EXPECT_EQ(Code.str(), format(test::messUp(Code), Style));
}
ExecutionContext::ExecutionResult
ExecutionContext::executeFunction(llvm::StringRef funcname,
Interpreter& interp,
clang::QualType retType,
StoredValueRef* returnValue)
{
// Call a function without arguments, or with an SRet argument, see SRet below
// We don't care whether something was unresolved before.
m_unresolvedSymbols.clear();
llvm::Function* f = m_engine->FindFunctionNamed(funcname.str().c_str());
if (!f) {
llvm::errs() << "ExecutionContext::executeFunction: "
"could not find function named " << funcname << '\n';
return kExeFunctionNotCompiled;
}
m_engine->getPointerToFunction(f);
// check if there is any unresolved symbol in the list
if (!m_unresolvedSymbols.empty()) {
llvm::SmallVector<llvm::Function*, 100> funcsToFree;
for (std::set<std::string>::const_iterator i = m_unresolvedSymbols.begin(),
e = m_unresolvedSymbols.end(); i != e; ++i) {
llvm::errs() << "ExecutionContext::executeFunction: symbol '" << *i
<< "' unresolved while linking function '" << funcname
<< "'!\n";
llvm::Function *ff = m_engine->FindFunctionNamed(i->c_str());
// i could also reference a global variable, in which case ff == 0.
if (ff)
funcsToFree.push_back(ff);
}
freeCallersOfUnresolvedSymbols(funcsToFree, m_engine.get());
m_unresolvedSymbols.clear();
return kExeUnresolvedSymbols;
}
std::vector<llvm::GenericValue> args;
bool wantReturn = (returnValue);
StoredValueRef aggregateRet;
if (f->hasStructRetAttr()) {
// Function expects to receive the storage for the returned aggregate as
// first argument. Allocate returnValue:
aggregateRet = StoredValueRef::allocate(interp, retType,
f->getReturnType());
if (returnValue) {
*returnValue = aggregateRet;
} else {
returnValue = &aggregateRet;
}
args.push_back(returnValue->get().getGV());
// will get set as arg0, must not assign.
wantReturn = false;
}
if (wantReturn) {
llvm::GenericValue gvRet = m_engine->runFunction(f, args);
// rescue the ret value (which might be aggregate) from the stack
*returnValue = StoredValueRef::bitwiseCopy(interp, Value(gvRet, retType));
} else {
m_engine->runFunction(f, args);
}
return kExeSuccess;
}
ProtoBufExport::ProtoBufExport(std::FILE *file, llvm::StringRef const targetName, clang::CompilerInstance const &ci)
: outputFile(file), out(outputFile.get()), mapper(out, ci) {
ct::proto::Prelude prelude;
prelude.set_targetfile(targetName.str());
out.writeMessage<ct::proto::Prelude>(prelude);
}
ExecutionContext::ExecutionResult
ExecutionContext::executeFunction(llvm::StringRef funcname,
const clang::ASTContext& Ctx,
clang::QualType retType,
StoredValueRef* returnValue)
{
// Call a function without arguments, or with an SRet argument, see SRet below
if (!m_CxaAtExitRemapped) {
// Rewire atexit:
llvm::Function* atExit = m_engine->FindFunctionNamed("__cxa_atexit");
llvm::Function* clingAtExit
= m_engine->FindFunctionNamed("cling_cxa_atexit");
if (atExit && clingAtExit) {
void* clingAtExitAddr = m_engine->getPointerToFunction(clingAtExit);
assert(clingAtExitAddr && "cannot find cling_cxa_atexit");
m_engine->updateGlobalMapping(atExit, clingAtExitAddr);
m_CxaAtExitRemapped = true;
}
}
// We don't care whether something was unresolved before.
m_unresolvedSymbols.clear();
llvm::Function* f = m_engine->FindFunctionNamed(funcname.str().c_str());
if (!f) {
llvm::errs() << "ExecutionContext::executeFunction: "
"could not find function named " << funcname << '\n';
return kExeFunctionNotCompiled;
}
m_engine->getPointerToFunction(f);
// check if there is any unresolved symbol in the list
if (!m_unresolvedSymbols.empty()) {
llvm::SmallVector<llvm::Function*, 100> funcsToFree;
for (std::set<std::string>::const_iterator i = m_unresolvedSymbols.begin(),
e = m_unresolvedSymbols.end(); i != e; ++i) {
llvm::errs() << "ExecutionContext::executeFunction: symbol '" << *i
<< "' unresolved while linking function '" << funcname
<< "'!\n";
llvm::Function *ff = m_engine->FindFunctionNamed(i->c_str());
assert(ff && "cannot find function to free");
funcsToFree.push_back(ff);
}
freeCallersOfUnresolvedSymbols(funcsToFree, m_engine.get());
m_unresolvedSymbols.clear();
return kExeUnresolvedSymbols;
}
std::vector<llvm::GenericValue> args;
bool wantReturn = (returnValue);
StoredValueRef aggregateRet;
if (f->hasStructRetAttr()) {
// Function expects to receive the storage for the returned aggregate as
// first argument. Allocate returnValue:
aggregateRet = StoredValueRef::allocate(Ctx, retType, f->getReturnType());
if (returnValue) {
*returnValue = aggregateRet;
} else {
returnValue = &aggregateRet;
}
args.push_back(returnValue->get().getGV());
// will get set as arg0, must not assign.
wantReturn = false;
}
if (wantReturn) {
llvm::GenericValue gvRet = m_engine->runFunction(f, args);
// rescue the ret value (which might be aggregate) from the stack
*returnValue = StoredValueRef::bitwiseCopy(Ctx, Value(gvRet, retType));
} else {
m_engine->runFunction(f, args);
}
return kExeSuccess;
}
Interpreter::CompilationResult
MetaProcessor::readInputFromFile(llvm::StringRef filename,
Value* result,
bool ignoreOutmostBlock /*=false*/) {
{
// check that it's not binary:
std::ifstream in(filename.str().c_str(), std::ios::in | std::ios::binary);
char magic[1024] = {0};
in.read(magic, sizeof(magic));
size_t readMagic = in.gcount();
if (readMagic >= 4) {
llvm::StringRef magicStr(magic,in.gcount());
llvm::sys::fs::file_magic fileType
= llvm::sys::fs::identify_magic(magicStr);
if (fileType != llvm::sys::fs::file_magic::unknown) {
llvm::errs() << "Error in cling::MetaProcessor: "
"cannot read input from a binary file!\n";
return Interpreter::kFailure;
}
unsigned printable = 0;
for (size_t i = 0; i < readMagic; ++i)
if (isprint(magic[i]))
++printable;
if (10 * printable < 5 * readMagic) {
// 50% printable for ASCII files should be a safe guess.
llvm::errs() << "Error in cling::MetaProcessor: "
"cannot read input from a (likely) binary file!\n" << printable;
return Interpreter::kFailure;
}
}
}
std::ifstream in(filename.str().c_str());
in.seekg(0, std::ios::end);
size_t size = in.tellg();
std::string content(size, ' ');
in.seekg(0);
in.read(&content[0], size);
if (ignoreOutmostBlock && !content.empty()) {
static const char whitespace[] = " \t\r\n";
std::string::size_type posNonWS = content.find_first_not_of(whitespace);
// Handle comments before leading {
while (content[posNonWS] == '/' && content[posNonWS+1] == '/') {
// Remove the comment line
posNonWS = content.find_first_of('\n', posNonWS+2)+1;
}
std::string::size_type replaced = posNonWS;
if (posNonWS != std::string::npos) {
if (content[posNonWS] == '{') {
// hide the curly brace:
content[posNonWS] = ' ';
// and the matching closing '}'
posNonWS = content.find_last_not_of(whitespace);
if (posNonWS != std::string::npos) {
if (content[posNonWS] == ';' && content[posNonWS-1] == '}') {
content[posNonWS--] = ' '; // replace ';' and enter next if
}
if (content[posNonWS] == '}') {
content[posNonWS] = ' '; // replace '}'
} else {
std::string::size_type posComment = content.find_last_of('}');
if (content[posComment] == '}') {
content[posComment] = ' '; // replace '}'
}
posComment = content.find_first_not_of(whitespace, posComment);
if (content[posComment] == '/' && content[posComment+1] == '/') {
// More text (comments) are okay after the last '}', but
// we can not easily find it to remove it (so we need to upgrade
// this code to better handle the case with comments or
// preprocessor code before and after the leading { and
// trailing })
while (posComment <= posNonWS) {
content[posComment++] = ' '; // replace '}' and comment
}
} else {
content[replaced] = '{';
// By putting the '{' back, we keep the code as consistent as
// the user wrote it ... but we should still warn that we not
// goint to treat this file an unamed macro.
llvm::errs()
<< "Warning in cling::MetaProcessor: can not find the closing '}', "
<< llvm::sys::path::filename(filename)
<< " is not handled as an unamed script!\n";
} // did not find '}''
} // remove comments after the trailing '}'
} // find '}'
} // have '{'
} // have non-whitespace
} // ignore outmost block
std::string strFilename(filename.str());
m_CurrentlyExecutingFile = strFilename;
bool topmost = !m_TopExecutingFile.data();
if (topmost)
m_TopExecutingFile = m_CurrentlyExecutingFile;
Interpreter::CompilationResult ret;
// We don't want to value print the results of a unnamed macro.
content = "#line 2 \"" + filename.str() + "\" \n" + content;
if (process((content + ";").c_str(), ret, result)) {
// Input file has to be complete.
llvm::errs()
<< "Error in cling::MetaProcessor: file "
<< llvm::sys::path::filename(filename)
<< " is incomplete (missing parenthesis or similar)!\n";
ret = Interpreter::kFailure;
}
m_CurrentlyExecutingFile = llvm::StringRef();
if (topmost)
m_TopExecutingFile = llvm::StringRef();
return ret;
}
/// \brief Constructor.
FileInfo(llvm::StringRef Filename,
llvm::StringRef FileContents)
: Name(Filename.str()),
Contents(llvm::MemoryBuffer::getMemBuffer(FileContents, "", false))
{}
static void verifyFormat(
llvm::StringRef Code,
const FormatStyle &Style = getGoogleStyle(FormatStyle::LK_Java)) {
EXPECT_EQ(Code.str(), format(Code, Style)) << "Expected code is not stable";
EXPECT_EQ(Code.str(), format(test::messUp(Code), Style));
}
void verifyGoogleFormat(llvm::StringRef Code) {
EXPECT_EQ(Code.str(), format(messUp(Code), getGoogleStyle()));
}
// Append a string object argument to the top trace item.
void PPCallbacksTracker::appendArgument(const char *Name,
llvm::StringRef Value) {
appendArgument(Name, Value.str());
}
Status OptionGroupValueObjectDisplay::SetOptionValue(
uint32_t option_idx, llvm::StringRef option_arg,
ExecutionContext *execution_context) {
Status error;
const int short_option = g_option_table[option_idx].short_option;
bool success = false;
switch (short_option) {
case 'd': {
int32_t result;
result =
Args::StringToOptionEnum(option_arg, g_dynamic_value_types, 2, error);
if (error.Success())
use_dynamic = (lldb::DynamicValueType)result;
} break;
case 'T':
show_types = true;
break;
case 'L':
show_location = true;
break;
case 'F':
flat_output = true;
break;
case 'O':
use_objc = true;
break;
case 'R':
be_raw = true;
break;
case 'A':
ignore_cap = true;
break;
case 'D':
if (option_arg.getAsInteger(0, max_depth)) {
max_depth = UINT32_MAX;
error.SetErrorStringWithFormat("invalid max depth '%s'",
option_arg.str().c_str());
}
break;
case 'Z':
if (option_arg.getAsInteger(0, elem_count)) {
elem_count = UINT32_MAX;
error.SetErrorStringWithFormat("invalid element count '%s'",
option_arg.str().c_str());
}
break;
case 'P':
if (option_arg.getAsInteger(0, ptr_depth)) {
ptr_depth = 0;
error.SetErrorStringWithFormat("invalid pointer depth '%s'",
option_arg.str().c_str());
}
break;
case 'Y':
if (option_arg.empty())
no_summary_depth = 1;
else if (option_arg.getAsInteger(0, no_summary_depth)) {
no_summary_depth = 0;
error.SetErrorStringWithFormat("invalid pointer depth '%s'",
option_arg.str().c_str());
}
break;
case 'S':
use_synth = Args::StringToBoolean(option_arg, true, &success);
if (!success)
error.SetErrorStringWithFormat("invalid synthetic-type '%s'",
option_arg.str().c_str());
break;
case 'V':
run_validator = Args::StringToBoolean(option_arg, true, &success);
if (!success)
error.SetErrorStringWithFormat("invalid validate '%s'",
option_arg.str().c_str());
break;
default:
error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
break;
}
return error;
}
Error OptionValuePathMappings::SetValueFromString(llvm::StringRef value,
VarSetOperationType op) {
Error error;
Args args(value.str().c_str());
const size_t argc = args.GetArgumentCount();
switch (op) {
case eVarSetOperationClear:
Clear();
NotifyValueChanged();
break;
case eVarSetOperationReplace:
// Must be at least one index + 1 pair of paths, and the pair count must be
// even
if (argc >= 3 && (((argc - 1) & 1) == 0)) {
uint32_t idx =
StringConvert::ToUInt32(args.GetArgumentAtIndex(0), UINT32_MAX);
const uint32_t count = m_path_mappings.GetSize();
if (idx > count) {
error.SetErrorStringWithFormat(
"invalid file list index %u, index must be 0 through %u", idx,
count);
} else {
bool changed = false;
for (size_t i = 1; i < argc; i += 2, ++idx) {
const char *orginal_path = args.GetArgumentAtIndex(i);
const char *replace_path = args.GetArgumentAtIndex(i + 1);
if (VerifyPathExists(replace_path)) {
ConstString a(orginal_path);
ConstString b(replace_path);
if (!m_path_mappings.Replace(a, b, idx, m_notify_changes))
m_path_mappings.Append(a, b, m_notify_changes);
changed = true;
} else {
error.SetErrorStringWithFormat(
"the replacement path doesn't exist: \"%s\"", replace_path);
break;
}
}
if (changed)
NotifyValueChanged();
}
} else {
error.SetErrorString("replace operation takes an array index followed by "
"one or more path pairs");
}
break;
case eVarSetOperationAssign:
if (argc < 2 || (argc & 1)) {
error.SetErrorString("assign operation takes one or more path pairs");
break;
}
m_path_mappings.Clear(m_notify_changes);
// Fall through to append case
LLVM_FALLTHROUGH;
case eVarSetOperationAppend:
if (argc < 2 || (argc & 1)) {
error.SetErrorString("append operation takes one or more path pairs");
break;
} else {
bool changed = false;
for (size_t i = 0; i < argc; i += 2) {
const char *orginal_path = args.GetArgumentAtIndex(i);
const char *replace_path = args.GetArgumentAtIndex(i + 1);
if (VerifyPathExists(replace_path)) {
ConstString a(orginal_path);
ConstString b(replace_path);
m_path_mappings.Append(a, b, m_notify_changes);
m_value_was_set = true;
changed = true;
} else {
error.SetErrorStringWithFormat(
"the replacement path doesn't exist: \"%s\"", replace_path);
break;
}
}
if (changed)
NotifyValueChanged();
}
break;
case eVarSetOperationInsertBefore:
case eVarSetOperationInsertAfter:
// Must be at least one index + 1 pair of paths, and the pair count must be
// even
if (argc >= 3 && (((argc - 1) & 1) == 0)) {
uint32_t idx =
StringConvert::ToUInt32(args.GetArgumentAtIndex(0), UINT32_MAX);
const uint32_t count = m_path_mappings.GetSize();
if (idx > count) {
error.SetErrorStringWithFormat(
"invalid file list index %u, index must be 0 through %u", idx,
count);
} else {
bool changed = false;
if (op == eVarSetOperationInsertAfter)
++idx;
for (size_t i = 1; i < argc; i += 2, ++idx) {
const char *orginal_path = args.GetArgumentAtIndex(i);
const char *replace_path = args.GetArgumentAtIndex(i + 1);
if (VerifyPathExists(replace_path)) {
ConstString a(orginal_path);
ConstString b(replace_path);
m_path_mappings.Insert(a, b, idx, m_notify_changes);
changed = true;
} else {
error.SetErrorStringWithFormat(
"the replacement path doesn't exist: \"%s\"", replace_path);
break;
}
}
if (changed)
NotifyValueChanged();
}
} else {
error.SetErrorString("insert operation takes an array index followed by "
"one or more path pairs");
}
break;
case eVarSetOperationRemove:
if (argc > 0) {
std::vector<int> remove_indexes;
bool all_indexes_valid = true;
size_t i;
for (i = 0; all_indexes_valid && i < argc; ++i) {
const int idx =
StringConvert::ToSInt32(args.GetArgumentAtIndex(i), INT32_MAX);
if (idx == INT32_MAX)
all_indexes_valid = false;
else
remove_indexes.push_back(idx);
}
if (all_indexes_valid) {
size_t num_remove_indexes = remove_indexes.size();
if (num_remove_indexes) {
// Sort and then erase in reverse so indexes are always valid
std::sort(remove_indexes.begin(), remove_indexes.end());
for (size_t j = num_remove_indexes - 1; j < num_remove_indexes; ++j) {
m_path_mappings.Remove(j, m_notify_changes);
}
}
NotifyValueChanged();
} else {
error.SetErrorStringWithFormat(
"invalid array index '%s', aborting remove operation",
args.GetArgumentAtIndex(i));
}
} else {
error.SetErrorString("remove operation takes one or more array index");
}
break;
case eVarSetOperationInvalid:
error = OptionValue::SetValueFromString(value, op);
break;
}
return error;
}
static void demangle(llvm::raw_ostream &os, llvm::StringRef name,
swift::Demangle::Context &DCtx,
const swift::Demangle::DemangleOptions &options) {
bool hadLeadingUnderscore = false;
if (name.startswith("__")) {
hadLeadingUnderscore = true;
name = name.substr(1);
}
swift::Demangle::NodePointer pointer = DCtx.demangleSymbolAsNode(name);
if (ExpandMode || TreeOnly) {
llvm::outs() << "Demangling for " << name << '\n';
llvm::outs() << getNodeTreeAsString(pointer);
}
if (RemangleMode) {
std::string remangled;
if (!pointer || !(name.startswith(MANGLING_PREFIX_STR) ||
name.startswith("_S"))) {
// Just reprint the original mangled name if it didn't demangle or is in
// the old mangling scheme.
// This makes it easier to share the same database between the
// mangling and demangling tests.
remangled = name;
} else {
remangled = swift::Demangle::mangleNode(pointer);
// Also accept the future mangling prefix.
// TODO: remove the special "_S" handling as soon as MANGLING_PREFIX_STR
// gets "_S".
if (name.startswith("_S")) {
assert(remangled.find(MANGLING_PREFIX_STR) == 0);
remangled = "_S" + remangled.substr(3);
}
if (name != remangled) {
llvm::errs() << "\nError: re-mangled name \n " << remangled
<< "\ndoes not match original name\n " << name << '\n';
exit(1);
}
}
if (hadLeadingUnderscore) llvm::outs() << '_';
llvm::outs() << remangled;
return;
}
if (!TreeOnly) {
if (RemangleNew) {
if (!pointer) {
llvm::errs() << "Can't de-mangle " << name << '\n';
exit(1);
}
std::string remangled = swift::Demangle::mangleNode(pointer);
llvm::outs() << remangled;
return;
}
std::string string = swift::Demangle::nodeToString(pointer, options);
if (!CompactMode)
llvm::outs() << name << " ---> ";
if (Classify) {
std::string Classifications;
std::string cName = name.str();
if (!swift::Demangle::isSwiftSymbol(cName.c_str()))
Classifications += 'N';
if (DCtx.isThunkSymbol(name)) {
if (!Classifications.empty())
Classifications += ',';
Classifications += "T:";
Classifications += DCtx.getThunkTarget(name);
} else {
assert(DCtx.getThunkTarget(name).empty());
}
if (pointer && !DCtx.hasSwiftCallingConvention(name)) {
if (!Classifications.empty())
Classifications += ',';
Classifications += 'C';
}
if (!Classifications.empty())
llvm::outs() << '{' << Classifications << "} ";
}
llvm::outs() << (string.empty() ? name : llvm::StringRef(string));
}
DCtx.clear();
}
/// ApplyQAOverride - Apply a list of edits to the input argument lists.
///
/// The input string is a space separate list of edits to perform,
/// they are applied in order to the input argument lists. Edits
/// should be one of the following forms:
///
/// '#': Silence information about the changes to the command line arguments.
///
/// '^': Add FOO as a new argument at the beginning of the command line.
///
/// '+': Add FOO as a new argument at the end of the command line.
///
/// 's/XXX/YYY/': Substitute the regular expression XXX with YYY in the command
/// line.
///
/// 'xOPTION': Removes all instances of the literal argument OPTION.
///
/// 'XOPTION': Removes all instances of the literal argument OPTION,
/// and the following argument.
///
/// 'Ox': Removes all flags matching 'O' or 'O[sz0-9]' and adds 'Ox'
/// at the end of the command line.
///
/// \param OS - The stream to write edit information to.
/// \param Args - The vector of command line arguments.
/// \param Edit - The override command to perform.
/// \param SavedStrings - Set to use for storing string representations.
static void ApplyOneQAOverride(llvm::raw_ostream &OS,
llvm::SmallVectorImpl<const char*> &Args,
llvm::StringRef Edit,
std::set<std::string> &SavedStrings) {
// This does not need to be efficient.
if (Edit[0] == '^') {
const char *Str =
SaveStringInSet(SavedStrings, Edit.substr(1));
OS << "### Adding argument " << Str << " at beginning\n";
Args.insert(Args.begin() + 1, Str);
} else if (Edit[0] == '+') {
const char *Str =
SaveStringInSet(SavedStrings, Edit.substr(1));
OS << "### Adding argument " << Str << " at end\n";
Args.push_back(Str);
} else if (Edit[0] == 's' && Edit[1] == '/' && Edit.endswith("/") &&
Edit.slice(2, Edit.size()-1).find('/') != llvm::StringRef::npos) {
llvm::StringRef MatchPattern = Edit.substr(2).split('/').first;
llvm::StringRef ReplPattern = Edit.substr(2).split('/').second;
ReplPattern = ReplPattern.slice(0, ReplPattern.size()-1);
for (unsigned i = 1, e = Args.size(); i != e; ++i) {
std::string Repl = llvm::Regex(MatchPattern).sub(ReplPattern, Args[i]);
if (Repl != Args[i]) {
OS << "### Replacing '" << Args[i] << "' with '" << Repl << "'\n";
Args[i] = SaveStringInSet(SavedStrings, Repl);
}
}
} else if (Edit[0] == 'x' || Edit[0] == 'X') {
std::string Option = Edit.substr(1, std::string::npos);
for (unsigned i = 1; i < Args.size();) {
if (Option == Args[i]) {
OS << "### Deleting argument " << Args[i] << '\n';
Args.erase(Args.begin() + i);
if (Edit[0] == 'X') {
if (i < Args.size()) {
OS << "### Deleting argument " << Args[i] << '\n';
Args.erase(Args.begin() + i);
} else
OS << "### Invalid X edit, end of command line!\n";
}
} else
++i;
}
} else if (Edit[0] == 'O') {
for (unsigned i = 1; i < Args.size();) {
const char *A = Args[i];
if (A[0] == '-' && A[1] == 'O' &&
(A[2] == '\0' ||
(A[3] == '\0' && (A[2] == 's' || A[2] == 'z' ||
('0' <= A[2] && A[2] <= '9'))))) {
OS << "### Deleting argument " << Args[i] << '\n';
Args.erase(Args.begin() + i);
} else
++i;
}
OS << "### Adding argument " << Edit << " at end\n";
Args.push_back(SaveStringInSet(SavedStrings, '-' + Edit.str()));
} else {
OS << "### Unrecognized edit: " << Edit << "\n";
}
}
static void verifyFormat(llvm::StringRef Code) {
EXPECT_EQ(Code.str(), format(Code)) << "Expected code is not stable";
EXPECT_EQ(Code.str(), format(test::messUp(Code)));
}
StreamResult DiagLoader::readToNextRecordOrBlock(llvm::BitstreamCursor &Stream,
llvm::StringRef errorContext,
unsigned &blockOrRecordID,
bool atTopLevel) {
blockOrRecordID = 0;
while (!Stream.AtEndOfStream()) {
unsigned Code = Stream.ReadCode();
// Handle the top-level specially.
if (atTopLevel) {
if (Code == llvm::bitc::ENTER_SUBBLOCK) {
unsigned BlockID = Stream.ReadSubBlockID();
if (BlockID == llvm::bitc::BLOCKINFO_BLOCK_ID) {
if (Stream.ReadBlockInfoBlock()) {
reportInvalidFile("Malformed BlockInfoBlock in diagnostics file");
return Read_Failure;
}
continue;
}
blockOrRecordID = BlockID;
return Read_BlockBegin;
}
reportInvalidFile("Only blocks can appear at the top of a "
"diagnostic file");
return Read_Failure;
}
switch ((llvm::bitc::FixedAbbrevIDs)Code) {
case llvm::bitc::ENTER_SUBBLOCK:
blockOrRecordID = Stream.ReadSubBlockID();
return Read_BlockBegin;
case llvm::bitc::END_BLOCK:
if (Stream.ReadBlockEnd()) {
reportInvalidFile("Cannot read end of block");
return Read_Failure;
}
return Read_BlockEnd;
case llvm::bitc::DEFINE_ABBREV:
Stream.ReadAbbrevRecord();
continue;
case llvm::bitc::UNABBREV_RECORD:
reportInvalidFile("Diagnostics file should have no unabbreviated "
"records");
return Read_Failure;
default:
// We found a record.
blockOrRecordID = Code;
return Read_Record;
}
}
if (atTopLevel)
return Read_EndOfStream;
reportInvalidFile(Twine("Premature end of diagnostics file within ").str() +
errorContext.str());
return Read_Failure;
}
void MetaSema::actOnclassCommand(llvm::StringRef className) const {
if (!className.empty())
DisplayClass(m_Outs, &m_Interpreter, className.str().c_str(), true);
else
DisplayClasses(m_Outs, &m_Interpreter, false);
}
static void verifyFormat(llvm::StringRef Code) {
EXPECT_EQ(Code.str(), format(test::messUp(Code)));
}
void MetaSema::actOngCommand(llvm::StringRef varName) const {
if (varName.empty())
DisplayGlobals(m_Outs, &m_Interpreter);
else
DisplayGlobal(m_Outs, &m_Interpreter, varName.str().c_str());
}
Interpreter::CompilationResult
MetaProcessor::readInputFromFile(llvm::StringRef filename,
StoredValueRef* result /* = 0 */,
bool ignoreOutmostBlock /*=false*/) {
{
// check that it's not binary:
std::ifstream in(filename.str().c_str(), std::ios::in | std::ios::binary);
char magic[1024] = {0};
in.read(magic, sizeof(magic));
size_t readMagic = in.gcount();
if (readMagic >= 4) {
llvm::sys::LLVMFileType fileType
= llvm::sys::IdentifyFileType(magic, 4);
if (fileType != llvm::sys::Unknown_FileType) {
llvm::errs() << "Error in cling::MetaProcessor: "
"cannot read input from a binary file!\n";
return Interpreter::kFailure;
}
unsigned printable = 0;
for (size_t i = 0; i < readMagic; ++i)
if (isprint(magic[i]))
++printable;
if (10 * printable < 5 * readMagic) {
// 50% printable for ASCII files should be a safe guess.
llvm::errs() << "Error in cling::MetaProcessor: "
"cannot read input from a (likely) binary file!\n" << printable;
return Interpreter::kFailure;
}
}
}
std::ifstream in(filename.str().c_str());
in.seekg(0, std::ios::end);
size_t size = in.tellg();
std::string content(size, ' ');
in.seekg(0);
in.read(&content[0], size);
if (ignoreOutmostBlock && !content.empty()) {
static const char whitespace[] = " \t\r\n";
std::string::size_type posNonWS = content.find_first_not_of(whitespace);
std::string::size_type replaced = posNonWS;
if (posNonWS != std::string::npos) {
if (content[posNonWS] == '{') {
// hide the curly brace:
content[posNonWS] = ' ';
// and the matching closing '}'
posNonWS = content.find_last_not_of(whitespace);
if (posNonWS != std::string::npos) {
if (content[posNonWS] == ';' && content[posNonWS-1] == '}') {
content[posNonWS--] = ' '; // replace ';' and enter next if
}
if (content[posNonWS] == '}') {
content[posNonWS] = ' '; // replace '}'
} else {
// More text (comments) are okay after the last '}', but
// we can not easily find it to remove it (so we need to upgrade
// this code to better handle the case with comments or
// preprocessor code before and after the leading { and
// trailing })
content[replaced] = '{';
// By putting the '{' back, we keep the code as consistent as
// the user wrote it ... but we should still warn that we not
// goint to treat this file an unamed macro.
llvm::errs()
<< "Warning in cling::MetaProcessor: can not find the closing '}', "
<< llvm::sys::path::filename(filename)
<< " is not handled as an unamed script!\n";
}
} // find '}'
} // have '{'
} // have non-whitespace
} // ignore outmost block
std::string strFilename(filename.str());
m_CurrentlyExecutingFile = strFilename;
bool topmost = !m_TopExecutingFile.data();
if (topmost)
m_TopExecutingFile = m_CurrentlyExecutingFile;
Interpreter::CompilationResult ret = Interpreter::kSuccess;
process(content.c_str(), result, &ret);
m_CurrentlyExecutingFile = llvm::StringRef();
if (topmost)
m_TopExecutingFile = llvm::StringRef();
return ret;
}
void MetaSema::actOnTypedefCommand(llvm::StringRef typedefName) const {
if (typedefName.empty())
DisplayTypedefs(m_Outs, &m_Interpreter);
else
DisplayTypedef(m_Outs, &m_Interpreter, typedefName.str().c_str());
}
QString qStr(llvm::StringRef sr)
{
return QString::fromStdString(sr.str());
}
std::unique_ptr<llvm::Module>
klee::linkModules(std::vector<std::unique_ptr<llvm::Module>> &modules,
llvm::StringRef entryFunction, std::string &errorMsg) {
assert(!modules.empty() && "modules list should not be empty");
if (entryFunction.empty()) {
// If no entry function is provided, link all modules together into one
std::unique_ptr<llvm::Module> composite = std::move(modules.back());
modules.pop_back();
// Just link all modules together
for (auto &module : modules) {
if (linkTwoModules(composite.get(), std::move(module), errorMsg))
continue;
// Linking failed
errorMsg = "Linking archive module with composite failed:" + errorMsg;
return nullptr;
}
// clean up every module as we already linked in every module
modules.clear();
return composite;
}
// Starting from the module containing the entry function, resolve unresolved
// dependencies recursively
// search for the module containing the entry function
std::unique_ptr<llvm::Module> composite;
for (auto &module : modules) {
if (!module || !module->getNamedValue(entryFunction))
continue;
if (composite) {
errorMsg =
"Function " + entryFunction.str() +
" defined in different modules (" + module->getModuleIdentifier() +
" already defined in: " + composite->getModuleIdentifier() + ")";
return nullptr;
}
composite = std::move(module);
}
// fail if not found
if (!composite) {
errorMsg = "'" + entryFunction.str() + "' function not found in module.";
return nullptr;
}
while (true) {
std::set<std::string> undefinedSymbols;
GetAllUndefinedSymbols(composite.get(), undefinedSymbols);
// Stop in nothing is undefined
if (undefinedSymbols.empty())
break;
bool merged = false;
for (auto &module : modules) {
if (!module)
continue;
for (auto symbol : undefinedSymbols) {
GlobalValue *GV =
dyn_cast_or_null<GlobalValue>(module->getNamedValue(symbol));
if (!GV || GV->isDeclaration())
continue;
// Found symbol, therefore merge in module
KLEE_DEBUG_WITH_TYPE("klee_linker",
dbgs() << "Found " << GV->getName() << " in "
<< module->getModuleIdentifier() << "\n");
if (linkTwoModules(composite.get(), std::move(module), errorMsg)) {
module = nullptr;
merged = true;
break;
}
// Linking failed
errorMsg = "Linking archive module with composite failed:" + errorMsg;
return nullptr;
}
}
if (!merged)
break;
}
// Condense the module array
std::vector<std::unique_ptr<llvm::Module>> LeftoverModules;
for (auto &module : modules) {
if (module)
LeftoverModules.emplace_back(std::move(module));
}
modules.swap(LeftoverModules);
return composite;
}
PythonModule PythonModule::ImportModule(llvm::StringRef module) {
std::string str = module.str();
return PythonModule(PyRefType::Owned, PyImport_ImportModule(str.c_str()));
}
void
StringList::AppendString(llvm::StringRef str)
{
m_strings.push_back(str.str());
}
static void verifyFormat(
llvm::StringRef Code,
const FormatStyle &Style = getGoogleStyle(FormatStyle::LK_JavaScript)) {
std::string result = format(test::messUp(Code), Style);
EXPECT_EQ(Code.str(), result) << "Formatted:\n" << result;
}
void Log::PutString(llvm::StringRef str) { PutCString(str.str().c_str()); }