GitLab will be upgraded on June 2nd 2020 at 2.00 pm (AEDT) to 3.00 pm (AEDT) due to Critical Security Patch Availability. During the update, GitLab and Mattermost services will not be available. If you have any concerns with this, please talk to local Gitlab admin team.

Commit fa663278 authored by Kunshan Wang's avatar Kunshan Wang

Testing MuCtxIRBuilderPart

parent d89e5324
...@@ -12,29 +12,29 @@ end = "SCRIPT: END HERE" ...@@ -12,29 +12,29 @@ end = "SCRIPT: END HERE"
replaces = [(re.compile(x), y) for (x,y) in [ replaces = [(re.compile(x), y) for (x,y) in [
(r'BN', 'MuBundleNode'), (r'BN', 'MuBundleNode'),
(r'CN\[_\s*<:\s*Identified\]', 'MuChildNode'), (r'(CN|ChildNode)\[(_\s*<:\s*)?Identified\]', 'MuChildNode'),
(r'CN\[IdentifiedSettable\]', 'MuChildNode'), (r'(CN|ChildNode)\[(_\s*<:\s*)?IdentifiedSettable\]', 'MuChildNode'),
(r'CN\[Type\w*\]', 'MuTypeNode'), (r'(CN|ChildNode)\[Type\w*\]', 'MuTypeNode'),
(r'CN\[Abstract\w+Type\]', 'MuTypeNode'), (r'(CN|ChildNode)\[Abstract\w+Type\]', 'MuTypeNode'),
(r'CN\[FuncSig\]', 'MuFuncSigNode'), (r'(CN|ChildNode)\[FuncSig\]', 'MuFuncSigNode'),
(r'CN\[Const\w+\]', 'MuConstNode'), (r'(CN|ChildNode)\[Const\w+\]', 'MuConstNode'),
(r'CN\[GlobalCell\]', 'MuGlobalNode'), (r'(CN|ChildNode)\[GlobalCell\]', 'MuGlobalNode'),
(r'CN\[Function\]', 'MuFuncNode'), (r'(CN|ChildNode)\[Function\]', 'MuFuncNode'),
(r'CN\[ExposedFunc\]', 'MuExpFuncNode'), (r'(CN|ChildNode)\[ExposedFunc\]', 'MuExpFuncNode'),
(r'CN\[FuncVer\]', 'MuFuncVerNode'), (r'(CN|ChildNode)\[FuncVer\]', 'MuFuncVerNode'),
(r'CN\[BasicBlock\]', 'MuBBNode'), (r'(CN|ChildNode)\[BasicBlock\]', 'MuBBNode'),
(r'CN\[BB\]', 'MuBBNode'), (r'(CN|ChildNode)\[BB\]', 'MuBBNode'),
(r'CN\[SSAVariable\]', 'MuVarNode'), (r'(CN|ChildNode)\[SSAVariable\]', 'MuVarNode'),
(r'CN\[Var\]', 'MuVarNode'), (r'(CN|ChildNode)\[Var\]', 'MuVarNode'),
(r'CN\[LocalVariable\]', 'MuLocalVarNode'), (r'(CN|ChildNode)\[LocalVariable\]', 'MuLocalVarNode'),
(r'CN\[NorParam\]', 'MuNorParamNode'), (r'(CN|ChildNode)\[NorParam\]', 'MuNorParamNode'),
(r'CN\[ExcParam\]', 'MuExcParamNode'), (r'(CN|ChildNode)\[ExcParam\]', 'MuExcParamNode'),
(r'CN\[InstResult\]', 'MuInstResNode'), (r'(CN|ChildNode)\[InstResult\]', 'MuInstResNode'),
(r'CN\[Inst\w+\]', 'MuInstNode'), (r'(CN|ChildNode)\[Inst\w+\]', 'MuInstNode'),
(r'CN\[HasKeepAliveClause\]', 'MuInstNode'), (r'(CN|ChildNode)\[HasKeepAliveClause\]', 'MuInstNode'),
]] ]]
sig = re.compile(r'^( def (\w+)\(([^)]*)\):\s+\w+\s+=)', re.MULTILINE) sig = re.compile(r'^( def\s+(\w+)\s*\(([^)]*)\):\s+\w+\s+=)', re.MULTILINE)
arg = re.compile(r'(\w*):\s+([a-zA-Z0-9\[\]]+)') arg = re.compile(r'(\w*):\s+([a-zA-Z0-9\[\]]+)')
node_like = re.compile(r'Mu\w+Node') node_like = re.compile(r'Mu\w+Node')
node_seq_like = re.compile(r'Seq\[Mu\w+Node\]') node_seq_like = re.compile(r'Seq\[Mu\w+Node\]')
......
...@@ -58,12 +58,16 @@ class IRBuilder(globalBundle: GlobalBundle, idFactory: IDFactory) { ...@@ -58,12 +58,16 @@ class IRBuilder(globalBundle: GlobalBundle, idFactory: IDFactory) {
new ChildNode(ent) new ChildNode(ent)
} }
def getID(b: BN, node: CN[_ <: Identified]): Int = { def getID(b: BN, node: CN[Identified]): Int = {
node.id node.id
} }
def setName(b: BN, node: CN[IdentifiedSettable], name: String): Unit = { def setName(b: BN, node: CN[IdentifiedSettable], name: String): Unit = {
node.name = Some(name) node.name = Some(name)
// NOTE: When the name is set, the TrantientBundle's namespaces still do not index the object by its name,
// because the objects are added before their names are set. But by the time when the TrantientBundle is merged with
// the GlobalBundle, all objects in all namespaces will have been re-added to the GlobalBundle. For this reason,
// globalBundle.someNs.get("@the.name.of.object") will still return the object as long as it has a name.
} }
// format: OFF // format: OFF
......
...@@ -94,11 +94,81 @@ trait MuCtxIRBuilderPart { ...@@ -94,11 +94,81 @@ trait MuCtxIRBuilderPart {
irBuilder.setName(b, node, name) irBuilder.setName(b, node, name)
} }
def newTypeInt (b: MuBundleNode, len: Int): MuTypeNode = {
require(!b.isNull, "b must not be NULL")
addHandle(irBuilder.newTypeInt(b, len))
}
def newTypeFloat (b: MuBundleNode): MuTypeNode = {
require(!b.isNull, "b must not be NULL")
addHandle(irBuilder.newTypeFloat(b))
}
def newTypeDouble (b: MuBundleNode): MuTypeNode = {
require(!b.isNull, "b must not be NULL")
addHandle(irBuilder.newTypeDouble(b))
}
def newTypeUPtr (b: MuBundleNode): MuTypeNode = {
require(!b.isNull, "b must not be NULL")
addHandle(irBuilder.newTypeUPtr(b))
}
def newTypeUFuncPtr (b: MuBundleNode): MuTypeNode = {
require(!b.isNull, "b must not be NULL")
addHandle(irBuilder.newTypeUFuncPtr(b))
}
def newTypeVoid (b: MuBundleNode): MuTypeNode = {
require(!b.isNull, "b must not be NULL")
addHandle(irBuilder.newTypeVoid(b))
}
def newTypeRef (b: MuBundleNode): MuTypeNode = {
require(!b.isNull, "b must not be NULL")
addHandle(irBuilder.newTypeRef(b))
}
def newTypeIRef (b: MuBundleNode): MuTypeNode = {
require(!b.isNull, "b must not be NULL")
addHandle(irBuilder.newTypeIRef(b))
}
def newTypeWeakRef (b: MuBundleNode): MuTypeNode = {
require(!b.isNull, "b must not be NULL")
addHandle(irBuilder.newTypeWeakRef(b))
}
def newTypeFuncRef (b: MuBundleNode): MuTypeNode = {
require(!b.isNull, "b must not be NULL")
addHandle(irBuilder.newTypeFuncRef(b))
}
def newTypeTagRef64 (b: MuBundleNode): MuTypeNode = {
require(!b.isNull, "b must not be NULL")
addHandle(irBuilder.newTypeTagRef64(b))
}
def newTypeThreadRef (b: MuBundleNode): MuTypeNode = {
require(!b.isNull, "b must not be NULL")
addHandle(irBuilder.newTypeThreadRef(b))
}
def newTypeStackRef (b: MuBundleNode): MuTypeNode = {
require(!b.isNull, "b must not be NULL")
addHandle(irBuilder.newTypeStackRef(b))
}
def newTypeFrameCursorRef(b: MuBundleNode): MuTypeNode = { def newTypeFrameCursorRef(b: MuBundleNode): MuTypeNode = {
require(!b.isNull, "b must not be NULL") require(!b.isNull, "b must not be NULL")
addHandle(irBuilder.newTypeFrameCursorRef(b)) addHandle(irBuilder.newTypeFrameCursorRef(b))
} }
def newTypeIRNodeRef (b: MuBundleNode): MuTypeNode = {
require(!b.isNull, "b must not be NULL")
addHandle(irBuilder.newTypeIRNodeRef(b))
}
def newTypeStruct(b: MuBundleNode, fieldTys: Seq[MuTypeNode]): MuTypeNode = { def newTypeStruct(b: MuBundleNode, fieldTys: Seq[MuTypeNode]): MuTypeNode = {
require(!b.isNull, "b must not be NULL") require(!b.isNull, "b must not be NULL")
for((n,i) <- fieldTys.zipWithIndex) require(!n.isNull, "fieldTys[%d] must not be NULL".format(i)) for((n,i) <- fieldTys.zipWithIndex) require(!n.isNull, "fieldTys[%d] must not be NULL".format(i))
...@@ -112,17 +182,54 @@ trait MuCtxIRBuilderPart { ...@@ -112,17 +182,54 @@ trait MuCtxIRBuilderPart {
addHandle(irBuilder.newTypeHybrid(b, fixedTys, varTy)) addHandle(irBuilder.newTypeHybrid(b, fixedTys, varTy))
} }
def newTypeArray (b: MuBundleNode, elemTy: MuTypeNode, len: Long): MuTypeNode = {
require(!b.isNull, "b must not be NULL")
require(!elemTy.isNull, "elemTy must not be NULL")
addHandle(irBuilder.newTypeArray(b, elemTy, len))
}
def newTypeVector(b: MuBundleNode, elemTy: MuTypeNode, len: Long): MuTypeNode = { def newTypeVector(b: MuBundleNode, elemTy: MuTypeNode, len: Long): MuTypeNode = {
require(!b.isNull, "b must not be NULL") require(!b.isNull, "b must not be NULL")
require(!elemTy.isNull, "elemTy must not be NULL") require(!elemTy.isNull, "elemTy must not be NULL")
addHandle(irBuilder.newTypeVector(b, elemTy, len)) addHandle(irBuilder.newTypeVector(b, elemTy, len))
} }
def setTypeUFuncPtr(ufuncptr: MuTypeNode, sig: ChildNode[FuncSig]): Unit = { def setTypeUPtr (uptr: MuTypeNode, ty: MuTypeNode): Unit = {
require(!uptr.isNull, "uptr must not be NULL")
require(!ty.isNull, "ty must not be NULL")
irBuilder.setTypeUPtr(uptr, ty)
}
def setTypeRef (ref: MuTypeNode, ty: MuTypeNode): Unit = {
require(!ref.isNull, "ref must not be NULL")
require(!ty.isNull, "ty must not be NULL")
irBuilder.setTypeRef(ref, ty)
}
def setTypeIRef (iref: MuTypeNode, ty: MuTypeNode): Unit = {
require(!iref.isNull, "iref must not be NULL")
require(!ty.isNull, "ty must not be NULL")
irBuilder.setTypeIRef(iref, ty)
}
def setTypeWeakRef (weakref: MuTypeNode, ty: MuTypeNode): Unit = {
require(!weakref.isNull, "weakref must not be NULL")
require(!ty.isNull, "ty must not be NULL")
irBuilder.setTypeWeakRef(weakref, ty)
}
def setTypeUFuncPtr(ufuncptr: MuTypeNode, sig: MuFuncSigNode): Unit = {
require(!ufuncptr.isNull, "ufuncptr must not be NULL") require(!ufuncptr.isNull, "ufuncptr must not be NULL")
require(!sig.isNull, "sig must not be NULL")
irBuilder.setTypeUFuncPtr(ufuncptr, sig) irBuilder.setTypeUFuncPtr(ufuncptr, sig)
} }
def setTypeFuncRef (funcref: MuTypeNode, sig: MuFuncSigNode): Unit = {
require(!funcref.isNull, "funcref must not be NULL")
require(!sig.isNull, "sig must not be NULL")
irBuilder.setTypeFuncRef(funcref, sig)
}
def newFuncSig(b: MuBundleNode, paramTys: Seq[MuTypeNode], retTys: Seq[MuTypeNode]): MuFuncSigNode = { def newFuncSig(b: MuBundleNode, paramTys: Seq[MuTypeNode], retTys: Seq[MuTypeNode]): MuFuncSigNode = {
require(!b.isNull, "b must not be NULL") require(!b.isNull, "b must not be NULL")
for((n,i) <- paramTys.zipWithIndex) require(!n.isNull, "paramTys[%d] must not be NULL".format(i)) for((n,i) <- paramTys.zipWithIndex) require(!n.isNull, "paramTys[%d] must not be NULL".format(i))
...@@ -130,12 +237,37 @@ trait MuCtxIRBuilderPart { ...@@ -130,12 +237,37 @@ trait MuCtxIRBuilderPart {
addHandle(irBuilder.newFuncSig(b, paramTys, retTys)) addHandle(irBuilder.newFuncSig(b, paramTys, retTys))
} }
def newConstInt (b: MuBundleNode, ty: MuTypeNode, value: BigInt): MuConstNode = {
require(!b.isNull, "b must not be NULL")
require(!ty.isNull, "ty must not be NULL")
addHandle(irBuilder.newConstInt(b, ty, value))
}
def newConstFloat (b: MuBundleNode, ty: MuTypeNode, value: Float): MuConstNode = {
require(!b.isNull, "b must not be NULL")
require(!ty.isNull, "ty must not be NULL")
addHandle(irBuilder.newConstFloat(b, ty, value))
}
def newConstDouble(b: MuBundleNode, ty: MuTypeNode, value: Double): MuConstNode = { def newConstDouble(b: MuBundleNode, ty: MuTypeNode, value: Double): MuConstNode = {
require(!b.isNull, "b must not be NULL") require(!b.isNull, "b must not be NULL")
require(!ty.isNull, "ty must not be NULL") require(!ty.isNull, "ty must not be NULL")
addHandle(irBuilder.newConstDouble(b, ty, value)) addHandle(irBuilder.newConstDouble(b, ty, value))
} }
def newConstNull (b: MuBundleNode, ty: MuTypeNode): MuConstNode = {
require(!b.isNull, "b must not be NULL")
require(!ty.isNull, "ty must not be NULL")
addHandle(irBuilder.newConstNull(b, ty))
}
def newConstSeq (b: MuBundleNode, ty: MuTypeNode, elems: Seq[MuConstNode]): MuConstNode = {
require(!b.isNull, "b must not be NULL")
require(!ty.isNull, "ty must not be NULL")
for((n,i) <- elems.zipWithIndex) require(!n.isNull, "elems[%d] must not be NULL".format(i))
addHandle(irBuilder.newConstSeq(b, ty, elems))
}
def newGlobalCell(b: MuBundleNode, ty: MuTypeNode): MuGlobalNode = { def newGlobalCell(b: MuBundleNode, ty: MuTypeNode): MuGlobalNode = {
require(!b.isNull, "b must not be NULL") require(!b.isNull, "b must not be NULL")
require(!ty.isNull, "ty must not be NULL") require(!ty.isNull, "ty must not be NULL")
...@@ -487,5 +619,7 @@ trait MuCtxIRBuilderPart { ...@@ -487,5 +619,7 @@ trait MuCtxIRBuilderPart {
addHandle(irBuilder.newCommInst(bb, opcode, flags, tys, sigs, args)) addHandle(irBuilder.newCommInst(bb, opcode, flags, tys, sigs, args))
} }
// END: auto-generated code // END: auto-generated code
} }
\ No newline at end of file
package uvm.refimpl
import org.scalatest._
import ch.qos.logback.classic.Level._
import uvm._
import uvm.refimpl._
import uvm.refimpl.RichMuCtx._
import uvm.refimpl.itpr._
import uvm.refimpl.mem._
import uvm.ssavariables._
import uvm.ssavariables.AtomicRMWOptr._
import uvm.ssavariables.MemoryOrder._
import uvm.types._
import uvm.ir.textinput.ExtraMatchers
class MuCtxIRBuilderTest extends UvmBundleTesterBase with ExtraMatchers {
setLogLevels(ROOT_LOGGER_NAME -> INFO,
"uvm" -> INFO)
override def makeMicroVM() = new MicroVM(new VMConf())
behavior of "The IR Builder of MuCtx"
it should "create an empty bundle" in {
val ctx = microVM.newContext()
val b = ctx.newBundle()
ctx.loadBundleFromNode(b)
ctx.closeContext()
}
it should "create a bundle that contains types and sigs" in {
val ctx = microVM.newContext()
val b = ctx.newBundle()
val hi1 = ctx.newTypeInt(b, 1)
val hi8 = ctx.newTypeInt(b, 8)
val hi8_id = ctx.getID(b, hi8)
val hi16 = ctx.newTypeInt(b, 16)
val hi16_id = ctx.getID(b, hi16)
val hi32 = ctx.newTypeInt(b, 32)
val hi32_id = ctx.getID(b, hi32)
val hi64 = ctx.newTypeInt(b, 64)
val hi64_id = ctx.getID(b, hi64)
ctx.setName(b, hi64, "@i64")
val hf = ctx.newTypeFloat(b)
val hd = ctx.newTypeDouble(b)
val hs = ctx.newTypeStruct(b, Seq(hi8, hi16, hi32, hi64))
val hh = ctx.newTypeHybrid(b, Seq(hf, hd), hi8)
val ha = ctx.newTypeArray(b, hi8, 100)
val hv = ctx.newTypeVector(b, hf, 4)
val hsig = ctx.newFuncSig(b, Seq(hi8, hi16), Seq(hi32))
val hsig_id = ctx.getID(b, hsig)
val htr64 = ctx.newTypeTagRef64(b)
val hsr = ctx.newTypeStackRef(b)
val htr = ctx.newTypeThreadRef(b)
val hfcr = ctx.newTypeFrameCursorRef(b)
val hinr = ctx.newTypeIRNodeRef(b)
val hp = ctx.newTypeUPtr(b)
val hfp = ctx.newTypeUFuncPtr(b)
val hr = ctx.newTypeRef(b)
val hir = ctx.newTypeIRef(b)
val hwr = ctx.newTypeWeakRef(b)
val hfr = ctx.newTypeFuncRef(b)
ctx.setTypeUPtr(hp, hi64)
ctx.setTypeUFuncPtr(hfp, hsig)
ctx.setTypeRef(hr, hi64)
ctx.setTypeIRef(hir, hi64)
ctx.setTypeWeakRef(hwr, hi64)
ctx.setTypeFuncRef(hfr, hsig)
val hr1 = ctx.newTypeRef(b)
val hs1 = ctx.newTypeStruct(b, Seq(hi64, hr1))
ctx.setTypeRef(hr1, hs1)
val hr1_id = ctx.getID(b, hr1)
val hs1_id = ctx.getID(b, hs1)
ctx.loadBundleFromNode(b)
val gb = microVM.globalBundle
gb.typeNs(hi64_id) shouldBeA[TypeInt] { its => its.length shouldBe 64 }
gb.typeNs("@i64") shouldBe gb.typeNs(hi64_id)
gb.typeNs(hr1_id) shouldBeA[TypeRef] { its => its.ty shouldBe gb.typeNs(hs1_id) }
gb.typeNs(hs1_id) shouldBeA[TypeStruct] { its => its.fieldTys shouldBe Seq(gb.typeNs(hi64_id), gb.typeNs(hr1_id)) }
gb.funcSigNs(hsig_id) shouldBeA[FuncSig] { its =>
its.paramTys shouldBe Seq(gb.typeNs(hi8_id), gb.typeNs(hi16_id))
its.retTys shouldBe Seq(gb.typeNs(hi32_id))
}
ctx.closeContext()
}
it should "create a bundle with constants and global cells" in {
val ctx = microVM.newContext()
val b = ctx.newBundle()
val hi64 = ctx.newTypeInt(b, 64)
val hf = ctx.newTypeFloat(b)
val hd = ctx.newTypeDouble(b)
val hs = ctx.newTypeStruct(b, Seq(hi64, hi64))
val hr = ctx.newTypeRef(b)
ctx.setTypeRef(hr, hi64)
val hc1 = ctx.newConstInt(b, hi64, 0x123456789abcdef0L)
val hc2 = ctx.newConstInt(b, hi64, 0xfedcba9876543210L)
val hc3 = ctx.newConstSeq(b, hs, Seq(hc1, hc2))
val hc4 = ctx.newConstFloat(b, hf, 3.14F)
val hc5 = ctx.newConstDouble(b, hd, 3.14)
val hc6 = ctx.newConstNull(b, hr)
val hc1_id = ctx.getID(b, hc1)
val hc2_id = ctx.getID(b, hc2)
val hc3_id = ctx.getID(b, hc3)
val hc4_id = ctx.getID(b, hc4)
val hc5_id = ctx.getID(b, hc5)
val hc6_id = ctx.getID(b, hc6)
val hg = ctx.newGlobalCell(b, hi64)
val hg_id = ctx.getID(b, hg)
ctx.loadBundleFromNode(b)
val gb = microVM.globalBundle
gb.constantNs(hc1_id) shouldBeA[ConstInt] { its => its.num shouldBe 0x123456789abcdef0L }
gb.constantNs(hc2_id) shouldBeA[ConstInt] { its => its.num shouldBe 0xfedcba9876543210L }
gb.constantNs(hc3_id) shouldBeA[ConstSeq] { its =>
its.elems.map(_.asInstanceOf[ConstInt].num) shouldBe Seq(0x123456789abcdef0L, 0xfedcba9876543210L)
}
gb.constantNs(hc4_id) shouldBeA[ConstFloat] { its => its.num shouldBe 3.14f }
gb.constantNs(hc5_id) shouldBeA[ConstDouble] { its => its.num shouldBe 3.14 }
gb.constantNs(hc6_id) shouldBeA[ConstNull] thatsIt
gb.globalCellNs(hg_id) shouldBeA[GlobalCell] { its => its.cellTy shouldBeA[TypeInt] { itss => itss.length shouldBe 64 }}
val hc1v = ctx.handleFromConst(hc1_id).asInstanceOf[MuIntValue]
val hc1vv = ctx.handleToSInt(hc1v)
hc1vv shouldBe 0x123456789abcdef0L
val hirg = ctx.handleFromGlobal(hg_id)
val hirg_v0 = ctx.load(NOT_ATOMIC, hirg).asInstanceOf[MuIntValue]
val hirg_v0v = ctx.handleToSInt(hirg_v0)
hirg_v0v shouldBe 0
ctx.store(NOT_ATOMIC, hirg, hc1v)
val hirg_v1 = ctx.load(NOT_ATOMIC, hirg).asInstanceOf[MuIntValue]
val hirg_v1v = ctx.handleToSInt(hirg_v1)
hirg_v1v shouldBe 0x123456789abcdef0L
ctx.closeContext()
}
}
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment