funcode.js

//
// Parse WASM binary format for function bodies into executable javascript.
//

import Long from "long"
import stdlib from "../stdlib"
import { CompileError } from "../errors"
import {
  dump,
  stringifyJSValue,
  makeSigStr,
  inherits,
  isLittleEndian,
  isNaNPreserving32,
  isNaNPreserving64
} from "../utils"
import {
  PAGE_SIZE,
  TYPES,
  EXTERNAL_KINDS,
  EXTERNAL_KIND_NAMES,
  SECTIONS,
  TOKENS,
  OPCODES
} from "../constants"


function parseBlockType(s) {
  var v = s.read_varint7()
  if (v >= 0 || (v < TYPES.F64 && v !== TYPES.NONE)) {
    throw new CompileError("Invalid block_type: " + v)
  }
  return v
}


export default function translateFunctionCode(s, r, f) {

  var returnType = f.sig.return_types.length > 0 ? f.sig.return_types[0] : TYPES.NONE

  var funcBody = new FunctionBody(returnType)
  f.cfStack = new ControlFlowStack()
  f.cfStack.push(funcBody)

  f.getLocalTypeByIndex = function getLocalTypeByIndex(index) {
    var count = f.sig.param_types.length
    if (index < count) {
      return f.sig.param_types[index]
    }
    var next = 0
    while (next < f.locals.length) {
      count += f.locals[next].count
      if (count > index) {
        return f.locals[next].type
      }
      next++
    }
    throw new CompileError("local index too large: " + index)
  }

  DECODE: while (true) {
    var op = s.read_byte()
    switch (op) {

      case OPCODES.UNREACHABLE:
        f.cfStack.addTerminalStatement(new Unreachable())
        break

      case OPCODES.NOP:
        break

      case OPCODES.BLOCK:
        var sig = parseBlockType(s)
        f.cfStack.push(new Block(sig))
        break

      case OPCODES.LOOP:
        var sig = parseBlockType(s)
        f.cfStack.push(new Loop(sig))
        break

      case OPCODES.IF:
        var sig = parseBlockType(s)
        var cond = f.cfStack.popValue(TYPES.I32)
        f.cfStack.push(new IfElse(sig, cond))
        break

      case OPCODES.ELSE:
        f.cfStack.peek().switchToElseBranch()
        break

      case OPCODES.END:
        var cf = f.cfStack.pop()
        if (cf.index === 0) {
          break DECODE // End of the entire function body.
        }
        break

      case OPCODES.BR:
        var depth = s.read_varuint32()
        var cf = f.cfStack.getBranchTarget(depth)
        if (cf.branchResultType === TYPES.NONE) {
          f.cfStack.addTerminalStatement(new Branch(cf))
        } else {
          var result = f.cfStack.popValue(cf.branchResultType)
          f.cfStack.addTerminalStatement(new Branch(cf, result))
        }
        break

      case OPCODES.BR_IF:
        var depth = s.read_varuint32()
        var cf = f.cfStack.getBranchTarget(depth)
        var cond = f.cfStack.popValue(TYPES.I32)
        if (cf.branchResultType === TYPES.NONE) {
          f.cfStack.addStatement(new BranchIf(cond, cf))
        } else {
          // If the condition is false, we have to leave the
          // value on the stack.  Spill it to keep this simple
          // and avoid duplicating large expressions.
          f.cfStack.spillValueIfComposite()
          var result = f.cfStack.peekValue(cf.branchResultType)
          f.cfStack.addStatement(new BranchIf(cond, cf, result))
        }
        break

      case OPCODES.BR_TABLE:
        // Not-super-efficient implementation of br_table using
        // a big ol' switch statement.  I don't think there's
        // anything better we can do though...
        var count = s.read_varuint32()
        var target_cfs = []
        while (count > 0) {
          var depth = s.read_varuint32()
          target_cfs.push(f.cfStack.getBranchTarget(depth))
          count--
        }
        var depth = s.read_varuint32()
        var default_cf = f.cfStack.getBranchTarget(depth)
        target_cfs.forEach(function(cf) {
          if (cf.branchResultType !== default_cf.branchResultType) {
            throw new CompileError("br_table result type mis-match")
          }
        })
        var expr = f.cfStack.popValue(TYPES.I32)
        if (default_cf.branchResultType === TYPES.NONE) {
          f.cfStack.addTerminalStatement(new BranchTable(expr, default_cf, target_cfs))
        } else {
          var result = f.cfStack.popValue(default_cf.branchResultType)
          f.cfStack.addTerminalStatement(new BranchTable(expr, default_cf, target_cfs, result))
        }
        break

      case OPCODES.RETURN:
        var cf = f.cfStack.peekBottom()
        if (cf.branchResultType === TYPES.NONE) {
          f.cfStack.addTerminalStatement(new Branch(cf))
        } else {
          var result = f.cfStack.popValue(cf.branchResultType)
          f.cfStack.addTerminalStatement(new Branch(cf, result))
        }
        break

      case OPCODES.CALL:
        var index = s.read_varuint32()
        var callSig = r.getFunctionTypeSignatureByIndex(index)
        // The rightmost arg is the one on top of stack,
        // so we have to pop them in reverse.
        var args = new Array(callSig.param_types.length)
        for (var i = callSig.param_types.length - 1; i >= 0; i--) {
          args[i] = f.cfStack.popValue(callSig.param_types[i])
        }
        // The call might have side-effects, so spill anything
        // remaining on the stack.  XXX TODO: only spill affected values.
        f.cfStack.spillAllValues()
        f.cfStack.finalizeTrapConditions()
        if (callSig.return_types.length === 0) {
          f.cfStack.addStatement(new Drop(new Call(callSig, index, args)))
        } else {
          f.cfStack.pushValue(new Call(callSig, index, args))
          // Force immediate execution, for side-effects.
          // XXX TODO: this shouldn't be necessary; find the bug in our logic!
          f.cfStack.spillValue()
        }
        break

      case OPCODES.CALL_INDIRECT:
        var type_index = s.read_varuint32()
        var table_index = s.read_varuint1()
        r.getTableTypeByIndex(table_index)
        var callSig = r.getTypeSignatureByIndex(type_index)
        var callIdx = f.cfStack.popValue(TYPES.I32)
        // The rightmost arg is the one on top of stack,
        // so we have to pop them in reverse.
        var args = new Array(callSig.param_types.length)
        for (var i = callSig.param_types.length - 1; i >= 0; i--) {
          args[i] = f.cfStack.popValue(callSig.param_types[i])
        }
        // The call might have side-effects, so spill anything
        // remaining on the stack.  XXX TODO: only spill affected values.
        f.cfStack.spillAllValues()
        f.cfStack.finalizeTrapConditions()
        if (callSig.return_types.length === 0) {
          f.cfStack.addStatement(new Drop(new CallIndirect(callSig, callIdx, args)))
        } else {
          f.cfStack.pushValue(new CallIndirect(callSig, callIdx, args))
          // Force immediate execution, for side-effects.
          // XXX TODO: this shouldn't be necessary; find the bug in our logic!
          f.cfStack.spillValue()
        }
        break

      case OPCODES.DROP:
        // We use an explicit Drop statement in order to force
        // evaluation of any calls or side-effects in the expression.
        var expr = f.cfStack.popValue(TYPES.UNKNOWN)
        f.cfStack.addStatement(new Drop(expr))
        break

      case OPCODES.SELECT:
        var cond = f.cfStack.popValue(TYPES.I32)
        var typ = f.cfStack.peekType()
        var falseExpr = f.cfStack.popValue(typ)
        var trueExpr = f.cfStack.popValue(typ)
        f.cfStack.pushValue(new Select(cond, trueExpr, falseExpr))
        break

      case OPCODES.GET_LOCAL:
        var index = s.read_varuint32()
        f.cfStack.pushValue(new GetLocal(f.getLocalTypeByIndex(index), index))
        break

      case OPCODES.SET_LOCAL:
        var index = s.read_varuint32()
        var typ = f.getLocalTypeByIndex(index)
        var expr = f.cfStack.popValue(typ)
        // XXX TODO: only spill values that might be affected by the assignment.
        f.cfStack.spillAllValues()
        f.cfStack.addStatement(new SetLocal(typ, index, expr))
        break

      case OPCODES.TEE_LOCAL:
        var index = s.read_varuint32()
        var typ = f.getLocalTypeByIndex(index)
        var expr = f.cfStack.popValue(typ)
        // XXX TODO: only spill values that might be affected by the assignment.
        f.cfStack.spillAllValues()
        f.cfStack.addStatement(new SetLocal(typ, index, expr))
        f.cfStack.pushValue(new GetLocal(typ, index))
        break

      case OPCODES.GET_GLOBAL:
        var index = s.read_varuint32()
        var typ = r.getGlobalTypeByIndex(index)
        f.cfStack.pushValue(new GetGlobal(typ, index))
        break

      case OPCODES.SET_GLOBAL:
        var index = s.read_varuint32()
        if (! r.getGlobalMutabilityByIndex(index)) {
          throw new CompileError("global is immutable: " + index)
        }
        var typ = r.getGlobalTypeByIndex(index)
        var expr = f.cfStack.popValue(typ)
        // XXX TODO: only spill values that might be affected by the assignment.
        f.cfStack.spillAllValues()
        f.cfStack.addStatement(new SetGlobal(typ, index, expr))
        break

      case OPCODES.I32_LOAD:
        r.getMemoryTypeByIndex(0)
        var flags = s.read_varuint32()
        var offset = s.read_varuint32()
        f.cfStack.spillValueIfComposite()
        var addr = f.cfStack.popValue(TYPES.I32)
        addBoundsCheckTrapCondition(f, addr, offset, 4)
        f.cfStack.pushValue(new I32Load(addr, offset, flags))
        break

      case OPCODES.I64_LOAD:
        r.getMemoryTypeByIndex(0)
        var flags = s.read_varuint32()
        var offset = s.read_varuint32()
        f.cfStack.spillValueIfComposite()
        var addr = f.cfStack.popValue(TYPES.I32)
        addBoundsCheckTrapCondition(f, addr, offset, 8)
        if (flags === 3) { flags = 2 }
        f.cfStack.pushValue(new I32Load(addr, offset, flags))
        f.cfStack.pushValue(new I32Load(addr, offset + 4, flags))
        f.cfStack.pushValue(new I64From2xI32(
          f.cfStack.popValue(TYPES.I32),
          f.cfStack.popValue(TYPES.I32)
        ))
        break

      case OPCODES.F32_LOAD:
        r.getMemoryTypeByIndex(0)
        var flags = s.read_varuint32()
        var offset = s.read_varuint32()
        f.cfStack.spillValueIfComposite()
        var addr = f.cfStack.popValue(TYPES.I32)
        addBoundsCheckTrapCondition(f, addr, offset, 4)
        f.cfStack.pushValue(new F32Load(addr, offset, flags))
        break

      case OPCODES.F64_LOAD:
        r.getMemoryTypeByIndex(0)
        var flags = s.read_varuint32()
        var offset = s.read_varuint32()
        f.cfStack.spillValueIfComposite()
        var addr = f.cfStack.popValue(TYPES.I32)
        addBoundsCheckTrapCondition(f, addr, offset, 8)
        f.cfStack.pushValue(new F64Load(addr, offset, flags))
        break

      case OPCODES.I32_LOAD8_S:
        r.getMemoryTypeByIndex(0)
        var flags = s.read_varuint32()
        var offset = s.read_varuint32()
        f.cfStack.spillValueIfComposite()
        var addr = f.cfStack.popValue(TYPES.I32)
        addBoundsCheckTrapCondition(f, addr, offset, 1)
        f.cfStack.pushValue(new I32Load8S(addr, offset, flags))
        break

      case OPCODES.I32_LOAD8_U:
        r.getMemoryTypeByIndex(0)
        var flags = s.read_varuint32()
        var offset = s.read_varuint32()
        f.cfStack.spillValueIfComposite()
        var addr = f.cfStack.popValue(TYPES.I32)
        addBoundsCheckTrapCondition(f, addr, offset, 1)
        f.cfStack.pushValue(new I32Load8U(addr, offset, flags))
        break

      case OPCODES.I32_LOAD16_S:
        r.getMemoryTypeByIndex(0)
        var flags = s.read_varuint32()
        var offset = s.read_varuint32()
        f.cfStack.spillValueIfComposite()
        var addr = f.cfStack.popValue(TYPES.I32)
        addBoundsCheckTrapCondition(f, addr, offset, 2)
        f.cfStack.pushValue(new I32Load16S(addr, offset, flags))
        break

      case OPCODES.I32_LOAD16_U:
        r.getMemoryTypeByIndex(0)
        var flags = s.read_varuint32()
        var offset = s.read_varuint32()
        f.cfStack.spillValueIfComposite()
        var addr = f.cfStack.popValue(TYPES.I32)
        addBoundsCheckTrapCondition(f, addr, offset, 2)
        f.cfStack.pushValue(new I32Load16U(addr, offset, flags))
        break

      case OPCODES.I64_LOAD8_S:
        r.getMemoryTypeByIndex(0)
        var flags = s.read_varuint32()
        var offset = s.read_varuint32()
        f.cfStack.spillValueIfComposite()
        var addr = f.cfStack.popValue(TYPES.I32)
        addBoundsCheckTrapCondition(f, addr, offset, 1)
        f.cfStack.pushValue(new I32Load8S(addr, offset, flags))
        f.cfStack.pushValue(new I64FromI32S(f.cfStack.popValue(TYPES.I32)))
        break

      case OPCODES.I64_LOAD8_U:
        r.getMemoryTypeByIndex(0)
        var flags = s.read_varuint32()
        var offset = s.read_varuint32()
        f.cfStack.spillValueIfComposite()
        var addr = f.cfStack.popValue(TYPES.I32)
        addBoundsCheckTrapCondition(f, addr, offset, 1)
        f.cfStack.pushValue(new I32Load8U(addr, offset, flags))
        f.cfStack.pushValue(new I64FromI32U(f.cfStack.popValue(TYPES.I32)))
        break

      case OPCODES.I64_LOAD16_S:
        r.getMemoryTypeByIndex(0)
        var flags = s.read_varuint32()
        var offset = s.read_varuint32()
        f.cfStack.spillValueIfComposite()
        var addr = f.cfStack.popValue(TYPES.I32)
        addBoundsCheckTrapCondition(f, addr, offset, 2)
        f.cfStack.pushValue(new I32Load16S(addr, offset, flags))
        f.cfStack.pushValue(new I64FromI32S(f.cfStack.popValue(TYPES.I32)))
        break

      case OPCODES.I64_LOAD16_U:
        r.getMemoryTypeByIndex(0)
        var flags = s.read_varuint32()
        var offset = s.read_varuint32()
        f.cfStack.spillValueIfComposite()
        var addr = f.cfStack.popValue(TYPES.I32)
        addBoundsCheckTrapCondition(f, addr, offset, 2)
        f.cfStack.pushValue(new I32Load16U(addr, offset, flags))
        f.cfStack.pushValue(new I64FromI32U(f.cfStack.popValue(TYPES.I32)))
        break

      case OPCODES.I64_LOAD32_S:
        r.getMemoryTypeByIndex(0)
        var flags = s.read_varuint32()
        var offset = s.read_varuint32()
        f.cfStack.spillValueIfComposite()
        var addr = f.cfStack.popValue(TYPES.I32)
        addBoundsCheckTrapCondition(f, addr, offset, 4)
        f.cfStack.pushValue(new I32Load(addr, offset, flags))
        f.cfStack.pushValue(new I64FromI32S(f.cfStack.popValue(TYPES.I32)))
        break

      case OPCODES.I64_LOAD32_U:
        r.getMemoryTypeByIndex(0)
        var flags = s.read_varuint32()
        var offset = s.read_varuint32()
        f.cfStack.spillValueIfComposite()
        var addr = f.cfStack.popValue(TYPES.I32)
        addBoundsCheckTrapCondition(f, addr, offset, 4)
        f.cfStack.pushValue(new I32Load(addr, offset, flags))
        f.cfStack.pushValue(new I64FromI32U(f.cfStack.popValue(TYPES.I32)))
        break

      case OPCODES.I32_STORE:
        r.getMemoryTypeByIndex(0)
        var flags = s.read_varuint32()
        var offset = s.read_varuint32()
        var value = f.cfStack.popValue(TYPES.I32)
        f.cfStack.spillValueIfComposite()
        var addr = f.cfStack.popValue(TYPES.I32)
        addBoundsCheckTrapCondition(f, addr, offset, 4)
        // XXX TODO: spill only things affected by memory writes.
        f.cfStack.spillAllValues()
        f.cfStack.finalizeTrapConditions()
        f.cfStack.addStatement(new I32Store(value, addr, offset, flags))
        break

      case OPCODES.I64_STORE:
        r.getMemoryTypeByIndex(0)
        var flags = s.read_varuint32()
        var offset = s.read_varuint32()
        f.cfStack.spillValueIfComposite()
        var value = f.cfStack.popValue(TYPES.I64)
        f.cfStack.spillValueIfComposite()
        var addr = f.cfStack.popValue(TYPES.I32)
        addBoundsCheckTrapCondition(f, addr, offset, 8)
        // XXX TODO: spill only things affected by memory writes.
        f.cfStack.spillAllValues()
        f.cfStack.finalizeTrapConditions()
        if (flags === 3) { flags = 2 }
        f.cfStack.peek().statements.push(new I32Store(new I32FromI64Low(value), addr, offset, flags))
        f.cfStack.addStatement(new I32Store(new I32FromI64High(value), addr, offset + 4, flags))
        break

      case OPCODES.F32_STORE:
        r.getMemoryTypeByIndex(0)
        var flags = s.read_varuint32()
        var offset = s.read_varuint32()
        var value = f.cfStack.popValue(TYPES.F32)
        f.cfStack.spillValueIfComposite()
        var addr = f.cfStack.popValue(TYPES.I32)
        addBoundsCheckTrapCondition(f, addr, offset, 4)
        // XXX TODO: spill only things affected by memory writes.
        f.cfStack.spillAllValues()
        f.cfStack.finalizeTrapConditions()
        f.cfStack.addStatement(new F32Store(value, addr, offset, flags))
        break

      case OPCODES.F64_STORE:
        r.getMemoryTypeByIndex(0)
        var flags = s.read_varuint32()
        var offset = s.read_varuint32()
        var value = f.cfStack.popValue(TYPES.F64)
        f.cfStack.spillValueIfComposite()
        var addr = f.cfStack.popValue(TYPES.I32)
        addBoundsCheckTrapCondition(f, addr, offset, 8)
        // XXX TODO: spill only things affected by memory writes.
        f.cfStack.spillAllValues()
        f.cfStack.finalizeTrapConditions()
        f.cfStack.addStatement(new F64Store(value, addr, offset, flags))
        break

      case OPCODES.I32_STORE8:
        r.getMemoryTypeByIndex(0)
        var flags = s.read_varuint32()
        var offset = s.read_varuint32()
        var value = f.cfStack.popValue(TYPES.I32)
        f.cfStack.spillValueIfComposite()
        var addr = f.cfStack.popValue(TYPES.I32)
        addBoundsCheckTrapCondition(f, addr, offset, 1)
        // XXX TODO: spill only things affected by memory writes.
        f.cfStack.spillAllValues()
        f.cfStack.finalizeTrapConditions()
        f.cfStack.addStatement(new I32Store8(value, addr, offset, flags))
        break

      case OPCODES.I32_STORE16:
        r.getMemoryTypeByIndex(0)
        var flags = s.read_varuint32()
        var offset = s.read_varuint32()
        var value = f.cfStack.popValue(TYPES.I32)
        f.cfStack.spillValueIfComposite()
        var addr = f.cfStack.popValue(TYPES.I32)
        addBoundsCheckTrapCondition(f, addr, offset, 2)
        // XXX TODO: spill only things affected by memory writes.
        f.cfStack.spillAllValues()
        f.cfStack.finalizeTrapConditions()
        f.cfStack.addStatement(new I32Store16(value, addr, offset, flags))
        break

      case OPCODES.I64_STORE8:
        r.getMemoryTypeByIndex(0)
        var flags = s.read_varuint32()
        var offset = s.read_varuint32()
        var value = f.cfStack.popValue(TYPES.I64)
        f.cfStack.spillValueIfComposite()
        var addr = f.cfStack.popValue(TYPES.I32)
        addBoundsCheckTrapCondition(f, addr, offset, 1)
        // XXX TODO: spill only things affected by memory writes.
        f.cfStack.spillAllValues()
        f.cfStack.finalizeTrapConditions()
        value = new I32FromI64Low(value)
        f.cfStack.addStatement(new I32Store8(value, addr, offset, flags))
        break

      case OPCODES.I64_STORE16:
        r.getMemoryTypeByIndex(0)
        var flags = s.read_varuint32()
        var offset = s.read_varuint32()
        var value = f.cfStack.popValue(TYPES.I64)
        f.cfStack.spillValueIfComposite()
        var addr = f.cfStack.popValue(TYPES.I32)
        addBoundsCheckTrapCondition(f, addr, offset, 2)
        // XXX TODO: spill only things affected by memory writes.
        f.cfStack.spillAllValues()
        f.cfStack.finalizeTrapConditions()
        value = new I32FromI64Low(value)
        f.cfStack.addStatement(new I32Store16(value, addr, offset, flags))
        break

      case OPCODES.I64_STORE32:
        r.getMemoryTypeByIndex(0)
        var flags = s.read_varuint32()
        var offset = s.read_varuint32()
        var value = f.cfStack.popValue(TYPES.I64)
        f.cfStack.spillValueIfComposite()
        var addr = f.cfStack.popValue(TYPES.I32)
        addBoundsCheckTrapCondition(f, addr, offset, 4)
        // XXX TODO: spill only things affected by memory writes.
        f.cfStack.spillAllValues()
        f.cfStack.finalizeTrapConditions()
        value = new I32FromI64Low(value)
        f.cfStack.addStatement(new I32Store(value, addr, offset, flags))
        break

      case OPCODES.CURRENT_MEMORY:
        var index = s.read_varuint1()
        r.getMemoryTypeByIndex(index)
        f.cfStack.pushValue(new GetMemorySize(index))
        break

      case OPCODES.GROW_MEMORY:
        f.cfStack.finalizeTrapConditions()
        var index = s.read_varuint1()
        r.getMemoryTypeByIndex(index)
        var expr = f.cfStack.popValue(TYPES.I32)
        f.cfStack.pushValue(new GrowMemory(index, expr))
        f.cfStack.spillValue() // force immediate evaluation, because side-effects.
        break

      case OPCODES.I32_CONST:
        var val = s.read_varint32()
        f.cfStack.pushValue(new I32Constant(val))
        break

      case OPCODES.I64_CONST:
        var val = s.read_varint64()
        f.cfStack.pushValue(new I64Constant(val))
        break

      case OPCODES.F32_CONST:
        var val = s.read_float32()
        f.cfStack.pushValue(new F32Constant(val))
        break

      case OPCODES.F64_CONST:
        var val = s.read_float64()
        f.cfStack.pushValue(new F64Constant(val))
        break

      case OPCODES.I32_EQZ:
        var expr = f.cfStack.popValue(TYPES.I32)
        f.cfStack.pushValue(new I32Eqz(expr))
        break

      case OPCODES.I32_EQ:
        i32_binaryOp(f, "==")
        break

      case OPCODES.I32_NE:
        i32_binaryOp(f, "!=")
        break

      case OPCODES.I32_LT_S:
        i32_binaryOp(f, "<")
        break

      case OPCODES.I32_LT_U:
        i32_binaryOp_u(f, "<")
        break

      case OPCODES.I32_GT_S:
        i32_binaryOp(f, ">")
        break

      case OPCODES.I32_GT_U:
        i32_binaryOp_u(f, ">")
        break

      case OPCODES.I32_LE_S:
        i32_binaryOp(f, "<=")
        break

      case OPCODES.I32_LE_U:
        i32_binaryOp_u(f, "<=")
        break

      case OPCODES.I32_GE_S:
        i32_binaryOp(f, ">=")
        break

      case OPCODES.I32_GE_U:
        i32_binaryOp_u(f, ">=")
        break

      case OPCODES.I64_EQZ:
        var expr = f.cfStack.popValue(TYPES.I64)
        f.cfStack.pushValue(new I64Eqz(expr))
        break

      case OPCODES.I64_EQ:
        i64_compareFunc(f, "i64_eq")
        break

      case OPCODES.I64_NE:
        i64_compareFunc(f, "i64_ne")
        break

      case OPCODES.I64_LT_S:
        i64_compareFunc(f, "i64_lt_s")
        break

      case OPCODES.I64_LT_U:
        i64_compareFunc(f, "i64_lt_u")
        break

      case OPCODES.I64_GT_S:
        i64_compareFunc(f, "i64_gt_s")
        break

      case OPCODES.I64_GT_U:
        i64_compareFunc(f, "i64_gt_u")
        break

      case OPCODES.I64_LE_S:
        i64_compareFunc(f, "i64_le_s")
        break

      case OPCODES.I64_LE_U:
        i64_compareFunc(f, "i64_le_u")
        break

      case OPCODES.I64_GE_S:
        i64_compareFunc(f, "i64_ge_s")
        break

      case OPCODES.I64_GE_U:
        i64_compareFunc(f, "i64_ge_u")
        break

      case OPCODES.F32_EQ:
        f32_compareOp(f, "==")
        break

      case OPCODES.F32_NE:
        f32_compareOp(f, "!=")
        break

      case OPCODES.F32_LT:
        f32_compareOp(f, "<")
        break

      case OPCODES.F32_GT:
        f32_compareOp(f, ">")
        break

      case OPCODES.F32_LE:
        f32_compareOp(f, "<=")
        break

      case OPCODES.F32_GE:
        f32_compareOp(f, ">=")
        break

      case OPCODES.F64_EQ:
        f64_compareOp(f, "==")
        break

      case OPCODES.F64_NE:
        f64_compareOp(f, "!=")
        break

      case OPCODES.F64_LT:
        f64_compareOp(f, "<")
        break

      case OPCODES.F64_GT:
        f64_compareOp(f, ">")
        break

      case OPCODES.F64_LE:
        f64_compareOp(f, "<=")
        break

      case OPCODES.F64_GE:
        f64_compareOp(f, ">=")
        break

      case OPCODES.I32_CLZ:
        i32_unaryOp(f, "i32_clz")
        break

      case OPCODES.I32_CTZ:
        i32_unaryOp(f, "i32_ctz")
        break

      case OPCODES.I32_POPCNT:
        i32_unaryOp(f, "i32_popcnt")
        break

      case OPCODES.I32_ADD:
        i32_binaryOp(f, "+")
        break

      case OPCODES.I32_SUB:
        i32_binaryOp(f, "-")
        break

      case OPCODES.I32_MUL:
        i32_binaryFunc(f, "i32_mul")
        break

      case OPCODES.I32_DIV_S:
        // Spill both sides to tempvars, so we can add trap conditions.
        var rhs = f.cfStack.popValue(TYPES.I32)
        var lhs = f.cfStack.spillValueIfComposite()
        f.cfStack.pushValue(rhs)
        rhs = f.cfStack.spillValueIfComposite()
        f.cfStack.addTrapCondition(new I32Eqz(rhs))
        f.cfStack.addTrapCondition(new I32BinOp('&', 
          new I32BinOp('==', lhs, new I32Constant(stdlib.INT32_MIN)),
          new I32BinOp('==', rhs, new I32Constant(-1))
        ))
        i32_binaryOp(f, "/")
        break

      case OPCODES.I32_DIV_U:
        var rhs = f.cfStack.spillValueIfComposite()
        f.cfStack.addTrapCondition(new I32Eqz(rhs))
        i32_binaryOp_u(f, "/")
        break

      case OPCODES.I32_REM_S:
        var rhs = f.cfStack.spillValueIfComposite()
        f.cfStack.addTrapCondition(new I32Eqz(rhs))
        i32_binaryOp(f, "%")
        break

      case OPCODES.I32_REM_U:
        var rhs = f.cfStack.spillValueIfComposite()
        f.cfStack.addTrapCondition(new I32Eqz(rhs))
        i32_binaryOp_u(f, "%")
        break

      case OPCODES.I32_AND:
        i32_binaryOp(f, "&")
        break

      case OPCODES.I32_OR:
        i32_binaryOp(f, "|")
        break

      case OPCODES.I32_XOR:
        i32_binaryOp(f, "^")
        break

      case OPCODES.I32_SHL:
        i32_binaryOp(f, "<<")
        break

      case OPCODES.I32_SHR_S:
        i32_binaryOp(f, ">>")
        break

      case OPCODES.I32_SHR_U:
        i32_binaryOp(f, ">>>")
        break

      case OPCODES.I32_ROTL:
        i32_binaryFunc(f, "i32_rotl")
        break

      case OPCODES.I32_ROTR:
        i32_binaryFunc(f, "i32_rotr")
        break

      case OPCODES.I64_CLZ:
        i64_unaryFunc(f, "i64_clz")
        break

      case OPCODES.I64_CTZ:
        i64_unaryFunc(f, "i64_ctz")
        break

      case OPCODES.I64_POPCNT:
        i64_unaryFunc(f, "i64_popcnt")
        break

      case OPCODES.I64_ADD:
        i64_binaryFunc(f, "i64_add")
        break

      case OPCODES.I64_SUB:
        i64_binaryFunc(f, "i64_sub")
        break

      case OPCODES.I64_MUL:
        i64_binaryFunc(f, "i64_mul")
        break

      case OPCODES.I64_DIV_S:
        // Spill both sides to tempvars, so we can add trap conditions.
        var rhs = f.cfStack.popValue(TYPES.I64)
        var lhs = f.cfStack.spillValueIfComposite()
        f.cfStack.pushValue(rhs)
        rhs = f.cfStack.spillValueIfComposite()
        f.cfStack.addTrapCondition(new I64Eqz(rhs))
        f.cfStack.addTrapCondition(new I32BinOp('&', 
          new I64CompareFunc('i64_eq', lhs, new I64Constant(Long.MIN_VALUE)),
          new I64CompareFunc('i64_eq', rhs, new I64Constant(Long.NEG_ONE))
        ))
        i64_binaryFunc(f, "i64_div_s")
        break

      case OPCODES.I64_DIV_U:
        var rhs = f.cfStack.spillValueIfComposite()
        f.cfStack.addTrapCondition(new I64Eqz(rhs))
        i64_binaryFunc(f, "i64_div_u")
        break

      case OPCODES.I64_REM_S:
        var rhs = f.cfStack.spillValueIfComposite()
        f.cfStack.addTrapCondition(new I64Eqz(rhs))
        i64_binaryFunc(f, "i64_rem_s")
        break

      case OPCODES.I64_REM_U:
        var rhs = f.cfStack.spillValueIfComposite()
        f.cfStack.addTrapCondition(new I64Eqz(rhs))
        i64_binaryFunc(f, "i64_rem_u")
        break

      case OPCODES.I64_AND:
        i64_binaryFunc(f, "i64_and")
        break

      case OPCODES.I64_OR:
        i64_binaryFunc(f, "i64_or")
        break

      case OPCODES.I64_XOR:
        i64_binaryFunc(f, "i64_xor")
        break

      case OPCODES.I64_SHL:
        i64_binaryFunc(f, "i64_shl")
        break

      case OPCODES.I64_SHR_S:
        i64_binaryFunc(f, "i64_shr_s")
        break

      case OPCODES.I64_SHR_U:
        i64_binaryFunc(f, "i64_shr_u")
        break

      case OPCODES.I64_ROTL:
        i64_binaryFunc(f, "i64_rotl")
        break

      case OPCODES.I64_ROTR:
        i64_binaryFunc(f, "i64_rotr")
        break

      case OPCODES.F32_ABS:
        f32_unaryOp(f, "f32_abs")
        break

      case OPCODES.F32_NEG:
        f32_unaryOp(f, "f32_neg")
        break

      case OPCODES.F32_CEIL:
        f32_unaryOp(f, "f32_ceil")
        break

      case OPCODES.F32_FLOOR:
        f32_unaryOp(f, "f32_floor")
        break

      case OPCODES.F32_TRUNC:
        f32_unaryOp(f, "f32_trunc")
        break

      case OPCODES.F32_NEAREST:
        f32_unaryOp(f, "f32_nearest")
        break

      case OPCODES.F32_SQRT:
        f32_unaryOp(f, "f32_sqrt")
        break

      case OPCODES.F32_ADD:
        f32_binaryOp(f, "+")
        break

      case OPCODES.F32_SUB:
        f32_binaryOp(f, "-")
        break

      case OPCODES.F32_MUL:
        f32_binaryOp(f, "*")
        break

      case OPCODES.F32_DIV:
        f32_binaryOp(f, "/")
        break

      case OPCODES.F32_MIN:
        f32_binaryFunc(f, "f32_min")
        break

      case OPCODES.F32_MAX:
        f32_binaryFunc(f, "f32_max")
        break

      case OPCODES.F32_COPYSIGN:
        f32_binaryFunc(f, "f32_copysign")
        break

      case OPCODES.F64_ABS:
        f64_unaryOp(f, "f64_abs")
        break

      case OPCODES.F64_NEG:
        f64_unaryOp(f, "f64_neg")
        break

      case OPCODES.F64_CEIL:
        f64_unaryOp(f, "f64_ceil")
        break

      case OPCODES.F64_FLOOR:
        f64_unaryOp(f, "f64_floor")
        break

      case OPCODES.F64_TRUNC:
        f64_unaryOp(f, "f64_trunc")
        break

      case OPCODES.F64_NEAREST:
        f64_unaryOp(f, "f64_nearest")
        break

      case OPCODES.F64_SQRT:
        f64_unaryOp(f, "f64_sqrt")
        break

      case OPCODES.F64_ADD:
        f64_binaryOp(f, "+")
        break

      case OPCODES.F64_SUB:
        f64_binaryOp(f, "-")
        break

      case OPCODES.F64_MUL:
        f64_binaryOp(f, "*")
        break

      case OPCODES.F64_DIV:
        f64_binaryOp(f, "/")
        break

      case OPCODES.F64_MIN:
        f64_binaryFunc(f, "f64_min")
        break

      case OPCODES.F64_MAX:
        f64_binaryFunc(f, "f64_max")
        break

      case OPCODES.F64_COPYSIGN:
        f64_binaryFunc(f, "f64_copysign")
        break

      case OPCODES.I32_WRAP_I64:
        var operand = f.cfStack.popValue(TYPES.I64)
        f.cfStack.pushValue(new I32FromI64Low(operand))
        break

      case OPCODES.I32_TRUNC_S_F32:
        f.cfStack.spillValueIfComposite()
        var operand = f.cfStack.popValue(TYPES.F32)
        f.cfStack.addTrapCondition(new F32CompareOp('>=', operand, new F32Constant(stdlib.INT32_MAX)))
        f.cfStack.addTrapCondition(new F32CompareOp('<', operand, new F32Constant(stdlib.INT32_MIN)))
        f.cfStack.addTrapCondition(new F32IsNaN(operand))
        f.cfStack.pushValue(new I32TruncF32S(operand))
        break

      case OPCODES.I32_TRUNC_S_F64:
        f.cfStack.spillValueIfComposite()
        var operand = f.cfStack.popValue(TYPES.F64)
        f.cfStack.addTrapCondition(new F64CompareOp('>', operand, new F32Constant(stdlib.INT32_MAX)))
        f.cfStack.addTrapCondition(new F64CompareOp('<', operand, new F32Constant(stdlib.INT32_MIN)))
        f.cfStack.addTrapCondition(new F64IsNaN(operand))
        f.cfStack.pushValue(new I32TruncF64S(operand))
        break

      case OPCODES.I32_TRUNC_U_F32:
        f.cfStack.spillValueIfComposite()
        var operand = f.cfStack.popValue(TYPES.F32)
        f.cfStack.addTrapCondition(new F32CompareOp('>=', operand, new F32Constant(stdlib.UINT32_MAX)))
        f.cfStack.addTrapCondition(new F32CompareOp('<=', operand, new F32Constant(-1)))
        f.cfStack.addTrapCondition(new F32IsNaN(operand))
        f.cfStack.pushValue(new I32TruncF32U(operand))
        break

      case OPCODES.I32_TRUNC_U_F64:
        f.cfStack.spillValueIfComposite()
        var operand = f.cfStack.popValue(TYPES.F64)
        f.cfStack.addTrapCondition(new F64CompareOp('>', operand, new F64Constant(stdlib.UINT32_MAX)))
        f.cfStack.addTrapCondition(new F64CompareOp('<=', operand, new F64Constant(-1)))
        f.cfStack.addTrapCondition(new F64IsNaN(operand))
        f.cfStack.pushValue(new I32TruncF32U(operand))
        break

      case OPCODES.I64_EXTEND_S_I32:
        var operand = f.cfStack.popValue(TYPES.I32)
        f.cfStack.pushValue(new I64FromI32S(operand))
        break

      case OPCODES.I64_EXTEND_U_I32:
        var operand = f.cfStack.popValue(TYPES.I32)
        f.cfStack.pushValue(new I64FromI32U(operand))
        break

      case OPCODES.I64_TRUNC_S_F32:
        f.cfStack.spillValueIfComposite()
        var operand = f.cfStack.popValue(TYPES.F32)
        // XXX TODO: I actually don't understand floating-point much at all,
        //           right now am just hacking the tests into passing...
        f.cfStack.addTrapCondition(new F32CompareOp('>=', operand, new F32Constant(9.22337203685e+18)))
        f.cfStack.addTrapCondition(new F32CompareOp('<=', operand, new F32Constant(-9.22337313636e+18)))
        f.cfStack.addTrapCondition(new F32IsNaN(operand))
        f.cfStack.pushValue(new I64TruncF32S(operand))
        break

      case OPCODES.I64_TRUNC_S_F64:
        f.cfStack.spillValueIfComposite()
        var operand = f.cfStack.popValue(TYPES.F64)
        // XXX TODO: I actually don't understand floating-point much at all,
        //           right now am just hacking the tests into passing...
        f.cfStack.addTrapCondition(new F64CompareOp('>=', operand, new F64Constant(9223372036854775808.0)))
        f.cfStack.addTrapCondition(new F64CompareOp('<=', operand, new F64Constant(-9223372036854777856.0)))
        f.cfStack.addTrapCondition(new F64IsNaN(operand))
        f.cfStack.pushValue(new I64TruncF64S(operand))
        break

      case OPCODES.I64_TRUNC_U_F32:
        f.cfStack.spillValueIfComposite()
        var operand = f.cfStack.popValue(TYPES.F32)
        // XXX TODO: I actually don't understand floating-point much at all,
        //           right now am just hacking the tests into passing...
        f.cfStack.addTrapCondition(new F32CompareOp('>=', operand, new F32Constant(1.84467440737e+19)))
        f.cfStack.addTrapCondition(new F32CompareOp('<=', operand, new F32Constant(-1)))
        f.cfStack.addTrapCondition(new F32IsNaN(operand))
        f.cfStack.pushValue(new I64TruncF32U(operand))
        break

      case OPCODES.I64_TRUNC_U_F64:
        f.cfStack.spillValueIfComposite()
        var operand = f.cfStack.popValue(TYPES.F64)
        // XXX TODO: I actually don't understand floating-point much at all,
        //           right now am just hacking the tests into passing...
        f.cfStack.addTrapCondition(new F64CompareOp('>=', operand, new F64Constant(18446744073709551616.0)))
        f.cfStack.addTrapCondition(new F64CompareOp('<=', operand, new F64Constant(-1)))
        f.cfStack.addTrapCondition(new F64IsNaN(operand))
        f.cfStack.pushValue(new I64TruncF64U(operand))
        break

      case OPCODES.F32_CONVERT_S_I32:
        var operand = f.cfStack.popValue(TYPES.I32)
        f.cfStack.pushValue(new F32FromI32S(operand))
        break

      case OPCODES.F32_CONVERT_U_I32:
        var operand = f.cfStack.popValue(TYPES.I32)
        f.cfStack.pushValue(new F32FromI32U(operand))
        break

      case OPCODES.F32_CONVERT_S_I64:
        var operand = f.cfStack.popValue(TYPES.I64)
        f.cfStack.pushValue(new F32FromI64S(operand))
        break

      case OPCODES.F32_CONVERT_U_I64:
        var operand = f.cfStack.popValue(TYPES.I64)
        f.cfStack.pushValue(new F32FromI64U(operand))
        break

      case OPCODES.F32_DEMOTE_F64:
        var operand = f.cfStack.popValue(TYPES.F64)
        f.cfStack.pushValue(new F32FromF64(operand))
        break

      case OPCODES.F64_CONVERT_S_I32:
        var operand = f.cfStack.popValue(TYPES.I32)
        f.cfStack.pushValue(new F64FromI32S(operand))
        break

      case OPCODES.F64_CONVERT_U_I32:
        var operand = f.cfStack.popValue(TYPES.I32)
        f.cfStack.pushValue(new F64FromI32U(operand))
        break

      case OPCODES.F64_CONVERT_S_I64:
        var operand = f.cfStack.popValue(TYPES.I64)
        f.cfStack.pushValue(new F64FromI64S(operand))
        break

      case OPCODES.F64_CONVERT_U_I64:
        var operand = f.cfStack.popValue(TYPES.I64)
        f.cfStack.pushValue(new F64FromI64U(operand))
        break

      case OPCODES.F64_PROMOTE_F32:
        var operand = f.cfStack.popValue(TYPES.F32)
        f.cfStack.pushValue(new F64FromF32(operand))
        break

      case OPCODES.I32_REINTERPRET_F32:
        var operand = f.cfStack.popValue(TYPES.F32)
        f.cfStack.pushValue(new I32ReinterpretF32(operand))
        break

      case OPCODES.I64_REINTERPRET_F64:
        var operand = f.cfStack.popValue(TYPES.F64)
        f.cfStack.pushValue(new I64ReinterpretF64(operand))
        break

      case OPCODES.F32_REINTERPRET_I32:
        var operand = f.cfStack.popValue(TYPES.I32)
        f.cfStack.pushValue(new F32ReinterpretI32(operand))
        break

      case OPCODES.F64_REINTERPRET_I64:
        var operand = f.cfStack.popValue(TYPES.I64)
        f.cfStack.pushValue(new F64ReinterpretI64(operand))
        break

      default:
        throw new CompileError("unsupported opcode: 0x" + op.toString(16))
    }
  }

  // OK, we're now in a position to render the function code.

  function getLocalVarName(index, typ) {
    typ = typ || f.getLocalTypeByIndex(index)
    switch (typ) {
      case TYPES.I32:
        return "li" + index
      case TYPES.I64:
        return "ll" + index
      case TYPES.F32:
        return "lf" + index
      case TYPES.F64:
        return "ld" + index
      default:
        throw new CompileError("unexpected type of local")
    }
  }
  
  var params = []
  f.sig.param_types.forEach(function(typ, idx) {
    params.push(getLocalVarName(idx, typ, true))
  })
  r.putln("function ", f.name, "(", params.join(","), ") {")

  // Coerce parameters to appropriate types

  f.sig.param_types.forEach(function(typ, idx) {
    var nm = getLocalVarName(idx, typ)
    switch (typ) {
      case TYPES.I32:
        r.putln("  ", nm, " = ", nm, "|0")
        break
      case TYPES.I64:
        // No typecasting as it's not valid asmjs anyway.
        break
      case TYPES.F32:
        // XXX TODO: asmjs-style cast breaks our NaN-boxing
        r.putln("  ", nm, " = ToF32(", nm, ")")
        break
      case TYPES.F64:
        // XXX TODO: asmjs-style cast breaks our NaN-boxing
        // r.putln("  ", nm, " = +", nm)
        break
    }
  })

  // Declare local variables

  var idx = f.sig.param_types.length
  f.locals.forEach(function(l) {
    for (var i = 0; i < l.count; i++) {
      var nm = getLocalVarName(idx++, l.type)
      switch (l.type) {
        case TYPES.I32:
          r.putln("  var ", nm, " = 0")
          break
        case TYPES.I64:
          r.putln("  var ", nm, " = new Long(0, 0)")
          break
        case TYPES.F32:
          r.putln("  var ", nm, " = fround(0.0)")
          break
        case TYPES.F64:
          r.putln("  var ", nm, " = 0.0")
          break
      }
    }
  })

  // Declare temporary variables

  ;([TYPES.I32, TYPES.I64, TYPES.F32, TYPES.F64]).forEach(function(typ) {
    var count = f.cfStack.tempvars[typ].count
    for (var i = 0; i < count; i++) {
      switch (typ) {
        case TYPES.I32:
          r.putln("  var ti", i, " = 0")
          break
        case TYPES.I64:
          r.putln("  var tl", i, " = new Long(0, 0)")
          break
        case TYPES.F32:
          r.putln("  var tf", i, " = fround(0.0)")
          break
        case TYPES.F64:
          r.putln("  var td", i, " = 0.0")
          break
      }
    }
  })

  // Render the body itself.
  funcBody.render(r)

  // Phew!  That's everything for this function.
  r.putln("}")
}


