operationHelpers.scala 25.6 KB
Newer Older
Kunshan Wang's avatar
Kunshan Wang committed
1 2
package uvm.refimpl.itpr

3 4
import java.nio.charset.Charset

Kunshan Wang's avatar
Kunshan Wang committed
5
import uvm.refimpl._
6
import uvm.refimpl.mem.MemorySupport
7 8 9 10 11 12
import uvm.refimpl.mem.Mutator
import uvm.refimpl.mem.TypeSizes._
import uvm.refimpl.mem.TypeSizes
import uvm.ssavariables._
import uvm.ssavariables.AtomicRMWOptr._
import uvm.types._
Kunshan Wang's avatar
Kunshan Wang committed
13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

object OpHelper {

  val ONE = BigInt(1)

  def mask(n: Int): BigInt = {
    (ONE << n) - ONE
  }

  def truncFromBigInt(n: BigInt, len: Int): BigInt = n & mask(len)

  def zextToBigInt(n: BigInt, len: Int): BigInt = n & mask(len)

  def sextToBigInt(n: BigInt, len: Int): BigInt = {
    val bit = n.testBit(len - 1)
    if (bit) {
      n | (~mask(len - 1))
    } else {
      n & (mask(len - 1))
    }
  }

35 36 37 38 39
  // The BigInt in a BoxInt is always truncated to len bits.
  //
  // "prepare" means sign- or zero-extend the content to get the real math value.
  // "unprepare" means truncating a math value to len bits to be stored in a BoxInt.

Kunshan Wang's avatar
Kunshan Wang committed
40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96
  def prepareUnsigned(n: BigInt, len: Int): BigInt = truncFromBigInt(n, len)

  def prepareSigned(n: BigInt, len: Int): BigInt = {
    sextToBigInt(truncFromBigInt(n, len), len)
  }

  def unprepare(n: BigInt, len: Int): BigInt = truncFromBigInt(n, len)

  def trunc(n: BigInt, toLen: Int): BigInt = truncFromBigInt(n, toLen)

  def zext(n: BigInt, fromLen: Int, toLen: Int): BigInt = truncFromBigInt(n, fromLen)

  def sext(n: BigInt, fromLen: Int, toLen: Int): BigInt = {
    truncFromBigInt(sextToBigInt(n, fromLen), toLen)
  }

  def maxSInt(l: Int): BigInt = (BigInt(1) << (l - 1)) - 1
  def minSIntAbs(l: Int): BigInt = BigInt(1) << (l - 1)
  def maxUInt(l: Int): BigInt = (BigInt(1) << l) - 1

  /**
   * Convert a float to an integer. The result only has the lowest iLen binary digits.
   */
  def floatToI(n: Float, iLen: Int, signed: Boolean): BigInt = {
    val lExp = Math.getExponent(n)
    val rExp = lExp - 23
    val frac = (java.lang.Float.floatToRawIntBits(n) & 0x7fffff) | 0x800000;

    if (java.lang.Float.isNaN(n)) 0
    else if (signed) {
      if (java.lang.Float.isInfinite(n)) { if (n > 0.0F) maxSInt(iLen) else minSIntAbs(iLen) }
      else {
        if (lExp >= (iLen - 1)) if (n > 0.0F) maxSInt(iLen) else minSIntAbs(iLen)
        else if (lExp < 0) 0
        else {
          val abs = BigInt(frac) << rExp
          unprepare(if (n < 0.0F) -abs else abs, iLen)
        }
      }
    } else {
      if (n < 0.0F) 0
      else if (java.lang.Float.isInfinite(n)) maxUInt(iLen)
      else {
        if (lExp >= iLen) maxUInt(iLen)
        else if (lExp < 0) 0
        else unprepare(BigInt(frac) << rExp, iLen)
      }
    }
  }

  /**
   * Convert a float to an integer. The result only has the lowest iLen binary digits.
   */
  def doubleToI(n: Double, iLen: Int, signed: Boolean): BigInt = {
    val lExp = Math.getExponent(n)
    val rExp = lExp - 52
    val frac = (java.lang.Double.doubleToRawLongBits(n) & 0xfffffffffffffL) | 0x10000000000000L;
97

Kunshan Wang's avatar
Kunshan Wang committed
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 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184
    if (java.lang.Double.isNaN(n)) 0
    else if (signed) {
      if (java.lang.Double.isInfinite(n)) { if (n > 0.0D) maxSInt(iLen) else minSIntAbs(iLen) }
      else {
        if (lExp >= (iLen - 1)) if (n > 0.0D) maxSInt(iLen) else minSIntAbs(iLen)
        else if (lExp < 0) 0
        else {
          val abs = BigInt(frac) << rExp
          unprepare(if (n < 0.0D) -abs else abs, iLen)
        }
      }
    } else {
      if (n < 0.0D) 0
      else if (java.lang.Double.isInfinite(n)) maxUInt(iLen)
      else {
        if (lExp >= iLen) maxUInt(iLen)
        else if (lExp < 0) 0
        else unprepare(BigInt(frac) << rExp, iLen)
      }
    }
  }

