carbon-core 0.1.0

data/lib/carbon/tacky/context.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Carbon
+  module Tacky
+    # A "context."  This contains all of the information needed to build a
+    # function, such as instruction values (From LLVM), block mapping,
+    # parameters, and the build ({Concrete::Build}).
+    #
+    # @api private
+    class Context
+      extend Forwardable
+      # The values of instructions.  This is used to properly map
+      # {Tacky::Reference} values to the proper `LLVM::Value`s.
+      #
+      # @return [<::LLVM::Value>]
+      attr_reader :instructions
+
+      # The mapping for blocks.  This is used by instructions to map a
+      # {Tacky::Block} to the proper `LLVM::BasicBlock`, since many llvm
+      # instructions take basic blocks as parameters.
+      #
+      # @return [{Tacky::Block => ::LLVM::BasicBlock}]
+      attr_reader :blocks
+
+      # The generics that the function is being built with.
+      #
+      # @return [{::String => Concrete::Type}]
+      attr_reader :generics
+
+      # The parameters that are passed from the function.  This is used to
+      # convert {Tacky::Parameter} references to `LLVM::Value`s.
+      #
+      # @return [<::LLVM::Value>]
+      attr_reader :params
+
+      # The actual build.
+      #
+      # @return [Concrete::Build]
+      attr_reader :build
+
+      # (see Concrete::Build#types)
+      attr_reader :types
+      def_delegator :@build, :types
+
+      # (see Concrete::Build#functions)
+      attr_reader :functions
+      def_delegator :@build, :functions
+
+      # Initialize the context.
+      #
+      # @param build [Concrete::Build]
+      # @param generics [{::String => Concrete::Type}]
+      def initialize(build, generics)
+        @build = build
+        @generics = generics
+        @instructions = []
+        @blocks = {}
+        @params = []
+        freeze
+      end
+    end
+  end
+end

data/lib/carbon/tacky/function.rb

@@ -0,0 +1,137 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Tacky
+    # A pseudo function.  This is used for definitions in order to better
+    # serialize them.  However, each instruction uses a {Concrete::Type}
+    # instead of the LLVM type that it corresponds to, allowing expansion
+    # only upon generation.
+    #
+    # @api semiprivate
+    class Function
+      # A mutable counter for giving out instruction ids.  This makes it so
+      # that _all_ instruction ids are unique for every function.
+      #
+      # @api private
+      class Counter
+        # The value.
+        # @return [::Numeric]
+        attr_reader :value
+
+        # Initialize the counter.
+        #
+        # @param value [::Numeric] The initial value of the counter.
+        def initialize(value = 0)
+          @value = value
+        end
+
+        # Increments the counter by one, and returns the new value.
+        #
+        # @return [::Numeric]
+        def increment
+          @value += 1
+        end
+      end
+
+      # The basic blocks of the function.  The first block is expected to be
+      # the entry block; the rest can be in any order.
+      #
+      # @return [<Tacky::Block>]
+      attr_reader :blocks
+
+      # The instruction id counter.
+      #
+      # @return [Counter]
+      attr_reader :counter
+
+      # Creates a function with the given parameters and blocks.  The
+      # parameters are required; the blocks should not be given.
+      #
+      # @param parameters [<Concrete::Type>] The parameters that are passed
+      #   to the function.
+      # @param blocks [<Tacky::Block>] Should not be used.
+      def initialize(parameters, blocks = [])
+        @blocks = blocks
+        @parameters = parameters
+        @counter = Counter.new
+        params
+        freeze
+        build(&Proc.new) if block_given?
+      end
+
+      # Creates a new {Tacky::Block} with the given name, adding it to the
+      # block list, and returns it.
+      #
+      # @param name [::String] The name of the new block.
+      # @return [Tacky::Block] The new block.
+      def add(name = "")
+        block = Block.new(self, name)
+        @blocks << block
+        block
+      end
+
+      # Finds the block with the given name, if it exists.  Note that multiple
+      # blocks can have the same name and still be disparate.
+      #
+      # @param name [::String] The name of the block to find.
+      # @return [Tacky::Block] If the block can be found.
+      # @return [nil] Otherwise.
+      def find(name)
+        @blocks.find { |b| b.name == name }
+      end
+
+      # Returns a set of dependencies that the function depends on.  The set
+      # is built by asking the constituant blocks for their dependencies,
+      # and merging them all into one set.  If no blocks exist, or there are
+      # no dependencies, an empty set is returned.
+      #
+      # @api private
+      # @return [Set<Concrete::Type>] The dependencies of the function.
+      def dependencies
+        @blocks.map(&:dependencies).inject(Set.new, :merge)
+      end
+
+      # Creates the function for LLVM.  This has three main steps: first, mark
+      # the function parameters with names.  Second, create the function blocks
+      # for instructional use.  Third, call the constituant blocks for them
+      # to build themselves.
+      #
+      # @api private
+      # @param function [::LLVM::Function] The LLVM function.
+      # @param build [Concrete::Build] The build.  This should contain all
+      #   relevant information for building this function.
+      # @param generics [{::String => Concrete::Type}] The generics that are
+      #   being applied to the function.
+      # @return [void]
+      def call(function, build, generics)
+        context = Context.new(build, generics)
+        mark_function_params(context, function)
+
+        @blocks.each do |block|
+          context.blocks[block] = function.basic_blocks.append(block.name)
+        end.each { |block| block.call(context) }
+      end
+
+      # The parameters of the function.  These are enclosed with a
+      # {Tacky::Parameter} to allow the name of said parameters to be set.
+      # The parameters are given an index and a type.
+      #
+      # @return [Tacky::Parameter]
+      def params
+        @params ||= @parameters.each_with_index.map do |type, i|
+          Tacky::Parameter.new(i, type)
+        end
+      end
+
+    private
+
+      def mark_function_params(context, function)
+        params.zip(function.params).each do |(param, arg)|
+          arg.name = param.name
+          context.params << arg
+        end
+      end
+    end
+  end
+end

