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.
1086 Commits
99 Branches
41 Tags
26 MiB
Tree: 4ea1559d46
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '4ea1559d46'
${ noResults }
tinygo/interp/frame.go

541 lines
22 KiB
Raw Normal View History

interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
package interp
// This file implements the core interpretation routines, interpreting single
// functions.
import (
"errors"
"strings"
all: rename go-llvm to new import path the new import path is: tinygo.org/x/go-llvm
6 years ago
"tinygo.org/x/go-llvm"
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
)
type frame struct {
*Eval
fn llvm.Value
pkgName string
locals map[llvm.Value]Value
}
interp: report 'unreachable' instruction as an error This instruction should never be hit in real programs, but the interpreter may hit it after a call to panic(). This would always be a runtime error.
6 years ago
var ErrUnreachable = errors.New("interp: unreachable executed")
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
// evalBasicBlock evaluates a single basic block, returning the return value (if
// ending with a ret instruction), a list of outgoing basic blocks (if not
// ending with a ret instruction), or an error on failure.
// Most of it works at compile time. Some calls get translated into calls to be
// executed at runtime: calls to functions with side effects, external calls,
// and operations on the result of such instructions.
func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (retval Value, outgoing []llvm.Value, err error) {
for inst := bb.FirstInstruction(); !inst.IsNil(); inst = llvm.NextInstruction(inst) {
if fr.Debug {
print(indent)
inst.Dump()
println()
}
switch {
case !inst.IsABinaryOperator().IsNil():
lhs := fr.getLocal(inst.Operand(0)).(*LocalValue).Underlying
rhs := fr.getLocal(inst.Operand(1)).(*LocalValue).Underlying
switch inst.InstructionOpcode() {
// Standard binary operators
case llvm.Add:
interp: fix several bugs related to constant vs dirty values * Loading from a dirty global must be done at runtime (!). For some reason this wasn't already the case. * Global variables somehow had IsConstant() the wrong way round, returning the inverse from what they should. * Do binary and logical operations at runtime if necessary, relying on const propagation in the IR builder. * Don't try to interpret functions that take a dirty parameter. Call them at runtime.
6 years ago
fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateAdd(lhs, rhs, "")}
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
case llvm.FAdd:
interp: fix several bugs related to constant vs dirty values * Loading from a dirty global must be done at runtime (!). For some reason this wasn't already the case. * Global variables somehow had IsConstant() the wrong way round, returning the inverse from what they should. * Do binary and logical operations at runtime if necessary, relying on const propagation in the IR builder. * Don't try to interpret functions that take a dirty parameter. Call them at runtime.
6 years ago
fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateFAdd(lhs, rhs, "")}
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
case llvm.Sub:
interp: fix several bugs related to constant vs dirty values * Loading from a dirty global must be done at runtime (!). For some reason this wasn't already the case. * Global variables somehow had IsConstant() the wrong way round, returning the inverse from what they should. * Do binary and logical operations at runtime if necessary, relying on const propagation in the IR builder. * Don't try to interpret functions that take a dirty parameter. Call them at runtime.
6 years ago
fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateSub(lhs, rhs, "")}
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
case llvm.FSub:
interp: fix several bugs related to constant vs dirty values * Loading from a dirty global must be done at runtime (!). For some reason this wasn't already the case. * Global variables somehow had IsConstant() the wrong way round, returning the inverse from what they should. * Do binary and logical operations at runtime if necessary, relying on const propagation in the IR builder. * Don't try to interpret functions that take a dirty parameter. Call them at runtime.
6 years ago
fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateFSub(lhs, rhs, "")}
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
case llvm.Mul:
interp: fix several bugs related to constant vs dirty values * Loading from a dirty global must be done at runtime (!). For some reason this wasn't already the case. * Global variables somehow had IsConstant() the wrong way round, returning the inverse from what they should. * Do binary and logical operations at runtime if necessary, relying on const propagation in the IR builder. * Don't try to interpret functions that take a dirty parameter. Call them at runtime.
6 years ago
fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateMul(lhs, rhs, "")}
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
case llvm.FMul:
interp: fix several bugs related to constant vs dirty values * Loading from a dirty global must be done at runtime (!). For some reason this wasn't already the case. * Global variables somehow had IsConstant() the wrong way round, returning the inverse from what they should. * Do binary and logical operations at runtime if necessary, relying on const propagation in the IR builder. * Don't try to interpret functions that take a dirty parameter. Call them at runtime.
6 years ago
fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateFMul(lhs, rhs, "")}
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
case llvm.UDiv:
interp: fix several bugs related to constant vs dirty values * Loading from a dirty global must be done at runtime (!). For some reason this wasn't already the case. * Global variables somehow had IsConstant() the wrong way round, returning the inverse from what they should. * Do binary and logical operations at runtime if necessary, relying on const propagation in the IR builder. * Don't try to interpret functions that take a dirty parameter. Call them at runtime.
6 years ago
fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateUDiv(lhs, rhs, "")}
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
case llvm.SDiv:
interp: fix several bugs related to constant vs dirty values * Loading from a dirty global must be done at runtime (!). For some reason this wasn't already the case. * Global variables somehow had IsConstant() the wrong way round, returning the inverse from what they should. * Do binary and logical operations at runtime if necessary, relying on const propagation in the IR builder. * Don't try to interpret functions that take a dirty parameter. Call them at runtime.
6 years ago
fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateSDiv(lhs, rhs, "")}
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
case llvm.FDiv:
interp: fix several bugs related to constant vs dirty values * Loading from a dirty global must be done at runtime (!). For some reason this wasn't already the case. * Global variables somehow had IsConstant() the wrong way round, returning the inverse from what they should. * Do binary and logical operations at runtime if necessary, relying on const propagation in the IR builder. * Don't try to interpret functions that take a dirty parameter. Call them at runtime.
6 years ago
fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateFDiv(lhs, rhs, "")}
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
case llvm.URem:
interp: fix several bugs related to constant vs dirty values * Loading from a dirty global must be done at runtime (!). For some reason this wasn't already the case. * Global variables somehow had IsConstant() the wrong way round, returning the inverse from what they should. * Do binary and logical operations at runtime if necessary, relying on const propagation in the IR builder. * Don't try to interpret functions that take a dirty parameter. Call them at runtime.
6 years ago
fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateURem(lhs, rhs, "")}
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
case llvm.SRem:
interp: fix several bugs related to constant vs dirty values * Loading from a dirty global must be done at runtime (!). For some reason this wasn't already the case. * Global variables somehow had IsConstant() the wrong way round, returning the inverse from what they should. * Do binary and logical operations at runtime if necessary, relying on const propagation in the IR builder. * Don't try to interpret functions that take a dirty parameter. Call them at runtime.
6 years ago
fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateSRem(lhs, rhs, "")}
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
case llvm.FRem:
interp: fix several bugs related to constant vs dirty values * Loading from a dirty global must be done at runtime (!). For some reason this wasn't already the case. * Global variables somehow had IsConstant() the wrong way round, returning the inverse from what they should. * Do binary and logical operations at runtime if necessary, relying on const propagation in the IR builder. * Don't try to interpret functions that take a dirty parameter. Call them at runtime.
6 years ago
fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateFRem(lhs, rhs, "")}
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
// Logical operators
case llvm.Shl:
interp: fix several bugs related to constant vs dirty values * Loading from a dirty global must be done at runtime (!). For some reason this wasn't already the case. * Global variables somehow had IsConstant() the wrong way round, returning the inverse from what they should. * Do binary and logical operations at runtime if necessary, relying on const propagation in the IR builder. * Don't try to interpret functions that take a dirty parameter. Call them at runtime.
6 years ago
fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateShl(lhs, rhs, "")}
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
case llvm.LShr:
interp: fix several bugs related to constant vs dirty values * Loading from a dirty global must be done at runtime (!). For some reason this wasn't already the case. * Global variables somehow had IsConstant() the wrong way round, returning the inverse from what they should. * Do binary and logical operations at runtime if necessary, relying on const propagation in the IR builder. * Don't try to interpret functions that take a dirty parameter. Call them at runtime.
6 years ago
fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateLShr(lhs, rhs, "")}
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
case llvm.AShr:
interp: fix several bugs related to constant vs dirty values * Loading from a dirty global must be done at runtime (!). For some reason this wasn't already the case. * Global variables somehow had IsConstant() the wrong way round, returning the inverse from what they should. * Do binary and logical operations at runtime if necessary, relying on const propagation in the IR builder. * Don't try to interpret functions that take a dirty parameter. Call them at runtime.
6 years ago
fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateAShr(lhs, rhs, "")}
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
case llvm.And:
interp: fix several bugs related to constant vs dirty values * Loading from a dirty global must be done at runtime (!). For some reason this wasn't already the case. * Global variables somehow had IsConstant() the wrong way round, returning the inverse from what they should. * Do binary and logical operations at runtime if necessary, relying on const propagation in the IR builder. * Don't try to interpret functions that take a dirty parameter. Call them at runtime.
6 years ago
fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateAnd(lhs, rhs, "")}
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
case llvm.Or:
interp: fix several bugs related to constant vs dirty values * Loading from a dirty global must be done at runtime (!). For some reason this wasn't already the case. * Global variables somehow had IsConstant() the wrong way round, returning the inverse from what they should. * Do binary and logical operations at runtime if necessary, relying on const propagation in the IR builder. * Don't try to interpret functions that take a dirty parameter. Call them at runtime.
6 years ago
fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateOr(lhs, rhs, "")}
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
case llvm.Xor:
interp: fix several bugs related to constant vs dirty values * Loading from a dirty global must be done at runtime (!). For some reason this wasn't already the case. * Global variables somehow had IsConstant() the wrong way round, returning the inverse from what they should. * Do binary and logical operations at runtime if necessary, relying on const propagation in the IR builder. * Don't try to interpret functions that take a dirty parameter. Call them at runtime.
6 years ago
fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateXor(lhs, rhs, "")}
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
default:
return nil, nil, &Unsupported{inst}
}
// Memory operators
case !inst.IsAAllocaInst().IsNil():
interp: refactor to eliminate lots of code This may cause a small performance penalty, but the code is easier to maange as a result.
6 years ago
allocType := inst.Type().ElementType()
alloca := llvm.AddGlobal(fr.Mod, allocType, fr.pkgName+"$alloca")
compiler: rename getZeroValue to llvm.ConstNull It does the same thing but should be more complete, and it probably is faster as well (just one CGo call instead of several).
5 years ago
alloca.SetInitializer(llvm.ConstNull(allocType))
interp: refactor to eliminate lots of code This may cause a small performance penalty, but the code is easier to maange as a result.
6 years ago
alloca.SetLinkage(llvm.InternalLinkage)
fr.locals[inst] = &LocalValue{
Underlying: alloca,
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
Eval: fr.Eval,
}
case !inst.IsALoadInst().IsNil():
interp: refactor to eliminate lots of code This may cause a small performance penalty, but the code is easier to maange as a result.
6 years ago
operand := fr.getLocal(inst.Operand(0)).(*LocalValue)
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
var value llvm.Value
interp: fix segmentation fault in some builds A call to .IsConstant() also returns true for constant globals, not just constant expressions. Do an extra check that we're really operating on a constant expression.
6 years ago
if !operand.IsConstant() || inst.IsVolatile() || (!operand.Underlying.IsAConstantExpr().IsNil() && operand.Underlying.Opcode() == llvm.BitCast) {
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
value = fr.builder.CreateLoad(operand.Value(), inst.Name())
} else {
value = operand.Load()
}
if value.Type() != inst.Type() {
panic("interp: load: type does not match")
}
fr.locals[inst] = fr.getValue(value)
case !inst.IsAStoreInst().IsNil():
value := fr.getLocal(inst.Operand(0))
ptr := fr.getLocal(inst.Operand(1))
if inst.IsVolatile() {
fr.builder.CreateStore(value.Value(), ptr.Value())
} else {
ptr.Store(value.Value())
}
case !inst.IsAGetElementPtrInst().IsNil():
value := fr.getLocal(inst.Operand(0))
llvmIndices := make([]llvm.Value, inst.OperandsCount()-1)
for i := range llvmIndices {
llvmIndices[i] = inst.Operand(i + 1)
}
indices := make([]uint32, len(llvmIndices))
interp: fix GEP with const value in a local variable
6 years ago
for i, llvmIndex := range llvmIndices {
operand := fr.getLocal(llvmIndex)
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
if !operand.IsConstant() {
interp: fix GEP with const value in a local variable
6 years ago
// Not a constant operation.
// This should be detected by the scanner, but isn't at the
// moment.
panic("todo: non-const gep")
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
}
interp: fix GEP with const value in a local variable
6 years ago
indices[i] = uint32(operand.Value().ZExtValue())
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
}
result := value.GetElementPtr(indices)
if result.Type() != inst.Type() {
println(" expected:", inst.Type().String())
println(" actual: ", result.Type().String())
panic("interp: gep: type does not match")
}
fr.locals[inst] = result
// Cast operators
case !inst.IsATruncInst().IsNil():
value := fr.getLocal(inst.Operand(0))
interp: do cast operations at runtime if needed Cast operations will still be evaluated at compile time in all cases they did before because of the built-in constant propagation of the IRBuilder, but when one of the parameters is not a constant it will transparently be evaluated at runtime. This avoids some errors in the partial evaluator. It is not yet complete as all binops will need a similar treatment.
6 years ago
fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateTrunc(value.(*LocalValue).Value(), inst.Type(), "")}
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
case !inst.IsAZExtInst().IsNil():
value := fr.getLocal(inst.Operand(0))
interp: do cast operations at runtime if needed Cast operations will still be evaluated at compile time in all cases they did before because of the built-in constant propagation of the IRBuilder, but when one of the parameters is not a constant it will transparently be evaluated at runtime. This avoids some errors in the partial evaluator. It is not yet complete as all binops will need a similar treatment.
6 years ago
fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateZExt(value.(*LocalValue).Value(), inst.Type(), "")}
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
case !inst.IsASExtInst().IsNil():
value := fr.getLocal(inst.Operand(0))
interp: do cast operations at runtime if needed Cast operations will still be evaluated at compile time in all cases they did before because of the built-in constant propagation of the IRBuilder, but when one of the parameters is not a constant it will transparently be evaluated at runtime. This avoids some errors in the partial evaluator. It is not yet complete as all binops will need a similar treatment.
6 years ago
fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateSExt(value.(*LocalValue).Value(), inst.Type(), "")}
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
case !inst.IsAFPToUIInst().IsNil():
value := fr.getLocal(inst.Operand(0))
interp: do cast operations at runtime if needed Cast operations will still be evaluated at compile time in all cases they did before because of the built-in constant propagation of the IRBuilder, but when one of the parameters is not a constant it will transparently be evaluated at runtime. This avoids some errors in the partial evaluator. It is not yet complete as all binops will need a similar treatment.
6 years ago
fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateFPToUI(value.(*LocalValue).Value(), inst.Type(), "")}
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
case !inst.IsAFPToSIInst().IsNil():
value := fr.getLocal(inst.Operand(0))
interp: do cast operations at runtime if needed Cast operations will still be evaluated at compile time in all cases they did before because of the built-in constant propagation of the IRBuilder, but when one of the parameters is not a constant it will transparently be evaluated at runtime. This avoids some errors in the partial evaluator. It is not yet complete as all binops will need a similar treatment.
6 years ago
fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateFPToSI(value.(*LocalValue).Value(), inst.Type(), "")}
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
case !inst.IsAUIToFPInst().IsNil():
value := fr.getLocal(inst.Operand(0))
interp: do cast operations at runtime if needed Cast operations will still be evaluated at compile time in all cases they did before because of the built-in constant propagation of the IRBuilder, but when one of the parameters is not a constant it will transparently be evaluated at runtime. This avoids some errors in the partial evaluator. It is not yet complete as all binops will need a similar treatment.
6 years ago
fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateUIToFP(value.(*LocalValue).Value(), inst.Type(), "")}
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
case !inst.IsASIToFPInst().IsNil():
value := fr.getLocal(inst.Operand(0))
interp: do cast operations at runtime if needed Cast operations will still be evaluated at compile time in all cases they did before because of the built-in constant propagation of the IRBuilder, but when one of the parameters is not a constant it will transparently be evaluated at runtime. This avoids some errors in the partial evaluator. It is not yet complete as all binops will need a similar treatment.
6 years ago
fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateSIToFP(value.(*LocalValue).Value(), inst.Type(), "")}
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
case !inst.IsAFPTruncInst().IsNil():
value := fr.getLocal(inst.Operand(0))
interp: do cast operations at runtime if needed Cast operations will still be evaluated at compile time in all cases they did before because of the built-in constant propagation of the IRBuilder, but when one of the parameters is not a constant it will transparently be evaluated at runtime. This avoids some errors in the partial evaluator. It is not yet complete as all binops will need a similar treatment.
6 years ago
fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateFPTrunc(value.(*LocalValue).Value(), inst.Type(), "")}
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
case !inst.IsAFPExtInst().IsNil():
value := fr.getLocal(inst.Operand(0))
interp: do cast operations at runtime if needed Cast operations will still be evaluated at compile time in all cases they did before because of the built-in constant propagation of the IRBuilder, but when one of the parameters is not a constant it will transparently be evaluated at runtime. This avoids some errors in the partial evaluator. It is not yet complete as all binops will need a similar treatment.
6 years ago
fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateFPExt(value.(*LocalValue).Value(), inst.Type(), "")}
interp: support non-const ptrtoint instruction
6 years ago
case !inst.IsAPtrToIntInst().IsNil():
value := fr.getLocal(inst.Operand(0))
fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreatePtrToInt(value.Value(), inst.Type(), "")}
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
case !inst.IsABitCastInst().IsNil() && inst.Type().TypeKind() == llvm.PointerTypeKind:
operand := inst.Operand(0)
if !operand.IsACallInst().IsNil() {
fn := operand.CalledValue()
if !fn.IsAFunction().IsNil() && fn.Name() == "runtime.alloc" {
continue // special case: bitcast of alloc
}
}
compiler,runtime: implement a portable conservative GC
6 years ago
if _, ok := fr.getLocal(operand).(*MapValue); ok {
// Special case for runtime.trackPointer calls.
// Note: this might not be entirely sound in some rare cases
// where the map is stored in a dirty global.
uses := getUses(inst)
if len(uses) == 1 {
use := uses[0]
if !use.IsACallInst().IsNil() && !use.CalledValue().IsAFunction().IsNil() && use.CalledValue().Name() == "runtime.trackPointer" {
continue
}
}
// It is not possible in Go to bitcast a map value to a pointer.
panic("unimplemented: bitcast of map")
}
interp: refactor to eliminate lots of code This may cause a small performance penalty, but the code is easier to maange as a result.
6 years ago
value := fr.getLocal(operand).(*LocalValue)
fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateBitCast(value.Value(), inst.Type(), "")}
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
// Other operators
case !inst.IsAICmpInst().IsNil():
lhs := fr.getLocal(inst.Operand(0)).(*LocalValue).Underlying
rhs := fr.getLocal(inst.Operand(1)).(*LocalValue).Underlying
predicate := inst.IntPredicate()
interp: work around limitation of constfolding in IR builder The IR builder does not appear to fold comparisons of constant inttoptr instructions to const null pointer. So do it manually during interpretatin, as a somewhat ugly hack. This fixes https://github.com/tinygo-org/tinygo/issues/363
6 years ago
if predicate == llvm.IntEQ && lhs.Type().TypeKind() == llvm.PointerTypeKind {
// Unfortunately, the const propagation in the IR builder
// doesn't handle pointer compares of inttoptr values. So we
// implement it manually here.
interp: support some more expressions in const icmp
6 years ago
lhsNil, ok1 := isPointerNil(lhs)
rhsNil, ok2 := isPointerNil(rhs)
interp: work around limitation of constfolding in IR builder The IR builder does not appear to fold comparisons of constant inttoptr instructions to const null pointer. So do it manually during interpretatin, as a somewhat ugly hack. This fixes https://github.com/tinygo-org/tinygo/issues/363
6 years ago
if ok1 && ok2 {
if lhsNil && rhsNil {
// Both are nil, so this icmp is always evaluated to true.
fr.locals[inst] = &LocalValue{fr.Eval, llvm.ConstInt(fr.Mod.Context().Int1Type(), 1, false)}
continue
}
if lhsNil != rhsNil {
// Only one of them is nil, so this comparison must return false.
fr.locals[inst] = &LocalValue{fr.Eval, llvm.ConstInt(fr.Mod.Context().Int1Type(), 0, false)}
continue
}
}
}
interp: do cast operations at runtime if needed Cast operations will still be evaluated at compile time in all cases they did before because of the built-in constant propagation of the IRBuilder, but when one of the parameters is not a constant it will transparently be evaluated at runtime. This avoids some errors in the partial evaluator. It is not yet complete as all binops will need a similar treatment.
6 years ago
fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateICmp(predicate, lhs, rhs, "")}
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
case !inst.IsAFCmpInst().IsNil():
lhs := fr.getLocal(inst.Operand(0)).(*LocalValue).Underlying
rhs := fr.getLocal(inst.Operand(1)).(*LocalValue).Underlying
predicate := inst.FloatPredicate()
interp: do cast operations at runtime if needed Cast operations will still be evaluated at compile time in all cases they did before because of the built-in constant propagation of the IRBuilder, but when one of the parameters is not a constant it will transparently be evaluated at runtime. This avoids some errors in the partial evaluator. It is not yet complete as all binops will need a similar treatment.
6 years ago
fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateFCmp(predicate, lhs, rhs, "")}
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
case !inst.IsAPHINode().IsNil():
for i := 0; i < inst.IncomingCount(); i++ {
if inst.IncomingBlock(i) == incoming {
fr.locals[inst] = fr.getLocal(inst.IncomingValue(i))
}
}
case !inst.IsACallInst().IsNil():
callee := inst.CalledValue()
switch {
case callee.Name() == "runtime.alloc":
// heap allocation
users := getUses(inst)
var resultInst = inst
if len(users) == 1 && !users[0].IsABitCastInst().IsNil() {
// happens when allocating something other than i8*
resultInst = users[0]
}
size := fr.getLocal(inst.Operand(0)).(*LocalValue).Underlying.ZExtValue()
allocType := resultInst.Type().ElementType()
typeSize := fr.TargetData.TypeAllocSize(allocType)
elementCount := 1
if size != typeSize {
// allocate an array
if size%typeSize != 0 {
return nil, nil, &Unsupported{inst}
}
elementCount = int(size / typeSize)
allocType = llvm.ArrayType(allocType, elementCount)
}
alloc := llvm.AddGlobal(fr.Mod, allocType, fr.pkgName+"$alloc")
compiler: rename getZeroValue to llvm.ConstNull It does the same thing but should be more complete, and it probably is faster as well (just one CGo call instead of several).
5 years ago
alloc.SetInitializer(llvm.ConstNull(allocType))
interp: fix compile-time alloc linkage This makes sure compile-time allocations (globals with the $alloc suffix) can be eliminated when unused.
6 years ago
alloc.SetLinkage(llvm.InternalLinkage)
interp: refactor to eliminate lots of code This may cause a small performance penalty, but the code is easier to maange as a result.
6 years ago
result := &LocalValue{
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
Underlying: alloc,
Eval: fr.Eval,
}
if elementCount == 1 {
fr.locals[resultInst] = result
} else {
fr.locals[resultInst] = result.GetElementPtr([]uint32{0, 0})
}
case callee.Name() == "runtime.hashmapMake":
// create a map
keySize := inst.Operand(0).ZExtValue()
valueSize := inst.Operand(1).ZExtValue()
fr.locals[inst] = &MapValue{
Eval: fr.Eval,
PkgName: fr.pkgName,
KeySize: int(keySize),
ValueSize: int(valueSize),
}
case callee.Name() == "runtime.hashmapStringSet":
// set a string key in the map
m := fr.getLocal(inst.Operand(0)).(*MapValue)
interp: support map literals with integer keys
6 years ago
// "key" is a Go string value, which in the TinyGo calling convention is split up
// into separate pointer and length parameters.
interp: refactor to eliminate lots of code This may cause a small performance penalty, but the code is easier to maange as a result.
6 years ago
keyBuf := fr.getLocal(inst.Operand(1)).(*LocalValue)
keyLen := fr.getLocal(inst.Operand(2)).(*LocalValue)
valPtr := fr.getLocal(inst.Operand(3)).(*LocalValue)
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
m.PutString(keyBuf, keyLen, valPtr)
case callee.Name() == "runtime.hashmapBinarySet":
// set a binary (int etc.) key in the map
interp: support map literals with integer keys
6 years ago
m := fr.getLocal(inst.Operand(0)).(*MapValue)
interp: refactor to eliminate lots of code This may cause a small performance penalty, but the code is easier to maange as a result.
6 years ago
keyBuf := fr.getLocal(inst.Operand(1)).(*LocalValue)
valPtr := fr.getLocal(inst.Operand(2)).(*LocalValue)
interp: support map literals with integer keys
6 years ago
m.PutBinary(keyBuf, valPtr)
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
case callee.Name() == "runtime.stringConcat":
// adding two strings together
buf1Ptr := fr.getLocal(inst.Operand(0))
buf1Len := fr.getLocal(inst.Operand(1))
buf2Ptr := fr.getLocal(inst.Operand(2))
buf2Len := fr.getLocal(inst.Operand(3))
buf1 := getStringBytes(buf1Ptr, buf1Len.Value())
buf2 := getStringBytes(buf2Ptr, buf2Len.Value())
result := []byte(string(buf1) + string(buf2))
vals := make([]llvm.Value, len(result))
for i := range vals {
vals[i] = llvm.ConstInt(fr.Mod.Context().Int8Type(), uint64(result[i]), false)
}
globalType := llvm.ArrayType(fr.Mod.Context().Int8Type(), len(result))
globalValue := llvm.ConstArray(fr.Mod.Context().Int8Type(), vals)
global := llvm.AddGlobal(fr.Mod, globalType, fr.pkgName+"$stringconcat")
global.SetInitializer(globalValue)
global.SetLinkage(llvm.InternalLinkage)
global.SetGlobalConstant(true)
global.SetUnnamedAddr(true)
stringType := fr.Mod.GetTypeByName("runtime._string")
retPtr := llvm.ConstGEP(global, getLLVMIndices(fr.Mod.Context().Int32Type(), []uint32{0, 0}))
retLen := llvm.ConstInt(stringType.StructElementTypes()[1], uint64(len(result)), false)
compiler: rename getZeroValue to llvm.ConstNull It does the same thing but should be more complete, and it probably is faster as well (just one CGo call instead of several).
5 years ago
ret := llvm.ConstNull(stringType)
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
ret = llvm.ConstInsertValue(ret, retPtr, []uint32{0})
ret = llvm.ConstInsertValue(ret, retLen, []uint32{1})
fr.locals[inst] = &LocalValue{fr.Eval, ret}
case callee.Name() == "runtime.stringToBytes":
// convert a string to a []byte
bufPtr := fr.getLocal(inst.Operand(0))
bufLen := fr.getLocal(inst.Operand(1))
result := getStringBytes(bufPtr, bufLen.Value())
vals := make([]llvm.Value, len(result))
for i := range vals {
vals[i] = llvm.ConstInt(fr.Mod.Context().Int8Type(), uint64(result[i]), false)
}
globalType := llvm.ArrayType(fr.Mod.Context().Int8Type(), len(result))
globalValue := llvm.ConstArray(fr.Mod.Context().Int8Type(), vals)
global := llvm.AddGlobal(fr.Mod, globalType, fr.pkgName+"$bytes")
global.SetInitializer(globalValue)
global.SetLinkage(llvm.InternalLinkage)
global.SetGlobalConstant(true)
global.SetUnnamedAddr(true)
sliceType := inst.Type()
retPtr := llvm.ConstGEP(global, getLLVMIndices(fr.Mod.Context().Int32Type(), []uint32{0, 0}))
retLen := llvm.ConstInt(sliceType.StructElementTypes()[1], uint64(len(result)), false)
compiler: rename getZeroValue to llvm.ConstNull It does the same thing but should be more complete, and it probably is faster as well (just one CGo call instead of several).
5 years ago
ret := llvm.ConstNull(sliceType)
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
ret = llvm.ConstInsertValue(ret, retPtr, []uint32{0}) // ptr
ret = llvm.ConstInsertValue(ret, retLen, []uint32{1}) // len
ret = llvm.ConstInsertValue(ret, retLen, []uint32{2}) // cap
fr.locals[inst] = &LocalValue{fr.Eval, ret}
all: support interface asserts in interp This adds support for the math/rand package.
6 years ago
case callee.Name() == "runtime.interfaceImplements":
typecode := fr.getLocal(inst.Operand(0)).(*LocalValue).Underlying
interfaceMethodSet := fr.getLocal(inst.Operand(1)).(*LocalValue).Underlying
if typecode.IsAConstantExpr().IsNil() || typecode.Opcode() != llvm.PtrToInt {
panic("interp: expected typecode to be a ptrtoint")
}
typecode = typecode.Operand(0)
if interfaceMethodSet.IsAConstantExpr().IsNil() || interfaceMethodSet.Opcode() != llvm.GetElementPtr {
panic("interp: expected method set in runtime.interfaceImplements to be a constant gep")
}
interfaceMethodSet = interfaceMethodSet.Operand(0).Initializer()
methodSet := llvm.ConstExtractValue(typecode.Initializer(), []uint32{1})
if methodSet.IsAConstantExpr().IsNil() || methodSet.Opcode() != llvm.GetElementPtr {
panic("interp: expected method set to be a constant gep")
}
methodSet = methodSet.Operand(0).Initializer()
// Make a set of all the methods on the concrete type, for
// easier checking in the next step.
definedMethods := map[string]struct{}{}
for i := 0; i < methodSet.Type().ArrayLength(); i++ {
methodInfo := llvm.ConstExtractValue(methodSet, []uint32{uint32(i)})
name := llvm.ConstExtractValue(methodInfo, []uint32{0}).Name()
definedMethods[name] = struct{}{}
}
// Check whether all interface methods are also in the list
// of defined methods calculated above.
implements := uint64(1) // i1 true
for i := 0; i < interfaceMethodSet.Type().ArrayLength(); i++ {
name := llvm.ConstExtractValue(interfaceMethodSet, []uint32{uint32(i)}).Name()
if _, ok := definedMethods[name]; !ok {
// There is a method on the interface that is not
// implemented by the type.
implements = 0 // i1 false
break
}
}
fr.locals[inst] = &LocalValue{fr.Eval, llvm.ConstInt(fr.Mod.Context().Int1Type(), implements, false)}
runtime: add runtime.nanotime This function returns the current timestamp, or 0 at compile time. runtime.nanotime is used at package initialization by the time package starting with Go 1.12.
6 years ago
case callee.Name() == "runtime.nanotime":
fr.locals[inst] = &LocalValue{fr.Eval, llvm.ConstInt(fr.Mod.Context().Int64Type(), 0, false)}
compiler: add debug info for function arguments This commit adds debug info to function arguments, so that in many cases you can see them when compiling with less optimizations enabled. Unfortunately, due to the way Go SSA works, it is hard to preserve them in many cases. Local variables are not yet saved. Also, change the language type to C, to make sure lldb shows function arguments. The previous language was Modula 3, apparently due to a off-by-one error somewhere.
6 years ago
case callee.Name() == "llvm.dbg.value":
// do nothing
compiler,runtime: implement a portable conservative GC
6 years ago
case callee.Name() == "runtime.trackPointer":
// do nothing
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
case strings.HasPrefix(callee.Name(), "runtime.print") || callee.Name() == "runtime._panic":
interp: report &#39;unreachable&#39; instruction as an error This instruction should never be hit in real programs, but the interpreter may hit it after a call to panic(). This would always be a runtime error.
6 years ago
// This are all print instructions, which necessarily have side
// effects but no results.
// TODO: print an error when executing runtime._panic (with the
// exact error message it would print at runtime).
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
var params []llvm.Value
for i := 0; i < inst.OperandsCount()-1; i++ {
operand := fr.getLocal(inst.Operand(i)).Value()
fr.markDirty(operand)
params = append(params, operand)
}
// TODO: accurate debug info, including call chain
fr.builder.CreateCall(callee, params, inst.Name())
case !callee.IsAFunction().IsNil() && callee.IsDeclaration():
// external functions
var params []llvm.Value
for i := 0; i < inst.OperandsCount()-1; i++ {
operand := fr.getLocal(inst.Operand(i)).Value()
fr.markDirty(operand)
params = append(params, operand)
}
// TODO: accurate debug info, including call chain
result := fr.builder.CreateCall(callee, params, inst.Name())
if inst.Type().TypeKind() != llvm.VoidTypeKind {
fr.markDirty(result)
fr.locals[inst] = &LocalValue{fr.Eval, result}
}
case !callee.IsAFunction().IsNil():
// regular function
var params []Value
interp: fix several bugs related to constant vs dirty values * Loading from a dirty global must be done at runtime (!). For some reason this wasn&#39;t already the case. * Global variables somehow had IsConstant() the wrong way round, returning the inverse from what they should. * Do binary and logical operations at runtime if necessary, relying on const propagation in the IR builder. * Don&#39;t try to interpret functions that take a dirty parameter. Call them at runtime.
6 years ago
dirtyParams := false
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
for i := 0; i < inst.OperandsCount()-1; i++ {
interp: fix several bugs related to constant vs dirty values * Loading from a dirty global must be done at runtime (!). For some reason this wasn&#39;t already the case. * Global variables somehow had IsConstant() the wrong way round, returning the inverse from what they should. * Do binary and logical operations at runtime if necessary, relying on const propagation in the IR builder. * Don&#39;t try to interpret functions that take a dirty parameter. Call them at runtime.
6 years ago
local := fr.getLocal(inst.Operand(i))
if !local.IsConstant() {
dirtyParams = true
}
params = append(params, local)
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
}
var ret Value
scanResult := fr.Eval.hasSideEffects(callee)
interp: fix several bugs related to constant vs dirty values * Loading from a dirty global must be done at runtime (!). For some reason this wasn&#39;t already the case. * Global variables somehow had IsConstant() the wrong way round, returning the inverse from what they should. * Do binary and logical operations at runtime if necessary, relying on const propagation in the IR builder. * Don&#39;t try to interpret functions that take a dirty parameter. Call them at runtime.
6 years ago
if scanResult.severity == sideEffectLimited || dirtyParams && scanResult.severity != sideEffectAll {
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
// Side effect is bounded. This means the operation invokes
// side effects (like calling an external function) but it
// is known at compile time which side effects it invokes.
// This means the function can be called at runtime and the
// affected globals can be marked dirty at compile time.
llvmParams := make([]llvm.Value, len(params))
for i, param := range params {
llvmParams[i] = param.Value()
}
result := fr.builder.CreateCall(callee, llvmParams, inst.Name())
ret = &LocalValue{fr.Eval, result}
// mark all mentioned globals as dirty
for global := range scanResult.mentionsGlobals {
fr.markDirty(global)
}
} else {
// Side effect is one of:
// * None: no side effects, can be fully interpreted at
// compile time.
// * Unbounded: cannot call at runtime so we'll try to
// interpret anyway and hope for the best.
ret, err = fr.function(callee, params, fr.pkgName, indent+" ")
if err != nil {
return nil, nil, err
}
}
if inst.Type().TypeKind() != llvm.VoidTypeKind {
fr.locals[inst] = ret
}
default:
// function pointers, etc.
return nil, nil, &Unsupported{inst}
}
case !inst.IsAExtractValueInst().IsNil():
agg := fr.getLocal(inst.Operand(0)).(*LocalValue) // must be constant
indices := inst.Indices()
if agg.Underlying.IsConstant() {
newValue := llvm.ConstExtractValue(agg.Underlying, indices)
fr.locals[inst] = fr.getValue(newValue)
} else {
if len(indices) != 1 {
return nil, nil, errors.New("cannot handle extractvalue with not exactly 1 index")
}
fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateExtractValue(agg.Underlying, int(indices[0]), inst.Name())}
}
case !inst.IsAInsertValueInst().IsNil():
agg := fr.getLocal(inst.Operand(0)).(*LocalValue) // must be constant
val := fr.getLocal(inst.Operand(1))
indices := inst.Indices()
if agg.IsConstant() && val.IsConstant() {
newValue := llvm.ConstInsertValue(agg.Underlying, val.Value(), indices)
fr.locals[inst] = &LocalValue{fr.Eval, newValue}
} else {
if len(indices) != 1 {
return nil, nil, errors.New("cannot handle insertvalue with not exactly 1 index")
}
fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateInsertValue(agg.Underlying, val.Value(), int(indices[0]), inst.Name())}
}
case !inst.IsAReturnInst().IsNil() && inst.OperandsCount() == 0:
return nil, nil, nil // ret void
case !inst.IsAReturnInst().IsNil() && inst.OperandsCount() == 1:
return fr.getLocal(inst.Operand(0)), nil, nil
case !inst.IsABranchInst().IsNil() && inst.OperandsCount() == 3:
// conditional branch (if/then/else)
cond := fr.getLocal(inst.Operand(0)).Value()
if cond.Type() != fr.Mod.Context().Int1Type() {
panic("expected an i1 in a branch instruction")
}
thenBB := inst.Operand(1)
elseBB := inst.Operand(2)
interp: make errors during branches more reliable Previously, there was a suble error in that .IsConstant() is not always allowed to be called, resulting in a i1 that was not 0 or 1. Fix this by checking for the constants directly and adding some more diagnostics to catch more cases.
6 years ago
if !cond.IsAInstruction().IsNil() {
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
return nil, nil, errors.New("interp: branch on a non-constant")
interp: make errors during branches more reliable Previously, there was a suble error in that .IsConstant() is not always allowed to be called, resulting in a i1 that was not 0 or 1. Fix this by checking for the constants directly and adding some more diagnostics to catch more cases.
6 years ago
}
if !cond.IsAConstantExpr().IsNil() {
// This may happen when the instruction builder could not
// const-fold some instructions.
return nil, nil, errors.New("interp: branch on a non-const-propagated constant expression")
}
switch cond {
case llvm.ConstInt(fr.Mod.Context().Int1Type(), 0, false): // false
return nil, []llvm.Value{thenBB}, nil // then
case llvm.ConstInt(fr.Mod.Context().Int1Type(), 1, false): // true
return nil, []llvm.Value{elseBB}, nil // else
default:
panic("branch was not true or false")
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
}
case !inst.IsABranchInst().IsNil() && inst.OperandsCount() == 1:
// unconditional branch (goto)
return nil, []llvm.Value{inst.Operand(0)}, nil
case !inst.IsAUnreachableInst().IsNil():
interp: report &#39;unreachable&#39; instruction as an error This instruction should never be hit in real programs, but the interpreter may hit it after a call to panic(). This would always be a runtime error.
6 years ago
// Unreachable was reached (e.g. after a call to panic()).
// Report this as an error, as it is not supposed to happen.
return nil, nil, ErrUnreachable
interp: add new compile-time package initialization interpreter This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
6 years ago
default:
return nil, nil, &Unsupported{inst}
}
}
panic("interp: reached end of basic block without terminator")
}
// Get the Value for an operand, which is a constant value of some sort.
func (fr *frame) getLocal(v llvm.Value) Value {
if ret, ok := fr.locals[v]; ok {
return ret
} else if value := fr.getValue(v); value != nil {
return value
} else {
panic("cannot find value")
}
}