Class: Tem::Builders::Isa

Inherits:
Object
  • Object
show all
Defined in:
lib/tem/builders/isa.rb

Overview

Builder class for the ISA (Instruction Set Architecture) builder.

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(target, abi, opcode_type) ⇒ Isa

Creates a builder targeting a module / class.



117
118
119
120
121
122
 
# File 'lib/tem/builders/isa.rb', line 117

def initialize(target, abi, opcode_type)
  @target = target
  @target.const_set :Abi, abi
  @abi = abi
  @opcode_type = opcode_type
end

Instance Attribute Details

#target ⇒ Object (readonly)

The module / class impacted by the builder.



114
115
116
 
# File 'lib/tem/builders/isa.rb', line 114

def target
  @target
end

Class Method Details

.define_isa(class_or_module, abi, options) {|new(class_or_module, abi, options[:opcode_type])| ... } ⇒ Object

Creates a builder targeting a module / class.

class_or_module will receive the ISA method definitions. abi should be a class or module containing the ABI definitions that the ISA definitions refer to.

The following options are supported:

opcode_type:: the ABI type encoding the instructions' opcodes (required)

Yields:

  • (new(class_or_module, abi, options[:opcode_type])) 


23
24
25
 
# File 'lib/tem/builders/isa.rb', line 23

def self.define_isa(class_or_module, abi, options)  # :yields: isa
  yield new(class_or_module, abi, options[:opcode_type])
end

Instance Method Details

#instruction(opcode, name, *iargs) ⇒ Object

Defines the methods for handling an instruction in the IA.

The instruction’s arguments are provided as an array of hashes. Each hash describes one argument, and the ordering in the array reflects the encoding order. The following hash keys are supported: 

name:: if defined, the argument can be provided as a named argument;
       named arguments must follow positional arguments
type:: the ABI type encoding the argument (required)
reladdr:: if defined, the encoded argument value is relative to the
          address of the instruction containing the argument;

The result of encoding an instruction is a Hash with the following keys:

emit:: the bytes to be emitted into the code stream 
link_directives:: an array of directives for the code linker

Each linker directive refers to an address cell (location in the code representing an address that the linker must adjust. The following keys can be present:

type:: the ABI type for the address cell (required)
offset:: the address cell's offset in the emitted bytes (required)
address:: the absolute address to point to (mutually exclusive with label)
label:: the name of a label that the address must point to
relative:: if false, the address cell holds an absolute address;
           otherwise, the cell's value is computed as follows:
           target address - cell address + value of relative;
           (optional, default value is false)

The following methods are defined for a type named ‘name’:

* encode_name(*arguments) -> Hash



55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
 
# File 'lib/tem/builders/isa.rb', line 55

def instruction(opcode, name, *iargs)
  encoded_opcode = @abi.send :"to_#{@opcode_type}", opcode
  abi = @abi  # Capture the ABI in the method closures.
  named_indexes = {}
  iargs.map { |iarg| iarg[:name] }.
        each_with_index { |argname, i| named_indexes[argname] = i if argname }
  arg_encode_msgs = iargs.map { |iarg| :"to_#{iarg[:type]}" }
  defines = Proc.new do 
    define_method :"emit_#{name}" do |*args|
      # Flatten arguments by resolving named parameters to indexes.
      arg_index = 0
      fargs = []
      args.each_with_index do |arg, i|
        fargs[i] = arg and next unless arg.kind_of? Hash
        
        if i != args.length - 1
          raise "Named arguments must follow inline arguments! (arg #{i})"
        end
        arg.each do |k, v|
          raise "#{name} has no #{k} argument" unless i = named_indexes[k]
          raise "Argument #{k} was already assigned a value" if fargs[i]
          fargs[i] = v
        end
      end
        
      arg_count = fargs.inject(0) { |acc, v| v.nil? ? acc : acc + 1 }
      if arg_count != iargs.length
        raise "#{name} requires #{fargs.length} args, given #{arg_count}"
      end
      
      # Encode parameters.
      # @lines[@body.length] = Kernel.caller(0)
      
      emit = encoded_opcode
      link_directives = []
      fargs.each_with_index do |arg, i|
        if arg.kind_of?(Numeric) && !iargs[i][:reladdr]
          emit += abi.send arg_encode_msgs[i], arg
        else
          link_directive = { :type => iargs[i][:type], :offset => emit.length,
                             :relative => iargs[i][:reladdr] || false }
          if arg.kind_of? Numeric
            link_directive[:address] = arg.to_i
          else
            link_directive[:label] = arg.to_sym
          end
          link_directives << link_directive
          emit += abi.send arg_encode_msgs[i], 0
        end
      end
      { :emit => emit, :link_directives => link_directives }
    end
  end
  
  @target.class_eval(&defines)
  (class << @target; self; end).module_eval(&defines)
end