mirror of https://github.com/tinygo-org/tinygo.git
Browse Source
This commit refactors the compiler a bit to have all inline assembly in a separate file.pull/289/head
Ayke van Laethem
6 years ago
committed by
Ron Evans
Ron Evans
2 changed files with 170 additions and 114 deletions
@ -0,0 +1,162 @@ |
|||
package compiler |
|||
|
|||
// This file implements inline asm support by calling special functions.
|
|||
|
|||
import ( |
|||
"fmt" |
|||
"go/constant" |
|||
"regexp" |
|||
"strconv" |
|||
"strings" |
|||
|
|||
"golang.org/x/tools/go/ssa" |
|||
"tinygo.org/x/go-llvm" |
|||
) |
|||
|
|||
// This is a compiler builtin, which reads the given register by name:
|
|||
//
|
|||
// func ReadRegister(name string) uintptr
|
|||
//
|
|||
// The register name must be a constant, for example "sp".
|
|||
func (c *Compiler) emitReadRegister(args []ssa.Value) (llvm.Value, error) { |
|||
fnType := llvm.FunctionType(c.uintptrType, []llvm.Type{}, false) |
|||
regname := constant.StringVal(args[0].(*ssa.Const).Value) |
|||
target := llvm.InlineAsm(fnType, "mov $0, "+regname, "=r", false, false, 0) |
|||
return c.builder.CreateCall(target, nil, ""), nil |
|||
} |
|||
|
|||
// This is a compiler builtin, which emits a piece of inline assembly with no
|
|||
// operands or return values. It is useful for trivial instructions, like wfi in
|
|||
// ARM or sleep in AVR.
|
|||
//
|
|||
// func Asm(asm string)
|
|||
//
|
|||
// The provided assembly must be a constant.
|
|||
func (c *Compiler) emitAsm(args []ssa.Value) (llvm.Value, error) { |
|||
// Magic function: insert inline assembly instead of calling it.
|
|||
fnType := llvm.FunctionType(c.ctx.VoidType(), []llvm.Type{}, false) |
|||
asm := constant.StringVal(args[0].(*ssa.Const).Value) |
|||
target := llvm.InlineAsm(fnType, asm, "", true, false, 0) |
|||
return c.builder.CreateCall(target, nil, ""), nil |
|||
} |
|||
|
|||
// This is a compiler builtin, which allows assembly to be called in a flexible
|
|||
// way.
|
|||
//
|
|||
// func AsmFull(asm string, regs map[string]interface{})
|
|||
//
|
|||
// The asm parameter must be a constant string. The regs parameter must be
|
|||
// provided immediately. For example:
|
|||
//
|
|||
// arm.AsmFull(
|
|||
// "str {value}, {result}",
|
|||
// map[string]interface{}{
|
|||
// "value": 1
|
|||
// "result": &dest,
|
|||
// })
|
|||
func (c *Compiler) emitAsmFull(frame *Frame, instr *ssa.CallCommon) (llvm.Value, error) { |
|||
asmString := constant.StringVal(instr.Args[0].(*ssa.Const).Value) |
|||
registers := map[string]llvm.Value{} |
|||
registerMap := instr.Args[1].(*ssa.MakeMap) |
|||
for _, r := range *registerMap.Referrers() { |
|||
switch r := r.(type) { |
|||
case *ssa.DebugRef: |
|||
// ignore
|
|||
case *ssa.MapUpdate: |
|||
if r.Block() != registerMap.Block() { |
|||
return llvm.Value{}, c.makeError(instr.Pos(), "register value map must be created in the same basic block") |
|||
} |
|||
key := constant.StringVal(r.Key.(*ssa.Const).Value) |
|||
//println("value:", r.Value.(*ssa.MakeInterface).X.String())
|
|||
value, err := c.parseExpr(frame, r.Value.(*ssa.MakeInterface).X) |
|||
if err != nil { |
|||
return llvm.Value{}, err |
|||
} |
|||
registers[key] = value |
|||
case *ssa.Call: |
|||
if r.Common() == instr { |
|||
break |
|||
} |
|||
default: |
|||
return llvm.Value{}, c.makeError(instr.Pos(), "don't know how to handle argument to inline assembly: "+r.String()) |
|||
} |
|||
} |
|||
// TODO: handle dollar signs in asm string
|
|||
registerNumbers := map[string]int{} |
|||
var err error |
|||
argTypes := []llvm.Type{} |
|||
args := []llvm.Value{} |
|||
constraints := []string{} |
|||
asmString = regexp.MustCompile("\\{[a-zA-Z]+\\}").ReplaceAllStringFunc(asmString, func(s string) string { |
|||
// TODO: skip strings like {r4} etc. that look like ARM push/pop
|
|||
// instructions.
|
|||
name := s[1 : len(s)-1] |
|||
if _, ok := registers[name]; !ok { |
|||
if err == nil { |
|||
err = c.makeError(instr.Pos(), "unknown register name: "+name) |
|||
} |
|||
return s |
|||
} |
|||
if _, ok := registerNumbers[name]; !ok { |
|||
registerNumbers[name] = len(registerNumbers) |
|||
argTypes = append(argTypes, registers[name].Type()) |
|||
args = append(args, registers[name]) |
|||
switch registers[name].Type().TypeKind() { |
|||
case llvm.IntegerTypeKind: |
|||
constraints = append(constraints, "r") |
|||
case llvm.PointerTypeKind: |
|||
constraints = append(constraints, "*m") |
|||
default: |
|||
err = c.makeError(instr.Pos(), "unknown type in inline assembly for value: "+name) |
|||
return s |
|||
} |
|||
} |
|||
return fmt.Sprintf("${%v}", registerNumbers[name]) |
|||
}) |
|||
if err != nil { |
|||
return llvm.Value{}, err |
|||
} |
|||
fnType := llvm.FunctionType(c.ctx.VoidType(), argTypes, false) |
|||
target := llvm.InlineAsm(fnType, asmString, strings.Join(constraints, ","), true, false, 0) |
|||
return c.builder.CreateCall(target, args, ""), nil |
|||
} |
|||
|
|||
// This is a compiler builtin which emits an inline SVCall instruction. It can
|
|||
// be one of:
|
|||
//
|
|||
// func SVCall0(num uintptr) uintptr
|
|||
// func SVCall1(num uintptr, a1 interface{}) uintptr
|
|||
// func SVCall2(num uintptr, a1, a2 interface{}) uintptr
|
|||
// func SVCall3(num uintptr, a1, a2, a3 interface{}) uintptr
|
|||
// func SVCall4(num uintptr, a1, a2, a3, a4 interface{}) uintptr
|
|||
//
|
|||
// The num parameter must be a constant. All other parameters may be any scalar
|
|||
// value supported by LLVM inline assembly.
|
|||
func (c *Compiler) emitSVCall(frame *Frame, args []ssa.Value) (llvm.Value, error) { |
|||
num, _ := constant.Uint64Val(args[0].(*ssa.Const).Value) |
|||
llvmArgs := []llvm.Value{} |
|||
argTypes := []llvm.Type{} |
|||
asm := "svc #" + strconv.FormatUint(num, 10) |
|||
constraints := "={r0}" |
|||
for i, arg := range args[1:] { |
|||
arg = arg.(*ssa.MakeInterface).X |
|||
if i == 0 { |
|||
constraints += ",0" |
|||
} else { |
|||
constraints += ",{r" + strconv.Itoa(i) + "}" |
|||
} |
|||
llvmValue, err := c.parseExpr(frame, arg) |
|||
if err != nil { |
|||
return llvm.Value{}, err |
|||
} |
|||
llvmArgs = append(llvmArgs, llvmValue) |
|||
argTypes = append(argTypes, llvmValue.Type()) |
|||
} |
|||
// Implement the ARM calling convention by marking r1-r3 as
|
|||
// clobbered. r0 is used as an output register so doesn't have to be
|
|||
// marked as clobbered.
|
|||
constraints += ",~{r1},~{r2},~{r3}" |
|||
fnType := llvm.FunctionType(c.uintptrType, argTypes, false) |
|||
target := llvm.InlineAsm(fnType, asm, constraints, true, false, 0) |
|||
return c.builder.CreateCall(target, llvmArgs, ""), nil |
|||
} |
|||
Loading…
Reference in new issue