cStubsHelperFunctions.scala 5.71 KB
Newer Older
1 2 3 4 5 6 7 8
package uvm.refimpl.nat

import com.kenai.jffi.CallingConvention
import com.kenai.jffi.Closure
import com.kenai.jffi.Closure.Buffer
import com.kenai.jffi.{ Type => JType }

import CDefsHelperFunctions._
9
import NativeSupport._
Kunshan Wang's avatar
Kunshan Wang committed
10 11
import uvm.comminsts.CommInst
import uvm.comminsts.CommInsts
12 13 14
import uvm.ir.irbuilder.IRBuilder
import uvm.refimpl._
import uvm.refimpl.MicroVM
15
import uvm.ssavariables.{ AtomicRMWOptr, MemoryOrder }
16
import uvm.ssavariables.BinOpStatus
17
import uvm.ssavariables.Flag
18

Kunshan Wang's avatar
Kunshan Wang committed
19 20
class ExposedMethod(name: String, jRetTy: JType, jParamTys: Array[JType], invokeFunc: Buffer => Unit) {
  val closure = new SimpleClosure(name, invokeFunc)
21 22 23 24
  val handle = jffiClosureManager.newClosure(closure, jRetTy, jParamTys, CallingConvention.DEFAULT)
  def address = handle.getAddress()
}

Kunshan Wang's avatar
Kunshan Wang committed
25 26 27 28 29 30 31 32 33 34
class SimpleClosure(name: String, f: Buffer => Unit) extends Closure {
  def invoke(buffer: Buffer): Unit = try {
    f(buffer)
  } catch {
    case t: Throwable => {
      MuErrorNumber.setMuError(MuErrorNumber.MU_NATIVE_ERRNO)
      NativeClientSupport.logger.error(
          "Error thrown in Mu while native is calling %s. This is fatal.".format(name), t)
    }
  }
35 36 37
}

private object CDefsHelperFunctions {
38
  import NativeClientSupport._
Kunshan Wang's avatar
Kunshan Wang committed
39
  import NativeMemoryAccessHelper._
40

Kunshan Wang's avatar
Kunshan Wang committed
41 42
  def exposedMethod(name: String, jRetTy: JType, jParamTys: Array[JType])(invokeFunc: Buffer => Unit) = {
    new ExposedMethod(name: String, jRetTy, jParamTys, invokeFunc)
43
  }
Kunshan Wang's avatar
Kunshan Wang committed
44 45 46 47 48 49
  
  def readMuIDOptional(id: MuID): Option[MuID] = {
    if (id == 0) None else Some(id)
  }
  
  def readMuIDArray(base: Long, len: Long): IndexedSeq[MuID] = readIntArray(base, len)
50 51 52 53

  def readMuValueArray(base: Long, len: Long): IndexedSeq[MuValue] = {
    readLongArray(base, len).map(getMuValueNotNull)
  }
54

55
  def readFlagArray(base: Long, len: Long): IndexedSeq[Flag] = {
Kunshan Wang's avatar
Kunshan Wang committed
56
    readIntArray(base, len).map(toCallConv)
57
  }
58 59 60 61
  
  def intToBoolean(v: Int): Boolean = v != 0
  def booleanToInt(v: Boolean): Int = if (v) 1 else 0
  
Kunshan Wang's avatar
Kunshan Wang committed
62 63
  def toMuFlag(cc: Int): MuFlag = cc
  def toCallConv(cc: Int): Flag = cc match {
64
    case 0x00 => Flag("#DEFAULT")
Kunshan Wang's avatar
Kunshan Wang committed
65
    case _    => throw new IllegalArgumentException("Unknown calling convention %d (0x%x)".format(cc, cc))
66
  }
Kunshan Wang's avatar
Kunshan Wang committed
67 68
  
  def toCommInst(ci: Int): CommInst = CommInsts(ci)
69

70 71
  
  def toBinOpStatus(s: MuBinOpStatus): BinOpStatus = s
72 73 74 75 76 77

  implicit class RichMuVM(val mvm: MicroVM) extends AnyVal {
    def setTrapHandler(trap_handler: MuTrapHandlerFP, userdata: MuCPtr): Unit = {
      mvm.setTrapHandler(new NativeTrapHandler(trap_handler, userdata))
    }

Kunshan Wang's avatar
Kunshan Wang committed
78
    def getMuErrorPtr(): MuCPtr = MuErrorNumber.muErrorPtr.address()
79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130
  }