  def tr64IsInt(opnd: Long): Boolean = {
    (opnd & 0x7ff0000000000001L) == 0x7ff0000000000001L
  }

  def tr64IsFp(opnd: Long): Boolean = {
    (opnd & 0x7ff0000000000001L) != 0x7ff0000000000001L &&
      (opnd & 0x7ff0000000000003L) != 0x7ff0000000000002L
  }

  def tr64IsRef(opnd: Long): Boolean = {
    (opnd & 0x7ff0000000000003L) == 0x7ff0000000000002L
  }

  def intToTr64(opnd: Long): Long = {
    (0x7ff0000000000001L | ((opnd & 0x7ffffffffffffL) << 1) |
      ((opnd & 0x8000000000000L) << 12))
  }

  def fpToTr64(opnd: Double): Long = {
    var bits = java.lang.Double.doubleToRawLongBits(opnd)
    if (java.lang.Double.isNaN(opnd)) {
      bits = bits & 0xfff8000000000000L | 0x0000000000000008L
    }
    bits
  }

  def refToTr64(opnd: Long, tag: Long): Long = {
    (0x7ff0000000000002L | (opnd & 0x7ffffffffff8L) | ((opnd & 0x800000000000L) << 16) |
      ((tag & 0x3eL) << 46) |
      ((tag & 0x1) << 2))
  }

  def tr64ToInt(opnd: Long): Long = {
    (((opnd & 0xffffffffffffeL) >> 1) | ((opnd & 0x8000000000000000L) >> 12) & (1L << 51))
  }

  def tr64ToFp(opnd: Long): Double = java.lang.Double.longBitsToDouble(opnd)

  def tr64ToRef(opnd: Long): Long = {
    ((opnd & 0x7ffffffffff8L) |
      (((~(((opnd & 0x8000000000000000L) << 1) - 1)) >> 17) &
        0xffff800000000000L))
  }

  def tr64ToTag(opnd: Long): Long = {
    (((opnd & 0x000f800000000000L) >> 46) | ((opnd & 0x4) >> 2))
  }
}

object PrimOpHelpers {
  @throws(classOf[UvmDivisionByZeroException])
  def intBinOp(op: BinOptr.BinOptr, l: Int, op1v: BigInt, op2v: BigInt, ctx: => String): BigInt = {
    def pu(v: BigInt): BigInt = OpHelper.prepareUnsigned(v, l)
    def ps(v: BigInt): BigInt = OpHelper.prepareSigned(v, l)
    def up(v: BigInt): BigInt = OpHelper.unprepare(v, l)
    def shiftMask = {
      var i = 1
      while (i < l) { i <<= 1 }
      i - 1
    }
    def checkDivByZero(): Unit = {
      if (op2v == 0) throw new UvmDivisionByZeroException(ctx + "Division by zero.")
    }

    up(op match {
185 186 187
      case BinOptr.ADD  => pu(op1v) + pu(op2v)
      case BinOptr.SUB  => pu(op1v) - pu(op2v)
      case BinOptr.MUL  => pu(op1v) * pu(op2v)
Kunshan Wang's avatar
Kunshan Wang committed
188 189 190 191
      case BinOptr.UDIV => { checkDivByZero(); pu(op1v) / pu(op2v) }
      case BinOptr.SDIV => { checkDivByZero(); ps(op1v) / ps(op2v) }
      case BinOptr.UREM => { checkDivByZero(); pu(op1v) % pu(op2v) }
      case BinOptr.SREM => { checkDivByZero(); ps(op1v) % ps(op2v) }
192
      case BinOptr.SHL  => pu(op1v) << (op2v.intValue & shiftMask)
Kunshan Wang's avatar
Kunshan Wang committed
193 194
      case BinOptr.LSHR => pu(op1v) >> (op2v.intValue & shiftMask)
      case BinOptr.ASHR => ps(op1v) >> (op2v.intValue & shiftMask)
195 196 197 198
      case BinOptr.AND  => pu(op1v) & pu(op2v)
      case BinOptr.OR   => pu(op1v) | pu(op2v)
      case BinOptr.XOR  => pu(op1v) ^ pu(op2v)
      case _            => throw new UvmRuntimeException(ctx + "Binary operator %s is not suitable for integer.".format(op))
Kunshan Wang's avatar
Kunshan Wang committed
199 200 201 202 203 204 205 206 207 208
    })
  }