//
// A bunch of helpers for constructing different kinds of expression.
//

function i32_unaryOp(f, what) {
  var operand = f.cfStack.popValue(TYPES.I32)
  f.cfStack.pushValue(new I32UnaryOp(what, operand))
}

function i32_unaryOp_u(f, what) {
  var operand = f.cfStack.popValue(TYPES.I32)
  f.cfStack.pushValue(new UI32UnaryOp(what, operand))
}

function i32_binaryOp(f, what) {
  var rhs = f.cfStack.popValue(TYPES.I32)
  var lhs = f.cfStack.popValue(TYPES.I32)
  f.cfStack.pushValue(new I32BinOp(what, lhs, rhs))
}

function i32_binaryOp_u(f, what) {
  var rhs = f.cfStack.popValue(TYPES.I32)
  var lhs = f.cfStack.popValue(TYPES.I32)
  f.cfStack.pushValue(new UI32BinOp(what, lhs, rhs))
}

function i32_binaryFunc(f, what) {
  var rhs = f.cfStack.popValue(TYPES.I32)
  var lhs = f.cfStack.popValue(TYPES.I32)
  f.cfStack.pushValue(new I32BinFunc(what, lhs, rhs))
}

function i64_unaryFunc(f, what) {
  var operand = f.cfStack.popValue(TYPES.I64)
  f.cfStack.pushValue(new I64UnaryFunc(what, operand))
}

