223 lines
6.9 KiB
Go
223 lines
6.9 KiB
Go
package generator
|
|
|
|
import "fmt"
|
|
import "git.tebibyte.media/sashakoshka/fspl/llvm"
|
|
import "git.tebibyte.media/sashakoshka/fspl/entity"
|
|
|
|
func (this *generator) valueToLocation (value llvm.Value) llvm.Value {
|
|
pointer := this.blockManager.newAllocaFront(value.Type())
|
|
this.blockManager.NewStore(value, pointer)
|
|
return pointer
|
|
}
|
|
|
|
func (this *generator) locationToValue (pointer llvm.Value, ty entity.Type) (llvm.Value, error) {
|
|
irType, err := this.generateType(ty)
|
|
if err != nil { return nil, err }
|
|
return this.blockManager.NewLoad(irType, pointer), nil
|
|
}
|
|
|
|
// generateExpression generates an expression and either returns a register
|
|
// representing the result, or a register containing the location of the result,
|
|
// whichever will generate the least IR. In the latter case, the boolean
|
|
// "location" will be true.
|
|
func (this *generator) generateExpression (expression entity.Expression) (register llvm.Value, location bool, err error) {
|
|
// TODO: some of these could stand to know that they have a choice in
|
|
// the matter.
|
|
|
|
switch expression := expression.(type) {
|
|
// these give us an address
|
|
case *entity.Dereference,
|
|
*entity.MemberAccess,
|
|
*entity.Slice,
|
|
*entity.Subscript,
|
|
*entity.LiteralArray,
|
|
*entity.LiteralString,
|
|
*entity.LiteralStruct,
|
|
*entity.Variable,
|
|
*entity.Declaration:
|
|
|
|
pointer, err := this.generateExpressionLoc(expression)
|
|
return pointer, true, err
|
|
|
|
// these give us a value
|
|
case *entity.Call,
|
|
*entity.MethodCall,
|
|
*entity.Reference,
|
|
*entity.Length,
|
|
*entity.ValueCast,
|
|
*entity.BitCast,
|
|
*entity.Operation,
|
|
*entity.LiteralInt,
|
|
*entity.LiteralFloat,
|
|
*entity.LiteralBoolean,
|
|
*entity.LiteralNil:
|
|
|
|
value, err := this.generateExpressionVal(expression)
|
|
return value, true, err
|
|
|
|
// these are capable of giving us both
|
|
case *entity.Block:
|
|
return this.generateBlock(expression)
|
|
|
|
default:
|
|
panic(fmt.Sprintf (
|
|
"BUG: generator doesnt know about expression %v, ty: %T",
|
|
expression, expression))
|
|
}
|
|
}
|
|
|
|
// generateExpressionVal generates an expression and returns a register
|
|
// representing the result.
|
|
func (this *generator) generateExpressionVal (expression entity.Expression) (llvm.Value, error) {
|
|
// we get an address from these, so we need to load the value
|
|
switch expression := expression.(type) {
|
|
case *entity.Dereference,
|
|
*entity.MemberAccess,
|
|
*entity.Slice,
|
|
*entity.Subscript,
|
|
*entity.LiteralArray,
|
|
*entity.LiteralString,
|
|
*entity.LiteralStruct:
|
|
|
|
pointer, err := this.generateExpressionLoc(expression)
|
|
if err != nil { return nil, err }
|
|
return this.locationToValue(pointer, expression.Type())
|
|
|
|
// we get a value from these, so we can return them as-is
|
|
case *entity.Variable:
|
|
return this.generateVariableVal(expression)
|
|
case *entity.Declaration:
|
|
return this.generateDeclarationVal(expression)
|
|
case *entity.Call:
|
|
return this.generateCallVal(expression)
|
|
case *entity.MethodCall:
|
|
return this.generateMethodCallVal(expression)
|
|
case *entity.Reference:
|
|
return this.generateReferenceVal(expression)
|
|
case *entity.Length:
|
|
return this.generateLengthVal(expression)
|
|
case *entity.ValueCast:
|
|
return this.generateValueCastVal(expression)
|
|
case *entity.BitCast:
|
|
return this.generateBitCastVal(expression)
|
|
case *entity.Operation:
|
|
return this.generateOperationVal(expression)
|
|
case *entity.Block:
|
|
return this.generateBlockVal(expression)
|
|
case *entity.IfElse:
|
|
return this.generateIfElseVal(expression, false)
|
|
case *entity.Loop:
|
|
return this.generateLoopVal(expression, false)
|
|
|
|
case *entity.LiteralInt:
|
|
return this.generateLiteralInt(expression)
|
|
case *entity.LiteralFloat:
|
|
return this.generateLiteralFloat(expression)
|
|
case *entity.LiteralBoolean:
|
|
return this.generateLiteralBoolean(expression)
|
|
case *entity.LiteralNil:
|
|
return this.generateLiteralNil(expression)
|
|
default:
|
|
panic(fmt.Sprintf (
|
|
"BUG: generator doesnt know about value expression %v, ty: %T",
|
|
expression, expression))
|
|
}
|
|
}
|
|
|
|
// generateExpressionLoc generates an expression and returns a register
|
|
// representing the address of the result. This function avoids adding alloca
|
|
// instructions whenever possible, trying to refer to the original data.
|
|
func (this *generator) generateExpressionLoc (expression entity.Expression) (llvm.Value, error) {
|
|
switch expression := expression.(type) {
|
|
|
|
// we get a value from these, so we need to store the value and then
|
|
// return an address to that
|
|
case *entity.Call,
|
|
*entity.MethodCall,
|
|
*entity.Reference,
|
|
*entity.Length,
|
|
*entity.ValueCast,
|
|
*entity.BitCast,
|
|
*entity.Operation,
|
|
*entity.LiteralInt,
|
|
*entity.LiteralFloat,
|
|
*entity.LiteralBoolean,
|
|
*entity.LiteralNil,
|
|
*entity.IfElse,
|
|
*entity.Loop:
|
|
|
|
value, err := this.generateExpressionVal(expression)
|
|
if err != nil { return nil, err }
|
|
return this.valueToLocation(value), nil
|
|
|
|
// we get an address from these, so we can return them as-is
|
|
case *entity.Variable:
|
|
return this.generateVariableLoc(expression)
|
|
case *entity.Declaration:
|
|
return this.generateDeclarationLoc(expression)
|
|
case *entity.Slice:
|
|
return this.generateSliceLoc(expression)
|
|
case *entity.Subscript:
|
|
return this.generateSubscriptLoc(expression)
|
|
case *entity.Dereference:
|
|
return this.generateDereferenceLoc(expression)
|
|
case *entity.MemberAccess:
|
|
return this.generateMemberAccessLoc(expression)
|
|
case *entity.Block:
|
|
return this.generateBlockLoc(expression)
|
|
case *entity.LiteralArray:
|
|
return this.generateLiteralArrayLoc(expression)
|
|
case *entity.LiteralString:
|
|
return this.generateLiteralStringLoc(expression)
|
|
case *entity.LiteralStruct:
|
|
return this.generateLiteralStructLoc(expression)
|
|
default:
|
|
panic(fmt.Sprintf (
|
|
"BUG: generator doesnt know about location expression %v, ty: %T",
|
|
expression, expression))
|
|
}
|
|
}
|
|
|
|
func (this *generator) generateStatement (statement entity.Statement) (register llvm.Value, location bool, err error) {
|
|
switch statement := statement.(type) {
|
|
case *entity.Assignment:
|
|
_, err := this.generateAssignment(statement)
|
|
return nil, false, err
|
|
case *entity.Break:
|
|
_, err := this.generateBreak(statement)
|
|
return nil, false, err
|
|
case *entity.Return:
|
|
_, err := this.generateReturn(statement)
|
|
return nil, false, err
|
|
|
|
case entity.Expression:
|
|
return this.generateExpression(statement)
|
|
default:
|
|
panic(fmt.Sprintf (
|
|
"BUG: generator doesnt know about statement %v, ty: %T",
|
|
statement, statement))
|
|
}
|
|
}
|
|
|
|
func (this *generator) generateStatementVal (statement entity.Statement) (llvm.Value, error) {
|
|
switch statement := statement.(type) {
|
|
case entity.Expression:
|
|
return this.generateExpressionVal(statement)
|
|
default:
|
|
panic(fmt.Sprintf (
|
|
"BUG: generator doesnt know about value statement %v, ty: %T",
|
|
statement, statement))
|
|
}
|
|
}
|
|
|
|
func (this *generator) generateStatementLoc (statement entity.Statement) (llvm.Value, error) {
|
|
switch statement := statement.(type) {
|
|
case entity.Expression:
|
|
return this.generateExpressionLoc(statement)
|
|
default:
|
|
panic(fmt.Sprintf (
|
|
"BUG: generator doesnt know about location statement %v, ty: %T",
|
|
statement, statement))
|
|
}
|
|
}
|