  def floatBinOp(op: BinOptr.BinOptr, op1v: Float, op2v: Float, ctx: => String): Float = {
    op match {
      case BinOptr.FADD => op1v + op2v
      case BinOptr.FSUB => op1v - op2v
      case BinOptr.FMUL => op1v * op2v
      case BinOptr.FDIV => op1v / op2v
      case BinOptr.FREM => Math.IEEEremainder(op1v, op2v).toFloat
209
      case _            => throw new UvmRuntimeException(ctx + "Binary operator %s is not suitable for float.".format(op))
Kunshan Wang's avatar
Kunshan Wang committed
210 211 212 213 214 215 216 217 218 219
    }
  }

  def doubleBinOp(op: BinOptr.BinOptr, op1v: Double, op2v: Double, ctx: => String): Double = {
    op match {
      case BinOptr.FADD => op1v + op2v
      case BinOptr.FSUB => op1v - op2v
      case BinOptr.FMUL => op1v * op2v
      case BinOptr.FDIV => op1v / op2v
      case BinOptr.FREM => Math.IEEEremainder(op1v, op2v)
220
      case _            => throw new UvmRuntimeException(ctx + "Binary operator %s is not suitable for double.".format(op))
Kunshan Wang's avatar
Kunshan Wang committed
221 222 223 224 225 226 227 228
    }
  }

  def intCmp(op: CmpOptr.CmpOptr, l: Int, op1v: BigInt, op2v: BigInt, ctx: => String): Boolean = {
    def pu(v: BigInt): BigInt = OpHelper.prepareUnsigned(v, l)
    def ps(v: BigInt): BigInt = OpHelper.prepareSigned(v, l)

    op match {
229 230
      case CmpOptr.EQ  => pu(op1v) == pu(op2v)
      case CmpOptr.NE  => pu(op1v) != pu(op2v)
Kunshan Wang's avatar
Kunshan Wang committed
231 232 233 234 235 236 237 238
      case CmpOptr.UGT => pu(op1v) > pu(op2v)
      case CmpOptr.UGE => pu(op1v) >= pu(op2v)
      case CmpOptr.ULT => pu(op1v) < pu(op2v)
      case CmpOptr.ULE => pu(op1v) <= pu(op2v)
      case CmpOptr.SGT => ps(op1v) > ps(op2v)
      case CmpOptr.SGE => ps(op1v) >= ps(op2v)
      case CmpOptr.SLT => ps(op1v) < ps(op2v)
      case CmpOptr.SLE => ps(op1v) <= ps(op2v)
239
      case _           => throw new UvmRuntimeException(ctx + "Comparison operator %s not suitable for integers".format(op))
Kunshan Wang's avatar
Kunshan Wang committed
240 241 242 243 244 245 246 247
    }
  }

  def floatCmp(op: CmpOptr.CmpOptr, op1v: Float, op2v: Float, ctx: => String): Boolean = {
    import java.lang.Float.isNaN
    def ord = !isNaN(op1v) && !isNaN(op2v)
    def uno = isNaN(op1v) || isNaN(op2v)
    op match {
248
      case CmpOptr.FTRUE  => true
Kunshan Wang's avatar
Kunshan Wang committed
249
      case CmpOptr.FFALSE => false
250 251 252 253 254 255 256 257 258 259 260 261 262 263 264
      case CmpOptr.FOEQ   => ord && op1v == op2v
      case CmpOptr.FONE   => ord && op1v != op2v
      case CmpOptr.FOGT   => ord && op1v > op2v
      case CmpOptr.FOGE   => ord && op1v >= op2v
      case CmpOptr.FOLT   => ord && op1v < op2v
      case CmpOptr.FOLE   => ord && op1v <= op2v
      case CmpOptr.FORD   => ord
      case CmpOptr.FUEQ   => uno || op1v == op2v
      case CmpOptr.FUNE   => uno || op1v != op2v
      case CmpOptr.FUGT   => uno || op1v > op2v
      case CmpOptr.FUGE   => uno || op1v >= op2v
      case CmpOptr.FULT   => uno || op1v < op2v
      case CmpOptr.FULE   => uno || op1v <= op2v
      case CmpOptr.FUNO   => uno
      case _              => throw new UvmRuntimeException(ctx + "Comparison operator %s is not suitable for float.".format(op))
Kunshan Wang's avatar
Kunshan Wang committed
265 266 267 268 269 270 271 272
    }
  }