function i64_binaryFunc(f, what) {
  var rhs = f.cfStack.popValue(TYPES.I64)
  var lhs = f.cfStack.popValue(TYPES.I64)
  f.cfStack.pushValue(new I64BinFunc(what, lhs, rhs))
}

function i64_compareFunc(f, what) {
  var rhs = f.cfStack.popValue(TYPES.I64)
  var lhs = f.cfStack.popValue(TYPES.I64)
  f.cfStack.pushValue(new I64CompareFunc(what, lhs, rhs))
}

function f32_compareOp(f, what) {
  var rhs = f.cfStack.popValue(TYPES.F32)
  var lhs = f.cfStack.popValue(TYPES.F32)
  f.cfStack.pushValue(new F32CompareOp(what, lhs, rhs))
}

function f32_unaryOp(f, what) {
  var operand = f.cfStack.popValue(TYPES.F32)
  f.cfStack.pushValue(new F32UnaryOp(what, operand))
}

function f32_binaryOp(f, what) {
  var rhs = f.cfStack.popValue(TYPES.F32)
  var lhs = f.cfStack.popValue(TYPES.F32)
  f.cfStack.pushValue(new F32BinOp(what, lhs, rhs))
}

function f32_binaryFunc(f, what) {
  var rhs = f.cfStack.popValue(TYPES.F32)
  var lhs = f.cfStack.popValue(TYPES.F32)
  f.cfStack.pushValue(new F32BinFunc(what, lhs, rhs))
}

function f64_compareOp(f, what) {
  var rhs = f.cfStack.popValue(TYPES.F64)
  var lhs = f.cfStack.popValue(TYPES.F64)
  f.cfStack.pushValue(new F64CompareOp(what, lhs, rhs))
}

function f64_unaryOp(f, what) {
  var operand = f.cfStack.popValue(TYPES.F64)
  f.cfStack.pushValue(new F64UnaryOp(what, operand))
}

function f64_binaryOp(f, what) {
  var rhs = f.cfStack.popValue(TYPES.F64)
  var lhs = f.cfStack.popValue(TYPES.F64)
  f.cfStack.pushValue(new F64BinOp(what, lhs, rhs))
}

function f64_binaryFunc(f, what) {
  var rhs = f.cfStack.popValue(TYPES.F64)
  var lhs = f.cfStack.popValue(TYPES.F64)
  f.cfStack.pushValue(new F64BinFunc(what, lhs, rhs))
}

function addBoundsCheckTrapCondition(f, addr, offset, size) {
  // A large offset might underflow when subtracting from memorySize,
  // so we add a separate check that it's within memory bounds.
  // XXX TODO: optimize this away most of the time.
  if (offset + size > stdlib.UINT32_MAX) {
    f.cfStack.addTrapCondition(new I32Constant(1))
  } else {
    f.cfStack.addTrapCondition(new UI32BinOp('<',
      new GetRawMemorySize(),
      new I32Constant(offset + size)
    ))
  }
  f.cfStack.addTrapCondition(new UI32BinOp('>',
    addr,
    new UI32BinOp('-', new GetRawMemorySize(), new I32Constant(offset + size))
  ))
}


// We represent WASM's "structured stack" as a "stack of stacks".
// Each time we enter a block, we push a new stack on top of
// the existing control-flow structures.  Code can only access
// items from within this top-most stack, not any of the stacks
// below it.

function ControlFlowStack() {
  this.stack = []
  this.tempvars = {}
  this.tempvars[TYPES.I32] = { count: 0, free: [] }
  this.tempvars[TYPES.I64] = { count: 0, free: [] }
  this.tempvars[TYPES.F32] = { count: 0, free: [] }
  this.tempvars[TYPES.F64] = { count: 0, free: [] }
}

ControlFlowStack.prototype.push = function push(cf) {
  var parent = null
  if (this.stack.length > 0) {
    parent = this.stack[this.stack.length - 1]
  }
  cf.initialize(this.stack.length, parent, this.tempvars)
  this.stack.push(cf)
  return cf
}

ControlFlowStack.prototype.pop = function pop() {
  var cf = this.stack.pop()
  cf.markEndOfBlock()
  if (this.stack.length > 0) {
    this.peek().addStatement(cf)
    if (cf.endReached) {
      if (cf.resultType !== TYPES.NONE) {
        this.peek().pushValue(new GetTempVar(cf.resultType, cf.getResultVar()))
      }
    } else {
      this.markDeadCode()
    }
  }
  return cf
}

ControlFlowStack.prototype.peek = function peek() {
  return this.stack[this.stack.length - 1]
}

ControlFlowStack.prototype.peekBottom = function peekBottom() {
  return this.stack[0]
}

ControlFlowStack.prototype.markDeadCode = function markDeadCode() {
  this.peek().markDeadCode()
}

ControlFlowStack.prototype.isDeadCode = function isDeadCode() {
  return this.peek().isDead
}

ControlFlowStack.prototype.addStatement = function addStatement(stmt) {
  return this.peek().addStatement(stmt)
}

ControlFlowStack.prototype.addTerminalStatement = function addTerminalStatement(stmt) {
  return this.peek().addTerminalStatement(stmt)
}

ControlFlowStack.prototype.pushValue = function pushValue(expr) {
  return this.peek().pushValue(expr)
}

ControlFlowStack.prototype.peekType = function peekType() {
  return this.peek().peekType()
}

ControlFlowStack.prototype.peekValue = function peekValue(wantType) {
  return this.peek().peekValue(wantType)
}

