From 98a197a0ca81bbb6e2f0ee0b27bcb32a3036d6c5 Mon Sep 17 00:00:00 2001 From: Torsten Ruger Date: Mon, 21 Apr 2014 00:07:33 +0300 Subject: [PATCH] better builder names and remove the funny make syntax --- lib/asm/arm/instruction.rb | 21 ++++++++++----------- lib/asm/arm/memory_access_builder.rb | 15 +++++---------- lib/asm/arm/normal_builder.rb | 15 +++++---------- lib/asm/arm/stack_builder.rb | 17 ++++++----------- 4 files changed, 26 insertions(+), 42 deletions(-) diff --git a/lib/asm/arm/instruction.rb b/lib/asm/arm/instruction.rb index 5f27b239..47850a80 100644 --- a/lib/asm/arm/instruction.rb +++ b/lib/asm/arm/instruction.rb @@ -1,8 +1,8 @@ require "asm/assembly_error" require "asm/arm/instruction_tools" -require "asm/arm/builder_a" -require "asm/arm/builder_b" -require "asm/arm/builder_d" +require "asm/arm/normal_builder" +require "asm/arm/memory_access_builder" +require "asm/arm/stack_builder" module Asm module Arm @@ -80,34 +80,34 @@ module Asm s = @s ? 1 : 0 case opcode when :adc, :add, :and, :bic, :eor, :orr, :rsb, :rsc, :sbc, :sub - a = BuilderA.make(OPC_DATA_PROCESSING, OPCODES[opcode], s) + a = NormalBuilder.new(OPC_DATA_PROCESSING, OPCODES[opcode], s) a.cond = COND_BITS[@cond] a.rd = reg_ref(args[0]) a.rn = reg_ref(args[1]) a.build_operand args[2] a.write io, as when :cmn, :cmp, :teq, :tst - a = BuilderA.make(OPC_DATA_PROCESSING, OPCODES[opcode], 1) + a = NormalBuilder.new(OPC_DATA_PROCESSING, OPCODES[opcode], 1) a.cond = COND_BITS[@cond] a.rn = reg_ref(args[0]) a.rd = 0 a.build_operand args[1] a.write io, as when :mov, :mvn - a = BuilderA.make(OPC_DATA_PROCESSING, OPCODES[opcode], s) + a = NormalBuilder.new(OPC_DATA_PROCESSING, OPCODES[opcode], s) a.cond = COND_BITS[@cond] a.rn = 0 a.rd = reg_ref(args[0]) a.build_operand args[1] a.write io, as when :strb, :str - a = BuilderB.make(OPC_MEMORY_ACCESS, (opcode == :strb ? 1 : 0), 0) + a = MemoryAccessBuilder.new(OPC_MEMORY_ACCESS, (opcode == :strb ? 1 : 0), 0) a.cond = COND_BITS[@cond] a.rd = reg_ref(args[1]) a.build_operand args[0] a.write io, as, @ast_asm, self when :ldrb, :ldr - a = BuilderB.make(OPC_MEMORY_ACCESS, (opcode == :ldrb ? 1 : 0), 1) + a = MemoryAccessBuilder.new(OPC_MEMORY_ACCESS, (opcode == :ldrb ? 1 : 0), 1) a.cond = COND_BITS[@cond] a.rd = reg_ref(args[0]) a.build_operand args[1] @@ -116,13 +116,12 @@ module Asm # downward growing, decrement before memory access # official ARM style stack as used by gas if (opcode == :push) - a = BuilderD.make(1,0,1,0) + a = StackBuilder.new(1,0,1,0) else - a = BuilderD.make(0,1,1,1) + a = StackBuilder.new(0,1,1,1) end a.cond = COND_BITS[@cond] a.rn = 13 # sp - puts "ARGS #{args.inspect}" a.build_operand args a.write io, as when :b, :bl diff --git a/lib/asm/arm/memory_access_builder.rb b/lib/asm/arm/memory_access_builder.rb index ce03c68c..38aa93fa 100644 --- a/lib/asm/arm/memory_access_builder.rb +++ b/lib/asm/arm/memory_access_builder.rb @@ -4,10 +4,10 @@ module Asm module Arm # ADDRESSING MODE 2 # Implemented: immediate offset with offset=0 - class BuilderB + class MemoryAccessBuilder include Asm::Arm::InstructionTools - def initialize + def initialize(inst_class, byte_access, load_store) @cond = 0b1110 @inst_class = 0 @i = 0 #I flag (third bit) @@ -19,18 +19,13 @@ module Asm @rn = 0 @rd = 0 @operand = 0 + @inst_class = inst_class + @byte_access = byte_access + @load_store = load_store end attr_accessor :cond, :inst_class, :i, :pre_post_index, :add_offset, :byte_access, :w, :load_store, :rn, :rd, :operand - def self.make(inst_class, byte_access, load_store) - a = new - a.inst_class = inst_class - a.byte_access = byte_access - a.load_store = load_store - a - end - # Build representation for target address def build_operand(arg) #str / ldr are _seruous instructions. With BIG possibilities no half are implemented diff --git a/lib/asm/arm/normal_builder.rb b/lib/asm/arm/normal_builder.rb index 90008a7b..74ecbbba 100644 --- a/lib/asm/arm/normal_builder.rb +++ b/lib/asm/arm/normal_builder.rb @@ -2,10 +2,10 @@ module Asm module Arm # ADDRESSING MODE 1 # Complete! - class BuilderA + class NormalBuilder include Asm::Arm::InstructionTools - def initialize + def initialize(inst_class, opcode, s) @cond = 0b1110 @inst_class = 0 @i = 0 @@ -14,18 +14,13 @@ module Asm @rn = 0 @rd = 0 @operand = 0 + @inst_class = inst_class + @opcode = opcode + @s = s end attr_accessor :cond, :inst_class, :i, :opcode, :s, :rn, :rd, :operand - def self.make(inst_class, opcode, s) - a = new - a.inst_class = inst_class - a.opcode = opcode - a.s = s - a - end - def calculate_u8_with_rr(arg) parts = arg.value.to_s(2).rjust(32,'0').scan(/^(0*)(.+?)0*$/).flatten pre_zeros = parts[0].length diff --git a/lib/asm/arm/stack_builder.rb b/lib/asm/arm/stack_builder.rb index 6253b469..444045d8 100644 --- a/lib/asm/arm/stack_builder.rb +++ b/lib/asm/arm/stack_builder.rb @@ -1,10 +1,10 @@ module Asm module Arm # ADDRESSING MODE 4 - class BuilderD + class StackBuilder include Asm::Arm::InstructionTools - def initialize + def initialize(pre_post, up_down, write, store_load) @cond = 0b1110 @inst_class = Asm::Arm::Instruction::OPC_STACK @pre_post_index = 0 @@ -14,19 +14,14 @@ module Asm @store_load = 0 @rn = 0 @operand = 0 + @pre_post_index = pre_post + @up_down = up_down + @write_base = write + @store_load = store_load end attr_accessor :cond, :inst_class, :pre_post_index, :up_down, :s, :write_base, :store_load, :rn, :operand - def self.make(pre_post, up_down, write, store_load) - a = new - a.pre_post_index = pre_post - a.up_down = up_down - a.write_base = write - a.store_load = store_load - a - end - # Build representation for source value def build_operand(arg) if (arg.is_a?(Array))