  def doubleCmp(op: CmpOptr.CmpOptr, op1v: Double, op2v: Double, ctx: => String): Boolean = {
    import java.lang.Double.isNaN
    def ord = !isNaN(op1v) && !isNaN(op2v)
    def uno = isNaN(op1v) || isNaN(op2v)
    op match {
273
      case CmpOptr.FTRUE  => true
Kunshan Wang's avatar
Kunshan Wang committed
274
      case CmpOptr.FFALSE => false
275 276 277 278 279 280 281 282 283 284 285 286 287 288 289
      case CmpOptr.FOEQ   => ord && op1v == op2v
      case CmpOptr.FONE   => ord && op1v != op2v
      case CmpOptr.FOGT   => ord && op1v > op2v
      case CmpOptr.FOGE   => ord && op1v >= op2v
      case CmpOptr.FOLT   => ord && op1v < op2v
      case CmpOptr.FOLE   => ord && op1v <= op2v
      case CmpOptr.FORD   => ord
      case CmpOptr.FUEQ   => uno || op1v == op2v
      case CmpOptr.FUNE   => uno || op1v != op2v
      case CmpOptr.FUGT   => uno || op1v > op2v
      case CmpOptr.FUGE   => uno || op1v >= op2v
      case CmpOptr.FULT   => uno || op1v < op2v
      case CmpOptr.FULE   => uno || op1v <= op2v
      case CmpOptr.FUNO   => uno
      case _              => throw new UvmRuntimeException(ctx + "Comparison operator %s is not suitable for double.".format(op))
Kunshan Wang's avatar
Kunshan Wang committed
290 291
    }
  }
292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326

  def refCmp(op: CmpOptr.CmpOptr, op1v: Word, op2v: Word, ctx: => String): Boolean = {
    op match {
      case CmpOptr.EQ => op1v == op2v
      case CmpOptr.NE => op1v != op2v
      case _          => throw new UvmRuntimeException(ctx + "Comparison operator %s is not suitable for ref.".format(op))
    }
  }

  def irefCmp(op: CmpOptr.CmpOptr, op1b: Word, op1o: Word, op2b: Word, op2o: Word, ctx: => String): Boolean = {
    val a1 = op1b + op1o
    val a2 = op2b + op2o

    def warnDiffObj() = if (op1b != op2b) throw new UvmRuntimeException(
      ctx + "Attempt to compare order of irefs in two different objects. lhs: 0x%x+0x%x rhs: 0x%x+0x%x".format(
        op1b, op1o, op2b, op2o))

    op match {
      case CmpOptr.EQ  => a1 == a2
      case CmpOptr.NE  => a1 != a2
      case CmpOptr.ULT => { warnDiffObj(); a1 < a2 }
      case CmpOptr.ULE => { warnDiffObj(); a1 <= a2 }
      case CmpOptr.UGT => { warnDiffObj(); a1 > a2 }
      case CmpOptr.UGE => { warnDiffObj(); a1 >= a2 }
      case _           => throw new UvmRuntimeException(ctx + "Comparison operator %s is not suitable for iref.".format(op))
    }
  }

  def objCmp[T <: AnyRef](op: CmpOptr.CmpOptr, obj1: T, obj2: T, kind: String, ctx: => String): Boolean = {
    op match {
      case CmpOptr.EQ => obj1 eq obj2
      case CmpOptr.NE => obj1 ne obj2
      case _          => throw new UvmRuntimeException(ctx + "Comparison operator %s is not suitable for %s.".format(op, kind))
    }
  }
Kunshan Wang's avatar
Kunshan Wang committed
327
}
Kunshan Wang's avatar
Kunshan Wang committed
328

329
object MemoryOperations {
330 331 332 333 334 335 336 337 338

  def addressOf(ptr: Boolean, vb: ValueBox): Word = {
    if (ptr) {
      vb.asInstanceOf[BoxPointer].addr
    } else {
      val lb = vb.asInstanceOf[BoxIRef]
      lb.objRef + lb.offset
    }
  }
339

340 341 342 343 344 345 346
  def noAccessViaPointer(ptr: Boolean, ty: Type) {
    if (ptr) {
      throw new UvmIllegalMemoryAccessException("Cannot access type %s via pointer".format(ty.repr))
    }
  }

