107 lines
4.0 KiB
Ruby
107 lines
4.0 KiB
Ruby
require_relative "attributed"
|
|
|
|
module Arm
|
|
|
|
# A Machines main responsibility is to instantiate Instructions.
|
|
# Arm instructions live in their own directory and are derived from their Risc
|
|
# couterparts to inherit list functionality
|
|
|
|
# Shortcuts are created to easily instantiate Instruction objects.
|
|
# Example: ArmMachine.pop -> StackInstruction.new( {:opcode => :pop}.merge(options) )
|
|
#
|
|
# Instructions work with options, so you can pass anything in, and the only thing the functions
|
|
# does is save you typing the clazz.new. It passes the function name as the :opcode
|
|
|
|
class ArmMachine
|
|
|
|
# conditions specify all the possibilities for branches. Branches are b + condition
|
|
# Example: beq means brach if equal.
|
|
# :al means always, so bal is an unconditional branch (but b() also works)
|
|
CONDITIONS = [:al ,:eq ,:ne ,:lt ,:le ,:ge,:gt ,:cs ,:mi ,:hi ,:cc ,:pl,:ls ,:vc ,:vs]
|
|
|
|
# here we create the shortcuts for the "standard" arm instructions that we use.
|
|
# (note that it is possible to add instructions by adding new classes and optionally
|
|
# new factory functions to this class)
|
|
def self.init
|
|
[:push, :pop].each do |inst|
|
|
define_instruction_one(inst , StackInstruction)
|
|
end
|
|
[:adc, :add, :and, :bic, :eor, :orr, :rsb, :rsc, :sbc, :sub , :mul].each do |inst|
|
|
define_instruction_three(inst , LogicInstruction)
|
|
end
|
|
[:mov, :mvn].each do |inst|
|
|
define_instruction_two(inst , MoveInstruction)
|
|
end
|
|
[:cmn, :cmp, :teq, :tst].each do |inst|
|
|
define_instruction_two(inst , CompareInstruction)
|
|
end
|
|
[:strb, :str , :ldrb, :ldr].each do |inst|
|
|
define_instruction_three(inst , MemoryInstruction)
|
|
end
|
|
[:b, :call , :swi].each do |inst|
|
|
define_instruction_one(inst , CallInstruction)
|
|
end
|
|
|
|
# create all possible branch instructions, but the CallInstruction demangles the
|
|
# code, and has opcode set to :b and :condition_code set to the condition
|
|
CONDITIONS.each do |suffix|
|
|
define_instruction_one("b#{suffix}".to_sym , CallInstruction)
|
|
define_instruction_one("call#{suffix}".to_sym , CallInstruction)
|
|
end
|
|
end
|
|
|
|
def self.def_method(name, &block)
|
|
self.class.send(:define_method, name , &block)
|
|
end
|
|
|
|
def self.class_for clazz
|
|
my_module = self.class.name.split("::").first
|
|
clazz_name = clazz.name.split("::").last
|
|
if(my_module != Risc )
|
|
module_class = eval("#{my_module}::#{clazz_name}") rescue nil
|
|
clazz = module_class if module_class
|
|
end
|
|
clazz
|
|
end
|
|
|
|
#defining the instruction (opcode, symbol) as an given class.
|
|
# the class is a Risc::Instruction derived base class and to create machine specific function
|
|
#
|
|
# These instruction classes must follow a naming pattern and take a hash in the contructor
|
|
# Example, a mov() opcode instantiates a Arm::MoveInstruction < Risc::MoveInstruction ,
|
|
#
|
|
def self.define_instruction_one(inst , clazz , defaults = {} )
|
|
clazz = class_for(clazz)
|
|
def_method(inst) do |first , options = nil|
|
|
options = {} if options == nil
|
|
options.merge defaults
|
|
options[:opcode] = inst
|
|
clazz.new(first , options)
|
|
end
|
|
end
|
|
|
|
# same for two args (left right, from to etc)
|
|
def self.define_instruction_two(inst , clazz , defaults = {} )
|
|
clazz = self.class_for(clazz)
|
|
def_method(inst) do |left ,right , options = nil|
|
|
options = {} if options == nil
|
|
options.merge defaults
|
|
options[:opcode] = inst
|
|
clazz.new(left , right ,options)
|
|
end
|
|
end
|
|
|
|
# same for three args (result = left right,)
|
|
def self.define_instruction_three(inst , clazz , defaults = {} )
|
|
clazz = self.class_for(clazz)
|
|
def_method(inst) do |result , left ,right = nil , options = nil|
|
|
options = {} if options == nil
|
|
options.merge defaults
|
|
options[:opcode] = inst
|
|
clazz.new(result, left , right ,options)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
Arm::ArmMachine.init
|