data/lib/carbon/tacky/instruction.rb

@@ -0,0 +1,170 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Tacky
+    # An instruction.  This is the building block of the rest of the Tacky
+    # structures.  Each instruction performs some sort of action.
+    class Instruction < Value
+      # Instructions that can be represented by this class that can have a
+      # name parameter.
+      #
+      # @return [<::String>]
+      NAMED_INSTRUCTIONS = %w(
+        add alloca and array_alloca array_malloc ashr bit_cast exact_sdiv
+        extract_element extract_value fadd fcmp fdiv fmul fp2si fp2ui fp_cast
+        fp_ext fp_trunc frem fsub gep global_string global_string_pointer icmp
+        inbounds_gep insert_element insert_value int2ptr int_cast invoke
+        is_not_null is_null load lshr malloc mul neg not nsw_add nsw_mul
+        nsw_neg nsw_sub nuw_add nuw_mul nuw_neg nuw_sub or phi pointer_cast
+        ptr2int ptr_diff sdiv select sext sext_or_bit_cast shl shuffle_vector
+        si2fp srem struct_gep sub trunc trunc_or_bit_cast udiv ui2fp urem xor
+        zext zext_or_bit_cast
+      ).freeze
+
+      # The name of the instruction.  This is limited to a specific set; see
+      # the method names on {Tacky::Builder} for what they can be.
+      #
+      # @return [::String]
+      attr_reader :instruction
+
+      # The parameters of the instruction.
+      #
+      # @return [<Reference, Parameter, Value, ::Object>]
+      attr_reader :parameters
+
+      # Initializes the instruction with the given id, name, and parameters.
+      #
+      # @param id [::Numeric] The ID of the instruction.  This is the number
+      #   of the instruction in the block.
+      # @param name [::Symbol, ::String] The name of the instruction.
+      # @param parameters [<Reference, Parameter, Value, ::Object>] The
+      #   parameters to be used with the instruction.
+      def initialize(id, name, parameters)
+        @value = id
+        @instruction = name.to_s
+        @parameters = parameters
+      end
+
+      # Builds the instruction.  If the instruction is special, i.e. it starts
+      # with an underscore, it is handled seperately.  Otherwise, it is handled
+      # normally.
+      #
+      # @api private
+      # @see #generate_null
+      # @see #generate_sizeof
+      # @see #generate_normal
+      # @param context [Tacky::Context] The context.
+      # @param block [::LLVM::BasicBlock] The block.
+      # @return [LLVM::Value]
+      def call(context, block)
+        case @instruction
+        when "_null"   then generate_null(context, block)
+        when "_sizeof" then generate_sizeof(context, block)
+        else generate_normal(context, block)
+        end
+      end
+
+      # The dependencies of the instruction.  If any of the parameters are a
+      # {Concrete::Type}, it is set as a dependency, and the result is put into
+      # a set and returned.
+      #
+      # @api private
+      # @return [Set<Concrete::Type>]
+      def dependencies
+        @parameters.select { |p| p.is_a?(Concrete::Type) }.inject(Set.new, :<<)
+      end
+
+      # Retrieves the name of the instruction.  The name of the instruction
+      # is essentally the name used by the return value that represents the
+      # instruction.  If this instruction is not a named instruction (i.e.
+      # {#instruction} is not in {NAMED_INSTRUCTIONS}), or the last parameter
+      # isn't a string, it returns an empty string (`""`).  Otherwise, it
+      # returns the last parameter.
+      #
+      # @return [::String] The name of the instruction.
+      def name
+        if NAMED_INSTRUCTIONS.include?(@instruction) &&
+           @parameters.last.is_a?(::String)
+          @parameters.last
+        else
+          ""
+        end
+      end
+
+      # Sets the name of the instruction.  The name of the instruction is
+      # essentially the name used by the return value that represents the
+      # instruction.  If this instruction is not a named instruction (i.e.
+      # {#instruction} is not in {NAMED_INSTRUCTIONS}), then this does nothing.
+      # If the last parameter is a string, this sets the last parameter to the
+      # new name.  Otherwise, it adds the name to the end of the parameters
+      # list.
+      #
+      # @param name [::String] The new name of the instruction.
+      # @return [::String] The new name of the instruction.
+      def name=(name)
+        return name unless NAMED_INSTRUCTIONS.include?(@instruction)
+        if @parameters.last.is_a?(::String)
+          @parameters[-1] = name
+        else
+          @parameters << name
+        end
+
+        name
+      end
+
+    private
+
+      # Generates a "normal" instruction.  It maps the parameters, then sends
+      # the instruction over to a builder for LLVM, before returning the
+      # result of the instruction.
+      #
+      # @param context [Tacky::Context] The context.
+      # @param block [::LLVM::BasicBlock] The block.
+      # @return [::LLVM::Value] The result of the llvm instruction.
+      def generate_normal(context, block)
+        params = mapped_parameters(context, block)
+        value = nil
+
+        block.build { |b| value = b.public_send(@instruction, *params) }
+        value
+      end
+
+      def generate_null(context, block)
+        params = mapped_parameters(context, block)
+        context.types.fetch(params.first).last.null
+      end
+
+      def generate_sizeof(context, block)
+        params = mapped_parameters(context, block)
+        context.types.fetch(params.first).last.size
+      end
+
+      def mapped_parameters(context, block)
+        @parameters.map { |p| mapped_parameter(p, context, block) }
+      end
+
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def mapped_parameter(param, context, _block)
+        case param
+        when Concrete::Type   then map_parameter_type(param, context)
+        when Tacky::Reference then context.instructions.fetch(param.id)
+        when Tacky::Parameter then context.params.fetch(param.value)
+        when ::Integer then LLVM.Int(param)
+        when ::Float then LLVM.Float(param)
+        when ::String then param
+        else fail ArgumentError, "Unexpected parameter #{param.class}"
+        end
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+
+      def map_parameter_type(param, context)
+        if param.function?
+          context.functions.fetch(param)
+        else
+          context.types.fetch(param).last
+        end
+      end
+    end
+  end
+end