  implicit class RichMuCtx(val ctx: MuCtx) extends AnyVal {
    def handleFromSInt8(num: Byte, len: Int): MuIntValue = ctx.handleFromInt(num, len)
    def handleFromUInt8(num: Byte, len: Int): MuIntValue = ctx.handleFromInt(BigInt(num) & 0xff, len)
    def handleFromSInt16(num: Short, len: Int): MuIntValue = ctx.handleFromInt(num, len)
    def handleFromUInt16(num: Short, len: Int): MuIntValue = ctx.handleFromInt(BigInt(num) & 0xffff, len)
    def handleFromSInt32(num: Int, len: Int): MuIntValue = ctx.handleFromInt(num, len)
    def handleFromUInt32(num: Int, len: Int): MuIntValue = ctx.handleFromInt(BigInt(num) & 0xffffffff, len)
    def handleFromSInt64(num: Long, len: Int): MuIntValue = ctx.handleFromInt(num, len)
    def handleFromUInt64(num: Long, len: Int): MuIntValue = ctx.handleFromInt(BigInt(num) & 0xffffffffffffffffL, len)
    def handleFromUInt64s(nums: IndexedSeq[Long], len: Int): MuIntValue = {
      val bigNum = unsignedLongSeqToBigInt(nums)
      ctx.handleFromInt(bigNum, len)
    }
    def handleToSInt8(h: MuIntValue): Byte = ctx.handleToSInt(h).toByte
    def handleToUInt8(h: MuIntValue): Byte = ctx.handleToUInt(h).toByte
    def handleToSInt16(h: MuIntValue): Short = ctx.handleToSInt(h).toShort
    def handleToUInt16(h: MuIntValue): Short = ctx.handleToUInt(h).toShort
    def handleToSInt32(h: MuIntValue): Int = ctx.handleToSInt(h).toInt
    def handleToUInt32(h: MuIntValue): Int = ctx.handleToUInt(h).toInt
    def handleToSInt64(h: MuIntValue): Long = ctx.handleToSInt(h).toLong
    def handleToUInt64(h: MuIntValue): Long = ctx.handleToUInt(h).toLong

    def cmpxchg(ordSucc: MemoryOrder.Value, ordFail: MemoryOrder.Value, weak: Boolean,
      loc: MuIRefValue, expected: MuValue, desired: MuValue, is_succ: IntPtr): MuValue = {
      val (v, s) = ctx.cmpXchg(ordSucc, ordFail, weak, loc, expected, desired)
      val sInt = if (s) 1 else 0
      theMemory.putInt(is_succ, sInt)
      v
    }

    def atomicrmw(ord: MemoryOrder.Value, op: AtomicRMWOptr.Value, loc: MuIRefValue, opnd: MuValue): MuValue = {
      ctx.atomicRMW(ord, op, loc, opnd)
    }

    def newThreadNor(stack: MuStackRefValue, threadLocal: Option[MuRefValue], vals: Seq[MuValue]): MuThreadRefValue = {
      ctx.newThread(stack, threadLocal, HowToResume.PassValues(vals))
    }

    def newThreadExc(stack: MuStackRefValue, threadLocal: Option[MuRefValue], exc: MuRefValue): MuThreadRefValue = {
      ctx.newThread(stack, threadLocal, HowToResume.ThrowExc(exc))
    }

    def dumpKeepalives(cursor: MuFCRefValue, results: MuValueFakArrayPtr): Unit = {
      val kas = ctx.dumpKeepalives(cursor)
      for ((ka, i) <- kas.zipWithIndex) {
        val fak = exposeMuValue(ctx, ka)
        val addr = results + i * WORD_SIZE_BYTES
        theMemory.putAddress(addr, fak)
      }
    }
Kunshan Wang's avatar
Kunshan Wang committed
131 132 133 134
  }
  
  implicit class RichMuIRBuilder(val b: IRBuilder) extends AnyVal {
    def newConstIntEx(id: MuID, ty: MuID, values: Seq[Long]): Unit = {
135
      val bigNum = unsignedLongSeqToBigInt(values)
Kunshan Wang's avatar
Kunshan Wang committed
136
      b.newConstInt(id, ty, bigNum)
137 138 139 140
    }
  }
  
  implicit def makeMuValueSeqCovariant[T <: MuValue, U <: T](seq: Seq[T]): Seq[U] = seq.asInstanceOf[Seq[U]]
Kunshan Wang's avatar
Kunshan Wang committed
141
  implicit def muValueAutoCast[T <: MuValue, U <: T](v: T): U = v.asInstanceOf[U]
142

143
}