ControlFlowStack.prototype.popValue = function popValue(wantType) {
  return this.peek().popValue(wantType)
}

ControlFlowStack.prototype.getBranchTarget = function getBranchTarget(depth) {
  var which = this.stack.length - (1 + depth)
  if (which < 0) {
    throw new CompileError("Branch depth too large")
  }
  return this.stack[which]
}

ControlFlowStack.prototype.spillValue = function spillValue() {
  return this.peek().spillValue()
}

ControlFlowStack.prototype.spillValueIfComposite = function spillValueIfComposite() {
  var v = this.peekValue()
  if (v instanceof _GetVar) {
    return v
  }
  if (v instanceof _Constant) {
    return v
  }
  return this.spillValue()
}

ControlFlowStack.prototype.spillAllValues = function spillAllValues() {
  for (var i = 0; i < this.stack.length; i++) {
    this.stack[i].spillAllValues()
  }
}

ControlFlowStack.prototype.addTrapCondition = function addTrapCondition(expr) {
  this.peek().addTrapCondition(expr)
}

ControlFlowStack.prototype.finalizeTrapConditions = function finalizeTrapConditions() {
  this.peek().finalizeTrapConditions()
}


//
// Classes for all of the many different kinds of expression
// we can build up.  These get acumulated on the value stack,
// as we traverse the function code, and eventually rendered
// into javascript expressions.  The hope is that by building
// up the expression in memory, we can avoid using lots of
// temporary variables in the generated JavaScript.
//

function _Expr(type) {
  this.type = type
}
inherits(_Expr, Object, {
  render: function render(r) {
    throw new CompileError('not implemented')
  },

  walkConsumedVariables: function walkConsumedVariables(cb) {
  }
})


function Undefined() {
  _Expr.call(this, TYPES.UNKNOWN)
}
inherits(Undefined, _Expr, {
  render: function render(r) {
    r.putstr("(UNDEFINED)")
  }
})



function _GetVar(type, index) {
  _Expr.call(this, type)
  this.index = index
}
inherits(_GetVar, _Expr, {
  render: function render(r) {
    switch (this.type) {
      case TYPES.I32:
        r.putstr(this.namePrefix)
        r.putstr("i")
        r.putstr(this.index)
        break
      case TYPES.I64:
        r.putstr(this.namePrefix)
        r.putstr("l")
        r.putstr(this.index)
        break
      case TYPES.F32:
        r.putstr(this.namePrefix)
        r.putstr("f")
        r.putstr(this.index)
        break
      case TYPES.F64:
        r.putstr(this.namePrefix)
        r.putstr("d")
        r.putstr(this.index)
        break
      default:
        throw new CompileError("unexpected type for variable: " + this.type)
    }
  },

  walkConsumedVariables: function walkConsumedVariables(cb) {
    cb(this)
  }
})


function GetTempVar(type, index) {
  _GetVar.call(this, type, index)
}
inherits(GetTempVar, _GetVar, {
  namePrefix: "t"
})


function GetLocal(type, index) {
  _GetVar.call(this, type, index)
}
inherits(GetLocal, _GetVar, {
  namePrefix: "l"
})


function GetGlobal(type, index) {
  _GetVar.call(this, type, index)
}
inherits(GetGlobal, _GetVar, {
  namePrefix: "G"
})


function _Constant(type, value) {
  _Expr.call(this, type)
  this.value = value
}
inherits(_Constant, _Expr, {
  render: function render(r) {
    r.putstr(stringifyJSValue(this.value))
  }
})


function I32Constant(value) {
  _Constant.call(this, TYPES.I32, value)
}
inherits(I32Constant, _Constant)


function I64Constant(value) {
  _Constant.call(this, TYPES.I64, value)
}
inherits(I64Constant, _Constant)


function F32Constant(value) {
  _Constant.call(this, TYPES.F32, value)
}
inherits(F32Constant, _Constant)


function F64Constant(value) {
  _Constant.call(this, TYPES.F64, value)
}
inherits(F64Constant, _Constant)



// Loads from memory


function _Load(type, addr, offset, size, flags) {
  _Expr.call(this, type)
  this.addr = addr
  this.offset = offset
  this.flags = flags
}
inherits(_Load, _Expr, {
  renderUnaligned: function renderUnaligned(r, func) {
    r.putstr(func)
    r.putstr("((")
    this.addr.render(r)
    r.putstr(") + ")
    r.putstr(this.offset)
    r.putstr(")")
  },

  renderMaybeAligned: function renderMaybeAligned(r, mask, shift, ta, fallback) { 
    if (! isLittleEndian) {
      this.renderUnaligned(r, fallback)
    } else {
      r.putstr("((((")
      this.addr.render(r)
      r.putstr(") + ")
      r.putstr(this.offset)
      r.putstr(") & ")
      r.putstr(mask)
      r.putstr(") ? ")
      r.putstr(fallback)
      r.putstr("((")
      this.addr.render(r)
      r.putstr(") + ")
      r.putstr(this.offset)
      r.putstr(") : (")
      r.putstr(ta)
      r.putstr("[((")
      this.addr.render(r)
      r.putstr(") + ")
      r.putstr(this.offset)
      r.putstr(")>>")
      r.putstr(shift)
      r.putstr("]")
      r.putstr("))")
    }
  },

  walkConsumedVariables: function walkConsumedVariables(cb) {
    this.addr.walkConsumedVariables(cb)
  }
})


function I32Load(addr, offset, flags) {
  _Load.call(this, TYPES.I32, addr, offset, 4, flags)
}
inherits(I32Load, _Load, {
  render: function render(r) {
    switch (this.flags) {
      case 0:
      case 1:
        this.renderUnaligned(r, "i32_load_unaligned")
        break
      case 2:
        this.renderMaybeAligned(r, "0x03", "2", "HI32", "i32_load_unaligned")
        break
      default:
        throw new CompileError("unsupported load flags")
    }
  }
})


function F32Load(addr, offset, flags) {
  _Load.call(this, TYPES.F32, addr, offset, 4, flags)
}
inherits(F32Load, _Load, {
  render: function render(r) {
    // XXX TODO: don't emit the NaN-fixup stuff if we don't need it,
    // either because the platform doesn't need it, or because we can
    // prove that the value will be canonicalized.
    if (! isNaNPreserving32) {
      r.putstr("f32_load_nan_bitpattern(")
    }
    switch (this.flags) {
      case 0:
      case 1:
        this.renderUnaligned(r, "f32_load_unaligned")
        break
      case 2:
        this.renderMaybeAligned(r, "0x03", "2", "HF32", "f32_load_unaligned")
        break
      default:
        throw new CompileError("unsupported load flags")
    }
    if (! isNaNPreserving32) {
      r.putstr(",(")
      this.addr.render(r)
      r.putstr(") + ")
      r.putstr(this.offset)
      r.putstr(")")
    }
  }
})


function F64Load(addr, offset, flags) {
  _Load.call(this, TYPES.F64, addr, offset, 8, flags)
}
inherits(F64Load, _Load, {
  render: function render(r) {
    // XXX TODO: don't emit the NaN-fixup stuff if we don't need it,
    // either because the platform doesn't need it, or because we can
    // prove that the value will be canonicalized.
    if (! isNaNPreserving64) {
      r.putstr("f64_load_nan_bitpattern(")
    }
    switch (this.flags) {
      case 0:
      case 1:
      case 2:
        this.renderUnaligned(r, "f64_load_unaligned")
        break
      case 3:
        this.renderMaybeAligned(r, "0x07", "3", "HF64", "f64_load_unaligned")
        break
      default:
        throw new CompileError("unsupported load flags")
    }
    if (! isNaNPreserving64) {
      r.putstr(",(")
      this.addr.render(r)
      r.putstr(") + ")
      r.putstr(this.offset)
      r.putstr(")")
    }
  }
})


function I32Load8S(addr, offset, flags) {
  _Load.call(this, TYPES.I32, addr, offset, 1, flags)
}
inherits(I32Load8S, _Load, {
  render: function render(r) {
    switch (this.flags) {
      case 0:
        r.putstr("HI8[(")
        this.addr.render(r)
        r.putstr(")+")
        r.putstr(this.offset)
        r.putstr("]")
        break
      default:
        throw new CompileError("unsupported load flags")
    }
  }
})


function I32Load8U(addr, offset, flags) {
  _Load.call(this, TYPES.I32, addr, offset, 1, flags)
}
inherits(I32Load8U, _Load, {
  render: function render(r) {
    switch (this.flags) {
      case 0:
        r.putstr("HU8[(")
        this.addr.render(r)
        r.putstr(")+")
        r.putstr(this.offset)
        r.putstr("]")
        break
      default:
        throw new CompileError("unsupported load flags")
    }
  }
})


function I32Load16S(addr, offset, flags) {
  _Load.call(this, TYPES.I32, addr, offset, 2, flags)
}
inherits(I32Load16S, _Load, {
  render: function render(r) {
    switch (this.flags) {
      case 0:
        this.renderUnaligned(r, "i32_load16_s_unaligned")
        break
      case 1:
        this.renderMaybeAligned(r, "0x01", "1", "HI16", "i32_load16_s_unaligned")
        break
      default:
        throw new CompileError("unsupported load flags")
    }
  }
})


function I32Load16U(addr, offset, flags) {
  _Load.call(this, TYPES.I32, addr, offset, 2, flags)
}
inherits(I32Load16U, _Load, {
  render: function render(r) {
    switch (this.flags) {
      case 0:
        this.renderUnaligned(r, "i32_load16_u_unaligned")
        break
      case 1:
        this.renderMaybeAligned(r, "0x01", "1", "HU16", "i32_load16_u_unaligned")
        break
      default:
        throw new CompileError("unsupported load flags")
    }
  }
})


function _UnaryOp(type, operand) {
  _Expr.call(this, type)
  this.operand = operand
}
inherits(_UnaryOp, _Expr, {
  walkConsumedVariables: function walkConsumedVariables(cb) {
    this.operand.walkConsumedVariables(cb)
  }
})


function _BinaryOp(type, lhs, rhs) {
  _Expr.call(this, type)
  this.lhs = lhs
  this.rhs = rhs

}
inherits(_BinaryOp, _Expr, {
  walkConsumedVariables: function walkConsumedVariables(cb) {
    this.lhs.walkConsumedVariables(cb)
    this.rhs.walkConsumedVariables(cb)
  }
})


function I32Eqz(operand) {
  _UnaryOp.call(this, TYPES.I32, operand)
}
inherits(I32Eqz, _UnaryOp, {
  render: function render(r) {
    r.putstr("(!")
    this.operand.render(r)
    r.putstr(")|0")
  }
})

function I32UnaryOp(what, operand) {
  _UnaryOp.call(this, TYPES.I32, operand)
  this.what = what
}
inherits(I32UnaryOp, _UnaryOp, {
  render: function render(r) {
    r.putstr(this.what)
    r.putstr("(")
    this.operand.render(r)
    r.putstr(")")
  }
})

function I32BinOp(what, lhs, rhs) {
  _BinaryOp.call(this, TYPES.I32, lhs, rhs)
  this.what = what
}
inherits(I32BinOp, _BinaryOp, {
  render: function render(r) {
    r.putstr("(((")
    this.lhs.render(r)
    r.putstr(")|0)")
    r.putstr(this.what)
    r.putstr("((")
    this.rhs.render(r)
    r.putstr(")|0)")
    r.putstr(")|0")
  }
})


function UI32BinOp(what, lhs, rhs) {
  _BinaryOp.call(this, TYPES.I32, lhs, rhs)
  this.what = what
}
inherits(UI32BinOp, _BinaryOp, {
  render: function render(r) {
    r.putstr("(((")
    this.lhs.render(r)
    r.putstr(")>>>0)")
    r.putstr(this.what)
    r.putstr("((")
    this.rhs.render(r)
    r.putstr(")>>>0)")
    r.putstr(")|0")
  }
})


function I32BinFunc(what, lhs, rhs) {
  _BinaryOp.call(this, TYPES.I32, lhs, rhs)
  this.what = what
}
inherits(I32BinFunc, _BinaryOp, {
  render: function render(r) {
    r.putstr(this.what)
    r.putstr("((")
    this.lhs.render(r)
    r.putstr(")|0")
    r.putstr(",(")
    this.rhs.render(r)
    r.putstr(")|0")
    r.putstr(")")
  }
})


function I64Eqz(operand) {
  _UnaryOp.call(this, TYPES.I32, operand)
}
inherits(I64Eqz, _UnaryOp, {
  render: function render(r) {
    r.putstr("(")
    this.operand.render(r)
    r.putstr(".isZero())|0")
  }
})

function I64UnaryFunc(what, operand) {
  _UnaryOp.call(this, TYPES.I64, operand)
  this.what = what
}
inherits(I64UnaryFunc, _UnaryOp, {
  render: function render(r) {
    r.putstr(this.what)
    r.putstr("(")
    this.operand.render(r)
    r.putstr(")")
  }
})

