class
Crystal::Compiler::CompilationUnit
Overview
An LLVM::Module with information to compile it.
Defined in:
compiler/crystal/compiler.crConstructors
Instance Method Summary
- #bc_name
- #bc_name_new
-
#compile(isolate_context = false)
To compile a file we first generate a
.bcfile and then create an object file from it. - #compiler : Crystal::Compiler
- #emit(emit_targets : EmitTarget, output_filename)
- #generate_bitcode
- #ll_name
- #llvm_mod : LLVM::Module
- #name : String
- #object_extension : String
- #object_filename
- #object_name
- #original_name : String
- #reused_previous_compilation=(reused_previous_compilation : Bool)
- #reused_previous_compilation? : Bool
- #temporary_object_name
Instance methods inherited from class Reference
==(other : self)==(other : JSON::Any)
==(other : YAML::Any)
==(other) ==, dup dup, hash(hasher) hash, initialize initialize, inspect(io : IO) : Nil inspect, object_id : UInt64 object_id, pretty_print(pp) : Nil pretty_print, same?(other : Reference) : Bool
same?(other : Nil) same?, to_s(io : IO) : Nil to_s
Constructor methods inherited from class Reference
new
new,
unsafe_construct(address : Pointer, *args, **opts) : self
unsafe_construct
Class methods inherited from class Reference
pre_initialize(address : Pointer)
pre_initialize
Instance methods inherited from class Object
! : Bool
!,
!=(other)
!=,
!~(other)
!~,
==(other)
==,
===(other : JSON::Any)===(other : YAML::Any)
===(other) ===, =~(other) =~, as(type : Class) as, as?(type : Class) as?, class class, dup dup, hash(hasher)
hash hash, in?(collection : Object) : Bool
in?(*values : Object) : Bool in?, inspect(io : IO) : Nil
inspect : String inspect, is_a?(type : Class) : Bool is_a?, itself itself, nil? : Bool nil?, not_nil!(message)
not_nil! not_nil!, pretty_inspect(width = 79, newline = "\n", indent = 0) : String pretty_inspect, pretty_print(pp : PrettyPrint) : Nil pretty_print, responds_to?(name : Symbol) : Bool responds_to?, tap(&) tap, to_json(io : IO) : Nil
to_json : String to_json, to_pretty_json(indent : String = " ") : String
to_pretty_json(io : IO, indent : String = " ") : Nil to_pretty_json, to_s(io : IO) : Nil
to_s : String to_s, to_yaml(io : IO) : Nil
to_yaml : String to_yaml, try(&) try, unsafe_as(type : T.class) forall T unsafe_as
Class methods inherited from class Object
from_json(string_or_io : String | IO, root : String)from_json(string_or_io : String | IO) from_json, from_yaml(string_or_io : String | IO) from_yaml
Macros inherited from class Object
class_getter(*names, &block)
class_getter,
class_getter!(*names)
class_getter!,
class_getter?(*names, &block)
class_getter?,
class_property(*names, &block)
class_property,
class_property!(*names)
class_property!,
class_property?(*names, &block)
class_property?,
class_setter(*names)
class_setter,
def_clone
def_clone,
def_equals(*fields)
def_equals,
def_equals_and_hash(*fields)
def_equals_and_hash,
def_hash(*fields)
def_hash,
delegate(*methods, to object)
delegate,
forward_missing_to(delegate)
forward_missing_to,
getter(*names, &block)
getter,
getter!(*names)
getter!,
getter?(*names, &block)
getter?,
property(*names, &block)
property,
property!(*names)
property!,
property?(*names, &block)
property?,
setter(*names)
setter
Constructor Detail
Instance Method Detail
To compile a file we first generate a .bc file and then create an
object file from it. These .bc files are stored in the cache
directory.
On a next compilation of the same project, and if the compile flags
didn't change (a combination of the target triple, mcpu and link flags,
amongst others), we check if the new .bc file is exactly the same as
the old one. In that case the .o file will also be the same, so we
simply reuse the old one. Generating an .o file is what takes most
time.
However, instead of directly generating the final .o file from the
.bc file, we generate it to a temporary name (.o.tmp) and then we
rename that file to .o. We do this because the compiler could be
interrupted while the .o file is being generated, leading to a
corrupted file that later would cause compilation issues. Moving a file
is an atomic operation so no corrupted .o file should be generated.