b5e29bf0c1
This is the first commit in a series to refactor the compiler. The
intention is to make sure every function to be compiled eventually has
its own IR builder. This will make it much easier to do other
refactorings in the future:
* Most code won't depend (directly) on the central Compiler object,
perhaps making it possible to eliminate it in the future. Right now
it's embedded in the `builder` struct but individual fields from the
`Compiler` can easily be moved into the `builder` object.
* Some functions are not directly exposed in Go SSA, they are wrapper
functions for something. At the moment they are included in the list
of functions to be compiled with the reachability analysis
(SimpleDCE) in the ir package, but eventually this reachability
analys will be removed. At that point, it would be very convenient
to be able to simply build a function with a new IR builder.
The `compilerContext` struct makes sure that it is not possible for
`builder` methods to accidentally use global state such as the global IR
builder. It is a transitional mechanism and may be removed when
finished.
64 строки
1,6 КиБ
Go
64 строки
1,6 КиБ
Go
package compiler
|
|
|
|
// This file contains some utility functions related to error handling.
|
|
|
|
import (
|
|
"go/scanner"
|
|
"go/token"
|
|
"go/types"
|
|
"path/filepath"
|
|
|
|
"tinygo.org/x/go-llvm"
|
|
)
|
|
|
|
// makeError makes it easy to create an error from a token.Pos with a message.
|
|
func (c *compilerContext) makeError(pos token.Pos, msg string) types.Error {
|
|
return types.Error{
|
|
Fset: c.ir.Program.Fset,
|
|
Pos: pos,
|
|
Msg: msg,
|
|
}
|
|
}
|
|
|
|
func (c *Compiler) addError(pos token.Pos, msg string) {
|
|
c.diagnostics = append(c.diagnostics, c.makeError(pos, msg))
|
|
}
|
|
|
|
// errorAt returns an error value at the location of the instruction.
|
|
// The location information may not be complete as it depends on debug
|
|
// information in the IR.
|
|
func errorAt(inst llvm.Value, msg string) scanner.Error {
|
|
return scanner.Error{
|
|
Pos: getPosition(inst),
|
|
Msg: msg,
|
|
}
|
|
}
|
|
|
|
// getPosition returns the position information for the given value, as far as
|
|
// it is available.
|
|
func getPosition(val llvm.Value) token.Position {
|
|
if !val.IsAInstruction().IsNil() {
|
|
loc := val.InstructionDebugLoc()
|
|
if loc.IsNil() {
|
|
return token.Position{}
|
|
}
|
|
file := loc.LocationScope().ScopeFile()
|
|
return token.Position{
|
|
Filename: filepath.Join(file.FileDirectory(), file.FileFilename()),
|
|
Line: int(loc.LocationLine()),
|
|
Column: int(loc.LocationColumn()),
|
|
}
|
|
} else if !val.IsAFunction().IsNil() {
|
|
loc := val.Subprogram()
|
|
if loc.IsNil() {
|
|
return token.Position{}
|
|
}
|
|
file := loc.ScopeFile()
|
|
return token.Position{
|
|
Filename: filepath.Join(file.FileDirectory(), file.FileFilename()),
|
|
Line: int(loc.SubprogramLine()),
|
|
}
|
|
} else {
|
|
return token.Position{}
|
|
}
|
|
}
|