func (fr *frame) memsetZero(ptr llvm.Value, size llvm.Value) {
memset := fr.runtime.memset
ptr = fr.builder.CreateBitCast(ptr, llvm.PointerType(llvm.Int8Type(), 0), "")
fill := llvm.ConstNull(llvm.Int8Type())
size = fr.createZExtOrTrunc(size, fr.target.IntPtrType(), "")
align := llvm.ConstInt(llvm.Int32Type(), 1, false)
isvolatile := llvm.ConstNull(llvm.Int1Type())
fr.builder.CreateCall(memset, []llvm.Value{ptr, fill, size, align, isvolatile}, "")
}
func (fr *frame) registerGcRoots() {
if len(fr.gcRoots) != 0 {
rootty := fr.gcRoots[0].Type()
roots := append(fr.gcRoots, llvm.ConstNull(rootty))
rootsarr := llvm.ConstArray(rootty, roots)
rootsstruct := llvm.ConstStruct([]llvm.Value{llvm.ConstNull(llvm.PointerType(llvm.Int8Type(), 0)), rootsarr}, false)
rootsglobal := llvm.AddGlobal(fr.module.Module, rootsstruct.Type(), "")
rootsglobal.SetInitializer(rootsstruct)
rootsglobal.SetLinkage(llvm.InternalLinkage)
fr.runtime.registerGcRoots.callOnly(fr, llvm.ConstBitCast(rootsglobal, llvm.PointerType(llvm.Int8Type(), 0)))
}
}
func (gi *globalInit) build(typ llvm.Type) llvm.Value {
if gi.val.C != nil {
return gi.val
}
if len(gi.elems) == 0 {
return llvm.ConstNull(typ)
}
switch typ.TypeKind() {
case llvm.StructTypeKind:
eltypes := typ.StructElementTypes()
elems := make([]llvm.Value, len(eltypes))
for i, eltyp := range eltypes {
elems[i] = gi.elems[i].build(eltyp)
}
return llvm.ConstStruct(elems, false)
case llvm.ArrayTypeKind:
eltyp := typ.ElementType()
elems := make([]llvm.Value, len(gi.elems))
for i := range gi.elems {
elems[i] = gi.elems[i].build(eltyp)
}
return llvm.ConstArray(eltyp, elems)
default:
panic("unexpected type")
}
}
func (fr *frame) compareStrings(lhs, rhs *govalue, op token.Token) *govalue {
if op == token.EQL {
if lhs.value.IsNull() {
return fr.compareStringEmpty(rhs.value)
}
if rhs.value.IsNull() {
return fr.compareStringEmpty(lhs.value)
}
}
result := fr.runtime.strcmp.call(fr, lhs.value, rhs.value)[0]
zero := llvm.ConstNull(fr.types.inttype)
var pred llvm.IntPredicate
switch op {
case token.EQL:
pred = llvm.IntEQ
case token.LSS:
pred = llvm.IntSLT
case token.GTR:
pred = llvm.IntSGT
case token.LEQ:
pred = llvm.IntSLE
case token.GEQ:
pred = llvm.IntSGE
case token.NEQ:
panic("NEQ is handled in govalue.BinaryOp")
default:
panic("unreachable")
}
result = fr.builder.CreateICmp(pred, result, zero, "")
result = fr.builder.CreateZExt(result, llvm.Int8Type(), "")
return newValue(result, types.Typ[types.Bool])
}
// emitInitPrologue emits the init-specific function prologue (guard check and
// initialization of dependent packages under the llgo native ABI), and returns
// the basic block into which the GC registration call should be emitted.
func (fr *frame) emitInitPrologue() llvm.BasicBlock {
if fr.GccgoABI {
return fr.builder.GetInsertBlock()
}
initGuard := llvm.AddGlobal(fr.module.Module, llvm.Int1Type(), "init$guard")
initGuard.SetLinkage(llvm.InternalLinkage)
initGuard.SetInitializer(llvm.ConstNull(llvm.Int1Type()))
returnBlock := llvm.AddBasicBlock(fr.function, "")
initBlock := llvm.AddBasicBlock(fr.function, "")
initGuardVal := fr.builder.CreateLoad(initGuard, "")
fr.builder.CreateCondBr(initGuardVal, returnBlock, initBlock)
fr.builder.SetInsertPointAtEnd(returnBlock)
fr.builder.CreateRetVoid()
fr.builder.SetInsertPointAtEnd(initBlock)
fr.builder.CreateStore(llvm.ConstInt(llvm.Int1Type(), 1, false), initGuard)
int8ptr := llvm.PointerType(fr.types.ctx.Int8Type(), 0)
ftyp := llvm.FunctionType(llvm.VoidType(), []llvm.Type{int8ptr}, false)
for _, pkg := range fr.pkg.Object.Imports() {
initname := ManglePackagePath(pkg.Path()) + "..import"
initfn := fr.module.Module.NamedFunction(initname)
if initfn.IsNil() {
initfn = llvm.AddFunction(fr.module.Module, initname, ftyp)
}
args := []llvm.Value{llvm.Undef(int8ptr)}
fr.builder.CreateCall(initfn, args, "")
}
return initBlock
}
func (fr *frame) callRecover(isDeferredRecover bool) *govalue {
startbb := fr.builder.GetInsertBlock()
recoverbb := llvm.AddBasicBlock(fr.function, "")
contbb := llvm.AddBasicBlock(fr.function, "")
canRecover := fr.builder.CreateTrunc(fr.canRecover, llvm.Int1Type(), "")
fr.builder.CreateCondBr(canRecover, recoverbb, contbb)
fr.builder.SetInsertPointAtEnd(recoverbb)
var recovered llvm.Value
if isDeferredRecover {
recovered = fr.runtime.deferredRecover.call(fr)[0]
} else {
recovered = fr.runtime.recover.call(fr)[0]
}
recoverbb = fr.builder.GetInsertBlock()
fr.builder.CreateBr(contbb)
fr.builder.SetInsertPointAtEnd(contbb)
eface := types.NewInterface(nil, nil)
llv := fr.builder.CreatePHI(fr.types.ToLLVM(eface), "")
llv.AddIncoming(
[]llvm.Value{llvm.ConstNull(llv.Type()), recovered},
[]llvm.BasicBlock{startbb, recoverbb},
)
return newValue(llv, eface)
}
func directDecode(ctx llvm.Context, allocaBuilder llvm.Builder, builder llvm.Builder, valType llvm.Type, args []llvm.Value) llvm.Value {
var alloca llvm.Value
switch len(args) {
case 0:
return llvm.ConstNull(ctx.StructType(nil, false))
case 1:
if args[0].Type().C == valType.C {
return args[0]
}
alloca = allocaBuilder.CreateAlloca(valType, "")
bitcast := builder.CreateBitCast(alloca, llvm.PointerType(args[0].Type(), 0), "")
builder.CreateStore(args[0], bitcast)
case 2:
alloca = allocaBuilder.CreateAlloca(valType, "")
var argTypes []llvm.Type
for _, a := range args {
argTypes = append(argTypes, a.Type())
}
encodeType := ctx.StructType(argTypes, false)
bitcast := builder.CreateBitCast(alloca, llvm.PointerType(encodeType, 0), "")
builder.CreateStore(args[0], builder.CreateStructGEP(bitcast, 0, ""))
builder.CreateStore(args[1], builder.CreateStructGEP(bitcast, 1, ""))
default:
panic("unexpected argTypes size")
}
return builder.CreateLoad(alloca, "")
}
func (fr *frame) chanSelect(sel *ssa.Select) (index, recvOk *govalue, recvElems []*govalue) {
n := uint64(len(sel.States))
if !sel.Blocking {
// non-blocking means there's a default case
n++
}
size := llvm.ConstInt(llvm.Int32Type(), n, false)
selectp := fr.runtime.newSelect.call(fr, size)[0]
// Allocate stack for the values to send and receive.
ptrs := make([]llvm.Value, len(sel.States))
for i, state := range sel.States {
chantyp := state.Chan.Type().Underlying().(*types.Chan)
elemtyp := fr.types.ToLLVM(chantyp.Elem())
if state.Dir == types.SendOnly {
ptrs[i] = fr.allocaBuilder.CreateAlloca(elemtyp, "")
fr.builder.CreateStore(fr.llvmvalue(state.Send), ptrs[i])
} else {
// Only allocate stack space if the received value is used.
used := chanSelectStateUsed(sel, len(recvElems))
if used {
ptrs[i] = fr.allocaBuilder.CreateAlloca(elemtyp, "")
} else {
ptrs[i] = llvm.ConstNull(llvm.PointerType(llvm.Int8Type(), 0))
}
recvElems = append(recvElems, newValue(ptrs[i], chantyp.Elem()))
}
}
// Create select{send,recv2} calls.
var receivedp llvm.Value
if len(recvElems) > 0 {
receivedp = fr.allocaBuilder.CreateAlloca(fr.types.ToLLVM(types.Typ[types.Bool]), "")
}
if !sel.Blocking {
// If the default case is chosen, the index must be -1.
fr.runtime.selectdefault.call(fr, selectp, llvm.ConstAllOnes(llvm.Int32Type()))
}
for i, state := range sel.States {
ch := fr.llvmvalue(state.Chan)
index := llvm.ConstInt(llvm.Int32Type(), uint64(i), false)
if state.Dir == types.SendOnly {
fr.runtime.selectsend.call(fr, selectp, ch, ptrs[i], index)
} else {
fr.runtime.selectrecv2.call(fr, selectp, ch, ptrs[i], receivedp, index)
}
}
// Fire off the select.
index = newValue(fr.runtime.selectgo.call(fr, selectp)[0], types.Typ[types.Int])
if len(recvElems) > 0 {
recvOk = newValue(fr.builder.CreateLoad(receivedp, ""), types.Typ[types.Bool])
for _, recvElem := range recvElems {
recvElem.value = fr.builder.CreateLoad(recvElem.value, "")
}
}
return index, recvOk, recvElems
}
func (fr *frame) memcpy(dest llvm.Value, src llvm.Value, size llvm.Value) {
memcpy := fr.runtime.memcpy
dest = fr.builder.CreateBitCast(dest, llvm.PointerType(llvm.Int8Type(), 0), "")
src = fr.builder.CreateBitCast(src, llvm.PointerType(llvm.Int8Type(), 0), "")
size = fr.createZExtOrTrunc(size, fr.target.IntPtrType(), "")
align := llvm.ConstInt(llvm.Int32Type(), 1, false)
isvolatile := llvm.ConstNull(llvm.Int1Type())
fr.builder.CreateCall(memcpy, []llvm.Value{dest, src, size, align, isvolatile}, "")
}
func (fr *frame) createLandingPad(cleanup bool) llvm.Value {
lp := fr.builder.CreateLandingPad(fr.runtime.gccgoExceptionType, fr.runtime.gccgoPersonality, 0, "")
if cleanup {
lp.SetCleanup(true)
} else {
lp.AddClause(llvm.ConstNull(llvm.PointerType(llvm.Int8Type(), 0)))
}
return lp
}
// If cond is true, reads the value from the given interface type, otherwise
// returns a nil value.
func (fr *frame) getInterfaceValueOrNull(cond llvm.Value, v *govalue, ty types.Type) *govalue {
val := fr.builder.CreateExtractValue(v.value, 1, "")
if _, ok := ty.Underlying().(*types.Pointer); ok {
val = fr.builder.CreateSelect(cond, val, llvm.ConstNull(val.Type()), "")
} else {
val = fr.loadOrNull(cond, val, ty).value
}
return newValue(val, ty)
}
func (v *Codegen) genSizeofExpr(n *parser.SizeofExpr) llvm.Value {
if n.Expr != nil {
gep := v.builder.CreateGEP(llvm.ConstNull(llvm.PointerType(v.typeToLLVMType(n.Expr.GetType()), 0)), []llvm.Value{llvm.ConstInt(llvm.Int32Type(), 1, false)}, "")
return v.builder.CreatePtrToInt(gep, v.typeToLLVMType(n.GetType()), "sizeof")
} else {
// we have a type
panic("can't do this yet")
}
}
// mapIterInit creates a map iterator
func (fr *frame) mapIterInit(m *govalue) []*govalue {
// We represent an iterator as a tuple (map, *bool). The second element
// controls whether the code we generate for "next" (below) calls the
// runtime function for the first or the next element. We let the
// optimizer reorganize this into something more sensible.
isinit := fr.allocaBuilder.CreateAlloca(llvm.Int1Type(), "")
fr.builder.CreateStore(llvm.ConstNull(llvm.Int1Type()), isinit)
return []*govalue{m, newValue(isinit, types.NewPointer(types.Typ[types.Bool]))}
}
func (n *ForExpr) Gen(cg *CG) llvm.Value {
startVal := n.Start.Gen(cg)
if startVal.IsNil() {
return errv("Code generation failed for start expression")
}
fun := cg.GetInsertBlock().Parent()
alloca := createEntryBlockAlloca(fun, n.Var)
cg.CreateStore(startVal, alloca)
loopBB := llvm.AddBasicBlock(fun, "loop")
cg.CreateBr(loopBB)
cg.SetInsertPointAtEnd(loopBB)
oldVal := cg.NamedValues[n.Var]
cg.NamedValues[n.Var] = alloca
if n.Body.Gen(cg).IsNil() {
return llvm.Value{}
}
var stepVal llvm.Value
if n.Step != nil {
stepVal = n.Step.Gen(cg)
if stepVal.IsNil() {
return llvm.ConstNull(llvm.DoubleType())
}
} else {
stepVal = llvm.ConstFloat(llvm.DoubleType(), 1)
}
endVal := n.End.Gen(cg)
if endVal.IsNil() {
return llvm.Value{}
}
curVar := cg.CreateLoad(alloca, n.Var)
nextVar := cg.CreateFAdd(curVar, stepVal, "nextvar")
cg.CreateStore(nextVar, alloca)
endVal = cg.CreateFCmp(llvm.FloatONE, endVal, llvm.ConstFloat(llvm.DoubleType(), 0), "loopcond")
afterBB := cg.AddBasicBlock(fun, "afterloop")
cg.CreateCondBr(endVal, loopBB, afterBB)
cg.SetInsertPointAtEnd(afterBB)
if !oldVal.IsNil() {
cg.NamedValues[n.Var] = oldVal
} else {
delete(cg.NamedValues, n.Var)
}
return llvm.ConstFloat(llvm.DoubleType(), 0)
}
// makeMap implements make(maptype[, initial space])
func (fr *frame) makeMap(typ types.Type, cap_ *govalue) *govalue {
// TODO(pcc): call __go_new_map_big here if needed
dyntyp := fr.types.getMapDescriptorPointer(typ)
dyntyp = fr.builder.CreateBitCast(dyntyp, llvm.PointerType(llvm.Int8Type(), 0), "")
var cap llvm.Value
if cap_ != nil {
cap = fr.convert(cap_, types.Typ[types.Uintptr]).value
} else {
cap = llvm.ConstNull(fr.types.inttype)
}
m := fr.runtime.newMap.call(fr, dyntyp, cap)
return newValue(m[0], typ)
}
func (fr *frame) loadOrNull(cond, ptr llvm.Value, ty types.Type) *govalue {
startbb := fr.builder.GetInsertBlock()
loadbb := llvm.AddBasicBlock(fr.function, "")
contbb := llvm.AddBasicBlock(fr.function, "")
fr.builder.CreateCondBr(cond, loadbb, contbb)
fr.builder.SetInsertPointAtEnd(loadbb)
llty := fr.types.ToLLVM(ty)
typedptr := fr.builder.CreateBitCast(ptr, llvm.PointerType(llty, 0), "")
loadedval := fr.builder.CreateLoad(typedptr, "")
fr.builder.CreateBr(contbb)
fr.builder.SetInsertPointAtEnd(contbb)
llv := fr.builder.CreatePHI(llty, "")
llv.AddIncoming(
[]llvm.Value{llvm.ConstNull(llty), loadedval},
[]llvm.BasicBlock{startbb, loadbb},
)
return newValue(llv, ty)
}
func (fr *frame) shift(lhs *govalue, rhs *govalue, op token.Token) *govalue {
rhs = fr.convert(rhs, lhs.Type())
lhsval := lhs.value
bits := rhs.value
unsigned := isUnsigned(lhs.Type())
// Shifting >= width of lhs yields undefined behaviour, so we must select.
max := llvm.ConstInt(bits.Type(), uint64(lhsval.Type().IntTypeWidth()-1), false)
var result llvm.Value
lessEqualWidth := fr.builder.CreateICmp(llvm.IntULE, bits, max, "")
if !unsigned && op == token.SHR {
bits := fr.builder.CreateSelect(lessEqualWidth, bits, max, "")
result = fr.builder.CreateAShr(lhsval, bits, "")
} else {
if op == token.SHL {
result = fr.builder.CreateShl(lhsval, bits, "")
} else {
result = fr.builder.CreateLShr(lhsval, bits, "")
}
zero := llvm.ConstNull(lhsval.Type())
result = fr.builder.CreateSelect(lessEqualWidth, result, zero, "")
}
return newValue(result, lhs.typ)
}
func (fr *frame) setupUnwindBlock(rec *ssa.BasicBlock, results *types.Tuple) {
recoverbb := llvm.AddBasicBlock(fr.function, "")
if rec != nil {
fr.translateBlock(rec, recoverbb)
} else if results.Len() == 0 || results.At(0).Anonymous() {
// TODO(pcc): Remove this code after https://codereview.appspot.com/87210044/ lands
fr.builder.SetInsertPointAtEnd(recoverbb)
values := make([]llvm.Value, results.Len())
for i := range values {
values[i] = llvm.ConstNull(fr.llvmtypes.ToLLVM(results.At(i).Type()))
}
fr.retInf.encode(llvm.GlobalContext(), fr.allocaBuilder, fr.builder, values)
} else {
fr.builder.SetInsertPointAtEnd(recoverbb)
fr.builder.CreateUnreachable()
}
checkunwindbb := llvm.AddBasicBlock(fr.function, "")
fr.builder.SetInsertPointAtEnd(checkunwindbb)
exc := fr.createLandingPad(true)
fr.runDefers()
frame := fr.builder.CreateLoad(fr.frameptr, "")
shouldresume := fr.builder.CreateIsNull(frame, "")
resumebb := llvm.AddBasicBlock(fr.function, "")
fr.builder.CreateCondBr(shouldresume, resumebb, recoverbb)
fr.builder.SetInsertPointAtEnd(resumebb)
fr.builder.CreateResume(exc)
fr.builder.SetInsertPointAtEnd(fr.unwindBlock)
fr.createLandingPad(false)
fr.runtime.checkDefer.invoke(fr, checkunwindbb, fr.frameptr)
fr.runDefers()
fr.builder.CreateBr(recoverbb)
}
func boolLLVMValue(v bool) (lv llvm.Value) {
if v {
return llvm.ConstInt(llvm.Int8Type(), 1, false)
}
return llvm.ConstNull(llvm.Int8Type())
}
// newValueFromConst converts a constant value to an LLVM value.
func (fr *frame) newValueFromConst(v exact.Value, typ types.Type) *govalue {
switch {
case v == nil:
llvmtyp := fr.types.ToLLVM(typ)
return newValue(llvm.ConstNull(llvmtyp), typ)
case isString(typ):
if isUntyped(typ) {
typ = types.Typ[types.String]
}
llvmtyp := fr.types.ToLLVM(typ)
strval := exact.StringVal(v)
strlen := len(strval)
i8ptr := llvm.PointerType(llvm.Int8Type(), 0)
var ptr llvm.Value
if strlen > 0 {
init := llvm.ConstString(strval, false)
ptr = llvm.AddGlobal(fr.module.Module, init.Type(), "")
ptr.SetInitializer(init)
ptr.SetLinkage(llvm.InternalLinkage)
ptr = llvm.ConstBitCast(ptr, i8ptr)
} else {
ptr = llvm.ConstNull(i8ptr)
}
len_ := llvm.ConstInt(fr.types.inttype, uint64(strlen), false)
llvmvalue := llvm.Undef(llvmtyp)
llvmvalue = llvm.ConstInsertValue(llvmvalue, ptr, []uint32{0})
llvmvalue = llvm.ConstInsertValue(llvmvalue, len_, []uint32{1})
return newValue(llvmvalue, typ)
case isInteger(typ):
if isUntyped(typ) {
typ = types.Typ[types.Int]
}
llvmtyp := fr.types.ToLLVM(typ)
var llvmvalue llvm.Value
if isUnsigned(typ) {
v, _ := exact.Uint64Val(v)
llvmvalue = llvm.ConstInt(llvmtyp, v, false)
} else {
v, _ := exact.Int64Val(v)
llvmvalue = llvm.ConstInt(llvmtyp, uint64(v), true)
}
return newValue(llvmvalue, typ)
case isBoolean(typ):
if isUntyped(typ) {
typ = types.Typ[types.Bool]
}
return newValue(boolLLVMValue(exact.BoolVal(v)), typ)
case isFloat(typ):
if isUntyped(typ) {
typ = types.Typ[types.Float64]
}
llvmtyp := fr.types.ToLLVM(typ)
floatval, _ := exact.Float64Val(v)
llvmvalue := llvm.ConstFloat(llvmtyp, floatval)
return newValue(llvmvalue, typ)
case typ == types.Typ[types.UnsafePointer]:
llvmtyp := fr.types.ToLLVM(typ)
v, _ := exact.Uint64Val(v)
llvmvalue := llvm.ConstInt(fr.types.inttype, v, false)
llvmvalue = llvm.ConstIntToPtr(llvmvalue, llvmtyp)
return newValue(llvmvalue, typ)
case isComplex(typ):
if isUntyped(typ) {
typ = types.Typ[types.Complex128]
}
llvmtyp := fr.types.ToLLVM(typ)
floattyp := llvmtyp.StructElementTypes()[0]
llvmvalue := llvm.ConstNull(llvmtyp)
realv := exact.Real(v)
imagv := exact.Imag(v)
realfloatval, _ := exact.Float64Val(realv)
imagfloatval, _ := exact.Float64Val(imagv)
llvmre := llvm.ConstFloat(floattyp, realfloatval)
llvmim := llvm.ConstFloat(floattyp, imagfloatval)
llvmvalue = llvm.ConstInsertValue(llvmvalue, llvmre, []uint32{0})
llvmvalue = llvm.ConstInsertValue(llvmvalue, llvmim, []uint32{1})
return newValue(llvmvalue, typ)
}
// Special case for string -> [](byte|rune)
if u, ok := typ.Underlying().(*types.Slice); ok && isInteger(u.Elem()) {
if v.Kind() == exact.String {
strval := fr.newValueFromConst(v, types.Typ[types.String])
return fr.convert(strval, typ)
}
}
panic(fmt.Sprintf("unhandled: t=%s(%T), v=%v(%T)", typ, typ, v, v))
}
func (u *unit) defineFunction(f *ssa.Function) {
// Only define functions from this package, or synthetic
// wrappers (which do not have a package).
if f.Pkg != nil && f.Pkg != u.pkg {
return
}
llfn := u.resolveFunctionGlobal(f)
linkage := u.getFunctionLinkage(f)
isMethod := f.Signature.Recv() != nil
// Methods cannot be referred to via a descriptor.
if !isMethod {
llfd := u.resolveFunctionDescriptorGlobal(f)
llfd.SetInitializer(llvm.ConstBitCast(llfn, llvm.PointerType(llvm.Int8Type(), 0)))
llfd.SetLinkage(linkage)
}
// We only need to emit a descriptor for functions without bodies.
if len(f.Blocks) == 0 {
return
}
ssaopt.LowerAllocsToStack(f)
if u.DumpSSA {
f.WriteTo(os.Stderr)
}
fr := newFrame(u, llfn)
defer fr.dispose()
fr.addCommonFunctionAttrs(fr.function)
fr.function.SetLinkage(linkage)
fr.logf("Define function: %s", f.String())
fti := u.llvmtypes.getSignatureInfo(f.Signature)
delete(u.undefinedFuncs, f)
fr.retInf = fti.retInf
// Push the compile unit and function onto the debug context.
if u.GenerateDebug {
u.debug.PushFunction(fr.function, f.Signature, f.Pos())
defer u.debug.PopFunction()
u.debug.SetLocation(fr.builder, f.Pos())
}
// If a function calls recover, we create a separate function to
// hold the real function, and this function calls __go_can_recover
// and bridges to it.
if callsRecover(f) {
fr = fr.bridgeRecoverFunc(fr.function, fti)
}
fr.blocks = make([]llvm.BasicBlock, len(f.Blocks))
fr.lastBlocks = make([]llvm.BasicBlock, len(f.Blocks))
for i, block := range f.Blocks {
fr.blocks[i] = llvm.AddBasicBlock(fr.function, fmt.Sprintf(".%d.%s", i, block.Comment))
}
fr.builder.SetInsertPointAtEnd(fr.blocks[0])
prologueBlock := llvm.InsertBasicBlock(fr.blocks[0], "prologue")
fr.builder.SetInsertPointAtEnd(prologueBlock)
// Map parameter positions to indices. We use this
// when processing locals to map back to parameters
// when generating debug metadata.
paramPos := make(map[token.Pos]int)
for i, param := range f.Params {
paramPos[param.Pos()] = i
llparam := fti.argInfos[i].decode(llvm.GlobalContext(), fr.builder, fr.builder)
if isMethod && i == 0 {
if _, ok := param.Type().Underlying().(*types.Pointer); !ok {
llparam = fr.builder.CreateBitCast(llparam, llvm.PointerType(fr.types.ToLLVM(param.Type()), 0), "")
llparam = fr.builder.CreateLoad(llparam, "")
}
}
fr.env[param] = newValue(llparam, param.Type())
}
// Load closure, extract free vars.
if len(f.FreeVars) > 0 {
for _, fv := range f.FreeVars {
fr.env[fv] = newValue(llvm.ConstNull(u.llvmtypes.ToLLVM(fv.Type())), fv.Type())
}
elemTypes := make([]llvm.Type, len(f.FreeVars)+1)
elemTypes[0] = llvm.PointerType(llvm.Int8Type(), 0) // function pointer
for i, fv := range f.FreeVars {
elemTypes[i+1] = u.llvmtypes.ToLLVM(fv.Type())
}
structType := llvm.StructType(elemTypes, false)
closure := fr.runtime.getClosure.call(fr)[0]
closure = fr.builder.CreateBitCast(closure, llvm.PointerType(structType, 0), "")
for i, fv := range f.FreeVars {
ptr := fr.builder.CreateStructGEP(closure, i+1, "")
ptr = fr.builder.CreateLoad(ptr, "")
fr.env[fv] = newValue(ptr, fv.Type())
}
}
// Allocate stack space for locals in the prologue block.
for _, local := range f.Locals {
typ := fr.llvmtypes.ToLLVM(deref(local.Type()))
alloca := fr.builder.CreateAlloca(typ, local.Comment)
fr.memsetZero(alloca, llvm.SizeOf(typ))
bcalloca := fr.builder.CreateBitCast(alloca, llvm.PointerType(llvm.Int8Type(), 0), "")
value := newValue(bcalloca, local.Type())
fr.env[local] = value
if fr.GenerateDebug {
paramIndex, ok := paramPos[local.Pos()]
if !ok {
paramIndex = -1
}
fr.debug.Declare(fr.builder, local, alloca, paramIndex)
}
}
// If this is the "init" function, enable init-specific optimizations.
if !isMethod && f.Name() == "init" {
fr.isInit = true
}
// If the function contains any defers, we must first create
// an unwind block. We can short-circuit the check for defers with
// f.Recover != nil.
if f.Recover != nil || hasDefer(f) {
fr.unwindBlock = llvm.AddBasicBlock(fr.function, "")
fr.frameptr = fr.builder.CreateAlloca(llvm.Int8Type(), "")
}
term := fr.builder.CreateBr(fr.blocks[0])
fr.allocaBuilder.SetInsertPointBefore(term)
for _, block := range f.DomPreorder() {
fr.translateBlock(block, fr.blocks[block.Index])
}
fr.fixupPhis()
if !fr.unwindBlock.IsNil() {
fr.setupUnwindBlock(f.Recover, f.Signature.Results())
}
// The init function needs to register the GC roots first. We do this
// after generating code for it because allocations may have caused
// additional GC roots to be created.
if fr.isInit {
fr.builder.SetInsertPointBefore(prologueBlock.FirstInstruction())
fr.registerGcRoots()
}
}
func (v *Codegen) genVariableDecl(n *parser.VariableDecl, semicolon bool) llvm.Value {
var res llvm.Value
if v.inFunction {
mangledName := n.Variable.MangledName(parser.MANGLE_ARK_UNSTABLE)
funcEntry := v.currentFunction.EntryBasicBlock()
// use this builder for the variable alloca
// this means all allocas go at the start of the function
// so each variable is only allocated once
allocBuilder := llvm.NewBuilder()
if funcEntry == v.builder.GetInsertBlock() {
allocBuilder.SetInsertPointAtEnd(funcEntry)
} else {
allocBuilder.SetInsertPointBefore(funcEntry.LastInstruction())
}
alloc := allocBuilder.CreateAlloca(v.typeToLLVMType(n.Variable.Type), mangledName)
// set allocated memory to zero
fn := v.curFile.Module.NamedFunction("llvm.memset.p0i8.i32")
if fn.IsNil() {
fnType := llvm.FunctionType(llvm.VoidType(), []llvm.Type{llvm.PointerType(llvm.IntType(8), 0), llvm.IntType(8), llvm.IntType(32), llvm.IntType(32), llvm.IntType(1)}, false)
fn = llvm.AddFunction(v.curFile.Module, "llvm.memset.p0i8.i32", fnType)
}
// cast alloc to byte array
castAlloc := allocBuilder.CreateBitCast(alloc, llvm.PointerType(llvm.IntType(8), 0), "")
// get type length
gep := allocBuilder.CreateGEP(llvm.ConstNull(llvm.PointerType(v.typeToLLVMType(n.Variable.Type), 0)), []llvm.Value{llvm.ConstInt(llvm.IntType(32), 1, false)}, "")
length := allocBuilder.CreatePtrToInt(gep, llvm.IntType(32), "")
// call memset intrinsic
allocBuilder.CreateCall(fn, []llvm.Value{castAlloc, llvm.ConstInt(llvm.IntType(8), 0, false), length, llvm.ConstInt(llvm.IntType(32), 0, false), llvm.ConstInt(llvm.IntType(1), 0, false)}, "")
allocBuilder.Dispose()
v.variableLookup[n.Variable] = alloc
if n.Assignment != nil {
if value := v.genExpr(n.Assignment); !value.IsNil() {
v.builder.CreateStore(value, alloc)
}
}
} else {
mangledName := n.Variable.MangledName(parser.MANGLE_ARK_UNSTABLE)
varType := v.typeToLLVMType(n.Variable.Type)
value := llvm.AddGlobal(v.curFile.Module, varType, mangledName)
value.SetLinkage(llvm.InternalLinkage)
value.SetGlobalConstant(!n.Variable.Mutable)
if n.Assignment != nil {
value.SetInitializer(v.genExpr(n.Assignment))
}
v.variableLookup[n.Variable] = value
}
return res
}
func (fr *frame) createMalloc(size llvm.Value) llvm.Value {
return fr.runtime.NewNopointers.callOnly(fr,
llvm.ConstNull(llvm.PointerType(llvm.Int8Type(), 0)),
fr.createZExtOrTrunc(size, fr.target.IntPtrType(), ""))[0]
}
// mapIterNext advances the iterator, and returns the tuple (ok, k, v).
func (fr *frame) mapIterNext(iter []*govalue) []*govalue {
maptyp := iter[0].Type().Underlying().(*types.Map)
ktyp := maptyp.Key()
klltyp := fr.types.ToLLVM(ktyp)
vtyp := maptyp.Elem()
vlltyp := fr.types.ToLLVM(vtyp)
m, isinitptr := iter[0], iter[1]
i8ptr := llvm.PointerType(llvm.Int8Type(), 0)
mapiterbufty := llvm.ArrayType(i8ptr, 4)
mapiterbuf := fr.allocaBuilder.CreateAlloca(mapiterbufty, "")
mapiterbufelem0ptr := fr.builder.CreateStructGEP(mapiterbuf, 0, "")
keybuf := fr.allocaBuilder.CreateAlloca(klltyp, "")
keyptr := fr.builder.CreateBitCast(keybuf, i8ptr, "")
valbuf := fr.allocaBuilder.CreateAlloca(vlltyp, "")
valptr := fr.builder.CreateBitCast(valbuf, i8ptr, "")
isinit := fr.builder.CreateLoad(isinitptr.value, "")
initbb := llvm.AddBasicBlock(fr.function, "")
nextbb := llvm.AddBasicBlock(fr.function, "")
contbb := llvm.AddBasicBlock(fr.function, "")
fr.builder.CreateCondBr(isinit, nextbb, initbb)
fr.builder.SetInsertPointAtEnd(initbb)
fr.builder.CreateStore(llvm.ConstAllOnes(llvm.Int1Type()), isinitptr.value)
fr.runtime.mapiterinit.call(fr, m.value, mapiterbufelem0ptr)
fr.builder.CreateBr(contbb)
fr.builder.SetInsertPointAtEnd(nextbb)
fr.runtime.mapiternext.call(fr, mapiterbufelem0ptr)
fr.builder.CreateBr(contbb)
fr.builder.SetInsertPointAtEnd(contbb)
mapiterbufelem0 := fr.builder.CreateLoad(mapiterbufelem0ptr, "")
okbit := fr.builder.CreateIsNotNull(mapiterbufelem0, "")
ok := fr.builder.CreateZExt(okbit, llvm.Int8Type(), "")
loadbb := llvm.AddBasicBlock(fr.function, "")
cont2bb := llvm.AddBasicBlock(fr.function, "")
fr.builder.CreateCondBr(okbit, loadbb, cont2bb)
fr.builder.SetInsertPointAtEnd(loadbb)
fr.runtime.mapiter2.call(fr, mapiterbufelem0ptr, keyptr, valptr)
loadbb = fr.builder.GetInsertBlock()
loadedkey := fr.builder.CreateLoad(keybuf, "")
loadedval := fr.builder.CreateLoad(valbuf, "")
fr.builder.CreateBr(cont2bb)
fr.builder.SetInsertPointAtEnd(cont2bb)
k := fr.builder.CreatePHI(klltyp, "")
k.AddIncoming(
[]llvm.Value{llvm.ConstNull(klltyp), loadedkey},
[]llvm.BasicBlock{contbb, loadbb},
)
v := fr.builder.CreatePHI(vlltyp, "")
v.AddIncoming(
[]llvm.Value{llvm.ConstNull(vlltyp), loadedval},
[]llvm.BasicBlock{contbb, loadbb},
)
return []*govalue{newValue(ok, types.Typ[types.Bool]), newValue(k, ktyp), newValue(v, vtyp)}
}
func (fr *frame) slice(x llvm.Value, xtyp types.Type, low, high, max llvm.Value) llvm.Value {
if !low.IsNil() {
low = fr.createZExtOrTrunc(low, fr.types.inttype, "")
} else {
low = llvm.ConstNull(fr.types.inttype)
}
if !high.IsNil() {
high = fr.createZExtOrTrunc(high, fr.types.inttype, "")
}
if !max.IsNil() {
max = fr.createZExtOrTrunc(max, fr.types.inttype, "")
}
var arrayptr, arraylen, arraycap llvm.Value
var elemtyp types.Type
var errcode uint64
switch typ := xtyp.Underlying().(type) {
case *types.Pointer: // *array
errcode = gccgoRuntimeErrorARRAY_SLICE_OUT_OF_BOUNDS
arraytyp := typ.Elem().Underlying().(*types.Array)
elemtyp = arraytyp.Elem()
arrayptr = x
arrayptr = fr.builder.CreateBitCast(arrayptr, llvm.PointerType(llvm.Int8Type(), 0), "")
arraylen = llvm.ConstInt(fr.llvmtypes.inttype, uint64(arraytyp.Len()), false)
arraycap = arraylen
case *types.Slice:
errcode = gccgoRuntimeErrorSLICE_SLICE_OUT_OF_BOUNDS
elemtyp = typ.Elem()
arrayptr = fr.builder.CreateExtractValue(x, 0, "")
arraylen = fr.builder.CreateExtractValue(x, 1, "")
arraycap = fr.builder.CreateExtractValue(x, 2, "")
case *types.Basic:
if high.IsNil() {
high = llvm.ConstAllOnes(fr.types.inttype) // -1
}
result := fr.runtime.stringSlice.call(fr, x, low, high)
return result[0]
default:
panic("unimplemented")
}
if high.IsNil() {
high = arraylen
}
if max.IsNil() {
max = arraycap
}
// Bounds checking: 0 <= low <= high <= max <= cap
zero := llvm.ConstNull(fr.types.inttype)
l0 := fr.builder.CreateICmp(llvm.IntSLT, low, zero, "")
hl := fr.builder.CreateICmp(llvm.IntSLT, high, low, "")
mh := fr.builder.CreateICmp(llvm.IntSLT, max, high, "")
cm := fr.builder.CreateICmp(llvm.IntSLT, arraycap, max, "")
cond := fr.builder.CreateOr(l0, hl, "")
cond = fr.builder.CreateOr(cond, mh, "")
cond = fr.builder.CreateOr(cond, cm, "")
fr.condBrRuntimeError(cond, errcode)
slicelen := fr.builder.CreateSub(high, low, "")
slicecap := fr.builder.CreateSub(max, low, "")
elemsize := llvm.ConstInt(fr.llvmtypes.inttype, uint64(fr.llvmtypes.Sizeof(elemtyp)), false)
offset := fr.builder.CreateMul(low, elemsize, "")
sliceptr := fr.builder.CreateInBoundsGEP(arrayptr, []llvm.Value{offset}, "")
llslicetyp := fr.llvmtypes.sliceBackendType().ToLLVM(fr.llvmtypes.ctx)
sliceValue := llvm.Undef(llslicetyp)
sliceValue = fr.builder.CreateInsertValue(sliceValue, sliceptr, 0, "")
sliceValue = fr.builder.CreateInsertValue(sliceValue, slicelen, 1, "")
sliceValue = fr.builder.CreateInsertValue(sliceValue, slicecap, 2, "")
return sliceValue
}
func (fr *frame) instruction(instr ssa.Instruction) {
fr.logf("[%T] %v @ %s\n", instr, instr, fr.pkg.Prog.Fset.Position(instr.Pos()))
if fr.GenerateDebug {
fr.debug.SetLocation(fr.builder, instr.Pos())
}
switch instr := instr.(type) {
case *ssa.Alloc:
typ := deref(instr.Type())
llvmtyp := fr.llvmtypes.ToLLVM(typ)
var value llvm.Value
if !instr.Heap {
value = fr.env[instr].value
fr.memsetZero(value, llvm.SizeOf(llvmtyp))
} else if fr.isInit && fr.shouldStaticallyAllocate(instr) {
// If this is the init function and we think it may be beneficial,
// allocate memory statically in the object file rather than on the
// heap. This allows us to optimize constant stores into such
// variables as static initializations.
global := llvm.AddGlobal(fr.module.Module, llvmtyp, "")
global.SetLinkage(llvm.InternalLinkage)
fr.addGlobal(global, typ)
ptr := llvm.ConstBitCast(global, llvm.PointerType(llvm.Int8Type(), 0))
fr.env[instr] = newValue(ptr, instr.Type())
} else {
value = fr.createTypeMalloc(typ)
value.SetName(instr.Comment)
value = fr.builder.CreateBitCast(value, llvm.PointerType(llvm.Int8Type(), 0), "")
fr.env[instr] = newValue(value, instr.Type())
}
case *ssa.BinOp:
lhs, rhs := fr.value(instr.X), fr.value(instr.Y)
fr.env[instr] = fr.binaryOp(lhs, instr.Op, rhs)
case *ssa.Call:
tuple := fr.callInstruction(instr)
if len(tuple) == 1 {
fr.env[instr] = tuple[0]
} else {
fr.tuples[instr] = tuple
}
case *ssa.ChangeInterface:
x := fr.value(instr.X)
// The source type must be a non-empty interface,
// as ChangeInterface cannot fail (E2I may fail).
if instr.Type().Underlying().(*types.Interface).NumMethods() > 0 {
x = fr.changeInterface(x, instr.Type(), false)
} else {
x = fr.convertI2E(x)
}
fr.env[instr] = x
case *ssa.ChangeType:
value := fr.llvmvalue(instr.X)
if _, ok := instr.Type().Underlying().(*types.Pointer); ok {
value = fr.builder.CreateBitCast(value, fr.llvmtypes.ToLLVM(instr.Type()), "")
}
fr.env[instr] = newValue(value, instr.Type())
case *ssa.Convert:
v := fr.value(instr.X)
fr.env[instr] = fr.convert(v, instr.Type())
case *ssa.Defer:
fn, arg := fr.createThunk(instr)
fr.runtime.Defer.call(fr, fr.frameptr, fn, arg)
case *ssa.Extract:
var elem llvm.Value
if t, ok := fr.tuples[instr.Tuple]; ok {
elem = t[instr.Index].value
} else {
tuple := fr.llvmvalue(instr.Tuple)
elem = fr.builder.CreateExtractValue(tuple, instr.Index, instr.Name())
}
elemtyp := instr.Type()
fr.env[instr] = newValue(elem, elemtyp)
case *ssa.Field:
fieldtyp := instr.Type()
if p, ok := fr.ptr[instr.X]; ok {
field := fr.builder.CreateStructGEP(p, instr.Field, instr.Name())
if fr.canAvoidElementLoad(*instr.Referrers()) {
fr.ptr[instr] = field
} else {
fr.env[instr] = newValue(fr.builder.CreateLoad(field, ""), fieldtyp)
}
} else {
value := fr.llvmvalue(instr.X)
field := fr.builder.CreateExtractValue(value, instr.Field, instr.Name())
fr.env[instr] = newValue(field, fieldtyp)
}
case *ssa.FieldAddr:
ptr := fr.llvmvalue(instr.X)
fr.nilCheck(instr.X, ptr)
xtyp := instr.X.Type().Underlying().(*types.Pointer).Elem()
ptrtyp := llvm.PointerType(fr.llvmtypes.ToLLVM(xtyp), 0)
ptr = fr.builder.CreateBitCast(ptr, ptrtyp, "")
fieldptr := fr.builder.CreateStructGEP(ptr, instr.Field, instr.Name())
fieldptr = fr.builder.CreateBitCast(fieldptr, llvm.PointerType(llvm.Int8Type(), 0), "")
fieldptrtyp := instr.Type()
fr.env[instr] = newValue(fieldptr, fieldptrtyp)
case *ssa.Go:
fn, arg := fr.createThunk(instr)
fr.runtime.Go.call(fr, fn, arg)
case *ssa.If:
cond := fr.llvmvalue(instr.Cond)
block := instr.Block()
trueBlock := fr.block(block.Succs[0])
falseBlock := fr.block(block.Succs[1])
cond = fr.builder.CreateTrunc(cond, llvm.Int1Type(), "")
fr.builder.CreateCondBr(cond, trueBlock, falseBlock)
case *ssa.Index:
var arrayptr llvm.Value
if ptr, ok := fr.ptr[instr.X]; ok {
arrayptr = ptr
} else {
array := fr.llvmvalue(instr.X)
arrayptr = fr.allocaBuilder.CreateAlloca(array.Type(), "")
fr.builder.CreateStore(array, arrayptr)
}
index := fr.llvmvalue(instr.Index)
arraytyp := instr.X.Type().Underlying().(*types.Array)
arraylen := llvm.ConstInt(fr.llvmtypes.inttype, uint64(arraytyp.Len()), false)
// The index may not have been promoted to int (for example, if it
// came from a composite literal).
index = fr.createZExtOrTrunc(index, fr.types.inttype, "")
// Bounds checking: 0 <= index < len
zero := llvm.ConstNull(fr.types.inttype)
i0 := fr.builder.CreateICmp(llvm.IntSLT, index, zero, "")
li := fr.builder.CreateICmp(llvm.IntSLE, arraylen, index, "")
cond := fr.builder.CreateOr(i0, li, "")
fr.condBrRuntimeError(cond, gccgoRuntimeErrorARRAY_INDEX_OUT_OF_BOUNDS)
addr := fr.builder.CreateGEP(arrayptr, []llvm.Value{zero, index}, "")
if fr.canAvoidElementLoad(*instr.Referrers()) {
fr.ptr[instr] = addr
} else {
fr.env[instr] = newValue(fr.builder.CreateLoad(addr, ""), instr.Type())
}
case *ssa.IndexAddr:
x := fr.llvmvalue(instr.X)
index := fr.llvmvalue(instr.Index)
var arrayptr, arraylen llvm.Value
var elemtyp types.Type
var errcode uint64
switch typ := instr.X.Type().Underlying().(type) {
case *types.Slice:
elemtyp = typ.Elem()
arrayptr = fr.builder.CreateExtractValue(x, 0, "")
arraylen = fr.builder.CreateExtractValue(x, 1, "")
errcode = gccgoRuntimeErrorSLICE_INDEX_OUT_OF_BOUNDS
case *types.Pointer: // *array
arraytyp := typ.Elem().Underlying().(*types.Array)
elemtyp = arraytyp.Elem()
fr.nilCheck(instr.X, x)
arrayptr = x
arraylen = llvm.ConstInt(fr.llvmtypes.inttype, uint64(arraytyp.Len()), false)
errcode = gccgoRuntimeErrorARRAY_INDEX_OUT_OF_BOUNDS
}
// The index may not have been promoted to int (for example, if it
// came from a composite literal).
index = fr.createZExtOrTrunc(index, fr.types.inttype, "")
// Bounds checking: 0 <= index < len
zero := llvm.ConstNull(fr.types.inttype)
i0 := fr.builder.CreateICmp(llvm.IntSLT, index, zero, "")
li := fr.builder.CreateICmp(llvm.IntSLE, arraylen, index, "")
cond := fr.builder.CreateOr(i0, li, "")
fr.condBrRuntimeError(cond, errcode)
ptrtyp := llvm.PointerType(fr.llvmtypes.ToLLVM(elemtyp), 0)
arrayptr = fr.builder.CreateBitCast(arrayptr, ptrtyp, "")
addr := fr.builder.CreateGEP(arrayptr, []llvm.Value{index}, "")
addr = fr.builder.CreateBitCast(addr, llvm.PointerType(llvm.Int8Type(), 0), "")
fr.env[instr] = newValue(addr, types.NewPointer(elemtyp))
case *ssa.Jump:
succ := instr.Block().Succs[0]
fr.builder.CreateBr(fr.block(succ))
case *ssa.Lookup:
x := fr.value(instr.X)
index := fr.value(instr.Index)
if isString(x.Type().Underlying()) {
fr.env[instr] = fr.stringIndex(x, index)
} else {
v, ok := fr.mapLookup(x, index)
if instr.CommaOk {
fr.tuples[instr] = []*govalue{v, ok}
} else {
fr.env[instr] = v
}
}
case *ssa.MakeChan:
fr.env[instr] = fr.makeChan(instr.Type(), fr.value(instr.Size))
case *ssa.MakeClosure:
llfn := fr.resolveFunctionGlobal(instr.Fn.(*ssa.Function))
llfn = llvm.ConstBitCast(llfn, llvm.PointerType(llvm.Int8Type(), 0))
fn := newValue(llfn, instr.Fn.(*ssa.Function).Signature)
bindings := make([]*govalue, len(instr.Bindings))
for i, binding := range instr.Bindings {
bindings[i] = fr.value(binding)
}
fr.env[instr] = fr.makeClosure(fn, bindings)
case *ssa.MakeInterface:
// fr.ptr[instr.X] will be set if a pointer load was elided by canAvoidLoad
if ptr, ok := fr.ptr[instr.X]; ok {
fr.env[instr] = fr.makeInterfaceFromPointer(ptr, instr.X.Type(), instr.Type())
} else {
receiver := fr.llvmvalue(instr.X)
fr.env[instr] = fr.makeInterface(receiver, instr.X.Type(), instr.Type())
}
case *ssa.MakeMap:
fr.env[instr] = fr.makeMap(instr.Type(), fr.value(instr.Reserve))
case *ssa.MakeSlice:
length := fr.value(instr.Len)
capacity := fr.value(instr.Cap)
fr.env[instr] = fr.makeSlice(instr.Type(), length, capacity)
case *ssa.MapUpdate:
m := fr.value(instr.Map)
k := fr.value(instr.Key)
v := fr.value(instr.Value)
fr.mapUpdate(m, k, v)
case *ssa.Next:
iter := fr.tuples[instr.Iter]
if instr.IsString {
fr.tuples[instr] = fr.stringIterNext(iter)
} else {
fr.tuples[instr] = fr.mapIterNext(iter)
}
case *ssa.Panic:
arg := fr.value(instr.X)
fr.callPanic(arg)
case *ssa.Phi:
typ := instr.Type()
phi := fr.builder.CreatePHI(fr.llvmtypes.ToLLVM(typ), instr.Comment)
fr.env[instr] = newValue(phi, typ)
fr.phis = append(fr.phis, pendingPhi{instr, phi})
case *ssa.Range:
x := fr.value(instr.X)
switch x.Type().Underlying().(type) {
case *types.Map:
fr.tuples[instr] = fr.mapIterInit(x)
case *types.Basic: // string
fr.tuples[instr] = fr.stringIterInit(x)
default:
panic(fmt.Sprintf("unhandled range for type %T", x.Type()))
}
case *ssa.Return:
vals := make([]llvm.Value, len(instr.Results))
for i, res := range instr.Results {
vals[i] = fr.llvmvalue(res)
}
fr.retInf.encode(llvm.GlobalContext(), fr.allocaBuilder, fr.builder, vals)
case *ssa.RunDefers:
fr.runDefers()
case *ssa.Select:
states := make([]selectState, len(instr.States))
for i, state := range instr.States {
states[i] = selectState{
Dir: state.Dir,
Chan: fr.value(state.Chan),
Send: fr.value(state.Send),
}
}
index, recvOk, recvElems := fr.chanSelect(states, instr.Blocking)
tuple := append([]*govalue{index, recvOk}, recvElems...)
fr.tuples[instr] = tuple
case *ssa.Send:
fr.chanSend(fr.value(instr.Chan), fr.value(instr.X))
case *ssa.Slice:
x := fr.llvmvalue(instr.X)
low := fr.llvmvalue(instr.Low)
high := fr.llvmvalue(instr.High)
max := fr.llvmvalue(instr.Max)
slice := fr.slice(x, instr.X.Type(), low, high, max)
fr.env[instr] = newValue(slice, instr.Type())
case *ssa.Store:
addr := fr.llvmvalue(instr.Addr)
value := fr.llvmvalue(instr.Val)
addr = fr.builder.CreateBitCast(addr, llvm.PointerType(value.Type(), 0), "")
// If this is the init function, see if we can simulate the effect
// of the store in a global's initializer, in which case we can avoid
// generating code for it.
if !fr.isInit || !fr.maybeStoreInInitializer(value, addr) {
fr.nilCheck(instr.Addr, addr)
fr.builder.CreateStore(value, addr)
}
case *ssa.TypeAssert:
x := fr.value(instr.X)
if instr.CommaOk {
v, ok := fr.interfaceTypeCheck(x, instr.AssertedType)
fr.tuples[instr] = []*govalue{v, ok}
} else {
fr.env[instr] = fr.interfaceTypeAssert(x, instr.AssertedType)
}
case *ssa.UnOp:
operand := fr.value(instr.X)
switch instr.Op {
case token.ARROW:
x, ok := fr.chanRecv(operand, instr.CommaOk)
if instr.CommaOk {
fr.tuples[instr] = []*govalue{x, ok}
} else {
fr.env[instr] = x
}
case token.MUL:
fr.nilCheck(instr.X, operand.value)
if !fr.canAvoidLoad(instr, operand.value) {
// The bitcast is necessary to handle recursive pointer loads.
llptr := fr.builder.CreateBitCast(operand.value, llvm.PointerType(fr.llvmtypes.ToLLVM(instr.Type()), 0), "")
fr.env[instr] = newValue(fr.builder.CreateLoad(llptr, ""), instr.Type())
}
default:
fr.env[instr] = fr.unaryOp(operand, instr.Op)
}
default:
panic(fmt.Sprintf("unhandled: %v", instr))
}
}
func (fr *frame) stringIterInit(str *govalue) []*govalue {
indexptr := fr.allocaBuilder.CreateAlloca(fr.types.inttype, "")
fr.builder.CreateStore(llvm.ConstNull(fr.types.inttype), indexptr)
return []*govalue{str, newValue(indexptr, types.Typ[types.Int])}
}