  def load(ptr: Boolean, ty: Type, loc: Word, br: ValueBox)(implicit microVM: MicroVM, memorySupport: MemorySupport): Unit = {
347 348 349
    def loadScalar(ty: Type, loc: Word, br: ValueBox): Unit = ty match {
      case TypeInt(l) =>
        val bi: BigInt = l match {
350 351 352 353
          case 8  => memorySupport.loadByte(loc, !ptr)
          case 16 => memorySupport.loadShort(loc, !ptr)
          case 32 => memorySupport.loadInt(loc, !ptr)
          case 64 => memorySupport.loadLong(loc, !ptr)
Kunshan Wang's avatar
Kunshan Wang committed
354 355 356 357 358
          case 128 => {
            val lowWord = memorySupport.loadLong(loc, !ptr)
            val highWord = memorySupport.loadLong(loc + 8, !ptr)
            (BigInt(highWord) << 64) + lowWord
          }
359
          case _ => throw new UvmUnimplementedOperationException("Loading int of length %d is not supported".format(l))
360 361 362
        }
        br.asInstanceOf[BoxInt].value = OpHelper.unprepare(bi, l)
      case _: TypeFloat =>
363
        val fv = memorySupport.loadFloat(loc, !ptr)
364 365
        br.asInstanceOf[BoxFloat].value = fv
      case _: TypeDouble =>
366
        val dv = memorySupport.loadDouble(loc, !ptr)
367 368
        br.asInstanceOf[BoxDouble].value = dv
      case _: TypeRef =>
369
        noAccessViaPointer(ptr, ty)
370
        val addr = memorySupport.loadLong(loc)
371 372
        br.asInstanceOf[BoxRef].objRef = addr
      case _: TypeIRef =>
373
        noAccessViaPointer(ptr, ty)
374 375
        val base = memorySupport.loadLong(loc)
        val offset = memorySupport.loadLong(loc + WORD_SIZE_BYTES)
376
        br.asInstanceOf[BoxIRef].oo = (base, offset)
377
      case _: TypeFuncRef =>
378
        noAccessViaPointer(ptr, ty)
379
        val fid = memorySupport.loadLong(loc).toInt
380 381
        val func = microVM.globalBundle.funcNs.get(fid)
        br.asInstanceOf[BoxFunc].func = func
382
      case _: TypeThreadRef =>
383
        noAccessViaPointer(ptr, ty)
384
        val tid = memorySupport.loadLong(loc).toInt
Kunshan Wang's avatar
Kunshan Wang committed
385
        val thr = microVM.threadStackManager.threadRegistry.get(tid)
386
        br.asInstanceOf[BoxThread].thread = thr
387
      case _: TypeStackRef =>
388
        noAccessViaPointer(ptr, ty)
389
        val sid = memorySupport.loadLong(loc).toInt
Kunshan Wang's avatar
Kunshan Wang committed
390
        val sta = microVM.threadStackManager.stackRegistry.get(sid)
391 392
        br.asInstanceOf[BoxStack].stack = sta
      case _: TypeTagRef64 =>
393
        noAccessViaPointer(ptr, ty)
394
        val raw = memorySupport.loadLong(loc)
395
        br.asInstanceOf[BoxTagRef64].raw = raw
396
      case _: TypeUPtr | _: TypeUFuncPtr =>
397 398
        val addr = memorySupport.loadLong(loc, !ptr)
        br.asInstanceOf[BoxPointer].addr = addr
399
      case _ => throw new UvmUnimplementedOperationException("Loading of type %s is not supporing".format(ty.getClass.getName))
400 401 402 403
    }

    ty match {
      case TypeVector(ety, len) =>
Kunshan Wang's avatar
Kunshan Wang committed
404
        val brs = br.asInstanceOf[BoxSeq].values
405 406 407 408 409 410 411 412
        val elemSkip = alignUp(sizeOf(ety), alignOf(ety))
        for ((brElem, i) <- brs.zipWithIndex) {
          loadScalar(ety, loc + elemSkip * i, brElem)
        }
      case sty => loadScalar(sty, loc, br)
    }
  }

Kunshan Wang's avatar
Kunshan Wang committed
413 414
  def store(ptr: Boolean, ty: Type, loc: Word, nvb: ValueBox)(implicit memorySupport: MemorySupport): Unit = {
    def storeScalar(ty: Type, loc: Word, nvb: ValueBox): Unit = ty match {
415 416 417
      case TypeInt(l) =>
        val bi = nvb.asInstanceOf[BoxInt].value
        l match {
418 419 420 421
          case 8  => memorySupport.storeByte(loc, bi.byteValue, !ptr)
          case 16 => memorySupport.storeShort(loc, bi.shortValue, !ptr)
          case 32 => memorySupport.storeInt(loc, bi.intValue, !ptr)
          case 64 => memorySupport.storeLong(loc, bi.longValue, !ptr)
Kunshan Wang's avatar
Kunshan Wang committed
422 423 424 425
          case 128 => {
            memorySupport.storeLong(loc, (bi & 0xffffffffffffffffL).longValue, !ptr)
            memorySupport.storeLong(loc + 8, (bi >> 64).longValue, !ptr)
          }
426
          case _ => throw new UvmUnimplementedOperationException("Storing int of length %d is not supported".format(l))
427 428 429
        }
      case _: TypeFloat =>
        val fv = nvb.asInstanceOf[BoxFloat].value
430
        memorySupport.storeFloat(loc, fv, !ptr)
431 432
      case _: TypeDouble =>
        val dv = nvb.asInstanceOf[BoxDouble].value
433
        memorySupport.storeDouble(loc, dv, !ptr)
434
      case _: TypeRef =>
435
        noAccessViaPointer(ptr, ty)
436
        val addr = nvb.asInstanceOf[BoxRef].objRef
437
        memorySupport.storeLong(loc, addr)
438
      case _: TypeIRef =>
439
        noAccessViaPointer(ptr, ty)
440
        val BoxIRef(base, offset) = nvb.asInstanceOf[BoxIRef]
441 442
        memorySupport.storeLong(loc, base)
        memorySupport.storeLong(loc + WORD_SIZE_BYTES, offset)
443
      case _: TypeFuncRef =>
444
        noAccessViaPointer(ptr, ty)
445
        val fid = nvb.asInstanceOf[BoxFunc].func.map(_.id).getOrElse(0)
446
        memorySupport.storeLong(loc, fid.toLong & 0xFFFFFFFFL)
447
      case _: TypeThreadRef =>
448
        noAccessViaPointer(ptr, ty)
449
        val tid = nvb.asInstanceOf[BoxThread].thread.map(_.id).getOrElse(0)
450
        memorySupport.storeLong(loc, tid.toLong & 0xFFFFFFFFL)
451
      case _: TypeStackRef =>
452
        noAccessViaPointer(ptr, ty)
453
        val sid = nvb.asInstanceOf[BoxStack].stack.map(_.id).getOrElse(0)
454
        memorySupport.storeLong(loc, sid.toLong & 0xFFFFFFFFL)
455
      case _: TypeTagRef64 =>
456
        noAccessViaPointer(ptr, ty)
457
        val raw = nvb.asInstanceOf[BoxTagRef64].raw
458
        memorySupport.storeLong(loc, raw)
459
      case _: TypeUPtr | _: TypeUFuncPtr =>
460 461
        val addr = nvb.asInstanceOf[BoxPointer].addr
        memorySupport.storeLong(loc, addr, !ptr)
462
      case _ => throw new UvmUnimplementedOperationException("Storing of type %s is not supporing".format(ty.getClass.getName))
463 464 465 466
    }

    ty match {
      case TypeVector(ety, len) =>
Kunshan Wang's avatar
Kunshan Wang committed
467
        val nvbs = nvb.asInstanceOf[BoxSeq].values
468
        val elemSkip = alignUp(sizeOf(ety), alignOf(ety))
Kunshan Wang's avatar
Kunshan Wang committed
469 470
        for ((nvbElem, i) <- nvbs.zipWithIndex) {
          storeScalar(ety, loc + elemSkip * i, nvbElem)
471
        }
Kunshan Wang's avatar
Kunshan Wang committed
472
      case sty => storeScalar(sty, loc, nvb)
473 474 475 476 477 478
    }
  }

