com.sun.squawk.compiler
Interface BaseCompiler

All Superinterfaces:

Types

All Known Subinterfaces:

Compiler, InterpCompiler

public interface BaseCompiler
extends Types

Language-independent base compiler interface to support general-purpose applications.

E_NONE

static final int E_NONE

Standard C-style calling convention and parameter passing procedures.

See Also:

Constant Field Values

E_NULL

static final int E_NULL

See Also:

Constant Field Values

E_REGISTER

static final int E_REGISTER

Squawk Interpreter procedure preamble. The address of the bytecodes to be interpreted are passed in the special JVM register. This preamble is used only for the Squawk Interpreter.

See Also:

Constant Field Values

E_ADDRESS

static final int E_ADDRESS

Compiled Squawk procedure preamble. The address of the compiled bytecodes are passed in the special JVM register. This preamble is used only for Squawk bytecode procedures that have been compiled into native code.

See Also:

Constant Field Values

C_NORMAL

static final int C_NORMAL

Normal C-style calling convention with the parameters and procedure address on the shadow stack. The parameters are passed as per the standard Application Binary Interface specification of the platform.

See Also:

Constant Field Values

C_DYNAMIC

static final int C_DYNAMIC

Normal C-style calling convention except the parameters are on the runtime stack but the procedure address is on the shadow stack.

See Also:

Constant Field Values

C_JVM

static final int C_JVM

Java-style calling convention for Squawk methods where the address of the method's bytecodes or machine code is passed to the function, and all parameters are provided on the shadow stack.

See Also:

Constant Field Values

C_JVM_DYNAMIC

static final int C_JVM_DYNAMIC

Java-style calling convention for Squawk methods with the parameters on the runtime stack but the method address on the shadow stack.

See Also:

Constant Field Values

P_LOW

static final int P_LOW

Local and parm register allocation hints.

A compliant compiler may ignore these values, but if the compiler does honor them then the following semantics is desired.

P_LOW variables may be allocated in registers or activation slots.

P_MEDIUM variables are better allocated in registers if there are free registers available, otherwise they are allocated in activation slots.

P_HIGH variables hust be allocated in registers, and a compiler that honors the hints should produce a fatal error if this is not possible.

Within each category the variables defined first have higher priority over those defined later.

See Also:

Constant Field Values

P_MEDIUM

static final int P_MEDIUM

Local and parm register allocation hints.

A compliant compiler may ignore these values, but if the compiler does honor them then the following semantics is desired.

P_LOW variables may be allocated in registers or activation slots.

P_MEDIUM variables are better allocated in registers if there are free registers available, otherwise they are allocated in activation slots.

P_HIGH variables hust be allocated in registers, and a compiler that honors the hints should produce a fatal error if this is not possible.

Within each category the variables defined first have higher priority over those defined later.

See Also:

Constant Field Values

P_HIGH

static final int P_HIGH

Local and parm register allocation hints.

A compliant compiler may ignore these values, but if the compiler does honor them then the following semantics is desired.

P_LOW variables may be allocated in registers or activation slots.

P_MEDIUM variables are better allocated in registers if there are free registers available, otherwise they are allocated in activation slots.

P_HIGH variables hust be allocated in registers, and a compiler that honors the hints should produce a fatal error if this is not possible.

Within each category the variables defined first have higher priority over those defined later.

See Also:

Constant Field Values

label

Label label()

Allocate a label.

Stack: ... -> ...

Returns:

the label

bind

Compiler bind(Label label)

Bind a label to the current location.

Stack: ... -> ...

Parameters:

label - the label to bind

Returns:

the compiler object

enter

Compiler enter(Label label,
               int preambleCode)

Emit a function prologue.

Stack: _ -> _

Parameters:

label - a label to be bound to the start of the function

preambleCode - the special preamble code for the function

Returns:

the compiler object

enter

Compiler enter(Label label)

Emit a function prologue.

Stack: _ -> _

Parameters:

label - a label to be bound to the start of the function

Returns:

the compiler object

enter

Compiler enter(int preambleCode)

Emit a function prologue.

Stack: _ -> _

Parameters:

preambleCode - the special preamble code for the function

Returns:

the compiler object

enter

Compiler enter()

Emit a function prologue.

Stack: _ -> _

Returns:

the compiler object

parm

Local parm(Type type,
           int hint)

Define a parameter variable.

Stack: _ -> _

Parameters:

type - the type of the local variable (Must be primary)

