def create_function_with_type(self, name: str, canonical_name: str, ty: FunctionType,
linkage: str,
calling_convention: str,
function_def: FunctionDefinition) -> RIALFunction:
"""
Creates an IR Function with the specified arguments. NOTHING MORE.
:param canonical_name:
:param canonical_name:
:param function_def:
:param name:
:param ty:
:param linkage:
:param calling_convention:
:return:
"""
# Create function with specified linkage (internal -> module only)
func = RIALFunction(ParserState.module(), ty, name=name, canonical_name=canonical_name)
func.linkage = linkage
func.calling_convention = calling_convention
func.definition = function_def
# Set argument names
for i, arg in enumerate(func.args):
arg.name = function_def.rial_args[i].name
ParserState.module().rial_functions.append(func)
return func
def check_struct_access_allowed(self, struct: RIALIdentifiedStructType):
# Public is always okay
if struct.definition.access_modifier == RIALAccessModifier.PUBLIC:
return True
# Private and same module
if struct.definition.access_modifier == RIALAccessModifier.PRIVATE:
return struct.module_name == ParserState.module().name
# Internal and same TLM
if struct.definition.access_modifier == RIALAccessModifier.INTERNAL:
return struct.module_name.split(':')[0] == ParserState.module().name.split(':')[0]
return False
def declare_non_constant_global_variable(self, identifier: str, value, access_modifier: RIALAccessModifier,
linkage: str):
"""
Needs to be called with create_in_global_ctor or otherwise the store/load operations are going to fail.
:param identifier:
:param value:
:param access_modifier:
:param linkage:
:return:
"""
if ParserState.module().get_global_safe(identifier) is not None:
return None
if self.current_func.name != "global_ctor":
return None
if isinstance(value, AllocaInstr):
variable = self.gen_global(identifier, null(value.type.pointee), value.type.pointee, access_modifier,
linkage, False)
elif isinstance(value, PointerType):
variable = self.gen_global(identifier, null(value.pointee.type), value.pointee.type, access_modifier,
linkage, False)
elif isinstance(value, FormattedConstant) or isinstance(value, AllocaInstr):
variable = self.gen_global(identifier, null(value.type.pointee), value.type.pointee, access_modifier,
linkage, False)
elif isinstance(value, Constant):
variable = self.gen_global(identifier, null(value.type), value.type, access_modifier, linkage, False)
else:
variable = self.gen_global(identifier, null(value.type), value.type, access_modifier, linkage, False)
self.assign_non_constant_global_variable(variable, value)
return variable
def check_function_call_allowed(self, func: RIALFunction):
# Unsafe in safe context is big no-no
if func.definition.unsafe and not self.currently_unsafe:
return False
# Public is always okay
if func.definition.access_modifier == RIALAccessModifier.PUBLIC:
return True
# Internal only when it's the same TLM
if func.definition.access_modifier == RIALAccessModifier.INTERNAL:
return func.module.name.split(':')[0] == ParserState.module().name.split(':')[0]
# Private is harder
if func.definition.access_modifier == RIALAccessModifier.PRIVATE:
# Allowed if not in struct and in current module
if func.definition.struct == "" and func.module.name == ParserState.module().name:
return True
# Allowed if in same struct irregardless of module
if self.current_struct is not None and self.current_struct.name == func.definition.struct:
return True
return False
def gen_global(self, name: str, value: Optional[ir.Constant], ty: Type, access_modifier: RIALAccessModifier,
linkage: str,
constant: bool):
rial_variable = ParserState.module().get_rial_variable(name)
if rial_variable is not None:
return rial_variable.backing_value
glob = ir.GlobalVariable(ParserState.module(), ty, name=name)
glob.linkage = linkage
glob.global_constant = constant
if value is not None:
glob.initializer = value
rial_variable = RIALVariable(name, map_llvm_to_type(ty), glob,
access_modifier)
ParserState.module().global_variables.append(rial_variable)
return glob
def create_identified_struct(self, name: str, linkage: str,
rial_access_modifier: RIALAccessModifier,
base_llvm_structs: List[RIALIdentifiedStructType],
body: List[RIALVariable]) -> RIALIdentifiedStructType:
# Build normal struct and switch out with RIALStruct
struct = ParserState.module().context.get_identified_type(name)
rial_struct = RIALIdentifiedStructType(struct.context, struct.name, struct.packed)
ParserState.module().context.identified_types[struct.name] = rial_struct
struct = rial_struct
ParserState.module().structs.append(struct)
# Create metadata definition
struct_def = StructDefinition(rial_access_modifier)
# Build body and body definition
props_def = dict()
props = list()
prop_offset = 0
for deriv in base_llvm_structs:
for prop in deriv.definition.properties.values():
props.append(ParserState.map_type_to_llvm(prop[1].rial_type))
props_def[prop[1].name] = (prop_offset, prop[1])
prop_offset += 1
struct_def.base_structs.append(deriv.name)
for bod in body:
props.append(ParserState.map_type_to_llvm(bod.rial_type))
props_def[bod.name] = (prop_offset, bod)
prop_offset += 1
struct.set_body(*tuple(props))
struct.module_name = ParserState.module().name
self.current_struct = struct
struct_def.properties = props_def
# Store def in metadata
struct.definition = struct_def
return struct
def declare_variable(self, identifier: str, value) -> Optional[AllocaInstr]:
variable = self.current_block.get_named_value(identifier)
if variable is not None:
return None
if isinstance(value, AllocaInstr) or isinstance(value, PointerType):
variable = value
variable.name = identifier
elif isinstance(value, CastInstr) and value.opname == "inttoptr":
variable = self.builder.alloca(value.type.pointee)
variable.name = identifier
rial_type = f"{map_llvm_to_type(value.type)}"
variable.set_metadata('type',
ParserState.module().add_metadata((rial_type,)))
self.builder.store(self.builder.load(value), variable)
elif isinstance(value, FormattedConstant):
variable = self.builder.alloca(value.type.pointee)
variable.name = identifier
rial_type = f"{map_llvm_to_type(value.type)}"
variable.set_metadata('type',
ParserState.module().add_metadata((rial_type,)))
self.builder.store(self.builder.load(value), variable)
elif isinstance(value, Constant):
variable = self.builder.alloca(value.type)
variable.name = identifier
rial_type = f"{map_llvm_to_type(value.type)}"
variable.set_metadata('type',
ParserState.module().add_metadata((rial_type,)))
self.builder.store(value, variable)
else:
variable = self.builder.alloca(value.type)
variable.name = identifier
rial_type = f"{map_llvm_to_type(value.type)}"
variable.set_metadata('type', ParserState.module().add_metadata((rial_type,)))
self.builder.store(value, variable)
self.current_block.add_named_value(identifier, variable)
return variable
def create_in_global_ctor(self):
current_block = self.current_block
current_func = self.current_func
current_struct = self.current_struct
conditional_block = self.conditional_block
end_block = self.end_block
pos = self.builder is not None and self.builder._anchor or 0
func = ParserState.module().get_global_safe('global_ctor')
if func is None:
func_type = self.create_function_type(ir.VoidType(), [], False)
func = self.create_function_with_type('global_ctor', 'global_ctor', func_type, "internal", "ccc",
FunctionDefinition('void'))
self.create_function_body(func, [])
struct_type = ir.LiteralStructType([ir.IntType(32), func_type.as_pointer(), ir.IntType(8).as_pointer()])
glob_value = ir.Constant(ir.ArrayType(struct_type, 1), [ir.Constant.literal_struct(
[ir.Constant(ir.IntType(32), 65535), func, NULL])])
glob_type = ir.ArrayType(struct_type, 1)
self.gen_global("llvm.global_ctors", glob_value, glob_type, RIALAccessModifier.PRIVATE, "appending", False)
else:
self.builder.position_before(func.entry_basic_block.terminator)
self.current_func = func
self.current_block = create_llvm_block(func.entry_basic_block)
self.current_struct = None
self.conditional_block = None
self.end_block = None
yield
self.finish_current_block()
self.finish_current_func()
self.current_block = current_block
self.current_func = current_func
self.current_struct = current_struct
self.conditional_block = conditional_block
self.end_block = end_block
self.builder._anchor = pos
self.builder._block = self.current_block is not None and self.current_block.block or None
return
def _get_by_identifier(self, identifier: str, variable: Optional = None) -> Optional:
if isinstance(variable, RIALVariable):
variable = variable.backing_value
if not variable is None and hasattr(variable, 'type') and isinstance(variable.type, PointerType):
if isinstance(variable.type.pointee, RIALIdentifiedStructType):
struct = ParserState.find_struct(variable.type.pointee.name)
if struct is None:
return None
if not self.check_struct_access_allowed(struct):
raise PermissionError(f"Tried accesssing struct {struct.name}")
prop = struct.definition.properties[identifier]
if prop is None:
return None
# Check property access
if not self.check_property_access_allowed(struct, prop[1]):
raise PermissionError(f"Tried to access property {prop[1].name} but it was not allowed!")
variable = self.builder.gep(variable, [ir.Constant(ir.IntType(32), 0),
ir.Constant(ir.IntType(32), prop[0])])
else:
# Search local variables
variable = self.current_block.get_named_value(identifier)
# Search for a global variable
if variable is None:
glob = ParserState.find_global(identifier)
# Check if in same module
if glob is not None:
if glob.backing_value.parent.name != ParserState.module().name:
glob_current_module = ParserState.module().get_global_safe(glob.name)
if glob_current_module is not None:
variable = glob_current_module
else:
# TODO: Check if global access is allowed
variable = self.gen_global(glob.name, None, glob.backing_value.type.pointee,
glob.access_modifier, "external",
glob.backing_value.global_constant)
else:
variable = glob.backing_value
# If variable is none, just do a full function search
if variable is None:
variable = ParserState.find_function(identifier)
if variable is None:
variable = ParserState.find_function(mangle_function_name(identifier, []))
# Check if in same module
if variable is not None:
if variable.module.name != ParserState.module().name:
variable_current_module = ParserState.module().get_global_safe(variable.name)
if variable_current_module is not None:
variable = variable_current_module
else:
variable = self.create_function_with_type(variable.name, variable.name, variable.function_type,
variable.linkage,
variable.calling_convention,
variable.definition)
return variable
def gen_function_call(self, possible_function_names: List[str],
llvm_args: List) -> Optional[CallInstr]:
func = None
# Check if it's actually a local variable
for function_name in possible_function_names:
var = self.get_definition(function_name)
if var is not None:
func = var
# Try to find by function name
if func is None:
for function_name in possible_function_names:
func = ParserState.find_function(function_name)
if func is not None:
break
# Try to find by function name but enable canonical name
if func is None:
rial_arg_types = [map_llvm_to_type(arg.type) for arg in llvm_args]
for function_name in possible_function_names:
func = ParserState.find_function(function_name, rial_arg_types)
if func is not None:
break
if func is None:
return None
if isinstance(func, RIALVariable):
func = func.backing_value
if isinstance(func, ir.PointerType) and isinstance(func.pointee, RIALFunction):
func = func.pointee
elif isinstance(func, GlobalVariable) or isinstance(func, AllocaInstr):
loaded_func = self.builder.load(func)
call = self.builder.call(loaded_func, llvm_args)
return call
# Check if call is allowed
if not self.check_function_call_allowed(func):
raise PermissionError(f"Tried calling function {func.name} from {self.current_func.name}")
# Check if function is declared in current module
if ParserState.module().get_global_safe(func.name) is None:
func = self.create_function_with_type(func.name, func.canonical_name, func.function_type, func.linkage,
func.calling_convention, func.definition)
args = list()
# Gen a load if necessary
for i, arg in enumerate(llvm_args):
llvm_arg = func.definition.rial_args[i].llvm_type
if llvm_arg == arg.type:
args.append(arg)
continue
args.append(self.builder.load(arg))
# Check type matching
for i, arg in enumerate(args):
if len(func.args) > i and arg.type != func.args[i].type:
# Check for base types
ty = isinstance(arg.type, PointerType) and arg.type.pointee or arg.type
func_arg_type = isinstance(func.args[i].type, PointerType) and func.args[i].type.pointee or func.args[
i].type
if isinstance(ty, RIALIdentifiedStructType):
struct = ParserState.find_struct(ty.name)
if struct is not None:
found = False
# Check if a base struct matches the type expected
# TODO: Recursive check
for base_struct in struct.definition.base_structs:
if base_struct == func_arg_type.name:
args.remove(arg)
args.insert(i, self.builder.bitcast(arg, ir.PointerType(base_struct)))
found = True
break
if found:
continue
# TODO: SLOC information
raise TypeError(
f"Function {func.name} expects a {func.args[i].type} but got a {arg.type}")
# Gen call
return self.builder.call(func, args)
def compile_file(path: str):
global exceptions
try:
last_modified = os.path.getmtime(path)
filename = CompilationManager.filename_from_path(path)
if check_cache(path):
CompilationManager.finish_file(path)
CompilationManager.files_to_compile.task_done()
return
module_name = CompilationManager.mod_name_from_path(filename)
module = CompilationManager.codegen.get_module(
module_name, filename, str(CompilationManager.config.source_path))
ParserState.set_module(module)
ParserState.set_llvmgen(LLVMGen())
if not ParserState.module().name.startswith(
"rial:builtin:always_imported"):
ParserState.module().dependencies.extend(
CompilationManager.always_imported)
# Remove the current module in case it's in the always imported list
if module_name in ParserState.module().dependencies:
ParserState.module().dependencies.remove(module_name)
with run_with_profiling(filename, ExecutionStep.READ_FILE):
with open(path, "r") as file:
contents = file.read()
desugar_transformer = DesugarTransformer()
primitive_transformer = PrimitiveASTTransformer()
parser = Lark_StandAlone(postlex=Postlexer())
# Parse the file
with run_with_profiling(filename, ExecutionStep.PARSE_FILE):
try:
ast = parser.parse(contents)
except Exception as e:
log_fail(f"Exception when parsing {filename}")
log_fail(e)
exceptions = True
CompilationManager.finish_file(path)
CompilationManager.files_to_compile.task_done()
return
if CompilationManager.config.raw_opts.print_tokens:
print(ast.pretty())
# Generate primitive IR (things we don't need other modules for)
with run_with_profiling(filename, ExecutionStep.GEN_IR):
ast = desugar_transformer.transform(ast)
ast = primitive_transformer.transform(ast)
struct_declaration_transformer = StructDeclarationTransformer()
function_declaration_transformer = FunctionDeclarationTransformer()
global_declaration_transformer = GlobalDeclarationTransformer()
transformer = ASTVisitor()
with run_with_profiling(filename, ExecutionStep.GEN_IR):
ast = struct_declaration_transformer.visit(ast)
if ast is not None:
ast = function_declaration_transformer.visit(ast)
if ast is not None:
ast = global_declaration_transformer.visit(ast)
# Declarations are all already collected so we can move on.
CompilationManager.modules[str(path)] = ParserState.module()
CompilationManager.finish_file(path)
if ast is not None:
transformer.visit(ast)
cache_path = str(CompilationManager.get_cache_path_str(path)).replace(
".rial", ".cache")
if Path(cache_path).exists(
) and CompilationManager.config.raw_opts.disable_cache:
os.remove(cache_path)
elif not CompilationManager.config.raw_opts.disable_cache:
Cache.cache_module(ParserState.module(), path, cache_path,
last_modified)
CompilationManager.files_to_compile.task_done()
except Exception as e:
log_fail("Internal Compiler Error: ")
log_fail(traceback.format_exc())
exceptions = True
CompilationManager.finish_file(path)
CompilationManager.files_to_compile.task_done()
def extension_function_decl(self, tree: Tree):
nodes = tree.children
access_modifier: RIALAccessModifier = nodes[0].access_modifier
unsafe: bool = nodes[0].unsafe
linkage = access_modifier.get_linkage()
calling_convention = self.default_cc
return_type = nodes[1].value
name = nodes[2].value
# Extension functions cannot be declared inside other classes.
if self.llvmgen.current_struct is not None:
log_fail(f"Extension function {name} cannot be declared inside another class!")
raise Discard()
if not self.mangling:
log_fail(f"Extension function {name} does not qualify for no mangling.")
raise Discard()
args: List[RIALVariable] = list()
this_arg = map_shortcut_to_type(nodes[3].value)
has_body = False
args.append(RIALVariable(nodes[4].value, nodes[3].value, None))
i = 5
while i < len(nodes):
if not isinstance(nodes[i], Token):
has_body = True
break
if nodes[i].type == "IDENTIFIER":
arg_type = nodes[i].value
i += 1
arg_name = nodes[i].value
args.append(RIALVariable(arg_name, arg_type, None))
i += 1
else:
break
# Map RIAL args to llvm arg types
llvm_args = [arg.llvm_type for arg in args if not arg.name.endswith("...")]
full_function_name = mangle_function_name(name, llvm_args, this_arg)
full_function_name = f"{ParserState.module().name}:{full_function_name}"
# Hasn't been declared previously, redeclare the function type here
llvm_return_type = ParserState.map_type_to_llvm(return_type)
func_type = self.llvmgen.create_function_type(llvm_return_type, llvm_args, False)
# Create the actual function in IR
func = self.llvmgen.create_function_with_type(full_function_name, name, func_type, linkage,
calling_convention,
FunctionDefinition(return_type, access_modifier, args,
self.llvmgen.current_struct is not None and self.llvmgen.current_struct.name or "",
unsafe))
# Update backing values
for i, arg in enumerate(func.args):
args[i].backing_value = arg
if is_builtin_type(this_arg):
if this_arg not in ParserState.builtin_types:
ParserState.builtin_types[this_arg] = dict()
ParserState.builtin_types[this_arg][func.name] = func
if not this_arg in ParserState.module().builtin_type_methods:
ParserState.module().builtin_type_methods[this_arg] = list()
ParserState.module().builtin_type_methods[this_arg].append(func.name)
else:
struct = ParserState.find_struct(this_arg)
if struct is None:
log_fail(f"Extension function for non-existing type {this_arg}")
ParserState.module().functions.remove(func)
raise Discard()
struct.definition.functions.append(func.name)
if not has_body:
raise Discard()
token = nodes[2]
metadata_token = MetadataToken(token.type, token.value)
metadata_token.metadata["func"] = func
metadata_token.metadata["body_start"] = i
nodes.remove(token)
nodes.insert(0, metadata_token)
return Tree('function_decl', nodes)