step9/0000775000100000010000000000000011026510032011376 5ustar vidarhvidarhstep9/test.c0000664000100000010000000000005611026506447012541 0ustar vidarhvidarh int main() { while (foo()) { bar(); } } step9/Makefile0000664000100000010000000000020511026506033013041 0ustar vidarhvidarh all: step9 step9: step9.o runtime.o step9.o: step9.s step9.s: step9.rb ruby step9.rb >step9.s clean: rm -f *~ *.o *.s step9 step9/runtime.c0000664000100000010000000000132711026505536013245 0ustar vidarhvidarh signed int add(signed int a, signed int b) { return a + b; } signed int sub(signed int a, signed int b) { return a - b; } signed int div(signed int a, signed int b) { return a / b; } signed int mul(signed int a, signed int b) { return a * b; } signed int ne(signed int a, signed int b) { return a != b; } signed int eq(signed int a, signed int b) { return a == b; } signed int not(signed int a) { return !a; } // Note that our "and" won't shortcircuit, as the // evaluation happens before this function is called. signed int and(signed int a, signed int b) { return a && b; } signed int gt(signed int a, signed int b) { return a > b; } signed int lt(signed int a, signed int b) { return a < b; } step9/step9.rb0000664000100000010000000001201711026507312012777 0ustar vidarhvidarh#!/bin/env ruby DO_BEFORE= [] DO_AFTER= [] class Function attr_reader :args,:body def initialize args,body @args = args @body = body end end class Scope def initialize compiler,func @c = compiler @func = func end def get_arg a a = a.to_sym @func.args.each_with_index {|arg,i| return [:arg,i] if arg == a } return [:atom,a] end end class Compiler PTR_SIZE=4 def initialize @global_functions = {} @string_constants = {} @seq = 0 end def get_arg(scope,a) # Handle strings or subexpressions return compile_exp(scope,a) if a.is_a?(Array) return [:int, a] if (a.is_a?(Fixnum)) return scope.get_arg(a) if (a.is_a?(Symbol)) seq = @string_constants[a] return [:strconst,seq] if seq seq = @seq @seq += 1 @string_constants[a] = seq return [:strconst,seq] end def output_constants puts "\t.section .rodata" @string_constants.each do |c,seq| puts ".LC#{seq}:" puts "\t.string \"#{c}\"" end end def output_functions @global_functions.each do |name,func| puts ".globl #{name}" puts ".type #{name}, @function" puts "#{name}:" puts "\tpushl %ebp" puts "\tmovl %esp, %ebp" compile_exp(Scope.new(self,func),func.body) puts "\tleave" puts "\tret" puts "\t.size #{name}, .-#{name}" puts end end def compile_defun scope,name, args, body @global_functions[name] = Function.new(args,body) return [:subexpr] end def compile_ifelse scope,cond, if_arm,else_arm compile_exp(scope,cond) puts "\ttestl\t%eax, %eax" else_arm_seq = @seq end_if_arm_seq = @seq + 1 @seq += 2 puts "\tje\t.L#{else_arm_seq}" compile_exp(scope,if_arm) puts "\tjmp\t.L#{end_if_arm_seq}" puts ".L#{else_arm_seq}:" compile_exp(scope,else_arm) puts ".L#{end_if_arm_seq}:" return [:subexpr] end def compile_lambda scope,args, body name = "lambda__#{@seq}" @seq += 1 compile_defun(scope,name, args,body) puts "\tmovl\t$#{name},%eax" return [:subexpr] end def compile_eval_arg scope,arg, call = false prefix = call ? "*" : "" atype, aparam = get_arg(scope,arg) return "$.LC#{aparam}" if atype == :strconst return "$#{aparam}" if atype == :int return aparam.to_s if atype == :atom if atype == :arg puts "\tmovl\t#{PTR_SIZE*(aparam+2)}(%ebp),%eax" end return "#{prefix}%eax" end def compile_call scope,func, args stack_adjustment = PTR_SIZE + (((args.length+0.5)*PTR_SIZE/(4.0*PTR_SIZE)).round) * (4*PTR_SIZE) puts "\tsubl\t$#{stack_adjustment}, %esp" args.each_with_index do |a,i| param = compile_eval_arg(scope,a) puts "\tmovl\t#{param},#{i>0 ? i*4 : ""}(%esp)" end res = compile_eval_arg(scope,func,true) res = "*%eax" if res == "%eax" # Ugly. Would be nicer to retain some knowledge of what "res" contains puts "\tcall\t#{res}" puts "\taddl\t$#{stack_adjustment}, %esp" return [:subexpr] end def compile_do(scope,*exp) exp.each { |e| compile_exp(scope,e) } return [:subexpr] end def compile_assign scope, left, right source = compile_eval_arg(scope, right) atype, aparam = get_arg(scope,left) raise "Expected a variable on left hand side of assignment" if atype != :arg puts "\tmovl\t#{source},#{PTR_SIZE*(aparam+2)}(%ebp)" return [:subexpr] end def compile_while(scope, cond, body) start_while_seq = @seq cond_seq = @seq + 1 @seq += 2 puts "\tjmp\t.L#{cond_seq}" puts ".L#{start_while_seq}:" compile_exp(scope,body) var = compile_eval_arg(scope,cond) puts ".L#{cond_seq}:" puts "\ttestl\t#{var}, #{var}" puts "\tjne\t.L#{start_while_seq}" return [:subexpr] end def compile_exp(scope,exp) return if !exp || exp.size == 0 return compile_do(scope,*exp[1..-1]) if exp[0] == :do return compile_defun(scope,*exp[1..-1]) if (exp[0] == :defun) return compile_ifelse(scope,*exp[1..-1]) if (exp[0] == :if) return compile_lambda(scope,*exp[1..-1]) if (exp[0] == :lambda) return compile_assign(scope,*exp[1..-1]) if (exp[0] == :assign) return compile_while(scope,*exp[1..-1]) if (exp[0] == :while) return compile_call(scope,exp[1],exp[2]) if (exp[0] == :call) return compile_call(scope,exp[0],exp[1..-1]) end def compile_main(exp) # Taken from gcc -S output puts <