hint - the P_XXXX priority hint.

Returns:

the compiler object

parm

Local parm(Type type)

Define a parameter variable.

Stack: _ -> _

Parameters:

type - the type of the local variable (Must be primary)

Returns:

the compiler object

result

Compiler result(Type type)

Define the function result.

Stack: _ -> _

Parameters:

type - the type of the parameter (Must be primary)

Returns:

the compiler object

leave

Compiler leave(MethodMap mmap)

Emit a function epilogue.

Stack: _ -> _

Returns:

the compiler object

leave

Compiler leave()

Emit a function epilogue.

Stack: _ -> _

Returns:

the compiler object

begin

Compiler begin()

Begin a code scope.

Stack: ... -> ...

Returns:

the compiler object

local

Local local(Type type,
            int hint)

Define a local variable type.

Stack: ... -> ...

Parameters:

type - the type of the local variable (Must be primary)

hint - the P_XXXX priority hint.

Returns:

the compiler object

local

Local local(Type type)

Define a local variable type.

Stack: ... -> ...

Parameters:

type - the type of the local variable (Must be primary)

Returns:

the compiler object

end

Compiler end()

End a code scope.

Stack: ... -> ...

Returns:

the compiler object

getLocalCount

int getLocalCount()

Return the number of locals currently defined.

Returns:

the number

tosType

Type tosType()

Return the type of the instruction on the top of the stack.

Stack: ... -> ...

Returns:

the type

loadParm

Compiler loadParm()

Get the value of a parameter word.

Stack: ..., INDEX -> ..., INT

Note that this method never returns a long. The user of this interface has to deal with longs as two words.

Checks: 1- The index needs to be of type INT.

Returns:

the compiler object

storeParm

Compiler storeParm()

Set the value of a parameter word.

Stack: ..., VALUE, INDEX -> ...

Checks: 1- The index needs to be of type INT.

Returns:

the compiler object

comment

Compiler comment(String str)

Add a comment node to the IR.

Stack: ... -> ...

Parameters:

str - the comment

Returns:

the compiler object

load

Compiler load(Local local)

Get a local variable or parameter and push it onto the stack.

Stack: ... -> ..., VALUE

Parameters:

local - the local variable to load

Returns:

the compiler object

store

Compiler store(Local local)

Set a local variable or parameter to a value popped from the stack.

Stack: ..., VALUE -> ...

Checks: 1- The local and the value from the stack need to be a primary type.

Parameters:

local - the local variable to store into

Returns:

the compiler object

read

Compiler read(Type type)

Load a value from a reference. The reference is popped from the stack and the type specified is loaded from that address. Secondary types (BYTE, UBYTE, SHORT, USHORT) are all widened to INT by this operation.

Stack: ..., REF -> ..., VALUE

Checks: 1- The value on the top of the stack is of type reference (REF) or OOP. 2- The type of data to be read is either of primary or secondary type.

Parameters:

type - the type of the data to load

Returns:

the compiler object

write

Compiler write(Type type)

Store a value at a reference. The value and reference are popped from the stack and the value is written to the referenced address according to the specified type. The type parameter is used to check primary types and to narrow secondry types.

Stack: ..., VALUE, REF -> ...

Checks: 1- The address on the top of the stack should be of type reference (REF). 2- The other value on the stack has to have the same primitive type as the type of the write. All types can be used with this method (primary, secondary), except for pseudo types.

Parameters:

type - the type of the data to load

Returns:

the compiler object

literal

Compiler literal(int n)

Push an integer constant onto the stack.

Stack: ... -> ..., VALUE

Parameters:

n - the value of the constant

Returns:

the compiler object

literal

Compiler literal(long n)

Push a long constant onto the stack.

Stack: ... -> ..., VALUE

Parameters:

n - the value of the constant

Returns:

the compiler object

literal

Compiler literal(float n)

Push a float constant onto the stack.

Stack: ... -> ..., VALUE

Parameters:

n - the value of the constant

Returns:

the compiler object

literal

Compiler literal(double n)

Push a double constant onto the stack.

Stack: ... -> ..., VALUE

Parameters:

n - the value of the constant

Returns:

the compiler object

literal

Compiler literal(boolean n)

Push a boolean constant onto the stack.

Stack: ... -> ..., VALUE

Parameters:

n - the value of the constant

Returns:

the compiler object

literal

Compiler literal(Object array)

Push an address of an array onto the stack.

Stack: ... -> ..., VALUE

Parameters:

