| blob | bdbceab2bb8c307432599cdeaeacade5d4985696 |
1 require 'voodoo/generators/common_code_generator'
3 module Voodoo
4 # = ARM GNU Assembler Code Generator
5 #
6 # The ARM code generator generates assembly code for use with
7 # the GNU assembler.
8 #
9 # == Calling Convention
10 #
11 # The first four arguments are passed in the registers r0 through r3.
12 # Any additional arguments are passed on the stack, starting at
13 # r13. r13 will always be a multiple of 8.
14 #
15 # The return address for the called function is passed in r14.
16 #
17 # The called function will store its return value in r0.
18 #
19 # The called function is required to preserve the values of registers
20 # r4 through r11 and register r13.
21 #
22 # This calling convention is compatible with the Procedure Call
23 # Standard for the ARM Architecture (AAPCS).
24 #
25 # == Call Frames
26 #
27 # Call frames have the following layout:
28 #
29 # When a function is called, it receives a stack frame that looks like
30 # the following:
31 #
32 # :
33 # old frame
34 # padding
35 # argn
36 # :
37 # arg4 <-- r13 points here
38 #
39 # The function prologue of functions generated by this code generator
40 # creates activation frames that look as follows:
41 #
42 # :
43 # old frame
44 # padding
45 # argn
46 # :
47 # arg4 <-- r11 points here
48 # saved r14
49 # saved r11
50 # :
51 # saved r4 <-- r13 points here
52 #
53 # == Register Usage
54 #
55 # Inside a function, registers r4..r8 and r10 are used for local variables
56 # and function arguments, whereas r11 is used as a frame pointer.
57 #
58 # r12 is used as a temporary, and r3 is used when another temporary
59 # is needed.
60 #
61 class ARMGasGenerator < CommonCodeGenerator
62 def initialize params
63 @WORDSIZE = 4
64 @CODE_ALIGNMENT = 4
65 @DATA_ALIGNMENT = @WORDSIZE
66 @FUNCTION_ALIGNMENT = @WORDSIZE
68 @INITIAL_FRAME_SIZE = 2 * @WORDSIZE
69 @NREGISTER_ARGS = 4
70 @NREGISTER_LOCALS = 6
71 @FP = :r11
72 @RETURN = :r0
73 @TEMPORARY = :r12
74 @constants = []
75 @frame_offset = 0
76 @frame_size = 0
77 @function_end_label = nil
78 @imports = {}
79 @if_labels = []
80 @saved_registers = []
81 super params
82 @output_file_suffix = '.s'
83 @features.merge! \
84 :'bits-per-word' => '32',
85 :'byte-order' => 'little-endian',
86 :'bytes-per-word' => 4
87 end
89 # Create an entry in the constants table,
90 # returning the label that will refer to the constant.
91 # The value may be an integer or a label.
92 def add_constant value
93 label = gensym
94 @constants << [label, value]
95 label
96 end
98 def align alignment = nil
99 unless alignment
100 # Get default alignment
101 case @section
102 when :code
103 alignment = @CODE_ALIGNMENT
104 when :data
105 alignment = @DATA_ALIGNMENT
106 when :function
107 alignment = @FUNCTION_ALIGNMENT
108 else
109 # Use data alignment as default
110 alignment = @DATA_ALIGNMENT
111 end
112 end
113 emit ".align #{alignment}\n" unless alignment == 0
114 end
116 # Returns the fp-relative offset for the nth (0-based) argument.
117 def arg_offset n
118 (n - @NREGISTER_ARGS) * @WORDSIZE
119 end
121 # Returns an fp-relative reference for the nth (0-based) argument.
122 def arg_reference n
123 offset_reference arg_offset(n)
124 end
126 # Return the register in which the nth (0-based) argument is stored, or
127 # nil if not stored in a register
128 def arg_register n
129 # The first @NREGISTER_ARGS arguments are in the v registers,
130 # the rest are on the stack.
131 if register_arg? n
132 "v#{n + 1}"
133 else
134 nil
135 end
136 end
138 # Test if op is a binary operation
139 def assymetric_binop? op
140 [:asr, :bsr, :div, :mod, :rol, :ror, :shl, :shr, :sub].member?(op)
141 end
143 # Test if a value is an at-expression
144 def at_expr? value
145 value.respond_to?(:[]) && value[0] == :'@'
146 end
148 # Begins a new block.
149 def begin_block *code
150 emit "# begin block\n"
151 # If we are starting a block at top level, create a frame
152 if @environment == @top_level
153 nlocals = count_locals code
154 create_frame nlocals, false
155 end
156 @environment = Environment.new @environment
157 end
159 # Emit function prologue and declare _formals_ as function arguments
160 def begin_function formals, nlocals
161 if @environment != @top_level
162 raise "Can only begin a function at top level"
163 end
165 @function_end_label = gensym
166 emit "# function #{formals.join ' '}\n"
167 environment = Environment.new @environment
168 formals.each_with_index do |formal, i|
169 if i < @NREGISTER_ARGS
170 environment.add_arg formal, arg_register(i)
171 else
172 environment.add_arg formal, arg_offset(i)
173 end
174 end
175 @environment = environment
176 emit_function_prologue formals, nlocals
177 end
179 # Test if op is a binary operation
180 def binop? op
181 assymetric_binop?(op) || symmetric_binop?(op)
182 end
184 # Define a byte with the given value
185 def byte value
186 emit ".byte #{value}\n"
187 end
189 # Call a function.
190 def call func, *args
191 emit "# call #{func} #{args.join ' '}\n"
193 # Calculate how many arguments need to be pushed on
194 # the stack, and allocate space for them.
195 nstack_args = number_of_stack_arguments args.length
196 old_frame_offset = @frame_offset
197 old_frame_size = @frame_size
198 grow_frame nstack_args if nstack_args > 0
200 # Put stack arguments on the stack
201 (@NREGISTER_ARGS...args.length).each do |n|
202 load_value_into_register args[n], @TEMPORARY
203 emit "str #{@TEMPORARY}, " +
204 "[sp , \##{(n - @NREGISTER_ARGS) * @WORDSIZE}]\n"
205 end
207 # Put register arguments in the right registers
208 nregister_args = number_of_register_arguments args.length
209 nregister_args.times do |n|
210 load_value_into_register args[n], :"a#{n + 1}"
211 end
213 # Call function
214 if global? func
215 emit "bl #{func}\n"
216 else
217 func_reg = load_value func
218 emit "blx #{func_reg}\n"
219 end
221 # Restore original stack frame
222 if old_frame_size != @frame_size
223 emit "add sp, sp, \##{@frame_size - old_frame_size}\n"
224 @frame_offset = old_frame_offset
225 @frame_size = old_frame_size
226 end
227 end
229 # Creates a stack frame for the given number of arguments
230 # and local variables.
231 def create_frame nvars, save_lr = true
232 # Calculate how many variables we will store in registers,
233 # and how many on the stack.
234 nregister_vars = [nvars, @NREGISTER_LOCALS].min
235 nstack_vars = nvars - nregister_vars
237 # Save the registers we will clobber to the stack.
238 clobbered = []
239 nregister_vars.times do |i|
240 clobbered << :"v#{i < 5 ? i + 1 : i + 2}"
241 end
242 clobbered << @FP
243 clobbered << :lr if save_lr
244 @saved_registers = clobbered
245 emit "stmfd sp!, {#{clobbered.join ', '}}\n"
246 emit "add #{@FP}, sp, \##{clobbered.length * @WORDSIZE}\n"
248 # Calculate frame size so that the stack pointer will
249 # be properly aligned at the end of emit_function_prologue.
250 @frame_size = (clobbered.length + nstack_vars) * @WORDSIZE
251 if @frame_size % 8 != 0
252 @frame_size = (@frame_size + 7) / 8 * 8
253 end
254 extra_space = @frame_size - clobbered.length * @WORDSIZE
255 if extra_space > 0
256 emit "sub sp, sp, \##{extra_space}\n"
257 end
258 @frame_offset = 0
259 end
261 # Start a conditional using the specified branch instruction
262 # after the comparison.
263 def common_if comp, x, y = nil
264 emit "# #{comp} #{x} #{y}\n"
266 xreg = load_value x, @TEMPORARY
267 yreg = load_value y, :a4
269 falselabel = @environment.gensym
270 @if_labels.push falselabel
272 emit "cmp #{xreg}, #{yreg}\n"
274 lut = { :ifeq => "bne", :ifge => "blt", :ifgt => "ble",
275 :ifle => "bgt", :iflt => "bge", :ifne => "beq" }
276 emit "#{lut[comp]} #{falselabel}\n"
277 end
279 # Counts the number of local variables created in
280 # a sequence of statements.
281 def count_locals statements
282 count = 0
283 each_statement(statements) do |statement|
284 if statement[0] == :let
285 # let introduces a single local
286 count = count + 1
287 end
288 end
289 count
290 end
292 # Destroys the current stack frame.
293 # If ret is true, loads the saved value of lr into pc.
294 def destroy_frame ret = false
295 # Set sp back to where saved registers were stored
296 saved = @saved_registers
297 emit "sub sp, #{@FP}, \##{saved.length * @WORDSIZE}\n"
299 if ret
300 index = saved.index :lr
301 if index
302 saved[index] = :pc
303 else
304 raise "Request to load saved lr into pc, but lr has not been saved"
305 end
306 end
307 emit "ldmfd sp!, {#{saved.join ', '}}\n"
309 emit_constants if ret
310 end
312 # Writes any constants that need to be written to the instruction
313 # stream, and clears the list of constants that need to be written.
314 def emit_constants
315 @constants.each do |x|
316 label x[0]
317 word x[1]
318 end
319 @constants = []
320 end
322 # Emit function prologue.
323 def emit_function_prologue formals = [], nlocals = 0
324 # Calculate the number of arguments we were passed in
325 # registers, the total number of values we need to save
326 # on the stack, then create a stack frame and save
327 # the v registers we will be using.
328 nregister_args = [formals.length, @NREGISTER_ARGS].min
329 nvars = nregister_args + nlocals
330 create_frame nvars, true
332 # Move arguments that were passed in registers into
333 # callee-save registers.
334 nregister_args.times do |i|
335 emit "cpy v#{i + 1}, a#{i + 1}\n"
336 end
337 end
339 # Ends the current block.
340 def end_block
341 emit "# end block\n"
343 # If we are returning to top level, restore stack pointer
344 # and saved registers.
345 if @environment.parent == @top_level
346 offset = @frame_size - @saved_registers.length * @WORDSIZE
347 if offset > 0
348 emit "add sp, sp, \##{offset}\n"
349 end
350 emit "ldmfd sp!, {#{@saved_registers.join ', '}}\n"
351 @frame_size = 0
352 @frame_offset = 0
353 @saved_registers = []
355 # If we need to emit constants, do so now
356 unless @constants.empty?
357 lbl = gensym
358 goto lbl
359 label lbl
360 end
361 end
363 # Restore old value of @environment
364 @environment = @environment.parent
365 end
367 # Ends a function body.
368 def end_function
369 if @environment == @top_level
370 raise "Cannot end function when not in a function"
371 end
373 emit "# function epilogue\n"
374 label @function_end_label
376 destroy_frame true
377 @frame_size = 0
378 @frame_offset = 0
379 @saved_registers = []
380 emit "# end function\n\n"
381 @environment = @top_level
382 end
384 # Ends a conditional.
385 def end_if
386 label @if_labels.pop
387 end
389 # Evaluate the binary operation expr and store the result in register
390 def eval_binop expr, register
391 op = expr[0]
393 # Emulation for div and mod, which ARM does not have instructions for
394 case op
395 when :div
396 func = :"__aeabi_idiv"
397 import func unless @imports.has_key? func
398 call func, expr[1], expr[2]
399 emit "cpy #{register}, r0\n" if register != :r0
400 return
401 when :mod
402 func = :"__aeabi_idivmod"
403 import func unless @imports.has_key? func
404 call func, expr[1], expr[2]
405 emit "cpy #{register}, r1\n" if register != :r1
406 return
407 end
409 x = load_value expr[1], :a4
410 y = load_value expr[2], @TEMPORARY
412 case op
413 when :bsr
414 emit "lsr #{register}, #{x}, #{y}\n"
415 when :or
416 emit "orr #{register}, #{x}, #{y}\n"
417 when :rol
418 emit "rsb #{y}, #{y}, #32\n"
419 emit "ror #{register}, #{x}, #{y}\n"
420 when :shl
421 emit "lsl #{register}, #{x}, #{y}\n"
422 when :shr
423 emit "lsr #{register}, #{x}, #{y}\n"
424 when :xor
425 emit "eor #{register}, #{x}, #{y}\n"
426 else
427 emit "#{expr[0]} #{register}, #{x}, #{y}\n"
428 end
429 end
431 # Evaluates the expression +expr+ and stores the result in +register+.
432 def eval_expr expr, register
433 if expr.length == 1
434 # Load value
435 load_value_into_register expr[0], register
436 else
437 # Evaluate expression
438 op = expr[0]
439 case op
440 when :call
441 call *expr[1..-1]
442 emit "cpy #{register}, #{@RETURN}\n" if register != @RETURN
443 when :'get-byte'
444 get_byte expr[1], expr[2], register
445 when :'get-word'
446 get_word expr[1], expr[2], register
447 when :not
448 load_value_into_register expr[1], register
449 emit "mvn #{@TEMPORARY}, #0\n"
450 emit "eor #{register}, #{register}, #{@TEMPORARY}\n"
451 else
452 if binop? op
453 eval_binop expr, register
454 else
455 raise "Not a magic word: #{op}"
456 end
457 end
458 end
459 end
461 # Export symbols from the current section
462 def export *symbols
463 symbols.each { |sym| emit ".globl #{sym}\n" }
464 end
466 # Add a function to the current section
467 def function formals, *code
468 nlocals = count_locals code
469 begin_function formals, nlocals
470 code.each { |action| add section, action }
471 end_function
472 end
474 # Load byte from _base_ + _offset_ into _register_
475 def get_byte base, offset, register
476 # If base is an integer, but offset isn't, swap them
477 if !integer?(offset) && integer?(base)
478 base, offset = [offset, base]
479 end
481 if integer? offset
482 base_reg = load_value base
483 if offset == 0
484 emit "ldrb #{register}, [#{base_reg}]\n"
485 else
486 emit "ldrb #{register}, [#{base_reg}, \##{offset}]\n"
487 end
488 else
489 base_reg = load_value base
490 offset_reg = load_value offset, :a4
491 emit "ldrb #{register}, [#{base_reg}, #{offset_reg}]\n"
492 end
493 end
495 # Load word from _base_ + _offset_ * _@WORDSIZE_ into _register_
496 def get_word base, offset, register
497 if integer? offset
498 base_reg = load_value base
499 if offset == 0
500 emit "ldr #{register}, [#{base_reg}]\n"
501 else
502 emit "ldr #{register}, [#{base_reg}, \##{offset * @WORDSIZE}]\n"
503 end
504 else
505 base_reg = load_value base
506 offset_reg = load_value offset, :a4
507 emit "ldr #{register}, [#{base_reg}, #{offset_reg}, LSL #2]\n"
508 end
509 end
511 # Test if a symbol refers to a global
512 def global? symbol
513 symbol?(symbol) && @environment[symbol] == nil
514 end
516 # Jump to a label.
517 def goto label
518 emit "b #{label}\n"
520 # If we have constants that need to be emitted, do so now
521 emit_constants
522 end
524 # Grows the current frame by n words, plus padding to
525 # respect alignment rules.
526 def grow_frame nwords
527 increment = (nwords * @WORDSIZE + 7) / 8 * 8
528 emit "sub sp, sp, \##{increment}\n"
529 @frame_size = @frame_size + increment
530 @frame_offset = @frame_offset + increment
531 end
533 # Start the false path of a conditional.
534 def ifelse
535 emit "# else\n"
536 newlabel = @environment.gensym
537 goto newlabel
538 lbl = @if_labels.pop
539 label lbl
540 @if_labels.push newlabel
541 end
543 # Test if x is equal to y
544 def ifeq x, y
545 common_if :ifeq, x, y
546 end
548 # Test if x is greater than or equal to y
549 def ifge x, y
550 common_if :ifge, x, y
551 end
553 # Test if x is strictly greater than y
554 def ifgt x, y
555 common_if :ifgt, x, y
556 end
558 # Test if x is less than or equal to y
559 def ifle x, y
560 common_if :ifle, x, y
561 end
563 # Test if x is strictly less than y
564 def iflt x, y
565 common_if :iflt, x, y
566 end
568 # Test if x different from y
569 def ifne x, y
570 common_if :ifne, x, y
571 end
573 # Import labels into the current section
574 def import *symbols
575 # Record imported labels in @imports
576 symbols.each { |sym| @imports[sym] = sym }
577 end
579 # Test if a value is an integer
580 def integer? value
581 value.kind_of? Integer
582 end
584 # Emit a label
585 def label name
586 emit "#{name}:\n"
587 end
589 # Introduce a new local variable
590 def let symbol, *expr
591 n = @environment.locals
592 register = local_register n
594 if register
595 # We will use a register to store the value
596 @environment.add_local symbol, register
597 eval_expr expr, register
598 else
599 # We will use the stack to store the value
600 offset = local_offset n
601 @environment.add_local symbol, offset
602 eval_expr expr, @TEMPORARY
603 emit "str #{@TEMPORARY}, #{offset_reference offset}\n"
604 end
605 end
607 # Load the value at the given address.
608 def load_at address, register = @TEMPORARY
609 load_value_into_register address, register
610 emit "ldr #{register}, [#{register}]\n"
611 register
612 end
614 # Load a value into a register.
615 # Returns the name of the register.
616 # If the value was already in a register, the name of that
617 # register is returned.
618 # Else, the value is loaded into a register and the name of
619 # that register is returned. The register to use in that case
620 # may be specified using the optional second argument.
621 def load_value x, register = @TEMPORARY
622 if integer? x
623 if x >= 0 && x <= 255
624 emit "mov #{register}, \##{x}\n"
625 return register
626 elsif x >= -255 && x < 0
627 emit "mvn #{register}, \##{-(x + 1)}\n"
628 return register
629 else
630 lbl = add_constant x
631 emit "ldr #{register}, #{lbl}\n"
632 return register
633 end
634 elsif symbol? x
635 binding = @environment[x]
636 if binding.kind_of? String
637 # Value is already in a register. Return register name.
638 return binding
639 elsif binding.kind_of? Integer
640 # Value is on the stack. Load from the stack.
641 emit "ldr #{register}, #{offset_reference binding}\n"
642 return register
643 else
644 # Assume global
645 lbl = add_constant x
646 emit "ldr #{register}, #{lbl}\n"
647 return register
648 end
649 elsif at_expr? x
650 load_at x[1], register
651 else
652 raise "Don't know how to load #{x.inspect}"
653 end
654 end
656 # Load a value into a specific register
657 def load_value_into_register x, register
658 reg = load_value x, register
659 if reg != register
660 emit "cpy #{register}, #{reg}\n"
661 end
662 end
664 # Returns the fp-relative reference for the nth (0-based) local.
665 def local_offset n
666 -@INITIAL_FRAME_SIZE - (n * @WORDSIZE)
667 end
669 # Return the register in which the nth local (0-based) is stored, or
670 # nil if not stored in a register
671 def local_register n
672 if register_local? n
673 n = n + number_of_register_arguments
674 if n < 5
675 "v#{n + 1}"
676 else
677 "v#{n + 2}"
678 end
679 else
680 nil
681 end
682 end
684 # Calculate the number of register arguments,
685 # given the total number of arguments.
686 def number_of_register_arguments n = @environment.args
687 [n, @NREGISTER_ARGS].min
688 end
690 # Calculate the number of stack arguments,
691 # given the total number of arguments.
692 def number_of_stack_arguments n = @environment.args
693 [0, n - @NREGISTER_ARGS].max
694 end
696 # Given an offset, returns an fp-relative reference.
697 def offset_reference offset
698 "[#{@FP}, \##{offset}]"
699 end
701 # Returns true if the nth (0-based) argument is stored in a register
702 def register_arg? n
703 n < @NREGISTER_ARGS
704 end
706 # Returns true if the nth (0-based) local is stored in a register
707 def register_local? n
708 (n + number_of_register_arguments) < @NREGISTER_LOCALS
709 end
711 # Returns from a function.
712 #
713 # _words_ may contain an expression to be evaluated. The result
714 # of the evaluation is returned from the function.
715 def ret *words
716 emit "# return #{words.join ' '}\n"
717 # Compute return value and store it in @RETURN
718 eval_expr(words, @RETURN) unless words.empty?
719 # Go to epilogue
720 goto @function_end_label
721 end
723 # Set a variable to the result of evaluating an expression
724 def set symbol, *expr
725 if at_expr? symbol
726 eval_expr expr, :r3
727 register = load_value symbol[1]
728 emit "str r3, [#{register}]\n"
729 else
730 x = @environment[symbol]
731 if x == nil
732 raise "Cannot change value of constant #{symbol}"
733 elsif x.kind_of? String
734 eval_expr expr, x
735 else
736 eval_expr expr, @TEMPORARY
737 emit "str #{@TEMPORARY}, #{offset_reference x}\n"
738 end
739 end
740 end
742 # Set the byte at _base_ + _offset_ to _value_
743 def set_byte base, offset, value
744 emit "# set-byte #{base} #{offset} #{value}\n"
745 # If base is an integer, but offset isn't, swap them
746 if !integer?(offset) && integer?(base)
747 base, offset = [offset, base]
748 end
750 if integer? offset
751 base_reg = load_value base, :a4
752 load_value_into_register value, @TEMPORARY
753 if offset == 0
754 emit "strb #{@TEMPORARY}, [#{base_reg}]\n"
755 else
756 emit "strb #{@TEMPORARY}, [#{base_reg}, \##{offset}]\n"
757 end
758 else
759 eval_binop [:add, base, offset], :a4
760 load_value_into_register value, @TEMPORARY
761 emit "strb #{@TEMPORARY}, [a4]\n"
762 end
763 end
765 # Set the word at _base_ + _offset_ * +@WORDSIZE+ to _value_
766 def set_word base, offset, value
767 emit "# set-word #{base} #{offset} #{value}\n"
768 # If base is an integer, but offset isn't, swap them
769 if !integer?(offset) && integer?(base)
770 base, offset = [offset, base]
771 end
773 if integer? offset
774 base_reg = load_value base, :a4
775 load_value_into_register value, @TEMPORARY
776 if offset == 0
777 emit "str #{@TEMPORARY}, [#{base_reg}]\n"
778 else
779 emit "str #{@TEMPORARY}, [#{base_reg}, \##{offset * @WORDSIZE}]\n"
780 end
781 else
782 load_value_into_register base, :a4
783 load_value_into_register offset, @TEMPORARY
784 emit "add a4, a4, #{@TEMPORARY}, LSL #2\n"
785 load_value_into_register value, @TEMPORARY
786 emit "str #{@TEMPORARY}, [a4]\n"
787 end
788 end
790 # Define a string with the given value
791 def string value
792 code = ''
793 value.each_byte do |b|
794 if b == 92
795 code << "\\\\"
796 elsif b >= 32 && b < 127 && b != 34
797 code << b.chr
798 else
799 code << sprintf("\\%03o", b)
800 end
801 end
802 emit ".ascii \"#{code}\"\n"
803 end
805 # Test if a value is a symbol
806 def symbol? value
807 value.kind_of? Symbol
808 end
810 # Test if op is a symmetric binary operation (i.e. it will yield the
811 # same result if the order of its source operands is changed).
812 def symmetric_binop? op
813 [:add, :and, :mul, :or, :xor].member? op
814 end
816 # Call a function, re-using the current call frame if possible.
817 def tail_call func, *args
818 emit "# tail-call #{func} #{args.join ' '}\n"
820 # Compute number of stack arguments
821 nstackargs = number_of_stack_arguments args.length
822 # If we need more stack arguments than we have now,
823 # perform a normal call and return
824 if nstackargs > number_of_stack_arguments(@environment.args)
825 emit "# Not enough space for proper tail call; using regular call\n"
826 ret :call, func, *args
827 end
829 # We will assign arguments from left to right.
830 # Find places that we will overwrite before we read them,
831 # and store their values in some newly allocated stack space.
832 old_frame_offset = @frame_offset
833 old_frame_size = @frame_size
834 overwritten = {}
835 (@NREGISTER_ARGS...args.length).each do |i|
836 arg = args[i]
837 arg = arg[1] if at_expr? arg
838 if symbol?(arg)
839 binding = @environment[arg]
840 if binding[0] == :arg && binding[1] >= @NREGISTER_ARGS &&
841 binding[1] < i
842 # Argument i is a stack argument, but the value we will assign
843 # it is a stack argument that comes before it, so we will
844 # have overwritten it by the time we get to it.
845 overwritten[arg] = nil
846 end
847 end
848 end
850 unless overwritten.empty?
851 # Allocate space for arguments to be saved
852 grow_frame overwritten.length
853 # Save values
854 offset = 0
855 overwritten.each_key do |key|
856 reg = load_value key
857 emit "str #{reg}, [sp, \##{offset}]\n"
858 overwritten[key] = offset
859 offset = offset + @WORDSIZE
860 end
861 end
863 # Assign arguments
864 args.each_index do |i|
865 arg = args[i]
866 if register_arg? i
867 load_value_into_register arg, "a#{i + 1}"
868 else
869 # Test if this is a value we saved
870 sym = at_expr?(arg) ? arg[1] : arg
871 saved = overwritten[sym]
872 if saved
873 # Saved value, load from stack
874 reg = @TEMPORARY
875 emit "ldr #{reg}, [sp, \##{saved}]\n"
876 else
877 # Regular value, use load_value
878 reg = load_value arg
879 end
880 emit "str #{reg}, #{arg_reference i}\n"
881 end
882 end
884 # Load address of function to be called into @TEMPORARY
885 load_value_into_register func, @TEMPORARY
887 # Destroy current activation frame and enter func
888 destroy_frame false
889 emit "bx #{@TEMPORARY}\n"
890 emit_constants
891 end
893 # Define a word with the given value
894 def word value
895 emit ".int #{value}\n"
896 end
898 # Write generated code to the given IO object.
899 def write io
900 @sections.each do |section,code|
901 unless code.empty?
902 io.puts ".section #{section.to_s}"
903 io.puts code
904 io.puts
905 end
906 end
907 end
908 end
910 # Register class for little endian ARM
911 Voodoo::CodeGenerator.register_generator ARMGasGenerator,
912 :architecture => :arm,
913 :format => :gas
914 end