data/lib/carbon/tacky/parameter.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Tacky
+    # A parameter that's been passed in by a function.  This just contains the
+    # number, name, and type of the parameter, for proper mapping later.
+    class Parameter < Value
+      # Initializes the parameter with the given number, name, and type.
+      #
+      # @param number [::Numeric] The number of the parameter.  The far left
+      #   of a parameter list is zero (0).
+      # @param type [Concrete::Type] The type of the parameter.
+      # @param name [::String] The name of the parameter.  If one is not given,
+      #   the name is autogenerated.
+      def initialize(number, type, name = "")
+        @name = name
+        @type = type
+        @value = number
+      end
+    end
+  end
+end

data/lib/carbon/tacky/reference.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Tacky
+    # A "reference."  A reference is essentially a mapping to an instruction
+    # that returned a value, and the reference takes the place of said value.
+    # The reference represents the return value of an instruction.
+    class Reference
+      # The id of the instruction that this reference points to.
+      #
+      # @return [::Numeric]
+      attr_reader :id
+
+      # Initializes the reference with the given ID.
+      #
+      # @param id [::Numeric] The ID.
+      def initialize(id)
+        @id = id
+      end
+    end
+  end
+end

data/lib/carbon/tacky/value.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Tacky
+    # A "value."  A value can be a parameter, a reference, or a number.
+    #
+    # @todo TODO: Figure out if I still need this.
+    class Value
+      # The name of the value.  This can be set in order to make the resulting
+      # LLVM IR pretty.
+      #
+      # @return [::String]
+      attr_accessor :name
+
+      # The type of the value.  This is used in order to determine typing
+      # information for LLVM.
+      #
+      # @return [Concrete::Type] If it is set.
+      # @return [nil] If it is not set or determinable.
+      attr_accessor :type
+
+      # The actual value.
+      #
+      # @return [::Object]
+      attr_accessor :value
+
+      # Initialize the value.
+      #
+      # @param name [::String] The name of the value.
+      # @param type [Concrete::Type, nil] The type of the value.
+      # @param value [::Object] The actual value.
+      def initialize(name, type, value)
+        @name = name
+        @type = type
+        @value = value
+      end
+    end
+  end
+end