array - the array

Returns:

the compiler object

symbol

Compiler symbol(String name)

Push an address of an unresolved symbol onto the stack.

Stack: ... -> ..., VALUE

Parameters:

name - the name of the symbol

Returns:

the compiler object

literal

Compiler literal(Label label)

Push the address of a label onto the stack.

Stack: ... -> ..., VALUE

Parameters:

label - the label

Returns:

the compiler object

data

Compiler data(Label label,
              Object obj)

Define some data.

Stack: _ -> _

Parameters:

label - the label to the data

obj - the array

Returns:

the compiler object

dup

Compiler dup()

Dup the top element of the stack.

Stack: ... -> ..., VALUE

Returns:

the compiler object

dupReceiver

Compiler dupReceiver()

Dup the receiver element of the stack.

Stack: ... -> ..., VALUE

In a method call, the receiver is the object whose method is being invoked. This is the implicit first parameter of method calls. Used by all functions that have an invoke virtual.

Returns:

the compiler object

drop

Compiler drop()

Pop the top element of the compiler stack.

Stack: ..., VALUE -> ...

Returns:

the compiler object

dumpAll

Compiler dumpAll()

Pop all the element of the compiler stack.

Stack: ... -> _

Returns:

the compiler object

swap

Compiler swap()

Swap the top two elements of the stack.

Stack: ... VALUE1, VALUE2 -> ..., VALUE2, VALUE1

Returns:

the compiler object

swapAll

Compiler swapAll()

Swap the contence of the stack.

Stack: [VALUE0, ..., VALUEN] -> [VALUEN, ... , VALUE0]

Returns:

the compiler object

swapForABI

Compiler swapForABI()

Swap the contence of the stack if the target ABI push parameters right-to-left.

Stack: [VALUE0, ..., VALUEN] -> [VALUEN, ... , VALUE0] // Only on right-to-left systems

Returns:

the compiler object

push

Compiler push()

Push the data onto the runtime stack.

Stack: ..., VALUE -> ...

Returns:

the compiler object

pop

Compiler pop(Type type)

Pop the top element of the runtime stack.

Stack: ... -> ..., VALUE

Parameters:

type - the data type to pop

Returns:

the compiler object

popAll

Compiler popAll()

Pop all the elements of the runtime stack.

Stack: ... -> ...

Returns:

the compiler object

force

Compiler force(Type to)

Pop the top most element, force it to be the new type, and push the result. Force uses the same bit representation.

Stack: ... OLDVALUE -> ..., NEWVALUE

Force rules:

• the source type is a primary type
• the destination type is a primary type
• the source and destination types are of the same bit size
• the following types cannot be forced
  • ref -> uint
  • oop -> anything other than ref
  • uint -> ref, oop, float
  • float -> uint, ref, oop

The force rules are summarized as follows

 From/to   int     uint    long    ulong   float   double  ref     oop
  int      fnop    f                       f               f32     f32
  uint     f       fnop                                    f32     f32
  long                     fnop    f               f       f64     f64
  ulong                    f       fnop                    f64     f64
  float    f                               fnop
  double                   f                       fnop
  ref      f32     f32     f64     f64                     fnop    f
  oop      f32     f32     f64     f64                     f       fnop
 

where

• f stands for force allowed
• fnop stands for force allowed and do nothing
• f32 stands for force allowed on 32 bit platform
• f64 stands for force allowed on 64 bit platform

Parameters:

to - the type to force to

Returns:

the compiler object

convert

Compiler convert(Type to)

Pop the top most element, convert it to a new type, and push the result. Conversions use different bit representation, where needed.

Stack: ... OLDVALUE -> ..., NEWVALUE

Convert rules:

• the source type is a primary type
• the destination type is a primary type, except when the source type is int, in which case the destination type can be a secondary type
• the following types can be converted

    From\To 2nd     int     uint    long    ulong   float   double  ref     oop
    2nd
    int     c       cnop            c               c       c
    uint                    cnop            c
    long            c               cnop            c       c
    ulong                   c               cnop
    float           c               c               cnop    c
    double          c               c               c       cnop
    ref                                                             cnop
    oop                                                                     cnop
        

  where
  • c stands for convert allowed
  • cnop stands for convert allowed and do nothing
  • 2nd stands for all secondary types

Parameters:

to - the type to convert to

Returns:

the compiler object

add

Compiler add()

Add the top two elements on the stack. They must be of the same type, or be a pointer and an integer.

