An AT&T assembly interpreter. It's not too great but you can do some simple math, as well as print out register values.

asm_interp.rb

# registers
$reg = {eax: 0, ebx: 0, ecx: 0, edx: 0, esi:0, edi: 0, esp: 0, ebp: 0}
$Stack = []
$verbose = false

def gr(term); $reg[term]; end
def valid_reg(term); !$reg[term[1..-1].to_sym].nil?; end
def valid_imm(term); term[1..-1].to_i && term != "$0" ? true : false; end

def eval_asm(line)
  comp = line.scan(/(\w+){1}(?:|,?\s?(.*?))$/).flatten
  op = comp[0]
  arg = []
  arg = comp[1].scan(/([\w%]+){1}(?:|,?\s?(.*?))$/).flatten.compact if !comp[1].nil?
    
  src = nil
  src_reg = false
  dest = :eax

  unless(arg.empty?)
    src = arg[0].to_i if valid_imm(arg[0])     #immediate
    if valid_reg(arg[0])   #register
      src = arg[0][1..-1].to_sym 
      src_reg = true
    end
    if(arg.size == 2)
      dest = arg[1][1..-1].to_sym if valid_reg(arg[1])
    end
  end
  
  if $verbose
    puts "----"
    puts "op: #{op.inspect}"
    puts "arg: #{arg.inspect}, size: #{arg.size}"
    puts "src: #{src.inspect}"
    puts "dest: #{dest.inspect}"
    puts "----"
  end
  
  case arg.size
  when 0
    case op
    when 'print_stack'
      $Stack.tap{|x| p x}
    else
      puts " => No such method"
    end
  when 1
    case op
    when 'print'
      puts " => " + $reg[src].to_s
    when 'pushl'
      $Stack << ( src_reg ? $reg[src] : src )
    when 'popl'
      $reg[src] = $Stack.pop
    else
      puts " => No such method"
    end
  when 2
    case op
    when 'movl'
      $reg[dest] = src
    when 'addl'
      $reg[dest] = $reg[dest] + (src_reg ? $reg[src] : src)
    when 'subl'
      $reg[dest] = $reg[dest] - (src_reg ? $reg[src] : src)
    when 'imull'
      $reg[dest] = $reg[dest] * (src_reg ? $reg[src] : src)
    else
      puts " => No such method"
    end
  end
end

def read_asm(input)
  input.split(/\r?\n/).each do |line|
    eval_asm(line)
  end
end

#read_asm("movl 4, %ebx\naddl 4, %ebx\nprint %ebx")
while cmd = gets.chomp
  break if cmd == "quit"
  read_asm(cmd)
end