461 lines
12 KiB
Go
461 lines
12 KiB
Go
package ssa
|
|
|
|
import (
|
|
"debug/dwarf"
|
|
"fmt"
|
|
"go/token"
|
|
"go/types"
|
|
"path/filepath"
|
|
|
|
"github.com/goplus/llvm"
|
|
)
|
|
|
|
type aDIBuilder struct {
|
|
di *llvm.DIBuilder
|
|
prog Program
|
|
diTypes map[Type]DIType
|
|
}
|
|
|
|
type diBuilder = *aDIBuilder
|
|
|
|
func newDIBuilder(prog Program, m llvm.Module) diBuilder {
|
|
ctx := m.Context()
|
|
m.AddNamedMetadataOperand("llvm.module.flags",
|
|
ctx.MDNode([]llvm.Metadata{
|
|
llvm.ConstInt(ctx.Int32Type(), 2, false).ConstantAsMetadata(), // Warning on mismatch
|
|
ctx.MDString("Debug Info Version"),
|
|
llvm.ConstInt(ctx.Int32Type(), 3, false).ConstantAsMetadata(),
|
|
}),
|
|
)
|
|
m.AddNamedMetadataOperand("llvm.module.flags",
|
|
ctx.MDNode([]llvm.Metadata{
|
|
llvm.ConstInt(ctx.Int32Type(), 7, false).ConstantAsMetadata(), // Max on mismatch
|
|
ctx.MDString("Dwarf Version"),
|
|
llvm.ConstInt(ctx.Int32Type(), 5, false).ConstantAsMetadata(),
|
|
}),
|
|
)
|
|
return &aDIBuilder{
|
|
di: llvm.NewDIBuilder(m),
|
|
prog: prog,
|
|
diTypes: make(map[*aType]DIType),
|
|
}
|
|
}
|
|
|
|
func (b diBuilder) Finalize() {
|
|
b.di.Finalize()
|
|
b.di.Destroy()
|
|
b.di = nil
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
type aCompilationUnit struct {
|
|
ll llvm.Metadata
|
|
}
|
|
|
|
type CompilationUnit = *aCompilationUnit
|
|
|
|
func (b diBuilder) createCompileUnit(filename, dir string) CompilationUnit {
|
|
return &aCompilationUnit{ll: b.di.CreateCompileUnit(llvm.DICompileUnit{
|
|
Language: llvm.DW_LANG_Go - 1, // strange, but it works
|
|
File: filename,
|
|
Dir: dir,
|
|
Producer: "LLGo",
|
|
Optimized: true,
|
|
RuntimeVersion: 1,
|
|
})}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
type aDIScopeMeta struct {
|
|
ll llvm.Metadata
|
|
}
|
|
|
|
type DIScopeMeta = *aDIScopeMeta
|
|
|
|
type DIScope interface {
|
|
scopeMeta(b diBuilder, pos token.Position) DIScopeMeta
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
type aDIFile struct {
|
|
ll llvm.Metadata
|
|
}
|
|
|
|
type DIFile = *aDIFile
|
|
|
|
func (b diBuilder) createFile(filename string) DIFile {
|
|
dir, file := filepath.Split(filename)
|
|
return &aDIFile{ll: b.di.CreateFile(file, dir)}
|
|
}
|
|
|
|
func (f DIFile) scopeMeta(b diBuilder, cu CompilationUnit, pos token.Position) DIScopeMeta {
|
|
return &aDIScopeMeta{b.file(pos.Filename).ll}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
type aDILexicalBlock struct {
|
|
ll llvm.Metadata
|
|
}
|
|
|
|
type DILexicalBlock = *aDILexicalBlock
|
|
|
|
func (b diBuilder) createLexicalBlock(scope DIScope, pos token.Position) DILexicalBlock {
|
|
block := llvm.DILexicalBlock{
|
|
File: b.file(pos.Filename).ll,
|
|
Line: pos.Line,
|
|
Column: pos.Column,
|
|
}
|
|
return &aDILexicalBlock{ll: b.di.CreateLexicalBlock(scope.scopeMeta(b, pos).ll, block)}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
type aDIType struct {
|
|
ll llvm.Metadata
|
|
}
|
|
|
|
type DIType = *aDIType
|
|
|
|
func (b diBuilder) createType(ty Type, pos token.Position) DIType {
|
|
var typ llvm.Metadata
|
|
switch t := ty.RawType().(type) {
|
|
case *types.Basic:
|
|
if t.Kind() == types.UnsafePointer {
|
|
typ = b.di.CreatePointerType(llvm.DIPointerType{
|
|
Name: "unsafe.Pointer",
|
|
SizeInBits: b.prog.SizeOf(b.prog.rawType(t)) * 8,
|
|
AlignInBits: uint32(b.prog.sizes.Alignof(t) * 8),
|
|
AddressSpace: 0,
|
|
})
|
|
return &aDIType{typ}
|
|
}
|
|
|
|
var encoding llvm.DwarfTypeEncoding
|
|
if t.Info()&types.IsBoolean != 0 {
|
|
encoding = llvm.DW_ATE_boolean
|
|
} else if t.Info()&types.IsUnsigned != 0 {
|
|
encoding = llvm.DW_ATE_unsigned
|
|
} else if t.Info()&types.IsInteger != 0 {
|
|
encoding = llvm.DW_ATE_signed
|
|
} else if t.Info()&types.IsFloat != 0 {
|
|
encoding = llvm.DW_ATE_float
|
|
} else if t.Info()&types.IsComplex != 0 {
|
|
encoding = llvm.DW_ATE_complex_float
|
|
} else if t.Info()&types.IsString != 0 {
|
|
typ = b.di.CreateBasicType(llvm.DIBasicType{
|
|
Name: "string",
|
|
SizeInBits: b.prog.SizeOf(b.prog.rawType(t)) * 8,
|
|
Encoding: llvm.DW_ATE_unsigned_char,
|
|
})
|
|
return &aDIType{typ}
|
|
} else {
|
|
encoding = llvm.DW_ATE_unsigned
|
|
panic("todo: basic type")
|
|
}
|
|
|
|
typ = b.di.CreateBasicType(llvm.DIBasicType{
|
|
Name: t.Name(),
|
|
SizeInBits: b.prog.SizeOf(b.prog.rawType(t)) * 8,
|
|
Encoding: encoding,
|
|
})
|
|
case *types.Pointer:
|
|
return b.createPointerType(b.prog.rawType(t.Elem()), pos)
|
|
case *types.Named:
|
|
return b.diType(b.prog.rawType(t.Underlying()), pos)
|
|
case *types.Interface:
|
|
return b.createBasicType(ty)
|
|
case *types.Slice:
|
|
return b.createBasicType(ty)
|
|
case *types.Struct:
|
|
return b.createStructType(ty, pos)
|
|
case *types.Signature:
|
|
return b.createFuncPtrType(b.prog.rawType(t), pos)
|
|
case *types.Tuple:
|
|
return b.createBasicType(ty)
|
|
case *types.Array:
|
|
return b.createBasicType(ty)
|
|
case *types.Chan:
|
|
return b.createBasicType(ty)
|
|
case *types.Map:
|
|
return b.createBasicType(ty)
|
|
default:
|
|
panic(fmt.Errorf("can't create debug info of type: %v, %T", ty.RawType(), ty.RawType()))
|
|
}
|
|
return &aDIType{typ}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
type aDIFunction struct {
|
|
ll llvm.Metadata
|
|
}
|
|
|
|
type DIFunction = *aDIFunction
|
|
|
|
func (b diBuilder) createFunction(scope DIScope, pos token.Position, name, linkageName string, ty DIType, isLocalToUnit, isDefinition, isOptimized bool) DIFunction {
|
|
return &aDIFunction{ll: scope.scopeMeta(b, pos).ll}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
type aDIGlobalVariableExpression struct {
|
|
ll llvm.Metadata
|
|
}
|
|
|
|
type DIGlobalVariableExpression = *aDIGlobalVariableExpression
|
|
|
|
func (b diBuilder) createGlobalVariableExpression(scope DIScope, pos token.Position, name, linkageName string, ty DIType, isLocalToUnit bool) DIGlobalVariableExpression {
|
|
return &aDIGlobalVariableExpression{
|
|
ll: b.di.CreateGlobalVariableExpression(
|
|
scope.scopeMeta(b, pos).ll,
|
|
llvm.DIGlobalVariableExpression{
|
|
Name: name,
|
|
LinkageName: linkageName,
|
|
File: b.file(pos.Filename).ll,
|
|
Line: pos.Line,
|
|
Type: ty.ll,
|
|
LocalToUnit: isLocalToUnit,
|
|
// TODO(lijie): check the following fields
|
|
// Expr: llvm.Metadata{},
|
|
// Decl: llvm.Metadata{},
|
|
// AlignInBits: 0,
|
|
},
|
|
),
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
type aDIVar struct {
|
|
ll llvm.Metadata
|
|
}
|
|
|
|
type DIVar = *aDIVar
|
|
|
|
func (b diBuilder) createParameterVariable(scope DIScope, pos token.Position, name string, argNo int, ty DIType) DIVar {
|
|
return &aDIVar{
|
|
ll: b.di.CreateParameterVariable(
|
|
scope.scopeMeta(b, pos).ll,
|
|
llvm.DIParameterVariable{
|
|
Name: name,
|
|
File: b.file(pos.Filename).ll,
|
|
Line: pos.Line,
|
|
ArgNo: argNo,
|
|
Type: ty.ll,
|
|
AlwaysPreserve: true,
|
|
},
|
|
),
|
|
}
|
|
}
|
|
|
|
func (b diBuilder) createAutoVariable(scope DIScope, pos token.Position, name string, ty DIType) DIVar {
|
|
return &aDIVar{
|
|
ll: b.di.CreateAutoVariable(
|
|
scope.scopeMeta(b, pos).ll,
|
|
llvm.DIAutoVariable{
|
|
Name: name,
|
|
File: b.file(pos.Filename).ll,
|
|
Line: pos.Line,
|
|
Type: ty.ll,
|
|
AlwaysPreserve: true,
|
|
},
|
|
),
|
|
}
|
|
}
|
|
|
|
func (b diBuilder) createBasicType(t Type) DIType {
|
|
return &aDIType{ll: b.di.CreateBasicType(llvm.DIBasicType{
|
|
Name: t.RawType().String(),
|
|
SizeInBits: b.prog.SizeOf(t) * 8,
|
|
Encoding: llvm.DW_ATE_unsigned,
|
|
})}
|
|
}
|
|
|
|
func (b diBuilder) createPointerType(ty Type, pos token.Position) DIType {
|
|
return &aDIType{ll: b.di.CreatePointerType(llvm.DIPointerType{
|
|
Pointee: b.diType(ty, pos).ll,
|
|
SizeInBits: b.prog.SizeOf(ty) * 8,
|
|
AlignInBits: uint32(b.prog.sizes.Alignof(ty.RawType())) * 8,
|
|
AddressSpace: 0,
|
|
})}
|
|
}
|
|
|
|
func (b diBuilder) createStructType(ty Type, pos token.Position) (ret DIType) {
|
|
scope := b.file(pos.Filename)
|
|
ret = &aDIType{b.di.CreateReplaceableCompositeType(
|
|
scope.ll,
|
|
llvm.DIReplaceableCompositeType{
|
|
Tag: dwarf.TagStructType,
|
|
Name: ty.RawType().String(),
|
|
},
|
|
)}
|
|
b.diTypes[ty] = ret
|
|
|
|
// Create struct type
|
|
structType := ty.RawType().(*types.Struct)
|
|
fields := make([]llvm.Metadata, structType.NumFields())
|
|
|
|
for i := 0; i < structType.NumFields(); i++ {
|
|
field := structType.Field(i)
|
|
fields[i] = b.di.CreateMemberType(
|
|
scope.ll,
|
|
llvm.DIMemberType{
|
|
Name: field.Name(),
|
|
File: b.file(pos.Filename).ll,
|
|
Line: pos.Line,
|
|
SizeInBits: b.prog.SizeOf(b.prog.rawType(field.Type())) * 8,
|
|
AlignInBits: 8,
|
|
OffsetInBits: b.prog.OffsetOf(ty, i) * 8,
|
|
Type: b.diType(b.prog.rawType(field.Type()), pos).ll,
|
|
},
|
|
)
|
|
}
|
|
st := b.di.CreateStructType(
|
|
scope.ll,
|
|
llvm.DIStructType{
|
|
Name: ty.RawType().String(),
|
|
File: b.file(pos.Filename).ll,
|
|
Line: pos.Line,
|
|
SizeInBits: b.prog.SizeOf(ty) * 8,
|
|
AlignInBits: uint32(b.prog.sizes.Alignof(structType) * 8),
|
|
Elements: fields,
|
|
},
|
|
)
|
|
ret.ll.ReplaceAllUsesWith(st)
|
|
ret.ll = st
|
|
return
|
|
}
|
|
|
|
func (b diBuilder) createFuncPtrType(ty Type, pos token.Position) DIType {
|
|
sig := ty.RawType().(*types.Signature)
|
|
retTy := b.diType(b.prog.rawType(sig.Results()), pos)
|
|
paramTys := make([]DIType, sig.Params().Len())
|
|
for i := 0; i < sig.Params().Len(); i++ {
|
|
paramTys[i] = b.diType(b.prog.rawType(sig.Params().At(i).Type()), pos)
|
|
}
|
|
rt := b.createSubroutineType(b.file(pos.Filename), retTy, paramTys)
|
|
return &aDIType{ll: b.di.CreatePointerType(llvm.DIPointerType{
|
|
Pointee: rt.ll,
|
|
SizeInBits: b.prog.SizeOf(ty) * 8,
|
|
AlignInBits: 8,
|
|
AddressSpace: 0,
|
|
})}
|
|
}
|
|
|
|
func (b diBuilder) createSubroutineType(file DIFile, retTy DIType, paramTys []DIType) DIType {
|
|
params := make([]llvm.Metadata, len(paramTys)+1)
|
|
params[0] = retTy.ll
|
|
for i, ty := range paramTys {
|
|
params[i+1] = ty.ll
|
|
}
|
|
return &aDIType{ll: b.di.CreateSubroutineType(llvm.DISubroutineType{
|
|
File: file.ll,
|
|
Parameters: params,
|
|
Flags: 0,
|
|
})}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
func (b diBuilder) dbgDeclare(v Expr, dv DIVar, scope DIScope, pos token.Position, blk BasicBlock) {
|
|
loc := llvm.DebugLoc{
|
|
Line: uint(pos.Line),
|
|
Col: uint(pos.Column),
|
|
Scope: scope.scopeMeta(b, pos).ll,
|
|
}
|
|
b.di.InsertDeclareAtEnd(
|
|
v.impl,
|
|
dv.ll,
|
|
b.di.CreateExpression(nil),
|
|
loc,
|
|
blk.last,
|
|
)
|
|
}
|
|
|
|
func (b diBuilder) dbgValue(v Expr, dv DIVar, scope DIScope, pos token.Position, blk BasicBlock) {
|
|
loc := llvm.DebugLoc{
|
|
Line: uint(pos.Line),
|
|
Col: uint(pos.Column),
|
|
Scope: scope.scopeMeta(b, pos).ll,
|
|
}
|
|
b.di.InsertValueAtEnd(
|
|
v.impl,
|
|
dv.ll,
|
|
b.di.CreateExpression(nil),
|
|
loc,
|
|
blk.last,
|
|
)
|
|
}
|
|
|
|
func (b diBuilder) diType(t Type, pos token.Position) DIType {
|
|
if ty, ok := b.diTypes[t]; ok {
|
|
return ty
|
|
}
|
|
ty := b.createType(t, pos)
|
|
b.diTypes[t] = ty
|
|
return ty
|
|
}
|
|
|
|
func (b diBuilder) varParam(f Function, pos token.Position, varName string, vt DIType, argNo int) DIVar {
|
|
return b.createParameterVariable(
|
|
f,
|
|
pos,
|
|
varName,
|
|
argNo,
|
|
vt,
|
|
)
|
|
}
|
|
|
|
func (b diBuilder) varAuto(f Function, pos token.Position, varName string, vt DIType) DIVar {
|
|
return b.createAutoVariable(
|
|
f,
|
|
pos,
|
|
varName,
|
|
vt,
|
|
)
|
|
}
|
|
|
|
func (b diBuilder) file(filename string) DIFile {
|
|
return b.createFile(filename)
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
func (b Builder) DIDeclare(v Expr, dv DIVar, scope DIScope, pos token.Position, blk BasicBlock) {
|
|
b.Pkg.diBuilder().dbgDeclare(v, dv, scope, pos, blk)
|
|
}
|
|
|
|
func (b Builder) DIValue(v Expr, dv DIVar, scope DIScope, pos token.Position, blk BasicBlock) {
|
|
b.Pkg.diBuilder().dbgValue(v, dv, scope, pos, blk)
|
|
}
|
|
|
|
func (b Builder) DIVarParam(f Function, pos token.Position, varName string, vt Type, argNo int) DIVar {
|
|
t := b.Pkg.diBuilder().diType(vt, pos)
|
|
return b.Pkg.diBuilder().varParam(f, pos, varName, t, argNo)
|
|
}
|
|
|
|
func (b Builder) DIVarAuto(f Function, pos token.Position, varName string, vt Type) DIVar {
|
|
t := b.Pkg.diBuilder().diType(vt, pos)
|
|
return b.Pkg.diBuilder().varAuto(f, pos, varName, t)
|
|
}
|
|
|
|
func (b Builder) DISetCurrentDebugLocation(f Function, pos token.Position) {
|
|
b.impl.SetCurrentDebugLocation(
|
|
uint(pos.Line),
|
|
uint(pos.Column),
|
|
f.scopeMeta(b.Pkg.diBuilder(), pos).ll,
|
|
f.impl.InstructionDebugLoc(),
|
|
)
|
|
}
|
|
|
|
func (b Builder) DebugFunction(f Function, pos token.Position) {
|
|
// attach debug info to function
|
|
f.scopeMeta(b.Pkg.di, pos)
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|