function I64BinFunc(what, lhs, rhs) {
  _BinaryOp.call(this, TYPES.I64, lhs, rhs)
  this.what = what
}
inherits(I64BinFunc, _BinaryOp, {
  render: function render(r) {
    r.putstr(this.what)
    r.putstr("(")
    this.lhs.render(r)
    r.putstr(",")
    this.rhs.render(r)
    r.putstr(")")
  }
})

function I64CompareFunc(what, lhs, rhs) {
  _BinaryOp.call(this, TYPES.I32, lhs, rhs)
  this.what = what
}
inherits(I64CompareFunc, _BinaryOp, {
  render: function render(r) {
    r.putstr(this.what)
    r.putstr("(")
    this.lhs.render(r)
    r.putstr(",")
    this.rhs.render(r)
    r.putstr(")|0")
  }
})


function F32Eqz(operand) {
  _UnaryOp.call(this, TYPES.I32, operand)
}
inherits(F32Eqz, _UnaryOp, {
  render: function render(r) {
    r.putstr("(!")
    this.operand.render(r)
    r.putstr(")|0")
  }
})


function F32IsNaN(operand) {
  _UnaryOp.call(this, TYPES.I32, operand)
}
inherits(F32IsNaN, _UnaryOp, {
  render: function render(r) {
    r.putstr("f32_isNaN(")
    this.operand.render(r)
    r.putstr(")")
  }
})

function F32UnaryOp(what, operand) {
  _UnaryOp.call(this, TYPES.F32, operand)
  this.what = what
}
inherits(F32UnaryOp, _UnaryOp, {
  render: function render(r) {
    r.putstr("ToF32(")
    r.putstr(this.what)
    r.putstr("(")
    this.operand.render(r)
    r.putstr("))")
  }
})

function F32CompareOp(what, lhs, rhs) {
  _BinaryOp.call(this, TYPES.I32, lhs, rhs)
  this.what = what
}
inherits(F32CompareOp, _BinaryOp, {
  render: function render(r) {
    // It's important to use fround() here so that
    // boxed NaNs don't compare equal to themselves
    r.putstr("(fround(")
    this.lhs.render(r)
    r.putstr(") ")
    r.putstr(this.what)
    r.putstr(" fround(")
    this.rhs.render(r)
    r.putstr("))|0")
  }
})

function F32BinOp(what, lhs, rhs) {
  _BinaryOp.call(this, TYPES.F32, lhs, rhs)
  this.what = what
}
inherits(F32BinOp, _BinaryOp, {
  render: function render(r) {
    // We can safely use fround() here because we're
    // allowed to canonicalize NaNs \o/
    r.putstr("fround((")
    this.lhs.render(r)
    r.putstr(")")
    r.putstr(this.what)
    r.putstr("(")
    this.rhs.render(r)
    r.putstr("))")
  }
})

function F32BinFunc(what, lhs, rhs) {
  _BinaryOp.call(this, TYPES.F32, lhs, rhs)
  this.what = what
}
inherits(F32BinFunc, _BinaryOp, {
  render: function render(r) {
    r.putstr(this.what)
    r.putstr("(")
    this.lhs.render(r)
    r.putstr(",")
    this.rhs.render(r)
    r.putstr(")")
  }
})


function F64Eqz(operand) {
  _UnaryOp.call(this, TYPES.I32, operand)
}
inherits(F64Eqz, _UnaryOp, {
  render: function render(r) {
    r.putstr("(!")
    this.operand.render(r)
    r.putstr(")|0")
  }
})


function F64IsNaN(operand) {
  _UnaryOp.call(this, TYPES.I32, operand)
}
inherits(F64IsNaN, _UnaryOp, {
  render: function render(r) {
    r.putstr("f64_isNaN(")
    this.operand.render(r)
    r.putstr(")")
  }
})


function F64UnaryOp(what, operand) {
  _UnaryOp.call(this, TYPES.F64, operand)
  this.what = what
}
inherits(F64UnaryOp, _UnaryOp, {
  render: function render(r) {
    r.putstr(this.what)
    r.putstr("(")
    this.operand.render(r)
    r.putstr(")")
  }
})

function F64CompareOp(what, lhs, rhs) {
  _BinaryOp.call(this, TYPES.I32, lhs, rhs)
  this.what = what
}
inherits(F64CompareOp, _BinaryOp, {
  render: function render(r) {
    // It's important to cast values with `+` here so that
    // boxed NaNs don't compare equal to themselves
    r.putstr("(+(")
    this.lhs.render(r)
    r.putstr(") ")
    r.putstr(this.what)
    r.putstr(" (+(")
    this.rhs.render(r)
    r.putstr(")))|0")
  }
})

function F64BinOp(what, lhs, rhs) {
  _BinaryOp.call(this, TYPES.F64, lhs, rhs)
  this.what = what
}
inherits(F64BinOp, _BinaryOp, {
  render: function render(r) {
    r.putstr("(")
    this.lhs.render(r)
    r.putstr(")")
    r.putstr(this.what)
    r.putstr("(")
    this.rhs.render(r)
    r.putstr(")")
  }
})

function F64BinFunc(what, lhs, rhs) {
  _BinaryOp.call(this, TYPES.F64, lhs, rhs)
  this.what = what
}
inherits(F64BinFunc, _BinaryOp, {
  render: function render(r) {
    r.putstr(this.what)
    r.putstr("(")
    this.lhs.render(r)
    r.putstr(",")
    this.rhs.render(r)
    r.putstr(")")
  }
})


function Select(cond, trueExpr, falseExpr) {
  _Expr.call(this, trueExpr.type)
  this.cond = cond
  this.trueExpr = trueExpr
  this.falseExpr = falseExpr
}
inherits(Select, _Expr, {
  render: function render(r) {
    r.putstr("((")
    this.cond.render(r)
    r.putstr(") ? (")
    this.trueExpr.render(r)
    r.putstr(") : (")
    this.falseExpr.render(r)
    r.putstr("))")
  },

  walkConsumedVariables: function walkConsumedVariables(cb) {
    this.cond.walkConsumedVariables(cb)
    this.trueExpr.walkConsumedVariables(cb)
    this.falseExpr.walkConsumedVariables(cb)
  }
})


function Call(typesig, index, args) {
  if (typesig.return_types.length === 0) {
    _Expr.call(this, TYPES.NONE)
  } else {
    _Expr.call(this, typesig.return_types[0])
  }
  this.typesig = typesig
  this.index = index
  this.args = args
}
inherits(Call, _Expr, {
  render: function render(r) {
    r.putstr("F")
    r.putstr(this.index)
    r.putstr("(")
    if (this.args.length > 0) {
      for (var i = 0; i < this.args.length - 1; i++) {
        this.args[i].render(r)
        r.putstr(",")
      }
      this.args[i].render(r)
    }
    r.putstr(")")
  },

  walkConsumedVariables: function walkConsumedVariables(cb) {
    this.args.forEach(function(arg) {
      arg.walkConsumedVariables(cb)
    })
  }
})


function CallIndirect(typesig, index, args) {
  if (typesig.return_types.length === 0) {
    _Expr.call(this, TYPES.NONE)
  } else {
    _Expr.call(this, typesig.return_types[0])
  }
  this.typesig = typesig
  this.index = index
  this.args = args
}
inherits(CallIndirect, _Expr, {
  render: function render(r) {
    // XXX TODO: in some cases we could use asmjs type-specific function tables here.
    // For now we just delegate to an externally-defined helper.
    r.putstr("call_")
    r.putstr(makeSigStr(this.typesig))
    r.putstr("(")
    this.index.render(r)
    for (var i = 0; i < this.args.length; i++) {
      r.putstr(",")
      this.args[i].render(r)
    }
    r.putstr(")")
  },

  walkConsumedVariables: function walkConsumedVariables(cb) {
    this.index.walkConsumedVariables(cb)
    this.args.forEach(function(arg) {
      arg.walkConsumedVariables(cb)
    })
  }
})


function GetRawMemorySize(index) {
  _Expr.call(this, TYPES.I32)
  this.index = index
}
inherits(GetRawMemorySize, _Expr, {
  render: function render(r) {
    r.putstr("memorySize")
  }
})

function GetMemorySize(index) {
  _Expr.call(this, TYPES.I32)
  this.index = index
}
inherits(GetMemorySize, _Expr, {
  render: function render(r) {
    r.putstr("(memorySize / ")
    r.putstr(PAGE_SIZE)
    r.putstr(")")
  }
})

function GrowMemory(index, expr) {
  _Expr.call(this, TYPES.I32)
  this.index = index
  this.expr = expr
}
inherits(GrowMemory, _Expr, {
  render: function render(r) {
    r.putstr("M")
    r.putstr(this.index)
    r.putstr("._grow(")
    this.expr.render(r)
    r.putstr(")")
  },

  walkConsumedVariables: function walkConsumedVariables(cb) {
    this.expr.walkConsumedVariables(cb)
  }
})


function I32FromI64Low(operand) {
  _UnaryOp.call(this, TYPES.I32, operand)
}
inherits(I32FromI64Low, _UnaryOp, {
  render: function render(r) {
    r.putstr("(")
    this.operand.render(r)
    r.putstr(".low)")
  }
})

function I32FromI64High(operand) {
  _UnaryOp.call(this, TYPES.I32, operand)
}
inherits(I32FromI64High, _UnaryOp, {
  render: function render(r) {
    r.putstr("(")
    this.operand.render(r)
    r.putstr(".high)")
  }
})

function I32TruncF32S(operand) {
  _UnaryOp.call(this, TYPES.I32, operand)
}
inherits(I32TruncF32S, _UnaryOp, {
  render: function render(r) {
    r.putstr("f32_trunc(")
    this.operand.render(r)
    r.putstr(")|0")
  }
})

function I32TruncF64S(operand) {
  _UnaryOp.call(this, TYPES.I32, operand)
}
inherits(I32TruncF64S, _UnaryOp, {
  render: function render(r) {
    r.putstr("f64_trunc(")
    this.operand.render(r)
    r.putstr(")|0")
  }
})

function I32TruncF32U(operand) {
  _UnaryOp.call(this, TYPES.I32, operand)
}
inherits(I32TruncF32U, _UnaryOp, {
  render: function render(r) {
    r.putstr("(f32_trunc(")
    this.operand.render(r)
    r.putstr(")|0)")
  }
})

function I32TruncF64U(operand) {
  _UnaryOp.call(this, TYPES.I32, operand)
}
inherits(I32TruncF64U, _UnaryOp, {
  render: function render(r) {
    r.putstr("(f64_trunc(")
    this.operand.render(r)
    r.putstr(")|0)")
  }
})

function I32ReinterpretF32(operand) {
  _UnaryOp.call(this, TYPES.I32, operand)
}
inherits(I32ReinterpretF32, _UnaryOp, {
  render: function render(r) {
    r.putstr("i32_reinterpret_f32(")
    this.operand.render(r)
    r.putstr(")")
  }
})

function I64FromI32S(operand) {
  _UnaryOp.call(this, TYPES.I64, operand)
}
inherits(I64FromI32S, _UnaryOp, {
  render: function render(r) {
    r.putstr("i64_from_i32_s(")
    this.operand.render(r)
    r.putstr(")")
  }
})

function I64FromI32U(operand) {
  _UnaryOp.call(this, TYPES.I64, operand)
}
inherits(I64FromI32U, _UnaryOp, {
  render: function render(r) {
    r.putstr("(new Long(")
    this.operand.render(r)
    r.putstr(", 0))")
  }
})

function I64From2xI32(high, low) {
  _Expr.call(this, TYPES.I64)
  this.high = high
  this.low = low
}
inherits(I64From2xI32, _Expr, {
  render: function render(r) {
    r.putstr("(new Long(")
    this.low.render(r)
    r.putstr(",")
    this.high.render(r)
    r.putstr("))")
  },

  walkConsumedVariables: function walkConsumedVariables(cb) {
    this.high.walkConsumedVariables(cb)
    this.low.walkConsumedVariables(cb)
  }
})


function I64TruncF32S(operand) {
  _UnaryOp.call(this, TYPES.I64, operand)
}
inherits(I64TruncF32S, _UnaryOp, {
  render: function render(r) {
    r.putstr("Long.fromNumber(f32_trunc(")
    this.operand.render(r)
    r.putstr("))")
  }
})

function I64TruncF64S(operand) {
  _UnaryOp.call(this, TYPES.I64, operand)
}
inherits(I64TruncF64S, _UnaryOp, {
  render: function render(r) {
    r.putstr("Long.fromNumber(f64_trunc(")
    this.operand.render(r)
    r.putstr("))")
  }
})

function I64TruncF32U(operand) {
  _UnaryOp.call(this, TYPES.I64, operand)
}
inherits(I64TruncF32U, _UnaryOp, {
  render: function render(r) {
    r.putstr("Long.fromNumber(f32_trunc(")
    this.operand.render(r)
    r.putstr("), true).toSigned()")
  }
})

function I64TruncF64U(operand) {
  _UnaryOp.call(this, TYPES.I64, operand)
}
inherits(I64TruncF64U, _UnaryOp, {
  render: function render(r) {
    r.putstr("Long.fromNumber(f64_trunc(")
    this.operand.render(r)
    r.putstr("), true).toSigned()")
  }
})

