github
/
tinygo
mirror of https://github.com/tinygo-org/tinygo.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2896 Commits
99 Branches
41 Tags
26 MiB
Tree: 1f43f32aae
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '1f43f32aae'
${ noResults }
tinygo/compiler/defer.go

611 lines
23 KiB
Raw Normal View History

compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
package compiler
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
// This file implements the 'defer' keyword in Go.
// Defer statements are implemented by transforming the function in the
// following way:
// * Creating an alloca in the entry block that contains a pointer (initially
// null) to the linked list of defer frames.
// * Every time a defer statement is executed, a new defer frame is created
// using alloca with a pointer to the previous defer frame, and the head
// pointer in the entry block is replaced with a pointer to this defer
// frame.
// * On return, runtime.rundefers is called which calls all deferred functions
// from the head of the linked list until it has gone through all defer
// frames.
compiler: add header comment to defer.go
6 years ago
compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
import (
compiler: implement func value and builtin defers Co-authored-by: Justin A. Wilson <maker.pro.game@gmail.com>
4 years ago
"go/types"
compiler: insert basic blocks at an appropriate location For example, this commit moves the 'throw' branch of an assertion (nil check, slice index check, etc) to the end of the function while inserting the "continue" branch right after the insert location. This makes the resulting IR easier to follow. For some reason, this also reduces code size a bit on average. The TinyGo smoke tests saw a reduction of 0.22%, mainly from WebAssembly. The drivers repo saw little average change in code size (-0.01%). This commit also adds a few compiler tests for the defer keyword.
3 years ago
"strconv"
compiler: remove ir package This package was long making the design of the compiler more complicated than it needs to be. Previously this package implemented several optimization passes, but those passes have since moved to work directly with LLVM IR instead of Go SSA. The only remaining pass is the SimpleDCE pass. This commit removes the *ir.Function type that permeated the whole compiler and instead switches to use *ssa.Function directly. The SimpleDCE pass is kept but is far less tightly coupled to the rest of the compiler so that it can easily be removed once the switch to building and caching packages individually happens.
4 years ago
"github.com/tinygo-org/tinygo/compiler/llvmutil"
compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
"golang.org/x/tools/go/ssa"
all: go fmt The import path changes changed the order of imports, but no `go fmt` was run before the commit. Oops...
6 years ago
"tinygo.org/x/go-llvm"
compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
)
compiler: implement recover() built-in function
3 years ago
// supportsRecover returns whether the compiler supports the recover() builtin
// for the current architecture.
func (b *builder) supportsRecover() bool {
switch b.archFamily() {
case "wasm32":
// Probably needs to be implemented using the exception handling
// proposal of WebAssembly:
// https://github.com/WebAssembly/exception-handling
return false
avr: add support for recover() You can see that it works with the following command: tinygo run -target=simavr ./testdata/recover.go This also gets the following tests to pass again: go test -run=Build -target=simavr -v Adding support for AVR was a bit more compliated because it's also necessary to save and restore the Y register.
2 years ago
case "riscv64", "xtensa":
compiler: implement recover() built-in function
3 years ago
// TODO: add support for these architectures
return false
default:
return true
}
}
// hasDeferFrame returns whether the current function needs to catch panics and
// run defers.
func (b *builder) hasDeferFrame() bool {
if b.fn.Recover == nil {
return false
}
return b.supportsRecover()
}
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
// deferInitFunc sets up this function for future deferred calls. It must be
// called from within the entry block when this function contains deferred
// calls.
compiler: refactor defer operations
5 years ago
func (b *builder) deferInitFunc() {
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
// Some setup.
compiler: remove ir package This package was long making the design of the compiler more complicated than it needs to be. Previously this package implemented several optimization passes, but those passes have since moved to work directly with LLVM IR instead of Go SSA. The only remaining pass is the SimpleDCE pass. This commit removes the *ir.Function type that permeated the whole compiler and instead switches to use *ssa.Function directly. The SimpleDCE pass is kept but is far less tightly coupled to the rest of the compiler so that it can easily be removed once the switch to building and caching packages individually happens.
4 years ago
b.deferFuncs = make(map[*ssa.Function]int)
compiler: refactor defer operations
5 years ago
b.deferInvokeFuncs = make(map[string]int)
compiler: remove ir package This package was long making the design of the compiler more complicated than it needs to be. Previously this package implemented several optimization passes, but those passes have since moved to work directly with LLVM IR instead of Go SSA. The only remaining pass is the SimpleDCE pass. This commit removes the *ir.Function type that permeated the whole compiler and instead switches to use *ssa.Function directly. The SimpleDCE pass is kept but is far less tightly coupled to the rest of the compiler so that it can easily be removed once the switch to building and caching packages individually happens.
4 years ago
b.deferClosureFuncs = make(map[*ssa.Function]int)
compiler: implement func value and builtin defers Co-authored-by: Justin A. Wilson <maker.pro.game@gmail.com>
4 years ago
b.deferExprFuncs = make(map[ssa.Value]int)
b.deferBuiltinFuncs = make(map[ssa.Value]deferBuiltin)
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
// Create defer list pointer.
compiler: refactor defer operations
5 years ago
deferType := llvm.PointerType(b.getLLVMRuntimeType("_defer"), 0)
b.deferPtr = b.CreateAlloca(deferType, "deferPtr")
b.CreateStore(llvm.ConstPointerNull(deferType), b.deferPtr)
compiler: implement recover() built-in function
3 years ago
if b.hasDeferFrame() {
// Set up the defer frame with the current stack pointer.
// This assumes that the stack pointer doesn't move outside of the
// function prologue/epilogue (an invariant maintained by TinyGo but
// possibly broken by the C alloca function).
// The frame pointer is _not_ saved, because it is marked as clobbered
// in the setjmp-like inline assembly.
runtime: move *task.DeferFrame here This is a refactor that makes the next commit simpler. Perhaps it should have been like this from the beginning but I didn't like all the casts.
2 years ago
deferFrameType := b.getLLVMRuntimeType("deferFrame")
compiler: implement recover() built-in function
3 years ago
b.deferFrame = b.CreateAlloca(deferFrameType, "deferframe.buf")
stackPointer := b.readStackPointer()
b.createRuntimeCall("setupDeferFrame", []llvm.Value{b.deferFrame, stackPointer}, "")
// Create the landing pad block, which is where control transfers after
// a panic.
b.landingpad = b.ctx.AddBasicBlock(b.llvmFn, "lpad")
}
}
// createLandingPad fills in the landing pad block. This block runs the deferred
// functions and returns (by jumping to the recover block). If the function is
// still panicking after the defers are run, the panic will be re-raised in
// destroyDeferFrame.
func (b *builder) createLandingPad() {
b.SetInsertPointAtEnd(b.landingpad)
// Add debug info, if needed.
// The location used is the closing bracket of the function.
if b.Debug {
pos := b.program.Fset.Position(b.fn.Syntax().End())
b.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), b.difunc, llvm.Metadata{})
}
b.createRunDefers()
// Continue at the 'recover' block, which returns to the parent in an
// appropriate way.
b.CreateBr(b.blockEntries[b.fn.Recover])
}
// createInvokeCheckpoint saves the function state at the given point, to
// continue at the landing pad if a panic happened. This is implemented using a
// setjmp-like construct.
func (b *builder) createInvokeCheckpoint() {
// Construct inline assembly equivalents of setjmp.
// The assembly works as follows:
// * All registers (both callee-saved and caller saved) are clobbered
// after the inline assembly returns.
// * The assembly stores the address just past the end of the assembly
// into the jump buffer.
// * The return value (eax, rax, r0, etc) is set to zero in the inline
// assembly but set to an unspecified non-zero value when jumping using
// a longjmp.
var asmString, constraints string
avr: add support for recover() You can see that it works with the following command: tinygo run -target=simavr ./testdata/recover.go This also gets the following tests to pass again: go test -run=Build -target=simavr -v Adding support for AVR was a bit more compliated because it's also necessary to save and restore the Y register.
2 years ago
resultType := b.uintptrType
compiler: implement recover() built-in function
3 years ago
switch b.archFamily() {
case "i386":
asmString = `
xorl %eax, %eax
movl $$1f, 4(%ebx)
1:`
constraints = "={eax},{ebx},~{ebx},~{ecx},~{edx},~{esi},~{edi},~{ebp},~{xmm0},~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{fpsr},~{fpcr},~{flags},~{dirflag},~{memory}"
// This doesn't include the floating point stack because TinyGo uses
// newer floating point instructions.
case "x86_64":
asmString = `
leaq 1f(%rip), %rax
movq %rax, 8(%rbx)
xorq %rax, %rax
1:`
constraints = "={rax},{rbx},~{rbx},~{rcx},~{rdx},~{rsi},~{rdi},~{rbp},~{r8},~{r9},~{r10},~{r11},~{r12},~{r13},~{r14},~{r15},~{xmm0},~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{fpsr},~{fpcr},~{flags},~{dirflag},~{memory}"
// This list doesn't include AVX/AVX512 registers because TinyGo
// doesn't currently enable support for AVX instructions.
case "arm":
// Note: the following assembly takes into account that the PC is
// always 4 bytes ahead on ARM. The PC that is stored always points
// to the instruction just after the assembly fragment so that
// tinygo_longjmp lands at the correct instruction.
if b.isThumb() {
// Instructions are 2 bytes in size.
asmString = `
movs r0, #0
mov r2, pc
str r2, [r1, #4]`
} else {
// Instructions are 4 bytes in size.
asmString = `
str pc, [r1, #4]
movs r0, #0`
}
constraints = "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"
case "aarch64":
asmString = `
adr x2, 1f
str x2, [x1, #8]
mov x0, #0
1:
`
constraints = "={x0},{x1},~{x1},~{x2},~{x3},~{x4},~{x5},~{x6},~{x7},~{x8},~{x9},~{x10},~{x11},~{x12},~{x13},~{x14},~{x15},~{x16},~{x17},~{x18},~{x19},~{x20},~{x21},~{x22},~{x23},~{x24},~{x25},~{x26},~{x27},~{x28},~{fp},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{q16},~{q17},~{q18},~{q19},~{q20},~{q21},~{q22},~{q23},~{q24},~{q25},~{q26},~{q27},~{q28},~{q29},~{q30},~{nzcv},~{ffr},~{vg},~{memory}"
// TODO: SVE registers, which we don't use in TinyGo at the moment.
avr: add support for recover() You can see that it works with the following command: tinygo run -target=simavr ./testdata/recover.go This also gets the following tests to pass again: go test -run=Build -target=simavr -v Adding support for AVR was a bit more compliated because it's also necessary to save and restore the Y register.
2 years ago
case "avr":
// Note: the Y register (R28:R29) is a fixed register and therefore
// needs to be saved manually. TODO: do this only once per function with
// a defer frame, not for every call.
resultType = b.ctx.Int8Type()
asmString = `
ldi r24, pm_lo8(1f)
ldi r25, pm_hi8(1f)
std z+2, r24
std z+3, r25
std z+4, r28
std z+5, r29
ldi r24, 0
1:`
constraints = "={r24},z,~{r0},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{r13},~{r14},~{r15},~{r16},~{r17},~{r18},~{r19},~{r20},~{r21},~{r22},~{r23},~{r25},~{r26},~{r27}"
compiler: implement recover() built-in function
3 years ago
case "riscv32":
asmString = `
la a2, 1f
sw a2, 4(a1)
li a0, 0
1:`
constraints = "={a0},{a1},~{a1},~{a2},~{a3},~{a4},~{a5},~{a6},~{a7},~{s0},~{s1},~{s2},~{s3},~{s4},~{s5},~{s6},~{s7},~{s8},~{s9},~{s10},~{s11},~{t0},~{t1},~{t2},~{t3},~{t4},~{t5},~{t6},~{ra},~{f0},~{f1},~{f2},~{f3},~{f4},~{f5},~{f6},~{f7},~{f8},~{f9},~{f10},~{f11},~{f12},~{f13},~{f14},~{f15},~{f16},~{f17},~{f18},~{f19},~{f20},~{f21},~{f22},~{f23},~{f24},~{f25},~{f26},~{f27},~{f28},~{f29},~{f30},~{f31},~{memory}"
default:
// This case should have been handled by b.supportsRecover().
b.addError(b.fn.Pos(), "unknown architecture for defer: "+b.archFamily())
}
avr: add support for recover() You can see that it works with the following command: tinygo run -target=simavr ./testdata/recover.go This also gets the following tests to pass again: go test -run=Build -target=simavr -v Adding support for AVR was a bit more compliated because it's also necessary to save and restore the Y register.
2 years ago
asmType := llvm.FunctionType(resultType, []llvm.Type{b.deferFrame.Type()}, false)
compiler: implement recover() built-in function
3 years ago
asm := llvm.InlineAsm(asmType, asmString, constraints, false, false, 0, false)
result := b.CreateCall(asm, []llvm.Value{b.deferFrame}, "setjmp")
result.AddCallSiteAttribute(-1, b.ctx.CreateEnumAttribute(llvm.AttributeKindID("returns_twice"), 0))
avr: add support for recover() You can see that it works with the following command: tinygo run -target=simavr ./testdata/recover.go This also gets the following tests to pass again: go test -run=Build -target=simavr -v Adding support for AVR was a bit more compliated because it's also necessary to save and restore the Y register.
2 years ago
isZero := b.CreateICmp(llvm.IntEQ, result, llvm.ConstInt(resultType, 0, false), "setjmp.result")
compiler: implement recover() built-in function
3 years ago
continueBB := b.insertBasicBlock("")
b.CreateCondBr(isZero, continueBB, b.landingpad)
b.SetInsertPointAtEnd(continueBB)
b.blockExits[b.currentBlock] = continueBB
compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
}
revise defer to use heap allocations when running a variable number of times
5 years ago
// isInLoop checks if there is a path from a basic block to itself.
func isInLoop(start *ssa.BasicBlock) bool {
// Use a breadth-first search to scan backwards through the block graph.
queue := []*ssa.BasicBlock{start}
checked := map[*ssa.BasicBlock]struct{}{}
for len(queue) > 0 {
// pop a block off of the queue
block := queue[len(queue)-1]
queue = queue[:len(queue)-1]
// Search through predecessors.
// Searching backwards means that this is pretty fast when the block is close to the start of the function.
// Defers are often placed near the start of the function.
for _, pred := range block.Preds {
if pred == start {
// cycle found
return true
}
if _, ok := checked[pred]; ok {
// block already checked
continue
}
// add to queue and checked map
queue = append(queue, pred)
checked[pred] = struct{}{}
}
}
return false
}
compiler: refactor defer operations
5 years ago
// createDefer emits a single defer instruction, to be run when this function
compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
// returns.
compiler: refactor defer operations
5 years ago
func (b *builder) createDefer(instr *ssa.Defer) {
compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
// The pointer to the previous defer struct, which we will replace to
// make a linked list.
compiler: refactor defer operations
5 years ago
next := b.CreateLoad(b.deferPtr, "defer.next")
compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
var values []llvm.Value
compiler: refactor defer operations
5 years ago
valueTypes := []llvm.Type{b.uintptrType, next.Type()}
compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
if instr.Call.IsInvoke() {
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
// Method call on an interface.
compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
// Get callback type number.
methodName := instr.Call.Method.FullName()
compiler: refactor defer operations
5 years ago
if _, ok := b.deferInvokeFuncs[methodName]; !ok {
b.deferInvokeFuncs[methodName] = len(b.allDeferFuncs)
b.allDeferFuncs = append(b.allDeferFuncs, &instr.Call)
compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
}
compiler: refactor defer operations
5 years ago
callback := llvm.ConstInt(b.uintptrType, uint64(b.deferInvokeFuncs[methodName]), false)
compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
// Collect all values to be put in the struct (starting with
// runtime._defer fields, followed by the call parameters).
compiler: refactor defer operations
5 years ago
itf := b.getValue(instr.Call.Value) // interface
compiler: pass interface typecode through defer frames Previously, the typecode was passed via a direct reference, which results in invalid IR when the defer is not reached in all return paths. It also results in incorrect behavior if the defer is in a loop, causing all defers to use the typecode of the last iteration.
5 years ago
typecode := b.CreateExtractValue(itf, 0, "invoke.func.typecode")
compiler: refactor defer operations
5 years ago
receiverValue := b.CreateExtractValue(itf, 1, "invoke.func.receiver")
compiler: pass interface typecode through defer frames Previously, the typecode was passed via a direct reference, which results in invalid IR when the defer is not reached in all return paths. It also results in incorrect behavior if the defer is in a loop, causing all defers to use the typecode of the last iteration.
5 years ago
values = []llvm.Value{callback, next, typecode, receiverValue}
valueTypes = append(valueTypes, b.uintptrType, b.i8ptrType)
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
for _, arg := range instr.Call.Args {
compiler: refactor defer operations
5 years ago
val := b.getValue(arg)
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
values = append(values, val)
valueTypes = append(valueTypes, val.Type())
compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
}
} else if callee, ok := instr.Call.Value.(*ssa.Function); ok {
// Regular function call.
compiler: remove ir package This package was long making the design of the compiler more complicated than it needs to be. Previously this package implemented several optimization passes, but those passes have since moved to work directly with LLVM IR instead of Go SSA. The only remaining pass is the SimpleDCE pass. This commit removes the *ir.Function type that permeated the whole compiler and instead switches to use *ssa.Function directly. The SimpleDCE pass is kept but is far less tightly coupled to the rest of the compiler so that it can easily be removed once the switch to building and caching packages individually happens.
4 years ago
if _, ok := b.deferFuncs[callee]; !ok {
b.deferFuncs[callee] = len(b.allDeferFuncs)
b.allDeferFuncs = append(b.allDeferFuncs, callee)
compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
}
compiler: remove ir package This package was long making the design of the compiler more complicated than it needs to be. Previously this package implemented several optimization passes, but those passes have since moved to work directly with LLVM IR instead of Go SSA. The only remaining pass is the SimpleDCE pass. This commit removes the *ir.Function type that permeated the whole compiler and instead switches to use *ssa.Function directly. The SimpleDCE pass is kept but is far less tightly coupled to the rest of the compiler so that it can easily be removed once the switch to building and caching packages individually happens.
4 years ago
callback := llvm.ConstInt(b.uintptrType, uint64(b.deferFuncs[callee]), false)
compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
// Collect all values to be put in the struct (starting with
// runtime._defer fields).
values = []llvm.Value{callback, next}
for _, param := range instr.Call.Args {
compiler: refactor defer operations
5 years ago
llvmParam := b.getValue(param)
compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
values = append(values, llvmParam)
valueTypes = append(valueTypes, llvmParam.Type())
}
} else if makeClosure, ok := instr.Call.Value.(*ssa.MakeClosure); ok {
// Immediately applied function literal with free variables.
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
// Extract the context from the closure. We won't need the function
// pointer.
// TODO: ignore this closure entirely and put pointers to the free
// variables directly in the defer struct, avoiding a memory allocation.
compiler: refactor defer operations
5 years ago
closure := b.getValue(instr.Call.Value)
context := b.CreateExtractValue(closure, 0, "")
compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
// Get the callback number.
compiler: remove ir package This package was long making the design of the compiler more complicated than it needs to be. Previously this package implemented several optimization passes, but those passes have since moved to work directly with LLVM IR instead of Go SSA. The only remaining pass is the SimpleDCE pass. This commit removes the *ir.Function type that permeated the whole compiler and instead switches to use *ssa.Function directly. The SimpleDCE pass is kept but is far less tightly coupled to the rest of the compiler so that it can easily be removed once the switch to building and caching packages individually happens.
4 years ago
fn := makeClosure.Fn.(*ssa.Function)
compiler: refactor defer operations
5 years ago
if _, ok := b.deferClosureFuncs[fn]; !ok {
b.deferClosureFuncs[fn] = len(b.allDeferFuncs)
b.allDeferFuncs = append(b.allDeferFuncs, makeClosure)
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
}
compiler: refactor defer operations
5 years ago
callback := llvm.ConstInt(b.uintptrType, uint64(b.deferClosureFuncs[fn]), false)
compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
// Collect all values to be put in the struct (starting with
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
// runtime._defer fields, followed by all parameters including the
// context pointer).
values = []llvm.Value{callback, next}
compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
for _, param := range instr.Call.Args {
compiler: refactor defer operations
5 years ago
llvmParam := b.getValue(param)
compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
values = append(values, llvmParam)
valueTypes = append(valueTypes, llvmParam.Type())
}
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
values = append(values, context)
valueTypes = append(valueTypes, context.Type())
compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
compiler: implement func value and builtin defers Co-authored-by: Justin A. Wilson <maker.pro.game@gmail.com>
4 years ago
} else if builtin, ok := instr.Call.Value.(*ssa.Builtin); ok {
compiler: support all kinds of deferred builtins This change extends defer support to all supported builitin functions. Not all of them make sense (such as len, cap, real, imag, etc) but this change for example adds support for `defer(delete(m, key))` which is used in the Go 1.15 encoding/json package.
4 years ago
var argTypes []types.Type
var argValues []llvm.Value
for _, arg := range instr.Call.Args {
argTypes = append(argTypes, arg.Type())
argValues = append(argValues, b.getValue(arg))
compiler: implement func value and builtin defers Co-authored-by: Justin A. Wilson <maker.pro.game@gmail.com>
4 years ago
}
if _, ok := b.deferBuiltinFuncs[instr.Call.Value]; !ok {
b.deferBuiltinFuncs[instr.Call.Value] = deferBuiltin{
compiler: support all kinds of deferred builtins This change extends defer support to all supported builitin functions. Not all of them make sense (such as len, cap, real, imag, etc) but this change for example adds support for `defer(delete(m, key))` which is used in the Go 1.15 encoding/json package.
4 years ago
callName: builtin.Name(),
pos: builtin.Pos(),
argTypes: argTypes,
callback: len(b.allDeferFuncs),
compiler: implement func value and builtin defers Co-authored-by: Justin A. Wilson <maker.pro.game@gmail.com>
4 years ago
}
b.allDeferFuncs = append(b.allDeferFuncs, instr.Call.Value)
}
callback := llvm.ConstInt(b.uintptrType, uint64(b.deferBuiltinFuncs[instr.Call.Value].callback), false)
// Collect all values to be put in the struct (starting with
// runtime._defer fields).
values = []llvm.Value{callback, next}
compiler: support all kinds of deferred builtins This change extends defer support to all supported builitin functions. Not all of them make sense (such as len, cap, real, imag, etc) but this change for example adds support for `defer(delete(m, key))` which is used in the Go 1.15 encoding/json package.
4 years ago
for _, param := range argValues {
values = append(values, param)
valueTypes = append(valueTypes, param.Type())
compiler: implement func value and builtin defers Co-authored-by: Justin A. Wilson <maker.pro.game@gmail.com>
4 years ago
}
compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
} else {
compiler: implement func value and builtin defers Co-authored-by: Justin A. Wilson <maker.pro.game@gmail.com>
4 years ago
funcValue := b.getValue(instr.Call.Value)
if _, ok := b.deferExprFuncs[instr.Call.Value]; !ok {
b.deferExprFuncs[instr.Call.Value] = len(b.allDeferFuncs)
b.allDeferFuncs = append(b.allDeferFuncs, &instr.Call)
}
callback := llvm.ConstInt(b.uintptrType, uint64(b.deferExprFuncs[instr.Call.Value]), false)
// Collect all values to be put in the struct (starting with
// runtime._defer fields, followed by all parameters including the
// context pointer).
values = []llvm.Value{callback, next, funcValue}
valueTypes = append(valueTypes, funcValue.Type())
for _, param := range instr.Call.Args {
llvmParam := b.getValue(param)
values = append(values, llvmParam)
valueTypes = append(valueTypes, llvmParam.Type())
}
compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
}
compiler: implement recover() built-in function
3 years ago
// Make a struct out of the collected values to put in the deferred call
// struct.
deferredCallType := b.ctx.StructType(valueTypes, false)
deferredCall := llvm.ConstNull(deferredCallType)
compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
for i, value := range values {
compiler: implement recover() built-in function
3 years ago
deferredCall = b.CreateInsertValue(deferredCall, value, i, "")
compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
}
revise defer to use heap allocations when running a variable number of times
5 years ago
// Put this struct in an allocation.
var alloca llvm.Value
if !isInLoop(instr.Block()) {
// This can safely use a stack allocation.
compiler: implement recover() built-in function
3 years ago
alloca = llvmutil.CreateEntryBlockAlloca(b.Builder, deferredCallType, "defer.alloca")
revise defer to use heap allocations when running a variable number of times
5 years ago
} else {
// This may be hit a variable number of times, so use a heap allocation.
compiler: implement recover() built-in function
3 years ago
size := b.targetData.TypeAllocSize(deferredCallType)
compiler: refactor defer operations
5 years ago
sizeValue := llvm.ConstInt(b.uintptrType, size, false)
compiler, runtime: add layout parameter to runtime.alloc This layout parameter is currently always nil and ignored, but will eventually contain a pointer to a memory layout. This commit also adds module verification to the transform tests, as I found out that it didn't (and therefore didn't initially catch all bugs).
3 years ago
nilPtr := llvm.ConstNull(b.i8ptrType)
allocCall := b.createRuntimeCall("alloc", []llvm.Value{sizeValue, nilPtr}, "defer.alloc.call")
compiler: implement recover() built-in function
3 years ago
alloca = b.CreateBitCast(allocCall, llvm.PointerType(deferredCallType, 0), "defer.alloc")
revise defer to use heap allocations when running a variable number of times
5 years ago
}
compiler: move settings to a separate Config struct Moving settings to a separate config struct has two benefits: - It decouples the compiler a bit from other packages, most importantly the compileopts package. Decoupling is generally a good thing. - Perhaps more importantly, it precisely specifies which settings are used while compiling and affect the resulting LLVM module. This will be necessary for caching the LLVM module. While it would have been possible to cache without this refactor, it would have been very easy to miss a setting and thus let the compiler work with invalid/stale data.
4 years ago
if b.NeedsStackObjects {
compiler: refactor defer operations
5 years ago
b.trackPointer(alloca)
compiler,runtime: implement a portable conservative GC
6 years ago
}
compiler: implement recover() built-in function
3 years ago
b.CreateStore(deferredCall, alloca)
compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
// Push it on top of the linked list by replacing deferPtr.
compiler: refactor defer operations
5 years ago
allocaCast := b.CreateBitCast(alloca, next.Type(), "defer.alloca.cast")
b.CreateStore(allocaCast, b.deferPtr)
compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
}
compiler: refactor defer operations
5 years ago
// createRunDefers emits code to run all deferred functions.
func (b *builder) createRunDefers() {
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
// Add a loop like the following:
// for stack != nil {
// _stack := stack
// stack = stack.next
// switch _stack.callback {
// case 0:
// // run first deferred call
// case 1:
// // run second deferred call
// // etc.
// default:
// unreachable
// }
// }
compiler: insert basic blocks at an appropriate location For example, this commit moves the 'throw' branch of an assertion (nil check, slice index check, etc) to the end of the function while inserting the "continue" branch right after the insert location. This makes the resulting IR easier to follow. For some reason, this also reduces code size a bit on average. The TinyGo smoke tests saw a reduction of 0.22%, mainly from WebAssembly. The drivers repo saw little average change in code size (-0.01%). This commit also adds a few compiler tests for the defer keyword.
3 years ago
// Create loop, in the order: loophead, loop, callback0, callback1, ..., unreachable, end.
end := b.insertBasicBlock("rundefers.end")
unreachable := b.ctx.InsertBasicBlock(end, "rundefers.default")
loop := b.ctx.InsertBasicBlock(unreachable, "rundefers.loop")
loophead := b.ctx.InsertBasicBlock(loop, "rundefers.loophead")
compiler: refactor defer operations
5 years ago
b.CreateBr(loophead)
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
// Create loop head:
// for stack != nil {
compiler: refactor defer operations
5 years ago
b.SetInsertPointAtEnd(loophead)
deferData := b.CreateLoad(b.deferPtr, "")
stackIsNil := b.CreateICmp(llvm.IntEQ, deferData, llvm.ConstPointerNull(deferData.Type()), "stackIsNil")
b.CreateCondBr(stackIsNil, end, loop)
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
// Create loop body:
// _stack := stack
// stack = stack.next
// switch stack.callback {
compiler: refactor defer operations
5 years ago
b.SetInsertPointAtEnd(loop)
nextStackGEP := b.CreateInBoundsGEP(deferData, []llvm.Value{
llvm.ConstInt(b.ctx.Int32Type(), 0, false),
llvm.ConstInt(b.ctx.Int32Type(), 1, false), // .next field
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
}, "stack.next.gep")
compiler: refactor defer operations
5 years ago
nextStack := b.CreateLoad(nextStackGEP, "stack.next")
b.CreateStore(nextStack, b.deferPtr)
gep := b.CreateInBoundsGEP(deferData, []llvm.Value{
llvm.ConstInt(b.ctx.Int32Type(), 0, false),
llvm.ConstInt(b.ctx.Int32Type(), 0, false), // .callback field
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
}, "callback.gep")
compiler: refactor defer operations
5 years ago
callback := b.CreateLoad(gep, "callback")
sw := b.CreateSwitch(callback, unreachable, len(b.allDeferFuncs))
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
compiler: refactor defer operations
5 years ago
for i, callback := range b.allDeferFuncs {
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
// Create switch case, for example:
// case 0:
// // run first deferred call
compiler: insert basic blocks at an appropriate location For example, this commit moves the 'throw' branch of an assertion (nil check, slice index check, etc) to the end of the function while inserting the "continue" branch right after the insert location. This makes the resulting IR easier to follow. For some reason, this also reduces code size a bit on average. The TinyGo smoke tests saw a reduction of 0.22%, mainly from WebAssembly. The drivers repo saw little average change in code size (-0.01%). This commit also adds a few compiler tests for the defer keyword.
3 years ago
block := b.insertBasicBlock("rundefers.callback" + strconv.Itoa(i))
compiler: refactor defer operations
5 years ago
sw.AddCase(llvm.ConstInt(b.uintptrType, uint64(i), false), block)
b.SetInsertPointAtEnd(block)
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
switch callback := callback.(type) {
case *ssa.CallCommon:
compiler: implement func value and builtin defers Co-authored-by: Justin A. Wilson <maker.pro.game@gmail.com>
4 years ago
// Call on an value or interface value.
// Get the real defer struct type and cast to it.
valueTypes := []llvm.Type{b.uintptrType, llvm.PointerType(b.getLLVMRuntimeType("_defer"), 0)}
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
if !callback.IsInvoke() {
compiler: implement recover() built-in function
3 years ago
//Expect funcValue to be passed through the deferred call.
compiler: implement func value and builtin defers Co-authored-by: Justin A. Wilson <maker.pro.game@gmail.com>
4 years ago
valueTypes = append(valueTypes, b.getFuncType(callback.Signature()))
} else {
//Expect typecode
valueTypes = append(valueTypes, b.uintptrType, b.i8ptrType)
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
}
compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
for _, arg := range callback.Args {
compiler: refactor defer operations
5 years ago
valueTypes = append(valueTypes, b.getLLVMType(arg.Type()))
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
}
compiler: implement func value and builtin defers Co-authored-by: Justin A. Wilson <maker.pro.game@gmail.com>
4 years ago
compiler: implement recover() built-in function
3 years ago
deferredCallType := b.ctx.StructType(valueTypes, false)
deferredCallPtr := b.CreateBitCast(deferData, llvm.PointerType(deferredCallType, 0), "defercall")
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
// Extract the params from the struct (including receiver).
forwardParams := []llvm.Value{}
compiler: refactor defer operations
5 years ago
zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
for i := 2; i < len(valueTypes); i++ {
compiler: implement recover() built-in function
3 years ago
gep := b.CreateInBoundsGEP(deferredCallPtr, []llvm.Value{zero, llvm.ConstInt(b.ctx.Int32Type(), uint64(i), false)}, "gep")
compiler: refactor defer operations
5 years ago
forwardParam := b.CreateLoad(gep, "param")
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
forwardParams = append(forwardParams, forwardParam)
compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
}
compiler: implement func value and builtin defers Co-authored-by: Justin A. Wilson &lt;maker.pro.game@gmail.com&gt;
4 years ago
var fnPtr llvm.Value
compiler: pass interface typecode through defer frames Previously, the typecode was passed via a direct reference, which results in invalid IR when the defer is not reached in all return paths. It also results in incorrect behavior if the defer is in a loop, causing all defers to use the typecode of the last iteration.
5 years ago
compiler: implement func value and builtin defers Co-authored-by: Justin A. Wilson &lt;maker.pro.game@gmail.com&gt;
4 years ago
if !callback.IsInvoke() {
// Isolate the func value.
funcValue := forwardParams[0]
forwardParams = forwardParams[1:]
//Get function pointer and context
fp, context := b.decodeFuncValue(funcValue, callback.Signature())
fnPtr = fp
//Pass context
forwardParams = append(forwardParams, context)
} else {
compiler: simplify interface lowering This commit simplifies the IR a little bit: instead of calling pseudo-functions runtime.interfaceImplements and runtime.interfaceMethod, real declared functions are being called that are then defined in the interface lowering pass. This should simplify the interaction between various transformation passes. It also reduces the number of lines of code, which is generally a good thing.
3 years ago
// Move typecode from the start to the end of the list of
// parameters.
forwardParams = append(forwardParams[1:], forwardParams[0])
fnPtr = b.getInvokeFunction(callback)
compiler: implement func value and builtin defers Co-authored-by: Justin A. Wilson &lt;maker.pro.game@gmail.com&gt;
4 years ago
// Add the context parameter. An interface call cannot also be a
// closure but we have to supply the parameter anyway for platforms
// with a strict calling convention.
forwardParams = append(forwardParams, llvm.Undef(b.i8ptrType))
}
compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
compiler: refactor defer operations
5 years ago
b.createCall(fnPtr, forwardParams, "")
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
compiler: remove ir package This package was long making the design of the compiler more complicated than it needs to be. Previously this package implemented several optimization passes, but those passes have since moved to work directly with LLVM IR instead of Go SSA. The only remaining pass is the SimpleDCE pass. This commit removes the *ir.Function type that permeated the whole compiler and instead switches to use *ssa.Function directly. The SimpleDCE pass is kept but is far less tightly coupled to the rest of the compiler so that it can easily be removed once the switch to building and caching packages individually happens.
4 years ago
case *ssa.Function:
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
// Direct call.
// Get the real defer struct type and cast to it.
compiler: refactor defer operations
5 years ago
valueTypes := []llvm.Type{b.uintptrType, llvm.PointerType(b.getLLVMRuntimeType("_defer"), 0)}
builder, compiler: compile and cache packages in parallel This commit switches from the previous behavior of compiling the whole program at once, to compiling every package in parallel and linking the LLVM bitcode files together for further whole-program optimization. This is a small performance win, but it has several advantages in the future: - There are many more things that can be done per package in parallel, avoiding the bottleneck at the end of the compiler phase. This should speed up the compiler futher. - This change is a necessary step towards a non-LTO build mode for fast incremental builds that only rebuild the changed package, when compiler speed is more important than binary size. - This change refactors the compiler in such a way that it will be easier to inspect the IR for one package only. Inspecting this IR will be very helpful for compiler developers.
4 years ago
for _, param := range getParams(callback.Signature) {
compiler: refactor defer operations
5 years ago
valueTypes = append(valueTypes, b.getLLVMType(param.Type()))
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
}
compiler: implement recover() built-in function
3 years ago
deferredCallType := b.ctx.StructType(valueTypes, false)
deferredCallPtr := b.CreateBitCast(deferData, llvm.PointerType(deferredCallType, 0), "defercall")
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
// Extract the params from the struct.
forwardParams := []llvm.Value{}
compiler: refactor defer operations
5 years ago
zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
builder, compiler: compile and cache packages in parallel This commit switches from the previous behavior of compiling the whole program at once, to compiling every package in parallel and linking the LLVM bitcode files together for further whole-program optimization. This is a small performance win, but it has several advantages in the future: - There are many more things that can be done per package in parallel, avoiding the bottleneck at the end of the compiler phase. This should speed up the compiler futher. - This change is a necessary step towards a non-LTO build mode for fast incremental builds that only rebuild the changed package, when compiler speed is more important than binary size. - This change refactors the compiler in such a way that it will be easier to inspect the IR for one package only. Inspecting this IR will be very helpful for compiler developers.
4 years ago
for i := range getParams(callback.Signature) {
compiler: implement recover() built-in function
3 years ago
gep := b.CreateInBoundsGEP(deferredCallPtr, []llvm.Value{zero, llvm.ConstInt(b.ctx.Int32Type(), uint64(i+2), false)}, "gep")
compiler: refactor defer operations
5 years ago
forwardParam := b.CreateLoad(gep, "param")
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
forwardParams = append(forwardParams, forwardParam)
}
compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
compiler: fix deferred calls to exported functions Previously using defer with an exported function generated an invalid function call due to differences between TinyGo&#39;s calling convention and the C calling convention.
5 years ago
// Plain TinyGo functions add some extra parameters to implement async functionality and function recievers.
// These parameters should not be supplied when calling into an external C/ASM function.
compiler: remove ir package This package was long making the design of the compiler more complicated than it needs to be. Previously this package implemented several optimization passes, but those passes have since moved to work directly with LLVM IR instead of Go SSA. The only remaining pass is the SimpleDCE pass. This commit removes the *ir.Function type that permeated the whole compiler and instead switches to use *ssa.Function directly. The SimpleDCE pass is kept but is far less tightly coupled to the rest of the compiler so that it can easily be removed once the switch to building and caching packages individually happens.
4 years ago
if !b.getFunctionInfo(callback).exported {
compiler: fix deferred calls to exported functions Previously using defer with an exported function generated an invalid function call due to differences between TinyGo&#39;s calling convention and the C calling convention.
5 years ago
// Add the context parameter. We know it is ignored by the receiving
// function, but we have to pass one anyway.
compiler: refactor defer operations
5 years ago
forwardParams = append(forwardParams, llvm.Undef(b.i8ptrType))
compiler: fix deferred calls to exported functions Previously using defer with an exported function generated an invalid function call due to differences between TinyGo&#39;s calling convention and the C calling convention.
5 years ago
}
all: rewrite goroutine lowering Before this commit, goroutine support was spread through the compiler. This commit changes this support, so that the compiler itself only generates simple intrinsics and leaves the real support to a compiler pass that runs as one of the TinyGo-specific optimization passes. The biggest change, that was done together with the rewrite, was support for goroutines in WebAssembly for JavaScript. The challenge in JavaScript is that in general no blocking operations are allowed, which means that programs that call time.Sleep() but do not start goroutines also have to be scheduled by the scheduler.
6 years ago
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
// Call real function.
compiler: implement recover() built-in function
3 years ago
b.createInvoke(b.getFunction(callback), forwardParams, "")
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
case *ssa.MakeClosure:
// Get the real defer struct type and cast to it.
compiler: remove ir package This package was long making the design of the compiler more complicated than it needs to be. Previously this package implemented several optimization passes, but those passes have since moved to work directly with LLVM IR instead of Go SSA. The only remaining pass is the SimpleDCE pass. This commit removes the *ir.Function type that permeated the whole compiler and instead switches to use *ssa.Function directly. The SimpleDCE pass is kept but is far less tightly coupled to the rest of the compiler so that it can easily be removed once the switch to building and caching packages individually happens.
4 years ago
fn := callback.Fn.(*ssa.Function)
compiler: refactor defer operations
5 years ago
valueTypes := []llvm.Type{b.uintptrType, llvm.PointerType(b.getLLVMRuntimeType("_defer"), 0)}
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
params := fn.Signature.Params()
for i := 0; i < params.Len(); i++ {
compiler: refactor defer operations
5 years ago
valueTypes = append(valueTypes, b.getLLVMType(params.At(i).Type()))
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
}
compiler: refactor defer operations
5 years ago
valueTypes = append(valueTypes, b.i8ptrType) // closure
compiler: implement recover() built-in function
3 years ago
deferredCallType := b.ctx.StructType(valueTypes, false)
deferredCallPtr := b.CreateBitCast(deferData, llvm.PointerType(deferredCallType, 0), "defercall")
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
// Extract the params from the struct.
forwardParams := []llvm.Value{}
compiler: refactor defer operations
5 years ago
zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
for i := 2; i < len(valueTypes); i++ {
compiler: implement recover() built-in function
3 years ago
gep := b.CreateInBoundsGEP(deferredCallPtr, []llvm.Value{zero, llvm.ConstInt(b.ctx.Int32Type(), uint64(i), false)}, "")
compiler: refactor defer operations
5 years ago
forwardParam := b.CreateLoad(gep, "param")
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
forwardParams = append(forwardParams, forwardParam)
}
compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
// Call deferred function.
compiler: remove ir package This package was long making the design of the compiler more complicated than it needs to be. Previously this package implemented several optimization passes, but those passes have since moved to work directly with LLVM IR instead of Go SSA. The only remaining pass is the SimpleDCE pass. This commit removes the *ir.Function type that permeated the whole compiler and instead switches to use *ssa.Function directly. The SimpleDCE pass is kept but is far less tightly coupled to the rest of the compiler so that it can easily be removed once the switch to building and caching packages individually happens.
4 years ago
b.createCall(b.getFunction(fn), forwardParams, "")
compiler: implement func value and builtin defers Co-authored-by: Justin A. Wilson &lt;maker.pro.game@gmail.com&gt;
4 years ago
case *ssa.Builtin:
db := b.deferBuiltinFuncs[callback]
//Get parameter types
valueTypes := []llvm.Type{b.uintptrType, llvm.PointerType(b.getLLVMRuntimeType("_defer"), 0)}
//Get signature from call results
params := callback.Type().Underlying().(*types.Signature).Params()
for i := 0; i < params.Len(); i++ {
valueTypes = append(valueTypes, b.getLLVMType(params.At(i).Type()))
}
compiler: implement recover() built-in function
3 years ago
deferredCallType := b.ctx.StructType(valueTypes, false)
deferredCallPtr := b.CreateBitCast(deferData, llvm.PointerType(deferredCallType, 0), "defercall")
compiler: implement func value and builtin defers Co-authored-by: Justin A. Wilson &lt;maker.pro.game@gmail.com&gt;
4 years ago
// Extract the params from the struct.
compiler: support all kinds of deferred builtins This change extends defer support to all supported builitin functions. Not all of them make sense (such as len, cap, real, imag, etc) but this change for example adds support for `defer(delete(m, key))` which is used in the Go 1.15 encoding/json package.
4 years ago
var argValues []llvm.Value
compiler: implement func value and builtin defers Co-authored-by: Justin A. Wilson &lt;maker.pro.game@gmail.com&gt;
4 years ago
zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
for i := 0; i < params.Len(); i++ {
compiler: implement recover() built-in function
3 years ago
gep := b.CreateInBoundsGEP(deferredCallPtr, []llvm.Value{zero, llvm.ConstInt(b.ctx.Int32Type(), uint64(i+2), false)}, "gep")
compiler: implement func value and builtin defers Co-authored-by: Justin A. Wilson &lt;maker.pro.game@gmail.com&gt;
4 years ago
forwardParam := b.CreateLoad(gep, "param")
compiler: support all kinds of deferred builtins This change extends defer support to all supported builitin functions. Not all of them make sense (such as len, cap, real, imag, etc) but this change for example adds support for `defer(delete(m, key))` which is used in the Go 1.15 encoding/json package.
4 years ago
argValues = append(argValues, forwardParam)
compiler: implement func value and builtin defers Co-authored-by: Justin A. Wilson &lt;maker.pro.game@gmail.com&gt;
4 years ago
}
compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
compiler: support all kinds of deferred builtins This change extends defer support to all supported builitin functions. Not all of them make sense (such as len, cap, real, imag, etc) but this change for example adds support for `defer(delete(m, key))` which is used in the Go 1.15 encoding/json package.
4 years ago
_, err := b.createBuiltin(db.argTypes, argValues, db.callName, db.pos)
if err != nil {
b.diagnostics = append(b.diagnostics, err)
}
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
default:
panic("unknown deferred function type")
compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
}
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
// Branch back to the start of the loop.
compiler: refactor defer operations
5 years ago
b.CreateBr(loophead)
compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
}
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
// Create default unreachable block:
// default:
// unreachable
// }
compiler: refactor defer operations
5 years ago
b.SetInsertPointAtEnd(unreachable)
b.CreateUnreachable()
compiler: avoid function pointers in defer calls Implement defer in a different way, which results in smaller binaries. The binary produced from testdata/calls.go (the only test case with defer) is reduced a bit in size, but the savings in bytes greatly vary by architecture: Cortex-M0: -96 .text / flash WebAssembly: -215 entire file Linux x64: -32 .text Deferred functions in TinyGo were implemented by creating a linked list of struct objects that contain a function pointer to a thunk, a pointer to the next object, and a list of parameters. When it was time to run deferred functions, a helper runtime function called each function pointer (the thunk) with the struct pointer as a parameter. This thunk would then in turn extract the saved function parameter from the struct and call the real function. What this commit changes, is that the loop to call deferred functions is moved into the end of the function (practically inlining it) and replacing the thunks with direct calls inside this loop. This makes it much easier for LLVM to perform all kinds of optimizations like inlining and dead argument elimination.
6 years ago
// End of loop.
compiler: refactor defer operations
5 years ago
b.SetInsertPointAtEnd(end)
compiler: move defer code out of compiler.go This puts all defer-related code into a single file, making it easier to understand it.
6 years ago
}