Stack: ..., VALUE1, VALUE2 -> ..., RESULT

Returns:

the compiler object

sub

Compiler sub()

Subtract the top two elements on the stack. They must be of the same type, or be a pointer and an integer.

Stack: ..., VALUE1, VALUE2 -> ..., RESULT

Returns:

the compiler object

mul

Compiler mul()

Multiply the top two elements on the stack. They must be of the same type.

Stack: ..., VALUE1, VALUE2 -> ..., RESULT

Returns:

the compiler object

div

Compiler div()

Divide the top two elements on the stack. They must be of the same type.

Stack: ..., VALUE1, VALUE2 -> ..., RESULT

Returns:

the compiler object

rem

Compiler rem()

Remainder the top two elements on the stack. They must be of the same type.

Stack: ..., VALUE1, VALUE2 -> ..., RESULT

Returns:

the compiler object

and

Compiler and()

And the top two elements on the stack. They must be of the same type.

Stack: ..., VALUE1, VALUE2 -> ..., RESULT

Returns:

the compiler object

or

Compiler or()

Or the top two elements on the stack. They must be of the same type.

Stack: ..., VALUE1, VALUE2 -> ..., RESULT

Returns:

the compiler object

xor

Compiler xor()

Xor the top two elements on the stack. They must be of the same type.

Stack: ..., VALUE1, VALUE2 -> ..., RESULT

Returns:

the compiler object

shl

Compiler shl()

Shift the second element on the stack left by the number of bits specified by the top element.

Stack: ..., VALUE1, VALUE2 -> ..., RESULT

Returns:

the compiler object

shr

Compiler shr()

Shift the second element on the stack right by the number of bits specified by the top element.

Stack: ..., VALUE1, VALUE2 -> ..., RESULT

Returns:

the compiler object

ushr

Compiler ushr()

Shift the second element on the stack right by the number of bits specified by the top element.

Stack: ..., VALUE1, VALUE2 -> ..., RESULT

Returns:

the compiler object

neg

Compiler neg()