function I64ReinterpretF64(operand) {
  _UnaryOp.call(this, TYPES.I64, operand)
}
inherits(I64ReinterpretF64, _UnaryOp, {
  render: function render(r) {
    r.putstr("i64_reinterpret_f64(")
    this.operand.render(r)
    r.putstr(")")
  }
})


function F32FromI32S(operand) {
  _UnaryOp.call(this, TYPES.F32, operand)
}
inherits(F32FromI32S, _UnaryOp, {
  render: function render(r) {
    r.putstr("ToF32((")
    this.operand.render(r)
    r.putstr(")|0)")
  }
})

function F32FromI32U(operand) {
  _UnaryOp.call(this, TYPES.F32, operand)
}
inherits(F32FromI32U, _UnaryOp, {
  render: function render(r) {
    r.putstr("ToF32((")
    this.operand.render(r)
    r.putstr(")>>>0)")
  }
})

function F32FromI64S(operand) {
  _UnaryOp.call(this, TYPES.F32, operand)
}
inherits(F32FromI64S, _UnaryOp, {
  render: function render(r) {
    r.putstr("ToF32(")
    this.operand.render(r)
    r.putstr(".toNumber())")
  }
})

function F32FromI64U(operand) {
  _UnaryOp.call(this, TYPES.F32, operand)
}
inherits(F32FromI64U, _UnaryOp, {
  render: function render(r) {
    r.putstr("ToF32(")
    this.operand.render(r)
    r.putstr(".toUnsigned().toNumber())")
  }
})

function F32FromF64(operand) {
  _UnaryOp.call(this, TYPES.F32, operand)
}
inherits(F32FromF64, _UnaryOp, {
  render: function render(r) {
    r.putstr("ToF32(")
    this.operand.render(r)
    r.putstr(")")
  }
})

function F32ReinterpretI32(operand) {
  _UnaryOp.call(this, TYPES.F32, operand)
}
inherits(F32ReinterpretI32, _UnaryOp, {
  render: function render(r) {
    r.putstr("f32_reinterpret_i32(")
    this.operand.render(r)
    r.putstr(")")
  }
})


function F64FromI32S(operand) {
  _UnaryOp.call(this, TYPES.F64, operand)
}
inherits(F64FromI32S, _UnaryOp, {
  render: function render(r) {
    r.putstr("+((")
    this.operand.render(r)
    r.putstr(")|0)")
  }
})

function F64FromI32U(operand) {
  _UnaryOp.call(this, TYPES.F64, operand)
}
inherits(F64FromI32U, _UnaryOp, {
  render: function render(r) {
    r.putstr("+((")
    this.operand.render(r)
    r.putstr(")>>>0)")
  }
})

function F64FromI64S(operand) {
  _UnaryOp.call(this, TYPES.F64, operand)
}
inherits(F64FromI64S, _UnaryOp, {
  render: function render(r) {
    r.putstr("+(")
    this.operand.render(r)
    r.putstr(".toNumber())")
  }
})

function F64FromI64U(operand) {
  _UnaryOp.call(this, TYPES.F64, operand)
}
inherits(F64FromI64U, _UnaryOp, {
  render: function render(r) {
    r.putstr("+(")
    this.operand.render(r)
    r.putstr(".toUnsigned().toNumber())")
  }
})

function F64FromF32(operand) {
  _UnaryOp.call(this, TYPES.F64, operand)
}
inherits(F64FromF32, _UnaryOp, {
  render: function render(r) {
    r.putstr("+(")
    this.operand.render(r)
    r.putstr(")")
  }
})

function F64ReinterpretI64(operand) {
  _UnaryOp.call(this, TYPES.F64, operand)
}
inherits(F64ReinterpretI64, _UnaryOp, {
  render: function render(r) {
    r.putstr("f64_reinterpret_i64(")
    this.operand.render(r)
    r.putstr(")")
  }
})


//
// Classes to represent various kinds of *statement*.
// Statements are immediately executed rather than manaed on a stack,
// and they consume expressions.
//


function _Stmt() {
}
inherits(_Stmt, Object, {
  render: function render(r) {
    throw new CompileError('not implemented')
  },
  walkConsumedVariables: function walkConsumedVariables(cb) {
  }
})


function _UnaryStmt(expr) {
  _Stmt.call(this)
  this.expr = expr
}
inherits(_UnaryStmt, _Stmt, {
  walkConsumedVariables: function walkConsumedVariables(cb) {
    this.expr.walkConsumedVariables(cb)
  }
})


function Debug(msg) {
  _Stmt.call(this)
  this.msg = msg
  this.exprs = []
  for (var i = 1; i < arguments.length; i++) {
    this.exprs.push(arguments[i])
  }
}
inherits(Debug, _Stmt, {
  render: function render(r) {
    r.putstr("WebAssembly._dump('")
    r.putstr(this.msg)
    r.putstr("'")
    for (var i = 0; i < this.exprs.length; i++) {
      r.putstr(",")
      this.exprs[i].render(r)
    }
    r.putstr(")\n")
  }
})

function Drop(expr) {
  _UnaryStmt.call(this, expr)
}
inherits(Drop, _UnaryStmt, {
  render: function render(r) {
    // XXX TODO: emit only the side-effects of the given expr,
    // but don't actually execute the entire thing?
    r.putstr("void (")
    this.expr.render(r)
    r.putstr(")")
  }
})


function Branch(cf, result) {
  _Stmt.call(this)
  this.cf = cf
  this.result = result
  cf.prepareIncomingBranch(this)
}
inherits(Branch, _Stmt, {
  render: function render(r) {
    this.cf.renderIncomingBranch(r, this.result)
  },

  walkConsumedVariables: function walkConsumedVariables(cb) {
    if (this.result) {
      this.result.walkConsumedVariables(cb)
    }
  }
})


function BranchIf(cond, cf, result) {
  _Stmt.call(this)
  this.cond = cond
  this.cf = cf
  this.result = result
  cf.prepareIncomingBranch(this)
}
inherits(BranchIf, _Stmt, {
  render: function render(r) {
    r.putstr("if (")
    this.cond.render(r)
    r.putstr(") {")
    this.cf.renderIncomingBranch(r, this.result)
    r.putstr("}")
  },

  walkConsumedVariables: function walkConsumedVariables(cb) {
    this.cond.walkConsumedVariables(cb)
    // We do *not* consume variables in the result,
    // they remain on the stack if the condition is false.
  }
})


function BranchTable(expr, default_cf, target_cfs, result) {
  _Stmt.call(this)
  this.expr = expr
  this.default_cf = default_cf
  this.target_cfs = target_cfs
  this.result = result
  default_cf.prepareIncomingBranch(this)
  target_cfs.forEach(function(cf) {
    cf.prepareIncomingBranch(this)
  })
}
inherits(BranchTable, _Stmt, {
  render: function render(r, parent) {
    var self = this
    r.putstr("switch (")
    this.expr.render(r)
    r.putstr(") {\n")
    this.target_cfs.forEach(function(cf, idx) {
      parent.renderIndent(r, 1)
      r.putstr("case ")
      r.putstr(idx)
      r.putstr(": ")
      cf.renderIncomingBranch(r, self.result)
      r.putstr("\n")
    })
    parent.renderIndent(r, 1)
    r.putstr("default: ")
    this.default_cf.renderIncomingBranch(r, this.result)
    r.putstr("\n")
    parent.renderIndent(r)
    r.putstr("}")
  },

  walkConsumedVariables: function walkConsumedVariables(cb) {
    this.expr.walkConsumedVariables(cb)
    if (this.result) {
      this.result.walkConsumedVariables(cb)
    }
  }
})


function _SetVar(type, index, expr) {
  _UnaryStmt.call(this, expr)
  this.type = type
  this.index = index
}
inherits(_SetVar, _UnaryStmt, {
  render: function render(r) {
    switch(this.type) {
      case TYPES.I32:
        r.putstr(this.namePrefix)
        r.putstr("i")
        r.putstr(this.index)
        r.putstr(" = (")
        this.expr.render(r)
        r.putstr(")|0")
        break
      case TYPES.I64:
        r.putstr(this.namePrefix)
        r.putstr("l")
        r.putstr(this.index)
        r.putstr(" = ")
        this.expr.render(r)
        break
      case TYPES.F32:
        r.putstr(this.namePrefix)
        r.putstr("f")
        r.putstr(this.index)
        r.putstr(" = ")
        this.expr.render(r)
        break
      case TYPES.F64:
        r.putstr(this.namePrefix)
        r.putstr("d")
        r.putstr(this.index)
        r.putstr(" = ")
        this.expr.render(r)
        break
      default:
        throw new CompileError("unexpected type for setvar: " + this.type)
    }
  }
})


function SetTempVar(type, index, expr) {
  _SetVar.call(this, type, index, expr)
}
inherits(SetTempVar, _SetVar, {
  namePrefix: "t"
})


function SetLocal(type, index, expr) {
  _SetVar.call(this, type, index, expr)
}
inherits(SetLocal, _SetVar, {
  namePrefix: "l"
})


function SetGlobal(type, index, expr) {
  _SetVar.call(this, type, index, expr)
}
inherits(SetGlobal, _SetVar, {
  namePrefix: "G"
})


function _Store(type, value, addr, offset, size, flags) {
  _Stmt.call(this)
  this.type = type
  this.value = value
  this.addr = addr
  this.offset = offset
  this.flags = flags
}
inherits(_Store, _Stmt, {
  renderUnaligned: function renderUnaligned(r, func) {
    r.putstr(func)
    r.putstr("((")
    this.addr.render(r)
    r.putstr(") + ")
    r.putstr(this.offset)
    r.putstr(",")
    this.value.render(r)
    r.putstr(")")
  },

  renderMaybeAligned: function renderMaybeAligned(r, mask, shift, ta, fallback) { 
    if (! isLittleEndian) {
      this.renderUnaligned(r, fallback)
    } else {
      r.putstr("if (((")
      this.addr.render(r)
      r.putstr(") + ")
      r.putstr(this.offset)
      r.putstr(") & ")
      r.putstr(mask)
      r.putstr(") { ")
      r.putstr(fallback) 
      r.putstr("((")
      this.addr.render(r)
      r.putstr(") + ")
      r.putstr(this.offset)
      r.putstr(",")
      this.value.render(r)
      r.putstr(") } else { ")
      r.putstr(ta)
      r.putstr("[((")
      this.addr.render(r)
      r.putstr(") + ")
      r.putstr(this.offset)
      r.putstr(")>>")
      r.putstr(shift)
      r.putstr("] = ")
      this.value.render(r)
      r.putstr("}")
    }
  },

  walkConsumedVariables: function walkConsumedVariables(cb) {
    this.addr.walkConsumedVariables(cb)
    this.value.walkConsumedVariables(cb)
  }
})

function I32Store(value, addr, offset, flags) {
  _Store.call(this, TYPES.I32, value, addr, offset, 4, flags)
}
inherits(I32Store, _Store, {
  render: function render(r) {
    switch (this.flags) {
      case 0:
      case 1:
        this.renderUnaligned(r, "i32_store_unaligned")
        break
      case 2:
        this.renderMaybeAligned(r, "0x03", "2", "HI32", "i32_store_unaligned")
        break
      default:
        throw new CompileError("unsupported store flags")
    }
  }
})

function F32Store(value, addr, offset, flags) {
  _Store.call(this, TYPES.F32, value, addr, offset, 4, flags)
}
inherits(F32Store, _Store, {
  render: function render(r) {
    switch (this.flags) {
      case 0:
      case 1:
        this.renderUnaligned(r, "f32_store_unaligned")
        break
      case 2:
        this.renderMaybeAligned(r, "0x03", "2", "HF32", "f32_store_unaligned")
        break
      default:
        throw new CompileError("unsupported store flags")
    }
    if (! isNaNPreserving32) {
      r.putstr("; if (f32_isNaN(")
      this.value.render(r)
      r.putstr(")) { f32_store_nan_bitpattern(")
      this.value.render(r)
      r.putstr(",(")
      this.addr.render(r)
      r.putstr(")+")
      r.putstr(this.offset)
      r.putstr(") }")
    }
  }
})

function F64Store(value, addr, offset, flags) {
  _Store.call(this, TYPES.F64, value, addr, offset, 8, flags)
}
inherits(F64Store, _Store, {
  render: function render(r) {
    switch (this.flags) {
      case 0:
      case 1:
      case 2:
        this.renderUnaligned(r, "f64_store_unaligned")
        break
      case 3:
        this.renderMaybeAligned(r, "0x07", "3", "HF64", "f64_store_unaligned")
        break
      default:
        throw new CompileError("unsupported store flags")
    }
    if (! isNaNPreserving64) {
      r.putstr("; if (f64_isNaN(")
      this.value.render(r)
      r.putstr(")) { f64_store_nan_bitpattern(")
      this.value.render(r)
      r.putstr(",(")
      this.addr.render(r)
      r.putstr(")+")
      r.putstr(this.offset)
      r.putstr(") }")
    }
  }
})


