use of com.oracle.truffle.llvm.runtime.debug.LLVMSourceContext in project sulong by graalvm.
the class LLVMParserRuntime method parse.
public static LLVMParserResult parse(Source source, ExternalLibrary library, BitcodeParserResult parserResult, LLVMLanguage language, LLVMContext context, NodeFactory nodeFactory) {
ModelModule model = parserResult.getModel();
TargetDataLayout layout = model.getTargetDataLayout();
assert layout != null;
LLVMModelVisitor module = new LLVMModelVisitor();
model.accept(module);
DataLayoutConverter.DataSpecConverterImpl targetDataLayout = DataLayoutConverter.getConverter(layout.getDataLayout());
context.setDataLayoutConverter(targetDataLayout);
LLVMParserRuntime runtime = new LLVMParserRuntime(source, library, language, context, nodeFactory, module.getAliases());
runtime.registerFunctions(model);
LLVMSymbolReadResolver symbolResolver = new LLVMSymbolReadResolver(runtime, runtime.getGlobalFrameDescriptor());
LLVMExpressionNode[] globals = runtime.createGlobalVariableInitializationNodes(symbolResolver, module.getGlobals());
RootNode globalVarInits = nodeFactory.createStaticInitsRootNode(runtime, globals);
RootCallTarget globalVarInitsTarget = Truffle.getRuntime().createCallTarget(globalVarInits);
LLVMExpressionNode[] deallocs = runtime.getDeallocations();
RootNode globalVarDeallocs = nodeFactory.createStaticInitsRootNode(runtime, deallocs);
RootCallTarget globalVarDeallocsTarget = Truffle.getRuntime().createCallTarget(globalVarDeallocs);
RootCallTarget constructorFunctions = runtime.getConstructors(module.getGlobals());
RootCallTarget destructorFunctions = runtime.getDestructors(module.getGlobals());
if (context.getEnv().getOptions().get(SulongEngineOption.ENABLE_LVI)) {
final LLVMSourceContext sourceContext = context.getSourceContext();
model.getSourceGlobals().forEach((symbol, irValue) -> {
final LLVMExpressionNode node = symbolResolver.resolve(irValue);
final LLVMDebugValue value = nodeFactory.createDebugStaticValue(node);
sourceContext.registerStatic(symbol, value);
});
model.getSourceStaticMembers().forEach(((type, symbol) -> {
final LLVMExpressionNode node = symbolResolver.resolve(symbol);
final LLVMDebugValue value = nodeFactory.createDebugStaticValue(node);
type.setValue(value);
}));
}
RootCallTarget mainFunctionCallTarget = null;
if (runtime.getScope().functionExists("@main")) {
LLVMFunctionDescriptor mainDescriptor = runtime.getScope().getFunctionDescriptor("@main");
LLVMFunctionDescriptor startDescriptor = runtime.getScope().getFunctionDescriptor("@_start");
RootCallTarget startCallTarget = startDescriptor.getLLVMIRFunction();
String applicationPath = source.getPath() == null ? "" : source.getPath().toString();
RootNode globalFunction = nodeFactory.createGlobalRootNode(runtime, startCallTarget, mainDescriptor, applicationPath);
RootCallTarget globalFunctionRoot = Truffle.getRuntime().createCallTarget(globalFunction);
RootNode globalRootNode = nodeFactory.createGlobalRootNodeWrapping(runtime, globalFunctionRoot, startDescriptor.getType().getReturnType());
mainFunctionCallTarget = Truffle.getRuntime().createCallTarget(globalRootNode);
}
return new LLVMParserResult(runtime.getScope(), mainFunctionCallTarget, globalVarInitsTarget, globalVarDeallocsTarget, constructorFunctions, destructorFunctions);
}
use of com.oracle.truffle.llvm.runtime.debug.LLVMSourceContext in project sulong by graalvm.
the class LLVMSourceScope method create.
@TruffleBoundary
public static Iterable<Scope> create(Node node, Frame frame, LLVMContext context) {
final LLVMSourceContext sourceContext = context.getSourceContext();
final RootNode rootNode = node.getRootNode();
LLVMNode llvmNode = findStatementNode(node);
if (rootNode == null || llvmNode == null) {
return Collections.singleton(new LLVMSourceScope(sourceContext, node).toScope(frame));
}
LLVMSourceLocation scope = llvmNode.getSourceLocation();
final SourceSection sourceSection = llvmNode.getSourceSection();
LLVMSourceScope baseScope = new LLVMSourceScope(sourceContext, new LinkedList<>(), rootNode);
LLVMSourceScope staticScope = null;
for (boolean isLocalScope = true; isLocalScope && scope != null; scope = scope.getParent()) {
final LLVMSourceScope next = toScope(scope, sourceContext, rootNode, sourceSection);
copySymbols(next, baseScope);
if (scope.getKind() == LLVMSourceLocation.Kind.FUNCTION) {
baseScope.setName(next.getName());
if (scope.getCompileUnit() != null) {
staticScope = toScope(scope.getCompileUnit(), sourceContext, null, sourceSection);
}
isLocalScope = false;
}
}
List<Scope> scopeList = new ArrayList<>();
scopeList.add(baseScope.toScope(frame));
for (; scope != null; scope = scope.getParent()) {
// e.g. lambdas are compiled to calls to a method in a locally defined class. We
// cannot access the locals of the enclosing function since they do not lie on the
// function's frame. They are still accessible from the calling function's frame, so
// we can simply ignore this scope here. Also, any variables actually used in the
// lambda would still be available as the members of the 'this' pointer.
final LLVMSourceScope next = toScope(scope, sourceContext, null, sourceSection);
switch(scope.getKind()) {
case NAMESPACE:
case FILE:
case BLOCK:
if (next.hasSymbols()) {
scopeList.add(next.toScope(frame));
}
break;
case COMPILEUNIT:
if (staticScope == null) {
staticScope = next;
} else {
copySymbols(next, staticScope);
}
break;
}
}
if (staticScope != null && staticScope.hasSymbols()) {
scopeList.add(staticScope.toScope(frame));
}
return Collections.unmodifiableList(scopeList);
}
Aggregations