  /**
   * Compare exchange. The result (the old value) is written into br. Return true if successful, false otherwise.
   */
479
  def cmpXchg(ptr: Boolean, ty: Type, loc: Word, eb: ValueBox, db: ValueBox, br: ValueBox)(implicit microVM: MicroVM, memorySupport: MemorySupport): Boolean = {
480 481 482 483 484 485
    ty match {
      case TypeInt(l) =>
        val ebi = eb.asInstanceOf[BoxInt].value
        val dbi = db.asInstanceOf[BoxInt].value
        val (succ, rbi) = l match {
          case 32 => {
486
            val (succ2, rv) = memorySupport.cmpXchgInt(loc, ebi.intValue, dbi.intValue, !ptr)
487 488 489
            (succ2, BigInt(rv))
          }
          case 64 => {
490
            val (succ2, rv) = memorySupport.cmpXchgLong(loc, ebi.longValue, dbi.longValue, !ptr)
491 492
            (succ2, BigInt(rv))
          }
493
          case _ => throw new UvmUnimplementedOperationException("CmpXchg on int of length %d is not supported".format(l))
494 495 496 497
        }
        br.asInstanceOf[BoxInt].value = OpHelper.unprepare(rbi, l)
        succ
      case _: TypeRef =>
498
        noAccessViaPointer(ptr, ty)
499 500
        val el = eb.asInstanceOf[BoxRef].objRef
        val dl = db.asInstanceOf[BoxRef].objRef
501
        val (succ, rl) = memorySupport.cmpXchgLong(loc, el, dl)
502 503 504
        br.asInstanceOf[BoxRef].objRef = rl
        succ
      case _: TypeIRef =>
505
        noAccessViaPointer(ptr, ty)
506 507
        val BoxIRef(el, eh) = eb.asInstanceOf[BoxIRef]
        val BoxIRef(dl, dh) = db.asInstanceOf[BoxIRef]
508
        val (succ, (rl, rh)) = memorySupport.cmpXchgI128(loc, (el, eh), (dl, dh))
509 510
        br.asInstanceOf[BoxIRef].oo = (rl, rh)
        succ
511
      case _: TypeFuncRef =>
512
        noAccessViaPointer(ptr, ty)
513 514
        val el = eb.asInstanceOf[BoxFunc].func.map(_.id).getOrElse(0).toLong
        val dl = db.asInstanceOf[BoxFunc].func.map(_.id).getOrElse(0).toLong
515
        val (succ, rl) = memorySupport.cmpXchgLong(loc, el, dl)
516 517 518
        val rf = microVM.globalBundle.funcNs.get(rl.toInt)
        br.asInstanceOf[BoxFunc].func = rf
        succ
519
      case _: TypeThreadRef =>
520
        noAccessViaPointer(ptr, ty)
521 522
        val el = eb.asInstanceOf[BoxThread].thread.map(_.id).getOrElse(0).toLong
        val dl = db.asInstanceOf[BoxThread].thread.map(_.id).getOrElse(0).toLong
523
        val (succ, rl) = memorySupport.cmpXchgLong(loc, el, dl)
Kunshan Wang's avatar
Kunshan Wang committed
524
        val rt = microVM.threadStackManager.threadRegistry.get(rl.toInt)
525 526
        br.asInstanceOf[BoxThread].thread = rt
        succ
527
      case _: TypeStackRef =>
528
        noAccessViaPointer(ptr, ty)
529 530
        val el = eb.asInstanceOf[BoxStack].stack.map(_.id).getOrElse(0).toLong
        val dl = db.asInstanceOf[BoxStack].stack.map(_.id).getOrElse(0).toLong
531
        val (succ, rl) = memorySupport.cmpXchgLong(loc, el, dl)
Kunshan Wang's avatar
Kunshan Wang committed
532
        val rs = microVM.threadStackManager.stackRegistry.get(rl.toInt)
533 534
        br.asInstanceOf[BoxStack].stack = rs
        succ
535
      case _: TypeUPtr | _: TypeUFuncPtr =>
536 537 538 539 540
        val el = eb.asInstanceOf[BoxPointer].addr
        val dl = db.asInstanceOf[BoxPointer].addr
        val (succ, rl) = memorySupport.cmpXchgLong(loc, el, dl, !ptr)
        br.asInstanceOf[BoxPointer].addr = rl
        succ
541
      case _ => throw new UvmUnimplementedOperationException("CmpXchg of type %s is not supporing".format(ty.getClass.getName))
542 543 544
    }
  }

545
  def atomicRMW(ptr: Boolean, ty: Type, op: AtomicRMWOptr, loc: Word, ob: ValueBox, br: ValueBox)(implicit microVM: MicroVM, memorySupport: MemorySupport): Unit = {
546 547 548 549
    ty match {
      case TypeInt(l) =>
        val obi = ob.asInstanceOf[BoxInt].value
        val rbi: BigInt = l match {
550 551
          case 32 => memorySupport.atomicRMWInt(op, loc, obi.intValue, !ptr)
          case 64 => memorySupport.atomicRMWLong(op, loc, obi.longValue, !ptr)
552
          case _  => throw new UvmUnimplementedOperationException("AtomicRMW on int of length %d is not supported".format(l))
553 554 555 556
        }
        br.asInstanceOf[BoxInt].value = OpHelper.unprepare(rbi, l)
      case _ =>
        if (op != XCHG) {
557
          throw new UvmUnimplementedOperationException("AtomicRMW operation other than XCHG only supports int. %s found.".format(ty.getClass.getName))
558 559 560
        } else {
          ty match {
            case _: TypeRef =>
561
              noAccessViaPointer(ptr, ty)
562
              val ol = ob.asInstanceOf[BoxRef].objRef
563
              val rl = memorySupport.atomicRMWLong(op, loc, ol)
564 565
              br.asInstanceOf[BoxRef].objRef = rl
            case _: TypeIRef =>
566
              noAccessViaPointer(ptr, ty)
567
              val BoxIRef(ol, oh) = ob.asInstanceOf[BoxIRef]
568
              val (rl, rh) = memorySupport.xchgI128(loc, (ol, oh))
569
              br.asInstanceOf[BoxIRef].oo = (rl, rh)
570
            case _: TypeFuncRef =>
571
              noAccessViaPointer(ptr, ty)
572
              val ol = ob.asInstanceOf[BoxFunc].func.map(_.id).getOrElse(0).toLong
573
              val rl = memorySupport.atomicRMWLong(op, loc, ol)
574 575
              val rf = microVM.globalBundle.funcNs.get(rl.toInt)
              br.asInstanceOf[BoxFunc].func = rf
576
            case _: TypeThreadRef =>
577
              noAccessViaPointer(ptr, ty)
578
              val ol = ob.asInstanceOf[BoxThread].thread.map(_.id).getOrElse(0).toLong
579
              val rl = memorySupport.atomicRMWLong(op, loc, ol)
Kunshan Wang's avatar
Kunshan Wang committed
580
              val rt = microVM.threadStackManager.threadRegistry.get(rl.toInt)
581
              br.asInstanceOf[BoxThread].thread = rt
582
            case _: TypeStackRef =>
583
              noAccessViaPointer(ptr, ty)
584
              val ol = ob.asInstanceOf[BoxStack].stack.map(_.id).getOrElse(0).toLong
585
              val rl = memorySupport.atomicRMWLong(op, loc, ol)
Kunshan Wang's avatar
Kunshan Wang committed
586
              val rs = microVM.threadStackManager.stackRegistry.get(rl.toInt)
587 588
              br.asInstanceOf[BoxStack].stack = rs
            case _: TypeTagRef64 =>
589
              noAccessViaPointer(ptr, ty)
590
              val ol = ob.asInstanceOf[BoxTagRef64].raw
591
              val rl = memorySupport.atomicRMWLong(op, loc, ol)
592
              br.asInstanceOf[BoxTagRef64].raw = rl
593
            case _: TypeUPtr | _: TypeUFuncPtr =>
594 595 596
              val ol = ob.asInstanceOf[BoxPointer].addr
              val rl = memorySupport.atomicRMWLong(op, loc, ol, !ptr)
              br.asInstanceOf[BoxPointer].addr = rl
597
            case _ =>
598
              throw new UvmUnimplementedOperationException("AtomicRMW XCHG of type %s is not supporing".format(ty.getClass.getName))
599 600 601
          }
        }
    }
Kunshan Wang's avatar
Kunshan Wang committed
602
  }
Kunshan Wang's avatar
Kunshan Wang committed
603 604 605 606