function I32Store8(value, addr, offset, flags) {
  _Store.call(this, TYPES.I32, value, addr, offset, 1, flags)
}
inherits(I32Store8, _Store, {
  render: function render(r) {
    switch (this.flags) {
      case 0:
        r.putstr("HU8[(")
        this.addr.render(r)
        r.putstr(")+")
        r.putstr(this.offset)
        r.putstr("] = ")
        this.value.render(r)
        break
      default:
        throw new CompileError("unsupported store flags")
    }
  }
})


function I32Store16(value, addr, offset, flags) {
  _Store.call(this, TYPES.I32, value, addr, offset, 2, flags)
}
inherits(I32Store16, _Store, {
  render: function render(r) {
    switch (this.flags) {
      case 0:
        this.renderUnaligned(r, "i32_store16_unaligned")
        break
      case 1:
        this.renderMaybeAligned(r, "0x01", "1", "HI16", "i32_store16_unaligned")
        break
      default:
        throw new CompileError("unsupported store flags")
    }
  }
})


function Unreachable() {
  _Stmt.call(this)
}
inherits(Unreachable, _Stmt, {
  render: function render(r) {
    r.putstr("trap('unreachable')\n")
  }
})


function TrapConditions(exprs) {
  _Stmt.call(this)
  this.exprs = exprs
}
inherits(TrapConditions, _Stmt, {
  render: function render(r, parent) {
    r.putstr("if (")
    this.exprs[0].render(r)
    r.putstr(") { trap() }")
    for (var i = 1; i < this.exprs.length; i++) {
      r.putstr("\n")
      parent.renderIndent(r)
      r.putstr("if (")
      this.exprs[i].render(r)
      r.putstr(") { trap() }")
    }
  },

  walkConsumedVariables: function walkConsumedVariables(cb) {
    // Trap conditions do not consume any variables,
    // we leave them live for the operations to follow.
  }
})


//
// Finally, and most importantly, we have the complex types of statement
// that form our control structures.  These are the thing that that get
// pushed and popped on the ControlFlowStack while we're translating the
// function code.
//

function ControlFlowStructure(resultType) {
  _Stmt.call(this)
  this.resultType = resultType
  this.branchResultType = resultType
  this.stack = []
  this.statements = []
  this.pendingTrapConditions = []
}
inherits(ControlFlowStructure, _Stmt, {

  initialize: function initialize(index, parent, tempvars) {
    this.index = index
    this.label = "L" + index
    this.isPolymorphic = false
    this.endReached = false
    this.isDead = parent ? parent.isDead : false
    this.tempvars = tempvars
    this.resultVar = null
  },

  getResultVar: function getResultVar() {
    if (this.resultVar === null) {
      if (this.resultType === TYPES.NONE) {
        throw new CompileError("no result var for NONE block")
      }
      this.resultVar = this.acquireTempVar(this.resultType)
    }
    return this.resultVar
  },

  markDeadCode: function markDeadCode() {
    this.isDead = true
    this.isPolymorphic = true
    // If there are unconsumed values on the stack, we have to evaluate them
    // in order to ensure any side-effects are performed.
    for (var i = 0; i < this.stack.length; i++) {
      this._pushStatement(new Drop(this.stack[i]))
    }
    this.stack = []
  },

  addStatement: function addStatement(stmt) {
    this.finalizeTrapConditions()
    this._pushStatement(stmt)
  },

  addTerminalStatement: function addTerminalStatement(stmt) {
    this.finalizeTrapConditions()
    this.markDeadCode()
    this._pushStatement(stmt)
  },

  _pushStatement: function _pushStatement(stmt) {
    var self = this
    // Any tempvars consumed by the statement are now free to be re-used.
    stmt.walkConsumedVariables(function (v) {
      if (v instanceof GetTempVar) {
        self.releaseTempVar(v.type, v.index)
      }
    })
    this.statements.push(stmt)
  },

  pushValue: function pushValue(value) {
    switch (value.type) {
      case TYPES.I32:
      case TYPES.I64:
      case TYPES.F32:
      case TYPES.F64:
        this.stack.push(value)
        break
      case TYPES.UNKNOWN:
        if (! this.isPolymorphic) {
          throw new CompileError("pushing value of unknown type: " + JSON.stringify(value))
        }
        break
      default:
        throw new CompileError("pushing unexpected value: " + JSON.stringify(value))
    }
    return value
  },

  peekType: function peekType() {
    if (this.stack.length === 0) {
      if (! this.isPolymorphic) {
        throw new CompileError("nothing on the stack")
      }
      return TYPES.UNKNOWN
    }
    return this.stack[this.stack.length - 1].type
  },

  peekValue: function peekValue(wantType) {
    if (this.stack.length === 0) {
      if (! this.isPolymorphic) {
        throw new CompileError("nothing on the stack")
      }
      return new Undefined()
    }
    var value = this.stack[this.stack.length - 1]
    wantType = wantType || TYPES.UNKNOWN
    if (wantType !== TYPES.UNKNOWN && value.type !== wantType && value.type !== TYPES.UNKNOWN) {
      if (! this.isPolymorphic) {
        throw new CompileError("Stack type mismatch: expected " + wantType + ", found " + value.type)
      }
      return new Undefined()
    }
    return value
  },

  popValue: function popValue(wantType) {
    if (this.stack.length === 0) {
      if (! this.isPolymorphic) {
        throw new CompileError("nothing on the stack")
      }
      return new Undefined()
    }
    var value = this.stack.pop()
    if (wantType !== TYPES.UNKNOWN && value.type !== wantType && value.type !== TYPES.UNKNOWN) {
      if (! this.isPolymorphic) {
        throw new CompileError("Stack type mismatch: expected " + wantType + ", found " + value.type)
      }
      return new Undefined()
    }
    return value
  },

  spillValue: function spillValue() {
    if (this.stack.length > 0) {
      var value = this.stack[this.stack.length - 1]
      if (! (value instanceof GetTempVar) && ! (value instanceof _Constant)) {
        var varNum = this.acquireTempVar(value.type)
        this._pushStatement(new SetTempVar(value.type, varNum, value))
        this.stack[this.stack.length - 1] = new GetTempVar(value.type, varNum)
      }
      return this.stack[this.stack.length - 1]
    }
  },

  spillAllValues: function spillAllValues() {
    for (var i = 0; i < this.stack.length; i++) {
      var value = this.stack[i]
      if (! (value instanceof GetTempVar) && ! (value instanceof _Constant)) {
        var varNum = this.acquireTempVar(value.type)
        this._pushStatement(new SetTempVar(value.type, varNum, value))
        this.stack[i] = new GetTempVar(value.type, varNum)
      }
    }
  },

  acquireTempVar: function acquireTempVar(typ) {
    var tvs = this.tempvars[typ]
    if (tvs.free.length > 0) {
      return tvs.free.pop()
    }
    return tvs.count++
  },

  releaseTempVar: function releaseTempVar(typ, num) {
    this.tempvars[typ].free.push(num)
  },

  // XXX TODO: this is where we want to try to merge trap conditions,
  // but it's probably going to be complicated.  For example, if we
  // have multiple bounds checks on the same variable, merge them into
  // a single check.
  //
  // I've got two broad ideas, neither of which is implemented yet:
  //
  //  * Avoid emitting trap conditions until the point where we must
  //    observe their side-effects.  Instead, collect them in memory
  //    and coalesce them when possible.
  //
  //  * After emitting a trap condition, maintain information about
  //    what it asserts and use that to avoid redundant future checks.
  //    For example, if we emit a trap condition saying "li0 < 20",
  //    then we should remember that fact until we emit a statement
  //    what will change the value of li0.

  addTrapCondition: function addTrapCondition(expr) {
    this.pendingTrapConditions.push(expr)
  },

  finalizeTrapConditions: function finalizeTrapConditions() {
    if (this.pendingTrapConditions.length > 0) {
      this._pushStatement(new TrapConditions(this.pendingTrapConditions))
      this.pendingTrapConditions = []
    }
  },

  render: function render(r) {
    var self = this
    this.statements.forEach(function(stmt) {
      self.renderIndent(r)
      stmt.render(r, self)
      r.putstr("\n")
    })
  },

  renderIndent: function renderIndent(r, extra) {
    var indent = this.index + 1 + (extra|0)
    while (indent > 0) {
      r.putstr("  ")
      indent--
    }
  },

  markEndOfBlock: function markEndOfBlock() {
    if (! this.isDead) {
      this.finalizeTrapConditions()
      this.endReached = true
      if (this.resultType !== TYPES.NONE) {
        var result = this.popValue(this.resultType)
        this.addStatement(new SetTempVar(this.resultType, this.getResultVar(), result))
      }
      if (this.stack.length > 0) {
        throw new CompileError("block left extra values on the stack")
      }
    }
  },

  switchToElseBranch: function switchToElseBranch() {
    throw new CompileError("mis-placed ELSE")
  },

  prepareIncomingBranch: function prepareIncomingBranch(stmt) {
    this.endReached = true
  }
})

// Function Body

function FunctionBody(resultType) {
  ControlFlowStructure.call(this, resultType)
  this.returnValue = null
}
inherits(FunctionBody, ControlFlowStructure, {

  markEndOfBlock: function markEndOfBlock() {
    if (! this.isDead) {
      this.finalizeTrapConditions()
      this.endReached = true
      if (this.resultType !== TYPES.NONE) {
        this.returnValue = this.popValue(this.resultType)
      }
      if (this.stack.length > 0) {
         throw new CompileError("function left extra values on the stack")
      }
    }
  },

  render: function render(r) {
    ControlFlowStructure.prototype.render.call(this, r)
    if (this.resultType !== TYPES.NONE && ! this.isDead) {
      this.renderIndent(r)
      r.putstr("return ")
      this.returnValue.render(r)
      r.putstr("\n")
    }
  },

  renderIncomingBranch: function renderIncomingBranch(r, result) {
    r.putstr("return")
    if (this.branchResultType !== TYPES.NONE) {
      r.putstr(" ")
      result.render(r)
    }
  }
})


// Loop

function Loop(resultType) {
  ControlFlowStructure.call(this, resultType)
  this.branchResultType = TYPES.NONE
}
inherits(Loop, ControlFlowStructure, {
  render: function render(r) {
    r.putstr(this.label)
    r.putstr(": while(1) {\n")
    ControlFlowStructure.prototype.render.call(this, r)
    this.renderIndent(r)
    r.putstr("break")
    this.renderIndent(r, -1)
    r.putstr("}")
  },

  renderIncomingBranch: function renderIncomingBranch(r, result) {
    if (result) {
      throw new CompileError("cant branch to Loop with a result")
    }
    r.putstr("continue ")
    r.putstr(this.label)
  }
})


// Block

function Block(resultType) {
  ControlFlowStructure.call(this, resultType)
}
inherits(Block, ControlFlowStructure, {
  render: function render(r) {
    r.putstr(this.label)
    r.putstr(": do {\n")
    ControlFlowStructure.prototype.render.call(this, r)
    this.renderIndent(r, -1)
    r.putstr("} while(0)")
  },

  prepareIncomingBranch: function prepareIncomingBranch(stmt) {
    if (this.branchResultType !== TYPES.NONE) {
      this.getResultVar()
    }
    ControlFlowStructure.prototype.prepareIncomingBranch.call(this, stmt)
  },

  renderIncomingBranch: function renderIncomingBranch(r, result) {
    if (this.branchResultType !== TYPES.NONE) {
      var stmt = new SetTempVar(this.resultType, this.getResultVar(), result)
      stmt.render(r)
      r.putstr("; ")
    }
    r.putstr("break ")
    r.putstr(this.label)
  }
})

// IfElse

function IfElse(resultType, condExpr) {
  ControlFlowStructure.call(this, resultType)
  this.condExpr = condExpr
  this.trueBranch = this.statements
  this.elseBranch = []
  this.startedOutDead = false
  this.trueBranchGoesDead = false
  this.elseBranchGoesDead = false
}
inherits(IfElse, Block, {

  initialize: function initialize(index, parent, tempvars) {
    ControlFlowStructure.prototype.initialize.call(this, index, parent, tempvars)
    this.startedOutDead = this.isDead
  },

  switchToElseBranch: function switchToElseBranch() {
    Block.prototype.markEndOfBlock.call(this)
    this.trueBranchGoesDead = this.isDead
    this.isDead = this.startedOutDead
    this.isPolymorphic = false
    this.statements = this.elseBranch
  },

  markEndOfBlock: function markEndOfBlock() {
    Block.prototype.markEndOfBlock.call(this)
    if (this.statements === this.elseBranch) {
      this.elseBranchGoesDead = this.isDead
      this.isDead = this.trueBranchGoesDead && this.elseBranchGoesDead
    } else {
      this.endReached = true
      this.isDead = this.startedOutDead
    }
  },

  render: function render(r) {
    r.putstr("if (")
    this.condExpr.render(r)
    r.putstr(") { ")
    this.statements = this.trueBranch
    Block.prototype.render.call(this, r)
    if (this.elseBranch.length > 0) {
      r.putstr("} else { ")
      this.statements = this.elseBranch
      Block.prototype.render.call(this, r)
    }
    r.putstr(" }")
  }
})