Negate (2's complement) the top element.

Stack: ..., VALUE -> ..., RESULT

Returns:

the compiler object

com

Compiler com()

Produce the 1's complement of the top element.

Stack: ..., VALUE -> ..., RESULT

Returns:

the compiler object

eq

Compiler eq()

Test the top two elements. Push true if s[0] == s[1] else false.

Stack: ..., VALUE1, VALUE2 -> ..., RESULT

Returns:

the compiler object

ne

Compiler ne()

Test the top two elements. Push true if s[0] != s[1] else false.

Stack: ..., VALUE1, VALUE2 -> ..., RESULT

Returns:

the compiler object

le

Compiler le()

Test the top two elements. Push true if s[0] <= s[1] else false.

Stack: ..., VALUE1, VALUE2 -> ..., RESULT

Returns:

the compiler object

lt

Compiler lt()

Test the top two elements. Push true if s[0] < s[1] else false.

Stack: ..., VALUE1, VALUE2 -> ..., RESULT

Returns:

the compiler object

ge

Compiler ge()

Test the top two elements. Push true if s[0] >= s[1] else false.

Stack: ..., VALUE1, VALUE2 -> ..., RESULT

Returns:

the compiler object

gt

Compiler gt()

Test the top two elements. Push true if s[0] > s[1] else false.

Stack: ..., VALUE1, VALUE2 -> ..., RESULT

Returns:

the compiler object

cmpl

Compiler cmpl()

Test the top two floating point elements. Push true if s[0] < s[1] else false.

Stack: ..., VALUE1, VALUE2 -> ..., RESULT

Returns:

the compiler object

cmpg

Compiler cmpg()

Test the top two floating point elements. Push true if s[0] > s[1] else false.

Stack: ..., VALUE1, VALUE2 -> ..., RESULT

Returns:

the compiler object

br

Compiler br(Label label)

Unconditionally branch to the label.

Stack: ... -> ...

Checks

• For a backward branch, the stack must be empty.

Parameters:

label - the label to branch to

Returns:

the compiler object

bt

Compiler bt(Label label)

Branch to the label if the popped value is true.

Stack: ..., VALUE -> ...

Parameters:

label - the label to branch to

Returns:

the compiler object

bf

Compiler bf(Label label)

Branch to the label if the popped value is false.

Stack: ..., VALUE -> ...

Parameters:

label - the label to branch to

Returns:

the compiler object

br

Compiler br(int dst)

Unconditionally branch to the label.

Stack: _ -> ._

Parameters:

dst - the absolute destination

Returns:

the compiler object

bt

Compiler bt(int dst)

Branch to the label if the popped value is true.

Stack: VALUE -> _

Parameters:

dst - the absolute destination

Returns:

the compiler object

bf

Compiler bf(int dst)

Branch to the label if the popped value is false.

Stack: VALUE -> _

Parameters:

dst - the absolute destination

Returns:

the compiler object

jump

Compiler jump()

Jump somewhere. The top most value must be the address of the function to be called.

Stack: ADDRESS -> _

Checks

• For a backward and forward branch, the stack must be empty.
• The popped value must be an address (i.e., it's base type must be REF or OOP).

Returns:

the compiler object

call

Compiler call(int nparms,
              Type type,
              int convention)

Call a function. The top most value must be the address of the function to be called.

Stack: ..., VALUEN to VALUE1, ADDRESS -> ..., [RESULT]

Checks

• There are enough parameters on the evaluation stack.
• The address (top of stack) parameter is of type INT (for 32-bit compilations).

Parameters:

nparms - the number of parameters to pop

type - the return type to be pushed onto the stack

convention - the calling convebtion

Returns:

the compiler object

call

Compiler call(int nparms,
              Type type)

Call a function. The top most value must be the address of the function to be called.

Stack: ..., VALUEN to VALUE1, ADDRESS -> ..., [RESULT]

Parameters:

nparms - the number of parameters to pop

type - the return type to be pushed onto the stack

Returns:

the compiler object

call

Compiler call(Type type)

Call a function. The top most value must be the address of the function to be called. and all the other parameters on the stack are taken as parameters.

Stack: ..., VALUEN to VALUE1, ADDRESS -> ..., [RESULT]

Parameters:

type - the return type to be pushed onto the stack

Returns:

the compiler object

call

Compiler call(Type type,
              int convention)

Call a function. The top most value must be the address of the function to be called. and all the other parameters on the stack are taken as parameters.

Stack: ..., VALUEN to VALUE1, ADDRESS -> ..., [RESULT]

Parameters:

type - the return type to be pushed onto the stack

convention - the calling convention

Returns:

the compiler object

ret

Compiler ret(Type type)

Return from a method. The return type overwrites the return type that the method would have had otherwise.

Stack: ..., [VALUE] -> _

Checks

• If a value is to be returned, the evaluation stack has a value to return.
• If no value is to be returned, the evaluation stack is empty.

Parameters:

type - the return type

Returns:

the compiler object

ret

Compiler ret()

Return from a method.

Stack: ..., [VALUE] -> _

Returns:

the compiler object

deadCode

Compiler deadCode()

Specify an unreachable place.

Stack: _ -> _

Returns:

the compiler object

loadsMustBeAligned

boolean loadsMustBeAligned()

Boolean to say if the machine can execute unaligned loads.

Returns:

true if it is true

isBigEndian

boolean isBigEndian()

Boolean to say if the machine uses big endian ordering.

Returns:

true if it is true

tableSwitchPadding

boolean tableSwitchPadding()

Boolean to say if the tableswitch and stableswitch are to be padded in such a way that the initial int (the low parameter) is placed on a 4 byte boundary.

Returns:

true if it is true

tableSwitchEndPadding

boolean tableSwitchEndPadding()

Boolean to say if the tableswitch and stableswitch are to be padded in such a way that the initial int (the low parameter) is placed on a 4 byte boundary and any padding at the start of the bytecode sequence is complemented at the end so that the size of the sequence is always a constant.

Returns:

true if it is true

compile

Compiler compile()

Compiler the IR.

Stack: _ -> _

Returns:

the compiler object

decode

void decode(int relocation)

Dumps the assembler output of the compiler to the console.

getCodeSize

int getCodeSize()

Get the length of the compiled code.

Returns:

the length in bytes

getCode

byte[] getCode()

Get the code array buffer.

Returns:

the code array

getRelocationInfo

int[] getRelocationInfo()

Return the relocation information. This is an array of ints where each entry describes one offset into the code where relocation is required. The format of each entry is such that the top 8 bits is a code indicating the type of relocation required and the low 24 bits is the offset.

Stack: _ -> _

Returns:

the relocation information.

getFixupInfo

SymbolicFixupTable getFixupInfo()

Return the offsets to unresolved symbols.

Stack: _ -> _

Returns:

the table of offset to symbol associations