  /**
   * Check if a memory location still holds a particular value. Used by futex.
   */
607
  def cmpInt(len: Int, loc: Word, expected: BigInt)(implicit memorySupport: MemorySupport): Boolean = len match {
Kunshan Wang's avatar
Kunshan Wang committed
608
    case 64 => {
609
      val expNum = OpHelper.prepareSigned(expected, len).longValue
610
      val actualNum = memorySupport.loadLong(loc)
Kunshan Wang's avatar
Kunshan Wang committed
611 612 613
      expNum == actualNum
    }
    case 32 => {
614
      val expNum = OpHelper.prepareSigned(expected, len).intValue
615
      val actualNum = memorySupport.loadInt(loc)
Kunshan Wang's avatar
Kunshan Wang committed
616 617
      expNum == actualNum
    }
618
    case _ => throw new UvmUnimplementedOperationException("Futex of %d bit int is not supported".format(len))
Kunshan Wang's avatar
Kunshan Wang committed
619
  }
620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650

  val US_ASCII = Charset.forName("US-ASCII")

  /**
   * Read an ASCII string from the memory.
   *
   * @param loc A ref to a @uvm.meta.bytes object.
   */
  def bytesToStr(loc: Word)(implicit memorySupport: MemorySupport): String = {
    // It is a hybrid<@i64 @i8> object. The length is determined by the fixed part. 
    val len = memorySupport.loadLong(loc)
    val bytes = new Array[Byte](len.toInt)
    val begin = loc + TypeSizes.WORD_SIZE_BYTES
    memorySupport.loadBytes(begin, bytes, 0, len, true)

    val result = new String(bytes, US_ASCII)
    result
  }

  /**
   * Create a Mu @uvm.meta.bytes object to hold an ASCII string.
   *
   * @return The address of the allocated object.
   */
  def strToBytes(str: String)(implicit memorySupport: MemorySupport, mutator: Mutator): Word = {
    val bytes = str.getBytes(US_ASCII)
    val len = bytes.length
    val loc = mutator.newHybrid(InternalTypes.BYTES, len)
    memorySupport.storeLong(loc, bytes.length.toLong)
    val begin = loc + TypeSizes.WORD_SIZE_BYTES
    memorySupport.storeBytes(begin, bytes, 0, len, true)
651

652 653
    loc
  }
Kunshan Wang's avatar
Kunshan Wang committed
654 655
}