| blob | 25c8c1dc57195dd1f2e821e335bc66156986cad3 |
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
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, r10, and r11 are used for
56 # local variables and function arguments.
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 @NREGISTER_ARGS = 4
69 @NREGISTER_LOCALS = 7
70 @RETURN = :r0
71 @TEMPORARY = :r12
72 @constants = []
73 @frame_offset = 0
74 @frame_size = 0
75 @function_end_label = nil
76 @imports = {}
77 @if_labels = []
78 @saved_registers = []
79 super params
80 @output_file_suffix = '.s'
81 end
83 # Create an entry in the constants table,
84 # returning the label that will refer to the constant.
85 # The value may be an integer or a label.
86 def add_constant value
87 label = gensym
88 @constants << [label, value]
89 label
90 end
92 def align alignment = nil
93 unless alignment
94 # Get default alignment
95 case @section
96 when :code
97 alignment = @CODE_ALIGNMENT
98 when :data
99 alignment = @DATA_ALIGNMENT
100 when :function
101 alignment = @FUNCTION_ALIGNMENT
102 else
103 # Use data alignment as default
104 alignment = @DATA_ALIGNMENT
105 end
106 end
107 emit ".align #{alignment}\n" unless alignment == 0
108 end
110 # Returns an sp-relative reference for the nth (0-based) argument.
111 def arg_reference n
112 "[sp, \##{@frame_size + (n - @NREGISTER_ARGS) * @WORDSIZE}]"
113 end
115 # Return the register in which the nth (0-based) argument is stored, or
116 # nil if not stored in a register
117 def arg_register n
118 # The first @NREGISTER_ARGS arguments are in the v registers,
119 # the rest are on the stack.
120 if register_arg? n
121 "v#{n + 1}"
122 else
123 nil
124 end
125 end
127 # Test if op is a binary operation
128 def assymetric_binop? op
129 [:asr, :bsr, :div, :mod, :rol, :ror, :shl, :shr, :sub].member?(op)
130 end
132 # Test if a value is an at-expression
133 def at_expr? value
134 value.respond_to?(:[]) && value[0] == :'@'
135 end
137 # Begins a new block.
138 def begin_block *code
139 emit "# begin block\n"
140 # If we are starting a block at top level, create a frame
141 if @environment == @top_level
142 nlocals = count_locals code
143 create_frame nlocals, false
144 end
145 @environment = Environment.new @environment
146 end
148 # Emit function prologue and declare _formals_ as function arguments
149 def begin_function formals, nlocals
150 if @environment != @top_level
151 raise "Can only begin a function at top level"
152 end
154 @function_end_label = gensym
155 emit "# function #{formals.join ' '}\n"
156 environment = Environment.new @environment
157 environment.add_args formals
158 @environment = environment
159 emit_function_prologue formals, nlocals
160 end
162 # Test if op is a binary operation
163 def binop? op
164 assymetric_binop?(op) || symmetric_binop?(op)
165 end
167 # Define a byte with the given value
168 def byte value
169 emit ".byte #{value}\n"
170 end
172 # Call a function.
173 def call func, *args
174 emit "# call #{func} #{args.join ' '}\n"
176 # Calculate how many arguments need to be pushed on
177 # the stack, and allocate space for them.
178 nstack_args = number_of_stack_arguments args.length
179 old_frame_offset = @frame_offset
180 old_frame_size = @frame_size
181 grow_frame nstack_args if nstack_args > 0
183 # Put stack arguments on the stack
184 (@NREGISTER_ARGS...args.length).each do |n|
185 load_value_into_register args[n], @TEMPORARY
186 emit "str #{@TEMPORARY}, " +
187 "[sp , \##{(n - @NREGISTER_ARGS) * @WORDSIZE}]\n"
188 end
190 # Put register arguments in the right registers
191 nregister_args = number_of_register_arguments args.length
192 nregister_args.times do |n|
193 load_value_into_register args[n], :"a#{n + 1}"
194 end
196 # Call function
197 if global? func
198 emit "bl #{func}\n"
199 else
200 func_reg = load_value func
201 emit "blx #{func_reg}\n"
202 end
204 # Restore original stack frame
205 if old_frame_size != @frame_size
206 emit "add sp, sp, \##{@frame_size - old_frame_size}\n"
207 @frame_offset = old_frame_offset
208 @frame_size = old_frame_size
209 end
210 end
212 # Creates a stack frame for the given number of arguments
213 # and local variables.
214 def create_frame nvars, save_lr = true
215 # Calculate how many variables we will store in registers,
216 # and how many on the stack.
217 nregister_vars = [nvars, @NREGISTER_LOCALS].min
218 nstack_vars = nvars - nregister_vars
220 # Save the registers we will clobber to the stack.
221 clobbered = []
222 nregister_vars.times do |i|
223 clobbered << :"v#{i < 5 ? i + 1 : i + 2}"
224 end
225 clobbered << :lr if save_lr
226 @saved_registers = clobbered
227 emit "stmfd sp!, {#{clobbered.join ', '}}\n"
229 # Calculate frame size so that the stack pointer will
230 # be properly aligned at the end of emit_function_prologue.
231 @frame_size = (clobbered.length + nstack_vars) * @WORDSIZE
232 if @frame_size % 8 != 0
233 @frame_size = (@frame_size + 7) / 8 * 8
234 end
235 extra_space = @frame_size - clobbered.length * @WORDSIZE
236 if extra_space > 0
237 emit "sub sp, sp, \##{extra_space}\n"
238 end
239 @frame_offset = 0
240 end
242 # Start a conditional using the specified branch instruction
243 # after the comparison.
244 def common_if comp, x, y = nil
245 emit "# #{comp} #{x} #{y}\n"
247 xreg = load_value x, @TEMPORARY
248 yreg = load_value y, :a4
250 falselabel = @environment.gensym
251 @if_labels.push falselabel
253 emit "cmp #{xreg}, #{yreg}\n"
255 lut = { :ifeq => "bne", :ifge => "blt", :ifgt => "ble",
256 :ifle => "bgt", :iflt => "bge", :ifne => "beq" }
257 emit "#{lut[comp]} #{falselabel}\n"
258 end
260 # Counts the number of local variables created in
261 # a sequence of statements.
262 def count_locals statements
263 count = 0
264 each_statement(statements) do |statement|
265 if statement[0] == :let
266 # let introduces a single local
267 count = count + 1
268 end
269 end
270 count
271 end
273 # Destroys the current stack frame.
274 # If ret is true, loads the saved value of lr into pc.
275 def destroy_frame ret = false
276 # Set sp back to where saved registers were stored
277 saved = @saved_registers
278 offset = @frame_size - saved.length * @WORDSIZE
279 if offset != 0
280 emit "add sp, sp, \##{offset}\n"
281 end
283 if ret
284 index = saved.index :lr
285 if index
286 saved[index] = :pc
287 else
288 raise "Request to load saved lr into pc, but lr has not been saved"
289 end
290 end
291 emit "ldmfd sp!, {#{saved.join ', '}}\n"
293 emit_constants if ret
294 end
296 # Writes any constants that need to be written to the instruction
297 # stream, and clears the list of constants that need to be written.
298 def emit_constants
299 @constants.each do |x|
300 label x[0]
301 word x[1]
302 end
303 @constants = []
304 end
306 # Emit function prologue.
307 def emit_function_prologue formals = [], nlocals = 0
308 # Calculate the number of arguments we were passed in
309 # registers, the total number of values we need to save
310 # on the stack, then create a stack frame and save
311 # the v registers we will be using.
312 nregister_args = [formals.length, @NREGISTER_ARGS].min
313 nvars = nregister_args + nlocals
314 create_frame nvars, true
316 # Move arguments that were passed in registers into
317 # callee-save registers.
318 nregister_args.times do |i|
319 emit "cpy v#{i + 1}, a#{i + 1}\n"
320 end
321 end
323 # Ends the current block.
324 def end_block
325 emit "# end block\n"
327 # If we are returning to top level, restore stack pointer
328 # and saved registers.
329 if @environment.parent == @top_level
330 offset = @frame_size - @saved_registers.length * @WORDSIZE
331 if offset > 0
332 emit "add sp, sp, \##{offset}\n"
333 end
334 emit "ldmfd sp!, {#{@saved_registers.join ', '}}\n"
335 @frame_size = 0
336 @frame_offset = 0
337 @saved_registers = []
339 # If we need to emit constants, do so now
340 unless @constants.empty?
341 lbl = gensym
342 goto lbl
343 label lbl
344 end
345 end
347 # Restore old value of @environment
348 @environment = @environment.parent
349 end
351 # Ends a function body.
352 def end_function
353 if @environment == @top_level
354 raise "Cannot end function when not in a function"
355 end
357 emit "# function epilogue\n"
358 label @function_end_label
360 destroy_frame true
361 @frame_size = 0
362 @frame_offset = 0
363 @saved_registers = []
364 emit "# end function\n\n"
365 @environment = @top_level
366 end
368 # Ends a conditional.
369 def end_if
370 label @if_labels.pop
371 end
373 # Evaluate the binary operation expr and store the result in register
374 def eval_binop expr, register
375 op = expr[0]
377 # Emulation for div and mod, which ARM does not have instructions for
378 case op
379 when :div
380 func = :"__aeabi_idiv"
381 import func unless @imports.has_key? func
382 call func, expr[1], expr[2]
383 emit "cpy #{register}, r0\n" if register != :r0
384 return
385 when :mod
386 func = :"__aeabi_idivmod"
387 import func unless @imports.has_key? func
388 call func, expr[1], expr[2]
389 emit "cpy #{register}, r1\n" if register != :r1
390 return
391 end
393 x = load_value expr[1], :a4
394 y = load_value expr[2], @TEMPORARY
396 case op
397 when :bsr
398 emit "lsr #{register}, #{x}, #{y}\n"
399 when :or
400 emit "orr #{register}, #{x}, #{y}\n"
401 when :rol
402 emit "rsb #{y}, #{y}, #32\n"
403 emit "ror #{register}, #{x}, #{y}\n"
404 when :shl
405 emit "lsl #{register}, #{x}, #{y}\n"
406 when :shr
407 emit "lsr #{register}, #{x}, #{y}\n"
408 when :xor
409 emit "eor #{register}, #{x}, #{y}\n"
410 else
411 emit "#{expr[0]} #{register}, #{x}, #{y}\n"
412 end
413 end
415 # Evaluates the expression +expr+ and stores the result in +register+.
416 def eval_expr expr, register
417 if expr.length == 1
418 # Load value
419 load_value_into_register expr[0], register
420 else
421 # Evaluate expression
422 op = expr[0]
423 case op
424 when :call
425 call *expr[1..-1]
426 emit "cpy #{register}, #{@RETURN}\n" if register != @RETURN
427 when :'get-byte'
428 get_byte expr[1], expr[2], register
429 when :'get-word'
430 get_word expr[1], expr[2], register
431 when :not
432 load_value_into_register expr[1], register
433 emit "mvn #{@TEMPORARY}, #0\n"
434 emit "eor #{register}, #{register}, #{@TEMPORARY}\n"
435 else
436 if binop? op
437 eval_binop expr, register
438 else
439 raise "Not a magic word: #{op}"
440 end
441 end
442 end
443 end
445 # Export symbols from the current section
446 def export *symbols
447 symbols.each { |sym| emit ".globl #{sym}\n" }
448 end
450 # Add a function to the current section
451 def function formals, *code
452 nlocals = count_locals code
453 begin_function formals, nlocals
454 code.each { |action| add section, action }
455 end_function
456 end
458 # Load byte from _base_ + _offset_ into _register_
459 def get_byte base, offset, register
460 # If base is an integer, but offset isn't, swap them
461 if !integer?(offset) && integer?(base)
462 base, offset = [offset, base]
463 end
465 if integer? offset
466 base_reg = load_value base
467 if offset == 0
468 emit "ldrb #{register}, [#{base_reg}]\n"
469 else
470 emit "ldrb #{register}, [#{base_reg}, \##{offset}]\n"
471 end
472 else
473 base_reg = load_value base
474 offset_reg = load_value offset, :a4
475 emit "ldrb #{register}, [#{base_reg}, #{offset_reg}]\n"
476 end
477 end
479 # Load word from _base_ + _offset_ * _@WORDSIZE_ into _register_
480 def get_word base, offset, register
481 if integer? offset
482 base_reg = load_value base
483 if offset == 0
484 emit "ldr #{register}, [#{base_reg}]\n"
485 else
486 emit "ldr #{register}, [#{base_reg}, \##{offset * @WORDSIZE}]\n"
487 end
488 else
489 base_reg = load_value base
490 offset_reg = load_value offset, :a4
491 emit "ldr #{register}, [#{base_reg}, #{offset_reg}, LSL #2]\n"
492 end
493 end
495 # Test if a symbol refers to a global
496 def global? symbol
497 symbol?(symbol) && @environment[symbol] == nil
498 end
500 # Jump to a label.
501 def goto label
502 emit "b #{label}\n"
504 # If we have constants that need to be emitted, do so now
505 emit_constants
506 end
508 # Grows the current frame by n words, plus padding to
509 # respect alignment rules.
510 def grow_frame nwords
511 increment = (nwords * @WORDSIZE + 7) / 8 * 8
512 emit "sub sp, sp, \##{increment}\n"
513 @frame_size = @frame_size + increment
514 @frame_offset = @frame_offset + increment
515 end
517 # Start the false path of a conditional.
518 def ifelse
519 emit "# else\n"
520 newlabel = @environment.gensym
521 goto newlabel
522 lbl = @if_labels.pop
523 label lbl
524 @if_labels.push newlabel
525 end
527 # Test if x is equal to y
528 def ifeq x, y
529 common_if :ifeq, x, y
530 end
532 # Test if x is greater than or equal to y
533 def ifge x, y
534 common_if :ifge, x, y
535 end
537 # Test if x is strictly greater than y
538 def ifgt x, y
539 common_if :ifgt, x, y
540 end
542 # Test if x is less than or equal to y
543 def ifle x, y
544 common_if :ifle, x, y
545 end
547 # Test if x is strictly less than y
548 def iflt x, y
549 common_if :iflt, x, y
550 end
552 # Test if x different from y
553 def ifne x, y
554 common_if :ifne, x, y
555 end
557 # Import labels into the current section
558 def import *symbols
559 # Record imported labels in @imports
560 symbols.each { |sym| @imports[sym] = sym }
561 end
563 # Test if a value is an integer
564 def integer? value
565 value.kind_of? Integer
566 end
568 # Emit a label
569 def label name
570 emit "#{name}:\n"
571 end
573 # Introduce a new local variable
574 def let symbol, *expr
575 emit "# let #{symbol} #{expr.join ' '}\n"
576 n = @environment.locals
577 @environment.add_local symbol
579 register = local_register n
580 if register
581 # We will use a register to store the value
582 eval_expr expr, register
583 else
584 # We will use the stack to store the value
585 ref = local_reference n
586 eval_expr expr, @TEMPORARY
587 emit "str #{@TEMPORARY}, #{ref}\n"
588 end
589 end
591 # Load the value at the given address.
592 def load_at address, register = @TEMPORARY
593 load_value_into_register address, register
594 emit "ldr #{register}, [#{register}]\n"
595 register
596 end
598 # Load a value into a register.
599 # Returns the name of the register.
600 # If the value was already in a register, the name of that
601 # register is returned.
602 # Else, the value is loaded into a register and the name of
603 # that register is returned. The register to use in that case
604 # may be specified using the optional second argument.
605 def load_value x, register = @TEMPORARY
606 if integer? x
607 if x >= 0 && x <= 255
608 emit "mov #{register}, \##{x}\n"
609 return register
610 elsif x >= -255 && x < 0
611 emit "mvn #{register}, \##{-(x + 1)}\n"
612 return register
613 else
614 lbl = add_constant x
615 emit "ldr #{register}, #{lbl}\n"
616 return register
617 end
618 elsif symbol? x
619 binding = @environment[x]
620 if binding
621 case binding[0]
622 when :arg
623 n = binding[1]
624 if register_arg? n
625 return arg_register(n)
626 else
627 emit "ldr #{register}, #{arg_reference binding[1]}\n"
628 return register
629 end
630 when :local
631 n = binding[1]
632 if register_local? n
633 return local_register(n)
634 else
635 emit "ldr #{register}, #{local_reference n}\n"
636 return register
637 end
638 else
639 raise "Don't know how to load #{x.inspect}"
640 end
641 else
642 # Assume global
643 lbl = add_constant x
644 emit "ldr #{register}, #{lbl}\n"
645 return register
646 end
647 elsif at_expr? x
648 load_at x[1], register
649 else
650 raise "Don't know how to load #{x.inspect}"
651 end
652 end
654 # Load a value into a specific register
655 def load_value_into_register x, register
656 reg = load_value x, register
657 if reg != register
658 emit "cpy #{register}, #{reg}\n"
659 end
660 end
662 # Returns an sp-relative reference for the nth (0-based) local.
663 def local_reference n
664 "[sp, \##{@frame_offset + (number_of_register_arguments + n) * @WORDSIZE}]"
665 end
667 # Return the register in which the nth local (0-based) is stored, or
668 # nil if not stored in a register
669 def local_register n
670 if register_local? n
671 n = n + number_of_register_arguments
672 if n < 5
673 "v#{n + 1}"
674 else
675 "v#{n + 2}"
676 end
677 else
678 nil
679 end
680 end
682 # Calculate the number of register arguments,
683 # given the total number of arguments.
684 def number_of_register_arguments n = @environment.args
685 [n, @NREGISTER_ARGS].min
686 end
688 # Calculate the number of stack arguments,
689 # given the total number of arguments.
690 def number_of_stack_arguments n = @environment.args
691 [0, n - @NREGISTER_ARGS].max
692 end
694 # Returns true if the nth (0-based) argument is stored in a register
695 def register_arg? n
696 n < @NREGISTER_ARGS
697 end
699 # Returns true if the nth (0-based) local is stored in a register
700 def register_local? n
701 (n + number_of_register_arguments) < @NREGISTER_LOCALS
702 end
704 # Returns from a function.
705 #
706 # _words_ may contain an expression to be evaluated. The result
707 # of the evaluation is returned from the function.
708 def ret *words
709 emit "# return #{words.join ' '}\n"
710 # Compute return value and store it in @RETURN
711 eval_expr(words, @RETURN) unless words.empty?
712 # Go to epilogue
713 goto @function_end_label
714 end
716 # Set a variable to the result of evaluating an expression
717 def set symbol, *expr
718 emit "# set #{symbol} #{expr.join ' '}\n"
720 x = @environment[symbol]
721 if x == nil
722 raise "Cannot change value of constant #{symbol}"
723 end
725 register = nil
726 case x[0]
727 when :arg
728 register = arg_register x[1]
729 when :local
730 register = local_register x[1]
731 end
733 if register
734 # Set new value
735 eval_expr expr, register
736 else
737 case x[0]
738 when :local
739 ref = local_reference x[1]
740 when :arg
741 ref = arg_reference x[1]
742 else
743 raise "??? #{sym} is neither a local nor an argument"
744 end
745 eval_expr expr, @TEMPORARY
746 emit "str #{@TEMPORARY}, #{ref}\n"
747 end
748 end
750 # Set the byte at _base_ + _offset_ to _value_
751 def set_byte base, offset, value
752 emit "# set-byte #{base} #{offset} #{value}\n"
753 # If base is an integer, but offset isn't, swap them
754 if !integer?(offset) && integer?(base)
755 base, offset = [offset, base]
756 end
758 if integer? offset
759 base_reg = load_value base, :a4
760 load_value_into_register value, @TEMPORARY
761 if offset == 0
762 emit "strb #{@TEMPORARY}, [#{base_reg}]\n"
763 else
764 emit "strb #{@TEMPORARY}, [#{base_reg}, \##{offset}]\n"
765 end
766 else
767 eval_binop [:add, base, offset], :a4
768 load_value_into_register value, @TEMPORARY
769 emit "strb #{@TEMPORARY}, [a4]\n"
770 end
771 end
773 # Set the word at _base_ + _offset_ * +@WORDSIZE+ to _value_
774 def set_word base, offset, value
775 emit "# set-word #{base} #{offset} #{value}\n"
776 # If base is an integer, but offset isn't, swap them
777 if !integer?(offset) && integer?(base)
778 base, offset = [offset, base]
779 end
781 if integer? offset
782 base_reg = load_value base, :a4
783 load_value_into_register value, @TEMPORARY
784 if offset == 0
785 emit "str #{@TEMPORARY}, [#{base_reg}]\n"
786 else
787 emit "str #{@TEMPORARY}, [#{base_reg}, \##{offset * @WORDSIZE}]\n"
788 end
789 else
790 load_value_into_register base, :a4
791 load_value_into_register offset, @TEMPORARY
792 emit "add a4, a4, #{@TEMPORARY}, LSL #2\n"
793 load_value_into_register value, @TEMPORARY
794 emit "str #{@TEMPORARY}, [a4]\n"
795 end
796 end
798 # Define a string with the given value
799 def string value
800 code = ''
801 value.each_byte do |b|
802 if b == 92
803 code << "\\\\"
804 elsif b >= 32 && b < 127 && b != 34
805 code << b.chr
806 else
807 code << sprintf("\\%03o", b)
808 end
809 end
810 emit ".ascii \"#{code}\"\n"
811 end
813 # Test if a value is a symbol
814 def symbol? value
815 value.kind_of? Symbol
816 end
818 # Test if op is a symmetric binary operation (i.e. it will yield the
819 # same result if the order of its source operands is changed).
820 def symmetric_binop? op
821 [:add, :and, :mul, :or, :xor].member? op
822 end
824 # Call a function, re-using the current call frame if possible.
825 def tail_call func, *args
826 emit "# tail-call #{func} #{args.join ' '}\n"
828 # Compute number of stack arguments
829 nstackargs = number_of_stack_arguments args.length
830 # If we need more stack arguments than we have now,
831 # perform a normal call and return
832 if nstackargs > number_of_stack_arguments(@environment.args)
833 emit "# Not enough space for proper tail call; using regular call\n"
834 ret :call, func, *args
835 end
837 # We will assign arguments from left to right.
838 # Find places that we will overwrite before we read them,
839 # and store their values in some newly allocated stack space.
840 old_frame_offset = @frame_offset
841 old_frame_size = @frame_size
842 overwritten = {}
843 (@NREGISTER_ARGS...args.length).each do |i|
844 arg = args[i]
845 arg = arg[1] if at_expr? arg
846 if symbol?(arg)
847 binding = @environment[arg]
848 if binding[0] == :arg && binding[1] >= @NREGISTER_ARGS &&
849 binding[1] < i
850 # Argument i is a stack argument, but the value we will assign
851 # it is a stack argument that comes before it, so we will
852 # have overwritten it by the time we get to it.
853 overwritten[arg] = nil
854 end
855 end
856 end
858 unless overwritten.empty?
859 # Allocate space for arguments to be saved
860 grow_frame overwritten.length
861 # Save values
862 offset = 0
863 overwritten.each_key do |key|
864 reg = load_value key
865 emit "str #{reg}, [sp, \##{offset}]\n"
866 overwritten[key] = offset
867 offset = offset + @WORDSIZE
868 end
869 end
871 # Assign arguments
872 args.each_index do |i|
873 arg = args[i]
874 if register_arg? i
875 load_value_into_register arg, "a#{i + 1}"
876 else
877 # Test if this is a value we saved
878 sym = at_expr?(arg) ? arg[1] : arg
879 saved = overwritten[sym]
880 if saved
881 # Saved value, load from stack
882 reg = @TEMPORARY
883 emit "ldr #{reg}, [sp, \##{saved}]\n"
884 else
885 # Regular value, use load_value
886 reg = load_value arg
887 end
888 emit "str #{reg}, #{arg_reference i}\n"
889 end
890 end
892 # Load address of function to be called into @TEMPORARY
893 load_value_into_register func, @TEMPORARY
895 # Destroy current activation frame and enter func
896 destroy_frame false
897 emit "bx #{@TEMPORARY}\n"
898 emit_constants
899 end
901 # Define a word with the given value
902 def word value
903 emit ".int #{value}\n"
904 end
906 # Write generated code to the given IO object.
907 def write io
908 @sections.each do |section,code|
909 unless code.empty?
910 io.puts ".section #{section.to_s}"
911 io.puts code
912 io.puts
913 end
914 end
915 end
917 end
919 # Register class for little endian ARM
920 Voodoo::CodeGenerator.register_generator ARMGasGenerator,
921 :architecture => :arm,
922 :format => :gas
923 end