def compile(self, module: ll.Module, builder: ll.IRBuilder):
inputs = []
for i in range(self.num_inputs):
path = self.get_pin(f'in{i}')
inputs.append(module.get_global(path))
output = module.get_global(self.get_pin('out'))
output_v = ll.Constant(INT_TYPE, 0)
if self.kind == 'and':
output_v = builder.not_(output_v)
for inp in inputs:
v = builder.load(inp)
if self.kind == 'and':
output_v = builder.and_(output_v, v)
elif self.kind == 'or':
output_v = builder.or_(output_v, v)
elif self.kind == 'xor':
output_v = builder.xor(output_v, v)
if self.negated:
output_v = builder.not_(output_v)
builder.store(output_v, output)
class GenerateLLVM(object):
def __init__(self):
# Perform the basic LLVM initialization. You need the following parts:
#
# 1. A top-level Module object
# 2. A Function instance in which to insert code
# 3. A Builder instance to generate instructions
#
# Note: For project 5, we don't have any user-defined
# functions so we're just going to emit all LLVM code into a top
# level function void main() { ... }. This will get changed later.
self.module = Module('module')
# All globals variables and function definitions go here
self.globals = {}
self.blocks = {}
# Initialize the runtime library functions (see below)
self.declare_runtime_library()
def declare_runtime_library(self):
# Certain functions such as I/O and string handling are often easier
# to implement in an external C library. This method should make
# the LLVM declarations for any runtime functions to be used
# during code generation. Please note that runtime function
# functions are implemented in C in a separate file gonert.c
self.runtime = {}
# Declare printing functions
self.runtime['_print_int'] = Function(self.module,
FunctionType(
void_type, [int_type]),
name="_print_int")
self.runtime['_print_float'] = Function(self.module,
FunctionType(
void_type, [float_type]),
name="_print_float")
self.runtime['_print_byte'] = Function(self.module,
FunctionType(
void_type, [byte_type]),
name="_print_byte")
def generate_code(self, ir_function):
# Given a sequence of SSA intermediate code tuples, generate LLVM
# instructions using the current builder (self.builder). Each
# opcode tuple (opcode, args) is dispatched to a method of the
# form self.emit_opcode(args)
# print(ir_function)
self.function = Function(
self.module,
FunctionType(LLVM_TYPE_MAPPING[ir_function.return_type], [
LLVM_TYPE_MAPPING[ptype] for _, ptype in ir_function.parameters
]),
name=ir_function.name)
self.block = self.function.append_basic_block('entry')
self.builder = IRBuilder(self.block)
# Save the function as a global to be referenced later on another
# function
self.globals[ir_function.name] = self.function
# All local variables are stored here
self.locals = {}
self.vars = ChainMap(self.locals, self.globals)
# Dictionary that holds all of the temporary registers created in
# the intermediate code.
self.temps = {}
# Setup the function parameters
for n, (pname, ptype) in enumerate(ir_function.parameters):
self.vars[pname] = self.builder.alloca(LLVM_TYPE_MAPPING[ptype],
name=pname)
self.builder.store(self.function.args[n], self.vars[pname])
# Allocate the return value and return_block
if ir_function.return_type:
self.vars['return'] = self.builder.alloca(
LLVM_TYPE_MAPPING[ir_function.return_type], name='return')
self.return_block = self.function.append_basic_block('return')
for opcode, *args in ir_function.code:
if hasattr(self, 'emit_' + opcode):
getattr(self, 'emit_' + opcode)(*args)
else:
print('Warning: No emit_' + opcode + '() method')
if not self.block.is_terminated:
self.builder.branch(self.return_block)
self.builder.position_at_end(self.return_block)
self.builder.ret(self.builder.load(self.vars['return'], 'return'))
def get_block(self, block_name):
block = self.blocks.get(block_name)
if block is None:
block = self.function.append_basic_block(block_name)
self.blocks[block_name] = block
return block
# ----------------------------------------------------------------------
# Opcode implementation. You must implement the opcodes. A few
# sample opcodes have been given to get you started.
# ----------------------------------------------------------------------
# Creation of literal values. Simply define as LLVM constants.
def emit_MOV(self, value, target, val_type):
self.temps[target] = Constant(val_type, value)
emit_MOVI = partialmethod(emit_MOV, val_type=int_type)
emit_MOVF = partialmethod(emit_MOV, val_type=float_type)
emit_MOVB = partialmethod(emit_MOV, val_type=byte_type)
# Allocation of GLOBAL variables. Declare as global variables and set to
# a sensible initial value.
def emit_VAR(self, name, var_type):
var = GlobalVariable(self.module, var_type, name=name)
var.initializer = Constant(var_type, 0)
self.globals[name] = var
emit_VARI = partialmethod(emit_VAR, var_type=int_type)
emit_VARF = partialmethod(emit_VAR, var_type=float_type)
emit_VARB = partialmethod(emit_VAR, var_type=byte_type)
# Allocation of LOCAL variables. Declare as local variables and set to
# a sensible initial value.
def emit_ALLOC(self, name, var_type):
self.locals[name] = self.builder.alloca(var_type, name=name)
emit_ALLOCI = partialmethod(emit_ALLOC, var_type=int_type)
emit_ALLOCF = partialmethod(emit_ALLOC, var_type=float_type)
emit_ALLOCB = partialmethod(emit_ALLOC, var_type=byte_type)
# Load/store instructions for variables. Load needs to pull a
# value from a global variable and store in a temporary. Store
# goes in the opposite direction.
def emit_LOADI(self, name, target):
self.temps[target] = self.builder.load(self.vars[name], name=target)
emit_LOADF = emit_LOADI
emit_LOADB = emit_LOADI
def emit_STOREI(self, source, target):
self.builder.store(self.temps[source], self.vars[target])
emit_STOREF = emit_STOREI
emit_STOREB = emit_STOREI
# Binary + operator
def emit_ADDI(self, left, right, target):
self.temps[target] = self.builder.add(self.temps[left],
self.temps[right],
name=target)
def emit_ADDF(self, left, right, target):
self.temps[target] = self.builder.fadd(self.temps[left],
self.temps[right],
name=target)
# Binary - operator
def emit_SUBI(self, left, right, target):
self.temps[target] = self.builder.sub(self.temps[left],
self.temps[right],
name=target)
def emit_SUBF(self, left, right, target):
self.temps[target] = self.builder.fsub(self.temps[left],
self.temps[right],
name=target)
# Binary * operator
def emit_MULI(self, left, right, target):
self.temps[target] = self.builder.mul(self.temps[left],
self.temps[right],
name=target)
def emit_MULF(self, left, right, target):
self.temps[target] = self.builder.fmul(self.temps[left],
self.temps[right],
name=target)
# Binary / operator
def emit_DIVI(self, left, right, target):
self.temps[target] = self.builder.sdiv(self.temps[left],
self.temps[right],
name=target)
def emit_DIVF(self, left, right, target):
self.temps[target] = self.builder.fdiv(self.temps[left],
self.temps[right],
name=target)
# Print statements
def emit_PRINT(self, source, runtime_name):
self.builder.call(self.runtime[runtime_name], [self.temps[source]])
emit_PRINTI = partialmethod(emit_PRINT, runtime_name="_print_int")
emit_PRINTF = partialmethod(emit_PRINT, runtime_name="_print_float")
emit_PRINTB = partialmethod(emit_PRINT, runtime_name="_print_byte")
def emit_CMPI(self, operator, left, right, target):
tmp = self.builder.icmp_signed(operator, self.temps[left],
self.temps[right], 'tmp')
# LLVM compares produce a 1-bit integer as a result. Since our IRcode using integers
# for bools, need to sign-extend the result up to the normal int_type to continue
# with further processing (otherwise you'll get a LLVM type error).
self.temps[target] = self.builder.zext(tmp, int_type, target)
def emit_CMPF(self, operator, left, right, target):
tmp = self.builder.fcmp_ordered(operator, self.temps[left],
self.temps[right], 'tmp')
self.temps[target] = self.builder.zext(tmp, int_type, target)
emit_CMPB = emit_CMPI
# Logical ops
def emit_AND(self, left, right, target):
self.temps[target] = self.builder.and_(self.temps[left],
self.temps[right], target)
def emit_OR(self, left, right, target):
self.temps[target] = self.builder.or_(self.temps[left],
self.temps[right], target)
def emit_XOR(self, left, right, target):
self.temps[target] = self.builder.xor(self.temps[left],
self.temps[right], target)
def emit_LABEL(self, lbl_name):
self.block = self.get_block(lbl_name)
self.builder.position_at_end(self.block)
def emit_BRANCH(self, dst_label):
if not self.block.is_terminated:
self.builder.branch(self.get_block(dst_label))
def emit_CBRANCH(self, test_target, true_label, false_label):
true_block = self.get_block(true_label)
false_block = self.get_block(false_label)
testvar = self.temps[test_target]
self.builder.cbranch(self.builder.trunc(testvar, IntType(1)),
true_block, false_block)
def emit_RET(self, register):
self.builder.store(self.temps[register], self.vars['return'])
self.builder.branch(self.return_block)
def emit_CALL(self, func_name, *registers):
# print(self.globals)
args = [self.temps[r] for r in registers[:-1]]
target = registers[-1]
self.temps[target] = self.builder.call(self.globals[func_name], args)
class GenerateLLVM(object):
def __init__(self):
# Perform the basic LLVM initialization. You need the following parts:
#
# 1. A top-level Module object
# 2. A Function instance in which to insert code
# 3. A Builder instance to generate instructions
#
# Note: For project 5, we don't have any user-defined
# functions so we're just going to emit all LLVM code into a top
# level function void main() { ... }. This will get changed later.
self.module = Module('module')
self.globals = {}
# Initialize the runtime library functions (see below)
self.declare_runtime_library()
def generate_function(self, name, return_type, arg_types, arg_names,
ircode):
self.function = Function(self.module,
FunctionType(return_type, arg_types),
name=name)
self.globals[name] = self.function
self.block = self.function.append_basic_block('entry')
self.builder = IRBuilder(self.block)
self.locals = {}
self.vars = ChainMap(self.locals, self.globals)
# Have to declare local variables for holding function arguments
for n, (name, ty) in enumerate(zip(arg_names, arg_types)):
self.locals[name] = self.builder.alloca(ty, name=name)
self.builder.store(self.function.args[n], self.locals[name])
# Dictionary that holds all of the temporary registers created in
# the intermediate code.
self.temps = {}
# Make the exit block for function return
self.return_block = self.function.append_basic_block('return')
if return_type != void_type:
self.return_var = self.builder.alloca(return_type, name='return')
self.generate_code(ircode)
if not self.block.is_terminated:
self.builder.branch(self.return_block)
self.builder.position_at_end(self.return_block)
if return_type != void_type:
self.builder.ret(self.builder.load(self.return_var))
else:
self.builder.ret_void()
def declare_runtime_library(self):
# Certain functions such as I/O and string handling are often easier
# to implement in an external C library. This method should make
# the LLVM declarations for any runtime functions to be used
# during code generation. Please note that runtime function
# functions are implemented in C in a separate file gonert.c
self.runtime = {}
# Declare printing functions
self.runtime['_print_int'] = Function(self.module,
FunctionType(
void_type, [int_type]),
name="_print_int")
self.runtime['_print_float'] = Function(self.module,
FunctionType(
void_type, [float_type]),
name="_print_float")
self.runtime['_print_byte'] = Function(self.module,
FunctionType(
void_type, [byte_type]),
name="_print_byte")
def generate_code(self, ircode):
# Given a sequence of SSA intermediate code tuples, generate LLVM
# instructions using the current builder (self.builder). Each
# opcode tuple (opcode, args) is dispatched to a method of the
# form self.emit_opcode(args)
# Collect and create all basic blocks
labels = [instr[1] for instr in ircode if instr[0] == 'LABEL']
self.basicblocks = {
name: self.function.append_basic_block(name)
for name in labels
}
for opcode, *args in ircode:
if hasattr(self, 'emit_' + opcode):
getattr(self, 'emit_' + opcode)(*args)
else:
print('Warning: No emit_' + opcode + '() method')
# ----------------------------------------------------------------------
# Opcode implementation. You must implement the opcodes. A few
# sample opcodes have been given to get you started.
# ----------------------------------------------------------------------
# Creation of literal values. Simply define as LLVM constants.
def emit_MOVI(self, value, target):
self.temps[target] = Constant(int_type, value)
def emit_MOVF(self, value, target):
self.temps[target] = Constant(float_type, value)
pass # You must implement
def emit_MOVB(self, value, target):
self.temps[target] = Constant(byte_type, value)
# Allocation of variables. Declare as global variables and set to
# a sensible initial value.
def emit_VARI(self, name):
var = GlobalVariable(self.module, int_type, name=name)
var.initializer = Constant(int_type, 0)
self.globals[name] = var
def emit_VARF(self, name):
var = GlobalVariable(self.module, float_type, name=name)
var.initializer = Constant(float_type, 0.0)
self.globals[name] = var
def emit_VARB(self, name):
var = GlobalVariable(self.module, byte_type, name=name)
var.initializer = Constant(byte_type, 0)
self.globals[name] = var
def emit_ALLOCI(self, name):
self.locals[name] = self.builder.alloca(int_type, name=name)
def emit_ALLOCF(self, name):
self.locals[name] = self.builder.alloca(float_type, name=name)
def emit_ALLOCB(self, name):
self.locals[name] = self.builder.alloca(byte_type, name=name)
# Load/store instructions for variables. Load needs to pull a
# value from a global variable and store in a temporary. Store
# goes in the opposite direction.
def emit_LOADI(self, name, target):
self.temps[target] = self.builder.load(self.vars[name], target)
def emit_LOADF(self, name, target):
self.temps[target] = self.builder.load(self.vars[name], target)
def emit_LOADB(self, name, target):
self.temps[target] = self.builder.load(self.vars[name], target)
pass # You must implement
def emit_STOREI(self, source, target):
self.builder.store(self.temps[source], self.vars[target])
def emit_STOREF(self, source, target):
self.builder.store(self.temps[source], self.vars[target])
def emit_STOREB(self, source, target):
self.builder.store(self.temps[source], self.vars[target])
# Binary + operator
def emit_ADDI(self, left, right, target):
self.temps[target] = self.builder.add(self.temps[left],
self.temps[right], target)
def emit_ADDF(self, left, right, target):
self.temps[target] = self.builder.fadd(self.temps[left],
self.temps[right], target)
pass # You must implement
# Binary - operator
def emit_SUBI(self, left, right, target):
self.temps[target] = self.builder.sub(self.temps[left],
self.temps[right], target)
pass # You must implement
def emit_SUBF(self, left, right, target):
self.temps[target] = self.builder.fsub(self.temps[left],
self.temps[right], target)
pass # You must implement
# Binary * operator
def emit_MULI(self, left, right, target):
self.temps[target] = self.builder.mul(self.temps[left],
self.temps[right], target)
pass # You must implement
def emit_MULF(self, left, right, target):
self.temps[target] = self.builder.fmul(self.temps[left],
self.temps[right], target)
pass # You must implement
# Binary / operator
def emit_DIVI(self, left, right, target):
self.temps[target] = self.builder.sdiv(self.temps[left],
self.temps[right], target)
pass # You must implement
def emit_DIVF(self, left, right, target):
self.temps[target] = self.builder.fdiv(self.temps[left],
self.temps[right], target)
pass # You must implement
def emit_CMPI(self, op, left, right, target):
result = self.builder.icmp_signed(op, self.temps[left],
self.temps[right], '_temp')
self.temps[target] = self.builder.zext(result, int_type, target)
def emit_CMPF(self, op, left, right, target):
result = self.builder.fcmp_ordered(op, self.temps[left],
self.temps[right], '_temp')
self.temps[target] = self.builder.zext(result, int_type, target)
def emit_CMPB(self, op, left, right, target):
result = self.builder.icmp_signed(op, self.temps[left],
self.temps[right], '_temp')
self.temps[target] = self.builder.zext(result, int_type, target)
def emit_AND(self, left, right, target):
self.temps[target] = self.builder.and_(self.temps[left],
self.temps[right], target)
def emit_OR(self, left, right, target):
self.temps[target] = self.builder.or_(self.temps[left],
self.temps[right], target)
def emit_XOR(self, left, right, target):
self.temps[target] = self.builder.xor(self.temps[left],
self.temps[right], target)
# Print statements
def emit_PRINTI(self, source):
self.builder.call(self.runtime['_print_int'], [self.temps[source]])
def emit_PRINTF(self, source):
self.builder.call(self.runtime['_print_float'], [self.temps[source]])
pass # You must implement
def emit_PRINTB(self, source):
self.builder.call(self.runtime['_print_byte'], [self.temps[source]])
pass # You must implement
def emit_LABEL(self, name):
self.block = self.basicblocks[name]
self.builder.position_at_end(self.block)
def emit_CBRANCH(self, test, true_label, false_label):
true_block = self.basicblocks[true_label]
false_block = self.basicblocks[false_label]
self.builder.cbranch(self.builder.trunc(self.temps[test], IntType(1)),
true_block, false_block)
def emit_BRANCH(self, next_label):
target = self.basicblocks[next_label]
if not self.block.is_terminated:
self.builder.branch(target)
def emit_CALL(self, name, *extra):
*args, target = extra
args = [self.temps[a] for a in args]
func = self.vars[name]
self.temps[target] = self.builder.call(func, args)
def emit_RET(self, source):
self.builder.store(self.temps[source], self.return_var)
self.builder.branch(self.return_block)
class GenerateLLVM(object):
def __init__(self):
self.module = Module('module')
self.globals = {}
self.blocks = {}
self.declare_runtime_library()
def declare_runtime_library(self):
self.runtime = {}
self.runtime['_print_int'] = Function(self.module,
FunctionType(
void_type, [int_type]),
name="_print_int")
self.runtime['_print_float'] = Function(self.module,
FunctionType(
void_type, [float_type]),
name="_print_float")
self.runtime['_print_byte'] = Function(self.module,
FunctionType(
void_type, [byte_type]),
name="_print_byte")
def generate_code(self, ir_function):
self.function = Function(
self.module,
FunctionType(LLVM_TYPE_MAPPING[ir_function.return_type], [
LLVM_TYPE_MAPPING[ptype] for _, ptype in ir_function.parameters
]),
name=ir_function.name)
self.block = self.function.append_basic_block('entry')
self.builder = IRBuilder(self.block)
self.globals[ir_function.name] = self.function
self.locals = {}
self.vars = ChainMap(self.locals, self.globals)
self.temps = {}
for n, (pname, ptype) in enumerate(ir_function.parameters):
self.vars[pname] = self.builder.alloca(LLVM_TYPE_MAPPING[ptype],
name=pname)
self.builder.store(self.function.args[n], self.vars[pname])
if ir_function.return_type:
self.vars['return'] = self.builder.alloca(
LLVM_TYPE_MAPPING[ir_function.return_type], name='return')
self.return_block = self.function.append_basic_block('return')
for opcode, *args in ir_function.code:
if hasattr(self, 'emit_' + opcode):
getattr(self, 'emit_' + opcode)(*args)
else:
print('Warning: No emit_' + opcode + '() method')
if not self.block.is_terminated:
self.builder.branch(self.return_block)
self.builder.position_at_end(self.return_block)
self.builder.ret(self.builder.load(self.vars['return'], 'return'))
def get_block(self, block_name):
block = self.blocks.get(block_name)
if block is None:
block = self.function.append_basic_block(block_name)
self.blocks[block_name] = block
return block
def emit_MOV(self, value, target, val_type):
self.temps[target] = Constant(val_type, value)
emit_MOVI = partialmethod(emit_MOV, val_type=int_type)
emit_MOVF = partialmethod(emit_MOV, val_type=float_type)
emit_MOVB = partialmethod(emit_MOV, val_type=byte_type)
def emit_VAR(self, name, var_type):
var = GlobalVariable(self.module, var_type, name=name)
var.initializer = Constant(var_type, 0)
self.globals[name] = var
emit_VARI = partialmethod(emit_VAR, var_type=int_type)
emit_VARF = partialmethod(emit_VAR, var_type=float_type)
emit_VARB = partialmethod(emit_VAR, var_type=byte_type)
def emit_ALLOC(self, name, var_type):
self.locals[name] = self.builder.alloca(var_type, name=name)
emit_ALLOCI = partialmethod(emit_ALLOC, var_type=int_type)
emit_ALLOCF = partialmethod(emit_ALLOC, var_type=float_type)
emit_ALLOCB = partialmethod(emit_ALLOC, var_type=byte_type)
def emit_LOADI(self, name, target):
self.temps[target] = self.builder.load(self.vars[name], name=target)
emit_LOADF = emit_LOADI
emit_LOADB = emit_LOADI
def emit_STOREI(self, source, target):
self.builder.store(self.temps[source], self.vars[target])
emit_STOREF = emit_STOREI
emit_STOREB = emit_STOREI
def emit_ADDI(self, left, right, target):
self.temps[target] = self.builder.add(self.temps[left],
self.temps[right],
name=target)
def emit_ADDF(self, left, right, target):
self.temps[target] = self.builder.fadd(self.temps[left],
self.temps[right],
name=target)
def emit_SUBI(self, left, right, target):
self.temps[target] = self.builder.sub(self.temps[left],
self.temps[right],
name=target)
def emit_SUBF(self, left, right, target):
self.temps[target] = self.builder.fsub(self.temps[left],
self.temps[right],
name=target)
def emit_MULI(self, left, right, target):
self.temps[target] = self.builder.mul(self.temps[left],
self.temps[right],
name=target)
def emit_MULF(self, left, right, target):
self.temps[target] = self.builder.fmul(self.temps[left],
self.temps[right],
name=target)
def emit_DIVI(self, left, right, target):
self.temps[target] = self.builder.sdiv(self.temps[left],
self.temps[right],
name=target)
def emit_DIVF(self, left, right, target):
self.temps[target] = self.builder.fdiv(self.temps[left],
self.temps[right],
name=target)
def emit_PRINT(self, source, runtime_name):
self.builder.call(self.runtime[runtime_name], [self.temps[source]])
emit_PRINTI = partialmethod(emit_PRINT, runtime_name="_print_int")
emit_PRINTF = partialmethod(emit_PRINT, runtime_name="_print_float")
emit_PRINTB = partialmethod(emit_PRINT, runtime_name="_print_byte")
def emit_CMPI(self, operator, left, right, target):
if operator == "=":
operator = "=="
tmp = self.builder.icmp_signed(operator, self.temps[left],
self.temps[right], 'tmp')
self.temps[target] = self.builder.zext(tmp, int_type, target)
def emit_CMPF(self, operator, left, right, target):
if operator == "=":
operator = "=="
tmp = self.builder.fcmp_ordered(operator, self.temps[left],
self.temps[right], 'tmp')
self.temps[target] = self.builder.zext(tmp, int_type, target)
emit_CMPB = emit_CMPI
def emit_AND(self, left, right, target):
self.temps[target] = self.builder.and_(self.temps[left],
self.temps[right], target)
def emit_OR(self, left, right, target):
self.temps[target] = self.builder.or_(self.temps[left],
self.temps[right], target)
def emit_XOR(self, left, right, target):
self.temps[target] = self.builder.xor(self.temps[left],
self.temps[right], target)
def emit_LABEL(self, lbl_name):
self.block = self.get_block(lbl_name)
self.builder.position_at_end(self.block)
def emit_BRANCH(self, dst_label):
if not self.block.is_terminated:
self.builder.branch(self.get_block(dst_label))
def emit_CBRANCH(self, test_target, true_label, false_label):
true_block = self.get_block(true_label)
false_block = self.get_block(false_label)
testvar = self.temps[test_target]
self.builder.cbranch(self.builder.trunc(testvar, IntType(1)),
true_block, false_block)
def emit_RET(self, register):
self.builder.store(self.temps[register], self.vars['return'])
self.builder.branch(self.return_block)
def emit_CALL(self, func_name, *registers):
args = [self.temps[r] for r in registers[:-1]]
target = registers[-1]
self.temps[target] = self.builder.call(self.globals[func_name], args)
def compile(self, module: ir.Module, builder: ir.IRBuilder,
symbols: SymbolTable) -> ir.Value:
bop = self.bop
exprL = self.exprL.compile(module, builder, symbols)
exprL_type = self.exprL.type_of()
exprL_int = exprL_type in IntTypes
exprR = self.exprR.compile(module, builder, symbols)
exprR_type = self.exprR.type_of()
exprR_int = exprR_type in IntTypes
if bop == '+':
if exprL_int and exprR_int:
return builder.add(exprL, exprR)
if exprL_int:
exprL = builder.sitofp(exprL, exprR_type.ir_type)
if exprR_int:
exprR = builder.sitofp(exprR, exprL_type.ir_type)
return builder.fadd(exprL, exprR)
if bop == '-':
if exprL_int and exprR_int:
return builder.sub(exprL, exprR)
if exprL_int:
exprL = builder.sitofp(exprL, exprL_type.ir_type)
if exprR_int:
exprR = builder.sitofp(exprL, exprR_type.ir_type)
return builder.fsub(exprL, exprR)
if bop == '*':
if exprL_int and exprR_int:
return builder.mul(exprL, exprR)
if exprL_int:
exprL = builder.sitofp(exprL, exprL_type.ir_type)
if exprR_int:
exprR = builder.sitofp(exprL, exprR_type.ir_type)
return builder.fmul(exprL, exprR)
if bop == '/':
if exprL_int:
exprL = builder.sitofp(exprL, exprL_type.ir_type)
if exprR_int:
exprR = builder.sitofp(exprL, exprR_type.ir_type)
return builder.fdiv(exprL, exprR)
if bop == '//':
return builder.sdiv(exprL, exprR)
if bop == '%':
if exprL_int and exprR_int:
return builder.srem(exprL, exprR)
if exprL_int:
exprL = builder.sitofp(exprL, exprL_type.ir_type)
if exprR_int:
exprR = builder.sitofp(exprL, exprR_type.ir_type)
return builder.frem(exprL, exprR)
if bop in ['&', '&&']:
return builder.and_(exprL, exprR)
if bop in ['|', '||']:
return builder.or_(exprL, exprR)
if bop == '^':
return builder.xor(exprL, exprR)
if bop in ['<', '<=', '>=', '>']:
if exprL_int and exprR_int:
return builder.icmp_signed(bop, exprL, exprR)
if exprL_int:
exprL = builder.sitofp(exprL, exprL_type.ir_type)
if exprR_int:
exprR = builder.sitofp(exprL, exprR_type.ir_type)
return builder.fcmp_ordered(bop, exprL, exprR)
if bop == '==':
if exprL_int and exprR_int:
return builder.icmp_signed(bop, exprL, exprR)
if exprL_int:
exprL = builder.sitofp(exprL, exprL_type.ir_type)
if exprR_int:
exprR = builder.sitofp(exprL, exprR_type.ir_type)
return builder.fcmp_ordered(bop, exprL, exprR)
if bop == '!=':
if exprL_int and exprR_int:
return builder.icmp_signed(bop, exprL, exprR)
if exprL_int:
exprL = builder.sitofp(exprL, exprL_type.ir_type)
if exprR_int:
exprR = builder.sitofp(exprL, exprR_type.ir_type)
return builder.fcmp_unordered(bop, exprL, exprR)
# if bop == '**':
# if bop in ['**', '*', '%', '-', '<<', '>>', '>>>', '<=', '>=', '<',
# '>', '&', '^', '|', '==', '!=', '&&', '||', '=', '+=',
# '-=', '*=', '&=', '|=', '^=', '<<=', '>>=', '>>>=', '%=']:
# data = (exprL, bop, exprR)
# if minify:
# return "({}{}{})".format(*data)
# return "({} {} {})".format(*data)
# converter = {
# '<=>': '<>=',
# '===': '==',
# '!==': '!=',
# '~=': '~==',
# '//=': '/='
# }
# if bop in converter.keys():
# data = (exprL, converter[bop], exprR)
# if minify:
# return "({}{}{})".format(*data)
# return "({} {} {})".format(*data)
# if bop == '+':
# if self.exprL.type_of() == StringType:
# return "{}..{}".format(exprL, exprR)
# return "{}+{}".format(exprL, exprR)
# if bop == '/':
# return "({}/double({}))".format(exprL, exprR)
# if bop == '//':
# return "floor({}/{})".format(exprL, exprR)
# if bop == 'is':
# return "{} is '{}'".format(exprL, exprR)
# if bop == '|>':
# return "({}({}))".format(exprR, exprL)
# if bop == '**=':
# data = (exprL, exprR)
# if minify:
# return "({0}={0}**{1})".format(*data)
# return "({0} = {0} ** {1})".format(*data)
# if bop == '/=':
# data = (exprL, exprR)
# if minify:
# return "({0}={0}/double({1}))".format(*data)
# return "({0} = {0} / double({1}))".format(*data)
WappaException(
"FATAL", "Unhandled Binary Operator {}".format(bop), self.tok)
return bop
