diff --git a/.gitignore b/.gitignore index c0b5a4c..6032b7d 100644 --- a/.gitignore +++ b/.gitignore @@ -2,3 +2,6 @@ target/ .mooncakes/ .DS_Store .moonagent/ +_build/ +_build +target diff --git a/IR/BasicBlock.mbt b/IR/BasicBlock.mbt index e208e2e..ad32bf0 100644 --- a/IR/BasicBlock.mbt +++ b/IR/BasicBlock.mbt @@ -5,25 +5,27 @@ /// /// Use `Function::addBasicBlock` to create a new `BasicBlock`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, []) -/// let fval = mod.addFunction(fty, "ret_42") -/// let bb = fval.addBasicBlock(name="entry") -/// builder.setInsertPoint(bb) -/// let forty_two = ctx.getConstInt32(42) -/// let _ = builder.createRet(forty_two) -/// inspect( -/// bb, -/// content=( -/// #|entry: -/// #| ret i32 42 -/// #| -/// ), -/// ) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, []) +/// let fval = mod.addFunction(fty, "ret_42") +/// let bb = fval.addBasicBlock(name="entry") +/// builder.setInsertPoint(bb) +/// let forty_two = ctx.getConstInt32(42) +/// let _ = builder.createRet(forty_two) +/// inspect( +/// bb, +/// content=( +/// #|entry: +/// #| ret i32 42 +/// #| +/// ), +/// ) +/// } /// ``` pub struct BasicBlock { uid : UInt64 @@ -52,22 +54,24 @@ fn BasicBlock::new(parent : Function, name~ : String?) -> BasicBlock { ///| /// Get the first instruction in the basic block. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "ret_42") -/// let arg0 = fval.getArg(0).unwrap() -/// let arg1 = fval.getArg(1).unwrap() -/// let bb = fval.addBasicBlock(name="entry") -/// builder.setInsertPoint(bb) -/// let sum1 = builder.createAdd(arg0, arg1, name="sum1") -/// let sum2 = builder.createAdd(arg0, arg1, name="sum2") -/// let mul = builder.createMul(sum1, sum2, name="mul") -/// let _ = builder.createRet(mul) -/// inspect(bb.firstInst().unwrap(), content=" %sum1 = add i32 %0, %1") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "ret_42") +/// let arg0 = fval.getArg(0).unwrap() +/// let arg1 = fval.getArg(1).unwrap() +/// let bb = fval.addBasicBlock(name="entry") +/// builder.setInsertPoint(bb) +/// let sum1 = builder.createAdd(arg0, arg1, name="sum1") +/// let sum2 = builder.createAdd(arg0, arg1, name="sum2") +/// let mul = builder.createMul(sum1, sum2, name="mul") +/// let _ = builder.createRet(mul) +/// inspect(bb.firstInst().unwrap(), content=" %sum1 = add i32 %0, %1") +/// } /// ``` pub fn BasicBlock::firstInst(self : BasicBlock) -> &Instruction? { self.head @@ -76,22 +80,24 @@ pub fn BasicBlock::firstInst(self : BasicBlock) -> &Instruction? { ///| /// Get the last instruction in the basic block. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "ret_42") -/// let arg0 = fval.getArg(0).unwrap() -/// let arg1 = fval.getArg(1).unwrap() -/// let bb = fval.addBasicBlock(name="entry") -/// builder.setInsertPoint(bb) -/// let sum1 = builder.createAdd(arg0, arg1, name="sum1") -/// let sum2 = builder.createAdd(arg0, arg1, name="sum2") -/// let mul = builder.createMul(sum1, sum2, name="mul") -/// let _ = builder.createRet(mul) -/// inspect(bb.lastInst().unwrap(), content=" ret i32 %mul") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "ret_42") +/// let arg0 = fval.getArg(0).unwrap() +/// let arg1 = fval.getArg(1).unwrap() +/// let bb = fval.addBasicBlock(name="entry") +/// builder.setInsertPoint(bb) +/// let sum1 = builder.createAdd(arg0, arg1, name="sum1") +/// let sum2 = builder.createAdd(arg0, arg1, name="sum2") +/// let mul = builder.createMul(sum1, sum2, name="mul") +/// let _ = builder.createRet(mul) +/// inspect(bb.lastInst().unwrap(), content=" ret i32 %mul") +/// } /// ``` pub fn BasicBlock::lastInst(self : BasicBlock) -> &Instruction? { loop self.head { @@ -103,16 +109,16 @@ pub fn BasicBlock::lastInst(self : BasicBlock) -> &Instruction? { ///| pub fn BasicBlock::instIter(self : BasicBlock) -> Iter[&Instruction] { - letrec f = yield_ => loop self.head { - Some(i) => { - let next_inst = i.next() - guard yield_(i) is IterContinue else { break IterEnd } - continue next_inst + let mut next_inst = self.head + Iterator::new(fn() { + match next_inst { + Some(inst) => { + next_inst = inst.next() + Some(inst) + } + None => None } - None => break IterContinue - } - - Iter::new(f) + }).iter() } ///| diff --git a/IR/Constants.mbt b/IR/Constants.mbt index 6120f4c..edfd27a 100644 --- a/IR/Constants.mbt +++ b/IR/Constants.mbt @@ -8,16 +8,18 @@ /// Use `Context::getConstInt8, getConstInt16, getConstInt32, getConstInt64` /// To create a new ConstantInt. /// -/// ```mbt test -/// let ctx = Context::new() -/// let i8 = ctx.getConstInt8(0) -/// let i16 = ctx.getConstInt16(1) -/// let i32 = ctx.getConstInt32(-2) -/// let i64 = ctx.getConstInt64(16) -/// inspect(i8, content="i8 0") -/// inspect(i16, content="i16 1") -/// inspect(i32, content="i32 -2") -/// inspect(i64, content="i64 16") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let i8 = ctx.getConstInt8(0) +/// let i16 = ctx.getConstInt16(1) +/// let i32 = ctx.getConstInt32(-2) +/// let i64 = ctx.getConstInt64(16) +/// inspect(i8, content="i8 0") +/// inspect(i16, content="i16 1") +/// inspect(i32, content="i32 -2") +/// inspect(i64, content="i64 16") +/// } /// ``` pub struct ConstantInt { // unique identifier for this value @@ -51,18 +53,20 @@ fn ConstantInt::getValue(self : ConstantInt) -> Int64 { ///| /// Get the value of this constant as a signed 64-bits integer. /// -/// ```mbt test -/// let ctx = Context::new() -/// let i8_zero = ctx.getConstInt8(0) -/// let i16_one = ctx.getConstInt16(1) -/// let i32_two = ctx.getConstInt32(2) -/// let i64_m1 = ctx.getConstInt64(-1) -/// let i8_m1 = ctx.getConstInt8(-1) -/// assert_eq(i8_zero.getValueAsInt64(), 0) -/// assert_eq(i16_one.getValueAsInt64(), 1) -/// assert_eq(i32_two.getValueAsInt64(), 2) -/// assert_eq(i64_m1.getValueAsInt64(), -1) -/// assert_eq(i8_m1.getValueAsInt64(), -1) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let i8_zero = ctx.getConstInt8(0) +/// let i16_one = ctx.getConstInt16(1) +/// let i32_two = ctx.getConstInt32(2) +/// let i64_m1 = ctx.getConstInt64(-1) +/// let i8_m1 = ctx.getConstInt8(-1) +/// assert_eq(i8_zero.getValueAsInt64(), 0) +/// assert_eq(i16_one.getValueAsInt64(), 1) +/// assert_eq(i32_two.getValueAsInt64(), 2) +/// assert_eq(i64_m1.getValueAsInt64(), -1) +/// assert_eq(i8_m1.getValueAsInt64(), -1) +/// } /// ``` pub fn ConstantInt::getValueAsInt64(self : ConstantInt) -> Int64 { self.value @@ -71,16 +75,18 @@ pub fn ConstantInt::getValueAsInt64(self : ConstantInt) -> Int64 { ///| /// Get the type of constant int value. /// -/// ```mbt test -/// let ctx = Context::new() -/// let i8_zero = ctx.getConstInt8(0) -/// let i16_one = ctx.getConstInt16(1) -/// let i32_m2 = ctx.getConstInt32(-2) -/// let i64_m16 = ctx.getConstInt64(-16) -/// inspect(i8_zero.getIntegerType(), content="i8") -/// inspect(i16_one.getIntegerType(), content="i16") -/// inspect(i32_m2.getIntegerType(), content="i32") -/// inspect(i64_m16.getIntegerType(), content="i64") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let i8_zero = ctx.getConstInt8(0) +/// let i16_one = ctx.getConstInt16(1) +/// let i32_m2 = ctx.getConstInt32(-2) +/// let i64_m16 = ctx.getConstInt64(-16) +/// inspect(i8_zero.getIntegerType(), content="i8") +/// inspect(i16_one.getIntegerType(), content="i16") +/// inspect(i32_m2.getIntegerType(), content="i32") +/// inspect(i64_m16.getIntegerType(), content="i64") +/// } /// ``` pub fn ConstantInt::getIntegerType(self : ConstantInt) -> &IntegerType { self.vty @@ -89,13 +95,15 @@ pub fn ConstantInt::getIntegerType(self : ConstantInt) -> &IntegerType { ///| /// Compare the value of this constant int with a signed integer. /// -/// ```mbt test -/// let ctx = Context::new() -/// assert_true(ctx.getConstInt8(0).equals(0)) -/// assert_true(ctx.getConstInt8(-1).equals(-1)) -/// assert_true(ctx.getConstInt8(1).equals(1)) -/// assert_true(ctx.getConstInt16(16).equals(16)) -/// assert_true(ctx.getConstInt32(-128).equals(-128)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// assert_true(ctx.getConstInt8(0).equals(0)) +/// assert_true(ctx.getConstInt8(-1).equals(-1)) +/// assert_true(ctx.getConstInt8(1).equals(1)) +/// assert_true(ctx.getConstInt16(16).equals(16)) +/// assert_true(ctx.getConstInt32(-128).equals(-128)) +/// } /// ``` pub fn[T : IntegerNumber] ConstantInt::equals( self : ConstantInt, @@ -139,21 +147,23 @@ pub fn ConstantInt::isMinValue(self : ConstantInt) -> Bool { /// **Note**: It will raise `TypeMismatchForBinaryOp` if the types of two /// ConstantInt are not the same. /// -/// ```mbt test -/// let ctx = Context::new() -/// let i8_0 = ctx.getConstInt8(0) -/// let i8_31 = ctx.getConstInt8(31) -/// inspect(i8_0.add(i8_31), content="i8 31") -/// let i16_5 = ctx.getConstInt16(5) -/// let i16_72 = ctx.getConstInt16(72) -/// inspect(i16_5.add(i16_72), content="i16 77") -/// let i32_m7 = ctx.getConstInt32(-7) -/// let i32_81 = ctx.getConstInt32(81) -/// inspect(i32_m7.add(i32_81), content="i32 74") -/// let i64_16 = ctx.getConstInt64(16) -/// let i64_m33 = ctx.getConstInt64(-33) -/// inspect(i64_16.add(i64_m33), content="i64 -17") -/// assert_true((try? i8_0.add(i16_5)) is Err(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let i8_0 = ctx.getConstInt8(0) +/// let i8_31 = ctx.getConstInt8(31) +/// inspect(i8_0.add(i8_31), content="i8 31") +/// let i16_5 = ctx.getConstInt16(5) +/// let i16_72 = ctx.getConstInt16(72) +/// inspect(i16_5.add(i16_72), content="i16 77") +/// let i32_m7 = ctx.getConstInt32(-7) +/// let i32_81 = ctx.getConstInt32(81) +/// inspect(i32_m7.add(i32_81), content="i32 74") +/// let i64_16 = ctx.getConstInt64(16) +/// let i64_m33 = ctx.getConstInt64(-33) +/// inspect(i64_16.add(i64_m33), content="i64 -17") +/// assert_true((try? i8_0.add(i16_5)) is Err(_)) +/// } /// ``` pub fn ConstantInt::add( self : ConstantInt, @@ -182,22 +192,24 @@ pub fn ConstantInt::add( /// **Note**: It will raise `TypeMismatchForBinaryOp` if the types of two /// ConstantInt are not the same. /// -/// ```mbt test -/// let ctx = Context::new() -/// let i8_0 = ctx.getConstInt8(0) -/// let i8_31 = ctx.getConstInt8(31) -/// inspect(i8_31.sub(i8_0), content="i8 31") -/// inspect(i8_0.sub(i8_31), content="i8 -31") -/// let i16_5 = ctx.getConstInt16(5) -/// let i16_72 = ctx.getConstInt16(72) -/// inspect(i16_72.sub(i16_5), content="i16 67") -/// let i32_m7 = ctx.getConstInt32(-7) -/// let i32_81 = ctx.getConstInt32(81) -/// inspect(i32_m7.sub(i32_81), content="i32 -88") -/// let i64_16 = ctx.getConstInt64(16) -/// let i64_m33 = ctx.getConstInt64(-33) -/// inspect(i64_16.sub(i64_m33), content="i64 49") -/// assert_true((try? i32_81.sub(i64_16)) is Err(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let i8_0 = ctx.getConstInt8(0) +/// let i8_31 = ctx.getConstInt8(31) +/// inspect(i8_31.sub(i8_0), content="i8 31") +/// inspect(i8_0.sub(i8_31), content="i8 -31") +/// let i16_5 = ctx.getConstInt16(5) +/// let i16_72 = ctx.getConstInt16(72) +/// inspect(i16_72.sub(i16_5), content="i16 67") +/// let i32_m7 = ctx.getConstInt32(-7) +/// let i32_81 = ctx.getConstInt32(81) +/// inspect(i32_m7.sub(i32_81), content="i32 -88") +/// let i64_16 = ctx.getConstInt64(16) +/// let i64_m33 = ctx.getConstInt64(-33) +/// inspect(i64_16.sub(i64_m33), content="i64 49") +/// assert_true((try? i32_81.sub(i64_16)) is Err(_)) +/// } /// ``` pub fn ConstantInt::sub( self : ConstantInt, @@ -226,20 +238,22 @@ pub fn ConstantInt::sub( /// **Note**: It will raise `TypeMismatchForBinaryOp` if the types of two /// ConstantInt are not the same. /// -/// ```mbt test -/// let ctx = Context::new() -/// let i8_0 = ctx.getConstInt8(0) -/// let i8_31 = ctx.getConstInt8(31) -/// inspect(i8_0.mul(i8_31), content="i8 0") -/// let i16_5 = ctx.getConstInt16(5) -/// let i16_72 = ctx.getConstInt16(72) -/// inspect(i16_5.mul(i16_72), content="i16 360") -/// let i32_m7 = ctx.getConstInt32(-7) -/// let i32_81 = ctx.getConstInt32(81) -/// inspect(i32_m7.mul(i32_81), content="i32 -567") -/// let i64_16 = ctx.getConstInt64(16) -/// let i64_m33 = ctx.getConstInt64(-33) -/// inspect(i64_16.mul(i64_m33), content="i64 -528") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let i8_0 = ctx.getConstInt8(0) +/// let i8_31 = ctx.getConstInt8(31) +/// inspect(i8_0.mul(i8_31), content="i8 0") +/// let i16_5 = ctx.getConstInt16(5) +/// let i16_72 = ctx.getConstInt16(72) +/// inspect(i16_5.mul(i16_72), content="i16 360") +/// let i32_m7 = ctx.getConstInt32(-7) +/// let i32_81 = ctx.getConstInt32(81) +/// inspect(i32_m7.mul(i32_81), content="i32 -567") +/// let i64_16 = ctx.getConstInt64(16) +/// let i64_m33 = ctx.getConstInt64(-33) +/// inspect(i64_16.mul(i64_m33), content="i64 -528") +/// } /// ``` pub fn ConstantInt::mul( self : ConstantInt, @@ -268,20 +282,22 @@ pub fn ConstantInt::mul( /// **Note**: It will raise `TypeMismatchForBinaryOp` if the types of two /// ConstantInt are not the same. /// -/// ```mbt test -/// let ctx = Context::new() -/// let i8_1 = ctx.getConstInt8(1) -/// let i8_31 = ctx.getConstInt8(31) -/// inspect(i8_31.sdiv(i8_1), content="i8 31") -/// let i16_5 = ctx.getConstInt16(5) -/// let i16_72 = ctx.getConstInt16(72) -/// inspect(i16_72.sdiv(i16_5), content="i16 14") -/// let i32_m7 = ctx.getConstInt32(-7) -/// let i32_81 = ctx.getConstInt32(81) -/// inspect(i32_m7.sdiv(i32_81), content="i32 0") -/// let i64_16 = ctx.getConstInt64(16) -/// let i64_m33 = ctx.getConstInt64(-33) -/// inspect(i64_16.sdiv(i64_m33), content="i64 0") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let i8_1 = ctx.getConstInt8(1) +/// let i8_31 = ctx.getConstInt8(31) +/// inspect(i8_31.sdiv(i8_1), content="i8 31") +/// let i16_5 = ctx.getConstInt16(5) +/// let i16_72 = ctx.getConstInt16(72) +/// inspect(i16_72.sdiv(i16_5), content="i16 14") +/// let i32_m7 = ctx.getConstInt32(-7) +/// let i32_81 = ctx.getConstInt32(81) +/// inspect(i32_m7.sdiv(i32_81), content="i32 0") +/// let i64_16 = ctx.getConstInt64(16) +/// let i64_m33 = ctx.getConstInt64(-33) +/// inspect(i64_16.sdiv(i64_m33), content="i64 0") +/// } /// ``` pub fn ConstantInt::sdiv( self : ConstantInt, @@ -314,47 +330,49 @@ pub fn ConstantInt::sdiv( /// **Note**: It will raise `TypeMismatchForBinaryOp` if the types of two /// ConstantInt are not the same. It will raise `DivisionByZeroError` if `other` is zero. /// -/// ```mbt test -/// let ctx = Context::new() -/// -/// // Test case 1: i8 unsigned division -/// // 200u8 / 10u8 = 20u8. ConstantInt stores 20L. -/// let i8_200 = ctx.getConstInt8(200) // Internally stored as -56L -/// let i8_10 = ctx.getConstInt8(10) -/// inspect(i8_200.udiv(i8_10), content="i8 20") -/// -/// // Test case 2: i8 unsigned division with -1 (255u8) -/// // 255u8 / 2u8 = 127u8. ConstantInt stores 127L. -/// let i8_m1 = ctx.getConstInt8(-1) // Internally stored as -1L, represents 255u8 -/// let i8_2 = ctx.getConstInt8(2) -/// inspect(i8_m1.udiv(i8_2), content="i8 127") -/// -/// // Test case 3: i32 unsigned division -/// // 2147483647u / 2u = 1073741823u. -/// let i32_max_signed = ctx.getConstInt32(@int.max_value) // 2147483647 -/// let i32_2 = ctx.getConstInt32(2) -/// inspect(i32_max_signed.udiv(i32_2), content="i32 1073741823") -/// -/// // Test case 4: i64 unsigned division (UInt64.max_value / 2) -/// // (-1L as UInt64) / 2 = (2^64 - 1) / 2 = 2^63 - 1 (which is Int64.max_value) -/// let i64_m1 = ctx.getConstInt64(-1L) -/// let i64_2 = ctx.getConstInt64(2L) -/// inspect(i64_m1.udiv(i64_2), content="i64 9223372036854775807") -/// -/// // Test case 5: Type mismatch -/// let i8_5 = ctx.getConstInt8(5) -/// let i16_2 = ctx.getConstInt16(2) -/// assert_true((try? i8_5.udiv(i16_2)) is Err(_)) -/// -/// // Test case 6: Division by zero -/// let i8_0 = ctx.getConstInt8(0) -/// assert_true((try? i8_5.udiv(i8_0)) is Err(_)) -/// -/// // Test case 7: i1 unsigned division -/// let i1_true = ctx.getConstTrue() -/// let i1_false = ctx.getConstFalse() -/// inspect(i1_true.udiv(i1_true), content="i1 true") // 1u / 1u = 1u -/// inspect(i1_false.udiv(i1_true), content="i1 false") // 0u / 1u = 0u +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// +/// // Test case 1: i8 unsigned division +/// // 200u8 / 10u8 = 20u8. ConstantInt stores 20L. +/// let i8_200 = ctx.getConstInt8(200) // Internally stored as -56L +/// let i8_10 = ctx.getConstInt8(10) +/// inspect(i8_200.udiv(i8_10), content="i8 20") +/// +/// // Test case 2: i8 unsigned division with -1 (255u8) +/// // 255u8 / 2u8 = 127u8. ConstantInt stores 127L. +/// let i8_m1 = ctx.getConstInt8(-1) // Internally stored as -1L, represents 255u8 +/// let i8_2 = ctx.getConstInt8(2) +/// inspect(i8_m1.udiv(i8_2), content="i8 127") +/// +/// // Test case 3: i32 unsigned division +/// // 2147483647u / 2u = 1073741823u. +/// let i32_max_signed = ctx.getConstInt32(@int.max_value) // 2147483647 +/// let i32_2 = ctx.getConstInt32(2) +/// inspect(i32_max_signed.udiv(i32_2), content="i32 1073741823") +/// +/// // Test case 4: i64 unsigned division (UInt64.max_value / 2) +/// // (-1L as UInt64) / 2 = (2^64 - 1) / 2 = 2^63 - 1 (which is Int64.max_value) +/// let i64_m1 = ctx.getConstInt64(-1L) +/// let i64_2 = ctx.getConstInt64(2L) +/// inspect(i64_m1.udiv(i64_2), content="i64 9223372036854775807") +/// +/// // Test case 5: Type mismatch +/// let i8_5 = ctx.getConstInt8(5) +/// let i16_2 = ctx.getConstInt16(2) +/// assert_true((try? i8_5.udiv(i16_2)) is Err(_)) +/// +/// // Test case 6: Division by zero +/// let i8_0 = ctx.getConstInt8(0) +/// assert_true((try? i8_5.udiv(i8_0)) is Err(_)) +/// +/// // Test case 7: i1 unsigned division +/// let i1_true = ctx.getConstTrue() +/// let i1_false = ctx.getConstFalse() +/// inspect(i1_true.udiv(i1_true), content="i1 true") // 1u / 1u = 1u +/// inspect(i1_false.udiv(i1_true), content="i1 false") // 0u / 1u = 0u +/// } /// ``` pub fn ConstantInt::udiv( self : ConstantInt, @@ -399,20 +417,22 @@ pub fn ConstantInt::udiv( ///| /// Bitwise AND two ConstantInt, useful in constant folding. /// -/// ```mbt test -/// let ctx = Context::new() -/// let i8_6 = ctx.getConstInt8(6) // 00000110 -/// let i8_3 = ctx.getConstInt8(3) // 00000011 -/// inspect(i8_6.compute_and(i8_3), content="i8 2") // 00000010 -/// let i16_m1 = ctx.getConstInt16(-1) // 1111111111111111 -/// let i16_all_set = ctx.getConstInt16(-1) -/// inspect(i16_m1.compute_and(i16_all_set), content="i16 -1") -/// let i32_pattern = ctx.getConstInt32(0x0F0F0F0F) -/// let i32_mask = ctx.getConstInt32(0xFF00FF00) -/// inspect(i32_pattern.compute_and(i32_mask), content="i32 251662080") // 0x0F000F00 -/// let i64_val = ctx.getConstInt64(0x123456789ABCDEF0L) -/// let i64_low_clear = ctx.getConstInt64(-1L << 4) // ...FFFFFFFFFFFFFFF0 -/// inspect(i64_val.compute_and(i64_low_clear), content="i64 1311768467463790320") // 0x123456789ABCDEF0 +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let i8_6 = ctx.getConstInt8(6) // 00000110 +/// let i8_3 = ctx.getConstInt8(3) // 00000011 +/// inspect(i8_6.compute_and(i8_3), content="i8 2") // 00000010 +/// let i16_m1 = ctx.getConstInt16(-1) // 1111111111111111 +/// let i16_all_set = ctx.getConstInt16(-1) +/// inspect(i16_m1.compute_and(i16_all_set), content="i16 -1") +/// let i32_pattern = ctx.getConstInt32(0x0F0F0F0F) +/// let i32_mask = ctx.getConstInt32(0xFF00FF00) +/// inspect(i32_pattern.compute_and(i32_mask), content="i32 251662080") // 0x0F000F00 +/// let i64_val = ctx.getConstInt64(0x123456789ABCDEF0L) +/// let i64_low_clear = ctx.getConstInt64(-1L << 4) // ...FFFFFFFFFFFFFFF0 +/// inspect(i64_val.compute_and(i64_low_clear), content="i64 1311768467463790320") // 0x123456789ABCDEF0 +/// } /// ``` pub fn ConstantInt::compute_and( self : ConstantInt, @@ -441,20 +461,22 @@ pub fn ConstantInt::compute_and( /// **Note**: It will raise `TypeMismatchForBinaryOp` if the types of two /// ConstantInt are not the same. /// -/// ```mbt test -/// let ctx = Context::new() -/// let i8_6 = ctx.getConstInt8(6) // 00000110 -/// let i8_3 = ctx.getConstInt8(3) // 00000011 -/// inspect(i8_6.or(i8_3), content="i8 7") // 00000111 -/// let i16_1 = ctx.getConstInt16(1) // ...0001 -/// let i16_2 = ctx.getConstInt16(2) // ...0010 -/// inspect(i16_1.or(i16_2), content="i16 3") // ...0011 -/// let i32_pattern = ctx.getConstInt32(0x0F0F0F0F) -/// let i32_mask = ctx.getConstInt32(0xF0F0F0F0) -/// inspect(i32_pattern.or(i32_mask), content="i32 -1") // 0xFFFFFFFF -/// let i64_val = ctx.getConstInt64(0L) -/// let i64_m1 = ctx.getConstInt64(-1L) -/// inspect(i64_val.or(i64_m1), content="i64 -1") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let i8_6 = ctx.getConstInt8(6) // 00000110 +/// let i8_3 = ctx.getConstInt8(3) // 00000011 +/// inspect(i8_6.or(i8_3), content="i8 7") // 00000111 +/// let i16_1 = ctx.getConstInt16(1) // ...0001 +/// let i16_2 = ctx.getConstInt16(2) // ...0010 +/// inspect(i16_1.or(i16_2), content="i16 3") // ...0011 +/// let i32_pattern = ctx.getConstInt32(0x0F0F0F0F) +/// let i32_mask = ctx.getConstInt32(0xF0F0F0F0) +/// inspect(i32_pattern.or(i32_mask), content="i32 -1") // 0xFFFFFFFF +/// let i64_val = ctx.getConstInt64(0L) +/// let i64_m1 = ctx.getConstInt64(-1L) +/// inspect(i64_val.or(i64_m1), content="i64 -1") +/// } /// ``` pub fn ConstantInt::or( self : ConstantInt, @@ -483,20 +505,22 @@ pub fn ConstantInt::or( /// **Note**: It will raise `TypeMismatchForBinaryOp` if the types of two /// ConstantInt are not the same. /// -/// ```mbt test -/// let ctx = Context::new() -/// let i8_6 = ctx.getConstInt8(6) // 00000110 -/// let i8_3 = ctx.getConstInt8(3) // 00000011 -/// inspect(i8_6.xor(i8_3), content="i8 5") // 00000101 -/// let i16_val = ctx.getConstInt16(0xAA) // ...10101010 -/// let i16_m1 = ctx.getConstInt16(-1) // ...11111111 -/// inspect(i16_val.xor(i16_m1), content="i16 -171") // ...01010101 (which is -0xAB or -171 for i16) -/// let i32_pattern = ctx.getConstInt32(0x0F0F0F0F) -/// let i32_self_xor = i32_pattern.xor(i32_pattern) -/// inspect(i32_self_xor, content="i32 0") -/// let i64_val = ctx.getConstInt64(12345L) -/// let i64_0 = ctx.getConstInt64(0L) -/// inspect(i64_val.xor(i64_0), content="i64 12345") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let i8_6 = ctx.getConstInt8(6) // 00000110 +/// let i8_3 = ctx.getConstInt8(3) // 00000011 +/// inspect(i8_6.xor(i8_3), content="i8 5") // 00000101 +/// let i16_val = ctx.getConstInt16(0xAA) // ...10101010 +/// let i16_m1 = ctx.getConstInt16(-1) // ...11111111 +/// inspect(i16_val.xor(i16_m1), content="i16 -171") // ...01010101 (which is -0xAB or -171 for i16) +/// let i32_pattern = ctx.getConstInt32(0x0F0F0F0F) +/// let i32_self_xor = i32_pattern.xor(i32_pattern) +/// inspect(i32_self_xor, content="i32 0") +/// let i64_val = ctx.getConstInt64(12345L) +/// let i64_0 = ctx.getConstInt64(0L) +/// inspect(i64_val.xor(i64_0), content="i64 12345") +/// } /// ``` pub fn ConstantInt::xor( self : ConstantInt, @@ -525,20 +549,22 @@ pub fn ConstantInt::xor( /// **Note**: It will raise `TypeMismatchForBinaryOp` if the types of two /// ConstantInt are not the same. /// -/// ```mbt test -/// let ctx = Context::new() -/// let i8_1 = ctx.getConstInt8(1) // 00000001 -/// let i8_3 = ctx.getConstInt8(3) // shift by 3 -/// inspect(i8_1.compute_shl(i8_3), content="i8 8") // 00001000 -/// let i16_5 = ctx.getConstInt16(5) // ...00000101 -/// let i16_2 = ctx.getConstInt16(2) // shift by 2 -/// inspect(i16_5.compute_shl(i16_2), content="i16 20") // ...00010100 -/// let i32_7 = ctx.getConstInt32(7) -/// let i32_4 = ctx.getConstInt32(4) -/// inspect(i32_7.compute_shl(i32_4), content="i32 112") // 7 << 4 = 112 -/// let i64_val = ctx.getConstInt64(0x123L) -/// let i64_8 = ctx.getConstInt64(8L) -/// inspect(i64_val.compute_shl(i64_8), content="i64 74496") // 0x123 << 8 = 0x12300 +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let i8_1 = ctx.getConstInt8(1) // 00000001 +/// let i8_3 = ctx.getConstInt8(3) // shift by 3 +/// inspect(i8_1.compute_shl(i8_3), content="i8 8") // 00001000 +/// let i16_5 = ctx.getConstInt16(5) // ...00000101 +/// let i16_2 = ctx.getConstInt16(2) // shift by 2 +/// inspect(i16_5.compute_shl(i16_2), content="i16 20") // ...00010100 +/// let i32_7 = ctx.getConstInt32(7) +/// let i32_4 = ctx.getConstInt32(4) +/// inspect(i32_7.compute_shl(i32_4), content="i32 112") // 7 << 4 = 112 +/// let i64_val = ctx.getConstInt64(0x123L) +/// let i64_8 = ctx.getConstInt64(8L) +/// inspect(i64_val.compute_shl(i64_8), content="i64 74496") // 0x123 << 8 = 0x12300 +/// } /// ``` pub fn ConstantInt::compute_shl( self : ConstantInt, @@ -567,20 +593,22 @@ pub fn ConstantInt::compute_shl( /// **Note**: It will raise `TypeMismatchForBinaryOp` if the types of two /// ConstantInt are not the same. /// -/// ```mbt test -/// let ctx = Context::new() -/// let i8_200 = ctx.getConstInt8(200) // 11001000 (as unsigned) -/// let i8_2 = ctx.getConstInt8(2) // shift by 2 -/// inspect(i8_200.lshr(i8_2), content="i8 50") // 00110010 (50) -/// let i16_val = ctx.getConstInt16(-32768) // 1000000000000000 -/// let i16_1 = ctx.getConstInt16(1) // shift by 1 -/// inspect(i16_val.lshr(i16_1), content="i16 16384") // 0100000000000000 (16384) -/// let i32_m1 = ctx.getConstInt32(-1) // 0xFFFFFFFF -/// let i32_4 = ctx.getConstInt32(4) // shift by 4 -/// inspect(i32_m1.lshr(i32_4), content="i32 268435455") // 0x0FFFFFFF -/// let i64_val = ctx.getConstInt64(0x8000000000000000L) // MSB set -/// let i64_1 = ctx.getConstInt64(1L) -/// inspect(i64_val.lshr(i64_1), content="i64 4611686018427387904") // logical shift +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let i8_200 = ctx.getConstInt8(200) // 11001000 (as unsigned) +/// let i8_2 = ctx.getConstInt8(2) // shift by 2 +/// inspect(i8_200.lshr(i8_2), content="i8 50") // 00110010 (50) +/// let i16_val = ctx.getConstInt16(-32768) // 1000000000000000 +/// let i16_1 = ctx.getConstInt16(1) // shift by 1 +/// inspect(i16_val.lshr(i16_1), content="i16 16384") // 0100000000000000 (16384) +/// let i32_m1 = ctx.getConstInt32(-1) // 0xFFFFFFFF +/// let i32_4 = ctx.getConstInt32(4) // shift by 4 +/// inspect(i32_m1.lshr(i32_4), content="i32 268435455") // 0x0FFFFFFF +/// let i64_val = ctx.getConstInt64(0x8000000000000000L) // MSB set +/// let i64_1 = ctx.getConstInt64(1L) +/// inspect(i64_val.lshr(i64_1), content="i64 4611686018427387904") // logical shift +/// } /// ``` pub fn ConstantInt::lshr( self : ConstantInt, @@ -627,25 +655,27 @@ pub fn ConstantInt::lshr( /// **Note**: It will raise `TypeMismatchForBinaryOp` if the types of two /// ConstantInt are not the same. /// -/// ```mbt test -/// let ctx = Context::new() -/// let i8_m1 = ctx.getConstInt8(-1) // 11111111 -/// let i8_2 = ctx.getConstInt8(2) // shift by 2 -/// inspect(i8_m1.ashr(i8_2), content="i8 -1") // 11111111 (sign extended) -/// let i16_m16 = ctx.getConstInt16(-16) // ...1111111111110000 -/// let i16_2 = ctx.getConstInt16(2) // shift by 2 -/// inspect(i16_m16.ashr(i16_2), content="i16 -4") // ...1111111111111100 -/// let i32_m8 = ctx.getConstInt32(-8) -/// let i32_1 = ctx.getConstInt32(1) -/// inspect(i32_m8.ashr(i32_1), content="i32 -4") // -8 >> 1 = -4 (arithmetic) -/// let i64_m128 = ctx.getConstInt64(-128L) -/// let i64_3 = ctx.getConstInt64(3L) -/// inspect(i64_m128.ashr(i64_3), content="i64 -16") // -128 >> 3 = -16 -/// -/// // Positive numbers should behave like logical shift -/// let i32_64 = ctx.getConstInt32(64) -/// let i32_2 = ctx.getConstInt32(2) -/// inspect(i32_64.ashr(i32_2), content="i32 16") // 64 >> 2 = 16 +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let i8_m1 = ctx.getConstInt8(-1) // 11111111 +/// let i8_2 = ctx.getConstInt8(2) // shift by 2 +/// inspect(i8_m1.ashr(i8_2), content="i8 -1") // 11111111 (sign extended) +/// let i16_m16 = ctx.getConstInt16(-16) // ...1111111111110000 +/// let i16_2 = ctx.getConstInt16(2) // shift by 2 +/// inspect(i16_m16.ashr(i16_2), content="i16 -4") // ...1111111111111100 +/// let i32_m8 = ctx.getConstInt32(-8) +/// let i32_1 = ctx.getConstInt32(1) +/// inspect(i32_m8.ashr(i32_1), content="i32 -4") // -8 >> 1 = -4 (arithmetic) +/// let i64_m128 = ctx.getConstInt64(-128L) +/// let i64_3 = ctx.getConstInt64(3L) +/// inspect(i64_m128.ashr(i64_3), content="i64 -16") // -128 >> 3 = -16 +/// +/// // Positive numbers should behave like logical shift +/// let i32_64 = ctx.getConstInt32(64) +/// let i32_2 = ctx.getConstInt32(2) +/// inspect(i32_64.ashr(i32_2), content="i32 16") // 64 >> 2 = 16 +/// } /// ``` pub fn ConstantInt::ashr( self : ConstantInt, @@ -674,41 +704,43 @@ pub fn ConstantInt::ashr( /// **Note**: It will raise `TypeMismatchForBinaryOp` if the types of two /// ConstantInt are not the same. Only ICMP_xxx predicates are supported. /// -/// ```mbt test -/// let ctx = Context::new() -/// let i8_5 = ctx.getConstInt8(5) -/// let i8_10 = ctx.getConstInt8(10) -/// let i8_m5 = ctx.getConstInt8(-5) -/// -/// // Test EQ -/// inspect(i8_5.compare(EQ, i8_5), content="i1 true") -/// inspect(i8_5.compare(EQ, i8_10), content="i1 false") -/// -/// // Test NE -/// inspect(i8_5.compare(NE, i8_10), content="i1 true") -/// inspect(i8_5.compare(NE, i8_5), content="i1 false") -/// -/// // Test SGT (signed greater than) -/// inspect(i8_10.compare(SGT, i8_5), content="i1 true") -/// inspect(i8_5.compare(SGT, i8_10), content="i1 false") -/// inspect(i8_5.compare(SGT, i8_m5), content="i1 true") -/// -/// // Test UGT (unsigned greater than) -/// let i8_200 = ctx.getConstInt8(200) // -56 as signed, 200 as unsigned -/// inspect(i8_200.compare(UGT, i8_10), content="i1 true") -/// inspect(i8_10.compare(UGT, i8_200), content="i1 false") -/// -/// // Test SLT (signed less than) -/// inspect(i8_5.compare(SLT, i8_10), content="i1 true") -/// inspect(i8_m5.compare(SLT, i8_5), content="i1 true") -/// -/// // Test ULE (unsigned less or equal) -/// inspect(i8_5.compare(ULE, i8_10), content="i1 true") -/// inspect(i8_5.compare(ULE, i8_5), content="i1 true") -/// -/// // Test type mismatch -/// let i16_5 = ctx.getConstInt16(5) -/// assert_true((try? i8_5.compare(EQ, i16_5)) is Err(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let i8_5 = ctx.getConstInt8(5) +/// let i8_10 = ctx.getConstInt8(10) +/// let i8_m5 = ctx.getConstInt8(-5) +/// +/// // Test EQ +/// inspect(i8_5.compare(EQ, i8_5), content="i1 true") +/// inspect(i8_5.compare(EQ, i8_10), content="i1 false") +/// +/// // Test NE +/// inspect(i8_5.compare(NE, i8_10), content="i1 true") +/// inspect(i8_5.compare(NE, i8_5), content="i1 false") +/// +/// // Test SGT (signed greater than) +/// inspect(i8_10.compare(SGT, i8_5), content="i1 true") +/// inspect(i8_5.compare(SGT, i8_10), content="i1 false") +/// inspect(i8_5.compare(SGT, i8_m5), content="i1 true") +/// +/// // Test UGT (unsigned greater than) +/// let i8_200 = ctx.getConstInt8(200) // -56 as signed, 200 as unsigned +/// inspect(i8_200.compare(UGT, i8_10), content="i1 true") +/// inspect(i8_10.compare(UGT, i8_200), content="i1 false") +/// +/// // Test SLT (signed less than) +/// inspect(i8_5.compare(SLT, i8_10), content="i1 true") +/// inspect(i8_m5.compare(SLT, i8_5), content="i1 true") +/// +/// // Test ULE (unsigned less or equal) +/// inspect(i8_5.compare(ULE, i8_10), content="i1 true") +/// inspect(i8_5.compare(ULE, i8_5), content="i1 true") +/// +/// // Test type mismatch +/// let i16_5 = ctx.getConstInt16(5) +/// assert_true((try? i8_5.compare(EQ, i16_5)) is Err(_)) +/// } /// ``` pub fn ConstantInt::compare( self : ConstantInt, @@ -794,21 +826,23 @@ pub fn ConstantInt::compare( /// **Note**: It will raise `TruncCastInstTypeMismatch` if the source type bit width /// is not greater than the destination type bit width. /// -/// ```mbt test -/// let ctx = Context::new() -/// let i32_255 = ctx.getConstInt32(255) -/// let i8_255 = i32_255.trunc(ctx.getInt8Ty()) -/// inspect(i8_255, content="i8 -1") -/// let i64_0xFFFF = ctx.getConstInt64(0xFFFF) -/// let i16_0xFFFF = i64_0xFFFF.trunc(ctx.getInt16Ty()) -/// inspect(i16_0xFFFF, content="i16 -1") -/// let i32_12345 = ctx.getConstInt32(12345) -/// let i16_12345 = i32_12345.trunc(ctx.getInt16Ty()) -/// inspect(i16_12345, content="i16 12345") -/// -/// // Test error case: cannot truncate to larger type -/// let i8_val = ctx.getConstInt8(42) -/// assert_true((try? i8_val.trunc(ctx.getInt32Ty())) is Err(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let i32_255 = ctx.getConstInt32(255) +/// let i8_255 = i32_255.trunc(ctx.getInt8Ty()) +/// inspect(i8_255, content="i8 -1") +/// let i64_0xFFFF = ctx.getConstInt64(0xFFFF) +/// let i16_0xFFFF = i64_0xFFFF.trunc(ctx.getInt16Ty()) +/// inspect(i16_0xFFFF, content="i16 -1") +/// let i32_12345 = ctx.getConstInt32(12345) +/// let i16_12345 = i32_12345.trunc(ctx.getInt16Ty()) +/// inspect(i16_12345, content="i16 12345") +/// +/// // Test error case: cannot truncate to larger type +/// let i8_val = ctx.getConstInt8(42) +/// assert_true((try? i8_val.trunc(ctx.getInt32Ty())) is Err(_)) +/// } /// ``` pub fn ConstantInt::trunc( self : ConstantInt, @@ -828,21 +862,23 @@ pub fn ConstantInt::trunc( /// **Note**: It will raise `ZExtCastInstTypeMismatch` if the source type bit width /// is not less than the destination type bit width. /// -/// ```mbt test -/// let ctx = Context::new() -/// let i8_255 = ctx.getConstInt8(255) // -1 as signed, 255 as unsigned -/// let i32_255 = i8_255.zext(ctx.getInt32Ty()) -/// inspect(i32_255, content="i32 255") -/// let i1_true = ctx.getConstTrue() -/// let i8_true = i1_true.zext(ctx.getInt8Ty()) -/// inspect(i8_true, content="i8 1") -/// let i16_42 = ctx.getConstInt16(42) -/// let i64_42 = i16_42.zext(ctx.getInt64Ty()) -/// inspect(i64_42, content="i64 42") -/// -/// // Test error case: cannot zext to smaller type -/// let i32_val = ctx.getConstInt32(42) -/// assert_true((try? i32_val.zext(ctx.getInt8Ty())) is Err(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let i8_255 = ctx.getConstInt8(255) // -1 as signed, 255 as unsigned +/// let i32_255 = i8_255.zext(ctx.getInt32Ty()) +/// inspect(i32_255, content="i32 255") +/// let i1_true = ctx.getConstTrue() +/// let i8_true = i1_true.zext(ctx.getInt8Ty()) +/// inspect(i8_true, content="i8 1") +/// let i16_42 = ctx.getConstInt16(42) +/// let i64_42 = i16_42.zext(ctx.getInt64Ty()) +/// inspect(i64_42, content="i64 42") +/// +/// // Test error case: cannot zext to smaller type +/// let i32_val = ctx.getConstInt32(42) +/// assert_true((try? i32_val.zext(ctx.getInt8Ty())) is Err(_)) +/// } /// ``` pub fn ConstantInt::zext( self : ConstantInt, @@ -870,21 +906,23 @@ pub fn ConstantInt::zext( /// **Note**: It will raise `SExtCastInstTypeMismatch` if the source type bit width /// is not less than the destination type bit width. /// -/// ```mbt test -/// let ctx = Context::new() -/// let i8_m1 = ctx.getConstInt8(-1) -/// let i32_m1 = i8_m1.sext(ctx.getInt32Ty()) -/// inspect(i32_m1, content="i32 -1") -/// let i1_true = ctx.getConstTrue() -/// let i8_true = i1_true.sext(ctx.getInt8Ty()) -/// inspect(i8_true, content="i8 -1") -/// let i16_42 = ctx.getConstInt16(42) -/// let i64_42 = i16_42.sext(ctx.getInt64Ty()) -/// inspect(i64_42, content="i64 42") -/// -/// // Test error case: cannot sext to smaller type -/// let i32_val = ctx.getConstInt32(42) -/// assert_true((try? i32_val.sext(ctx.getInt8Ty())) is Err(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let i8_m1 = ctx.getConstInt8(-1) +/// let i32_m1 = i8_m1.sext(ctx.getInt32Ty()) +/// inspect(i32_m1, content="i32 -1") +/// let i1_true = ctx.getConstTrue() +/// let i8_true = i1_true.sext(ctx.getInt8Ty()) +/// inspect(i8_true, content="i8 -1") +/// let i16_42 = ctx.getConstInt16(42) +/// let i64_42 = i16_42.sext(ctx.getInt64Ty()) +/// inspect(i64_42, content="i64 42") +/// +/// // Test error case: cannot sext to smaller type +/// let i32_val = ctx.getConstInt32(42) +/// assert_true((try? i32_val.sext(ctx.getInt8Ty())) is Err(_)) +/// } /// ``` pub fn ConstantInt::sext( self : ConstantInt, @@ -908,17 +946,19 @@ pub fn ConstantInt::sext( /// /// **Note**: It will raise `UIToFPInstTypeMismatch` if the source is not an integer type. /// -/// ```mbt test -/// let ctx = Context::new() -/// let i32_255 = ctx.getConstInt32(255) -/// let f32_255 = i32_255.uitofp(ctx.getFloatTy()) -/// assert_eq(f32_255.getValue(), 255.0) -/// let i8_m1 = ctx.getConstInt8(-1) // 255 as unsigned -/// let f64_255 = i8_m1.uitofp(ctx.getDoubleTy()) -/// assert_eq(f64_255.getValue(), 255.0) -/// let i64_0 = ctx.getConstInt64(0) -/// let f32_0 = i64_0.uitofp(ctx.getFloatTy()) -/// assert_eq(f32_0.getValue(), 0.0) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let i32_255 = ctx.getConstInt32(255) +/// let f32_255 = i32_255.uitofp(ctx.getFloatTy()) +/// assert_eq(f32_255.getValue(), 255.0) +/// let i8_m1 = ctx.getConstInt8(-1) // 255 as unsigned +/// let f64_255 = i8_m1.uitofp(ctx.getDoubleTy()) +/// assert_eq(f64_255.getValue(), 255.0) +/// let i64_0 = ctx.getConstInt64(0) +/// let f32_0 = i64_0.uitofp(ctx.getFloatTy()) +/// assert_eq(f32_0.getValue(), 0.0) +/// } /// ``` pub fn ConstantInt::uitofp(self : ConstantInt, dst_ty : &FPType) -> ConstantFP { let src_ty = self.vty.asIntegerTypeEnum() @@ -939,17 +979,19 @@ pub fn ConstantInt::uitofp(self : ConstantInt, dst_ty : &FPType) -> ConstantFP { /// /// **Note**: It will raise `SIToFPInstTypeMismatch` if the source is not an integer type. /// -/// ```mbt test -/// let ctx = Context::new() -/// let i32_m42 = ctx.getConstInt32(-42) -/// let f32_m42 = i32_m42.sitofp(ctx.getFloatTy()) -/// assert_eq(f32_m42.getValue(), -42.0) -/// let i8_127 = ctx.getConstInt8(127) -/// let f64_127 = i8_127.sitofp(ctx.getDoubleTy()) -/// assert_eq(f64_127.getValue(), 127.0) -/// let i64_0 = ctx.getConstInt64(0) -/// let f32_0 = i64_0.sitofp(ctx.getFloatTy()) -/// assert_eq(f32_0.getValue(), 0.0) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let i32_m42 = ctx.getConstInt32(-42) +/// let f32_m42 = i32_m42.sitofp(ctx.getFloatTy()) +/// assert_eq(f32_m42.getValue(), -42.0) +/// let i8_127 = ctx.getConstInt8(127) +/// let f64_127 = i8_127.sitofp(ctx.getDoubleTy()) +/// assert_eq(f64_127.getValue(), 127.0) +/// let i64_0 = ctx.getConstInt64(0) +/// let f32_0 = i64_0.sitofp(ctx.getFloatTy()) +/// assert_eq(f32_0.getValue(), 0.0) +/// } /// ``` pub fn ConstantInt::sitofp(self : ConstantInt, dst_ty : &FPType) -> ConstantFP { // Convert signed integer to floating point @@ -964,14 +1006,16 @@ pub fn ConstantInt::sitofp(self : ConstantInt, dst_ty : &FPType) -> ConstantFP { /// For constant folding, this always returns a null pointer since we cannot create /// meaningful pointer constants from integer values at compile time. /// -/// ```mbt test -/// let ctx = Context::new() -/// let i64_0 = ctx.getConstInt64(0) -/// let null_ptr = i64_0.inttoptr() -/// inspect(null_ptr, content="ptr null") -/// let i32_42 = ctx.getConstInt32(42) -/// let ptr_42 = i32_42.inttoptr() -/// inspect(ptr_42, content="ptr null") // Still null in constant folding +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let i64_0 = ctx.getConstInt64(0) +/// let null_ptr = i64_0.inttoptr() +/// inspect(null_ptr, content="ptr null") +/// let i32_42 = ctx.getConstInt32(42) +/// let ptr_42 = i32_42.inttoptr() +/// inspect(ptr_42, content="ptr null") // Still null in constant folding +/// } /// ``` pub fn ConstantInt::inttoptr(self : ConstantInt) -> ConstantPointerNull { let ctx = self.getType().getContext() @@ -985,24 +1029,26 @@ pub fn ConstantInt::inttoptr(self : ConstantInt) -> ConstantPointerNull { /// or if the cast is invalid. It will raise `BitCastOnlyAcceptPrimitiveTypes` if the source /// is not a primitive type. /// -/// ```mbt test -/// let ctx = Context::new() -/// -/// // Test i32 to f32 bitcast -/// let i32_val = ctx.getConstInt32(0x40000000) // 2.0 in float -/// let f32_val = i32_val.bitcast(ctx.getFloatTy()) -/// guard f32_val.asConstantEnum() is ConstantFP(f32_val) -/// assert_eq(f32_val.getValue(), 2.0) -/// -/// // Test i64 to f64 bitcast -/// let i64_val = ctx.getConstInt64(0x4000000000000000L) // 2.0 in double -/// let f64_val = i64_val.bitcast(ctx.getDoubleTy()) -/// guard f64_val.asConstantEnum() is ConstantFP(f64_val) -/// assert_eq(f64_val.getValue(), 2.0) -/// -/// // Test error case: different bit widths -/// let i8_val = ctx.getConstInt8(42) -/// assert_true((try? i8_val.bitcast(ctx.getFloatTy())) is Err(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// +/// // Test i32 to f32 bitcast +/// let i32_val = ctx.getConstInt32(0x40000000) // 2.0 in float +/// let f32_val = i32_val.bitcast(ctx.getFloatTy()) +/// guard f32_val.asConstantEnum() is ConstantFP(f32_val) +/// assert_eq(f32_val.getValue(), 2.0) +/// +/// // Test i64 to f64 bitcast +/// let i64_val = ctx.getConstInt64(0x4000000000000000L) // 2.0 in double +/// let f64_val = i64_val.bitcast(ctx.getDoubleTy()) +/// guard f64_val.asConstantEnum() is ConstantFP(f64_val) +/// assert_eq(f64_val.getValue(), 2.0) +/// +/// // Test error case: different bit widths +/// let i8_val = ctx.getConstInt8(42) +/// assert_true((try? i8_val.bitcast(ctx.getFloatTy())) is Err(_)) +/// } /// ``` pub fn ConstantInt::bitcast( self : ConstantInt, @@ -1151,16 +1197,18 @@ pub fn[T : Floating] ConstantFP::exactlyEquals( /// **Note**: It will raise `TypeMismatchForBinaryOp` if the types of two /// ConstantFP are not the same. /// -/// ```mbt test -/// let ctx = Context::new() -/// let f32_0 = ctx.getConstFloat(0.0) -/// let f32_1_5 = ctx.getConstFloat(1.5) -/// let result1 = f32_0.add(f32_1_5) -/// assert_eq(result1.getValue(), 1.5) -/// let f64_2_5 = ctx.getConstDouble(2.5) -/// let f64_m1_5 = ctx.getConstDouble(-1.5) -/// let result2 = f64_2_5.add(f64_m1_5) -/// assert_eq(result2.getValue(), 1.0) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let f32_0 = ctx.getConstFloat(0.0) +/// let f32_1_5 = ctx.getConstFloat(1.5) +/// let result1 = f32_0.add(f32_1_5) +/// assert_eq(result1.getValue(), 1.5) +/// let f64_2_5 = ctx.getConstDouble(2.5) +/// let f64_m1_5 = ctx.getConstDouble(-1.5) +/// let result2 = f64_2_5.add(f64_m1_5) +/// assert_eq(result2.getValue(), 1.0) +/// } /// ``` pub fn ConstantFP::add( self : ConstantFP, @@ -1182,16 +1230,18 @@ pub fn ConstantFP::add( /// **Note**: It will raise `TypeMismatchForBinaryOp` if the types of two /// ConstantFP are not the same. /// -/// ```mbt test -/// let ctx = Context::new() -/// let f32_0 = ctx.getConstFloat(0.0) -/// let f32_1_5 = ctx.getConstFloat(1.5) -/// let result1 = f32_0.sub(f32_1_5) -/// assert_eq(result1.getValue(), -1.5) -/// let f64_2_5 = ctx.getConstDouble(2.5) -/// let f64_m1_5 = ctx.getConstDouble(-1.5) -/// let result2 = f64_2_5.sub(f64_m1_5) -/// assert_eq(result2.getValue(), 4.0) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let f32_0 = ctx.getConstFloat(0.0) +/// let f32_1_5 = ctx.getConstFloat(1.5) +/// let result1 = f32_0.sub(f32_1_5) +/// assert_eq(result1.getValue(), -1.5) +/// let f64_2_5 = ctx.getConstDouble(2.5) +/// let f64_m1_5 = ctx.getConstDouble(-1.5) +/// let result2 = f64_2_5.sub(f64_m1_5) +/// assert_eq(result2.getValue(), 4.0) +/// } /// ``` pub fn ConstantFP::sub( self : ConstantFP, @@ -1213,16 +1263,18 @@ pub fn ConstantFP::sub( /// **Note**: It will raise `TypeMismatchForBinaryOp` if the types of two /// ConstantFP are not the same. /// -/// ```mbt test -/// let ctx = Context::new() -/// let f32_0 = ctx.getConstFloat(0.0) -/// let f32_1_5 = ctx.getConstFloat(1.5) -/// let result1 = f32_0.mul(f32_1_5) -/// assert_eq(result1.getValue(), 0.0) -/// let f64_2_5 = ctx.getConstDouble(2.5) -/// let f64_m1_5 = ctx.getConstDouble(-1.5) -/// let result2 = f64_2_5.mul(f64_m1_5) -/// assert_eq(result2.getValue(), -3.75) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let f32_0 = ctx.getConstFloat(0.0) +/// let f32_1_5 = ctx.getConstFloat(1.5) +/// let result1 = f32_0.mul(f32_1_5) +/// assert_eq(result1.getValue(), 0.0) +/// let f64_2_5 = ctx.getConstDouble(2.5) +/// let f64_m1_5 = ctx.getConstDouble(-1.5) +/// let result2 = f64_2_5.mul(f64_m1_5) +/// assert_eq(result2.getValue(), -3.75) +/// } /// ``` pub fn ConstantFP::mul( self : ConstantFP, @@ -1244,16 +1296,18 @@ pub fn ConstantFP::mul( /// **Note**: It will raise `TypeMismatchForBinaryOp` if the types of two /// ConstantFP are not the same. /// -/// ```mbt test -/// let ctx = Context::new() -/// let f32_0 = ctx.getConstFloat(0.0) -/// let f32_1_5 = ctx.getConstFloat(1.5) -/// let result1 = f32_0.div(f32_1_5) -/// assert_eq(result1.getValue(), 0.0) -/// let f64_2_5 = ctx.getConstDouble(2.5) -/// let f64_m1_5 = ctx.getConstDouble(-1.5) -/// let result2 = f64_2_5.div(f64_m1_5) -/// assert_eq(result2.getValue(), -5.0 / 3.0) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let f32_0 = ctx.getConstFloat(0.0) +/// let f32_1_5 = ctx.getConstFloat(1.5) +/// let result1 = f32_0.div(f32_1_5) +/// assert_eq(result1.getValue(), 0.0) +/// let f64_2_5 = ctx.getConstDouble(2.5) +/// let f64_m1_5 = ctx.getConstDouble(-1.5) +/// let result2 = f64_2_5.div(f64_m1_5) +/// assert_eq(result2.getValue(), -5.0 / 3.0) +/// } /// ``` pub fn ConstantFP::div( self : ConstantFP, @@ -1275,49 +1329,51 @@ pub fn ConstantFP::div( /// **Note**: It will raise `TypeMismatchForCmpInst` if the types of two /// ConstantFP are not the same. Only FCMP_xxx predicates are supported. /// -/// ```mbt test -/// let ctx = Context::new() -/// let f32_1_5 = ctx.getConstFloat(1.5) -/// let f32_2_5 = ctx.getConstFloat(2.5) -/// let f32_nan = ctx.getConstFloat(0.0 / 0.0) -/// -/// // Test FCMP_OEQ (ordered equal) -/// inspect(f32_1_5.compare(OEQ, f32_1_5), content="i1 true") -/// inspect(f32_1_5.compare(OEQ, f32_2_5), content="i1 false") -/// inspect(f32_nan.compare(OEQ, f32_nan), content="i1 false") // NaN != NaN -/// -/// // Test UEQ (unordered equal) -/// inspect(f32_1_5.compare(UEQ, f32_1_5), content="i1 true") -/// inspect(f32_nan.compare(UEQ, f32_nan), content="i1 true") // NaN == NaN in unordered -/// -/// // Test OGT (ordered greater than) -/// inspect(f32_2_5.compare(OGT, f32_1_5), content="i1 true") -/// inspect(f32_1_5.compare(OGT, f32_2_5), content="i1 false") -/// inspect(f32_nan.compare(OGT, f32_1_5), content="i1 false") // NaN comparisons are false -/// -/// // Test UGT (unordered greater than) -/// inspect(f32_2_5.compare(UGT, f32_1_5), content="i1 true") -/// inspect(f32_nan.compare(UGT, f32_1_5), content="i1 true") // NaN makes it unordered -/// -/// // Test OLT (ordered less than) -/// inspect(f32_1_5.compare(OLT, f32_2_5), content="i1 true") -/// inspect(f32_2_5.compare(OLT, f32_1_5), content="i1 false") -/// -/// // Test ORD (ordered - no NaNs) -/// inspect(f32_1_5.compare(ORD, f32_2_5), content="i1 true") -/// inspect(f32_nan.compare(ORD, f32_1_5), content="i1 false") -/// -/// // Test UNO (unordered - has NaNs) -/// inspect(f32_1_5.compare(UNO, f32_2_5), content="i1 false") -/// inspect(f32_nan.compare(UNO, f32_1_5), content="i1 true") -/// -/// // Test TRUE and FCMP_FALSE -/// inspect(f32_1_5.compare(TRUE, f32_2_5), content="i1 true") -/// inspect(f32_1_5.compare(FALSE, f32_2_5), content="i1 false") -/// -/// // Test type mismatch -/// let f64_1_5 = ctx.getConstDouble(1.5) -/// assert_true((try? f32_1_5.compare(OEQ, f64_1_5)) is Err(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let f32_1_5 = ctx.getConstFloat(1.5) +/// let f32_2_5 = ctx.getConstFloat(2.5) +/// let f32_nan = ctx.getConstFloat(0.0 / 0.0) +/// +/// // Test FCMP_OEQ (ordered equal) +/// inspect(f32_1_5.compare(OEQ, f32_1_5), content="i1 true") +/// inspect(f32_1_5.compare(OEQ, f32_2_5), content="i1 false") +/// inspect(f32_nan.compare(OEQ, f32_nan), content="i1 false") // NaN != NaN +/// +/// // Test UEQ (unordered equal) +/// inspect(f32_1_5.compare(UEQ, f32_1_5), content="i1 true") +/// inspect(f32_nan.compare(UEQ, f32_nan), content="i1 true") // NaN == NaN in unordered +/// +/// // Test OGT (ordered greater than) +/// inspect(f32_2_5.compare(OGT, f32_1_5), content="i1 true") +/// inspect(f32_1_5.compare(OGT, f32_2_5), content="i1 false") +/// inspect(f32_nan.compare(OGT, f32_1_5), content="i1 false") // NaN comparisons are false +/// +/// // Test UGT (unordered greater than) +/// inspect(f32_2_5.compare(UGT, f32_1_5), content="i1 true") +/// inspect(f32_nan.compare(UGT, f32_1_5), content="i1 true") // NaN makes it unordered +/// +/// // Test OLT (ordered less than) +/// inspect(f32_1_5.compare(OLT, f32_2_5), content="i1 true") +/// inspect(f32_2_5.compare(OLT, f32_1_5), content="i1 false") +/// +/// // Test ORD (ordered - no NaNs) +/// inspect(f32_1_5.compare(ORD, f32_2_5), content="i1 true") +/// inspect(f32_nan.compare(ORD, f32_1_5), content="i1 false") +/// +/// // Test UNO (unordered - has NaNs) +/// inspect(f32_1_5.compare(UNO, f32_2_5), content="i1 false") +/// inspect(f32_nan.compare(UNO, f32_1_5), content="i1 true") +/// +/// // Test TRUE and FCMP_FALSE +/// inspect(f32_1_5.compare(TRUE, f32_2_5), content="i1 true") +/// inspect(f32_1_5.compare(FALSE, f32_2_5), content="i1 false") +/// +/// // Test type mismatch +/// let f64_1_5 = ctx.getConstDouble(1.5) +/// assert_true((try? f32_1_5.compare(OEQ, f64_1_5)) is Err(_)) +/// } /// ``` pub fn ConstantFP::compare( self : ConstantFP, @@ -1365,23 +1421,25 @@ pub fn ConstantFP::compare( /// **Note**: It will raise `FPTruncCastInstTypeMismatch` if the source type bit width /// is not greater than the destination type bit width. /// -/// ```mbt test -/// let ctx = Context::new() -/// -/// // Test f64 to f32 truncation -/// let f64_1_5 = ctx.getConstDouble(1.5) -/// let f32_1_5 = f64_1_5.fptrunc(ctx.getFloatTy()) -/// assert_eq(f32_1_5.getValue(), 1.5) -/// -/// // Test f64 to f32 truncation with another value -/// let f64_precise = ctx.getConstDouble(2.5) -/// let f32_truncated = f64_precise.fptrunc(ctx.getFloatTy()) -/// // In constant folding, the value is preserved -/// assert_eq(f32_truncated.getValue(), 2.5) -/// -/// // Test error case: cannot truncate to larger type -/// let f32_val = ctx.getConstFloat(2.0) -/// assert_true((try? f32_val.fptrunc(ctx.getDoubleTy())) is Err(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// +/// // Test f64 to f32 truncation +/// let f64_1_5 = ctx.getConstDouble(1.5) +/// let f32_1_5 = f64_1_5.fptrunc(ctx.getFloatTy()) +/// assert_eq(f32_1_5.getValue(), 1.5) +/// +/// // Test f64 to f32 truncation with another value +/// let f64_precise = ctx.getConstDouble(2.5) +/// let f32_truncated = f64_precise.fptrunc(ctx.getFloatTy()) +/// // In constant folding, the value is preserved +/// assert_eq(f32_truncated.getValue(), 2.5) +/// +/// // Test error case: cannot truncate to larger type +/// let f32_val = ctx.getConstFloat(2.0) +/// assert_true((try? f32_val.fptrunc(ctx.getDoubleTy())) is Err(_)) +/// } /// ``` pub fn ConstantFP::fptrunc( self : ConstantFP, @@ -1403,22 +1461,24 @@ pub fn ConstantFP::fptrunc( /// **Note**: It will raise `FPExtCastInstTypeMismatch` if the source type bit width /// is not less than the destination type bit width. /// -/// ```mbt test -/// let ctx = Context::new() +/// ```mbt check +/// test { +/// let ctx = Context::new() /// -/// // Test f32 to f64 extension -/// let f32_1_5 = ctx.getConstFloat(1.5) -/// let f64_1_5 = f32_1_5.fpext(ctx.getDoubleTy()) -/// assert_eq(f64_1_5.getValue(), 1.5) +/// // Test f32 to f64 extension +/// let f32_1_5 = ctx.getConstFloat(1.5) +/// let f64_1_5 = f32_1_5.fpext(ctx.getDoubleTy()) +/// assert_eq(f64_1_5.getValue(), 1.5) /// -/// // Test f32 to f64 extension preserves value -/// let f32_pi = ctx.getConstFloat(3.14159265) -/// let f64_pi = f32_pi.fpext(ctx.getDoubleTy()) -/// assert_eq(f64_pi.getValue(), 3.1415927410125732) +/// // Test f32 to f64 extension preserves value +/// let f32_pi = ctx.getConstFloat(3.14159265) +/// let f64_pi = f32_pi.fpext(ctx.getDoubleTy()) +/// assert_eq(f64_pi.getValue(), 3.1415927410125732) /// -/// // Test error case: cannot extend to smaller type -/// let f64_val = ctx.getConstDouble(2.0) -/// assert_true((try? f64_val.fpext(ctx.getFloatTy())) is Err(_)) +/// // Test error case: cannot extend to smaller type +/// let f64_val = ctx.getConstDouble(2.0) +/// assert_true((try? f64_val.fpext(ctx.getFloatTy())) is Err(_)) +/// } /// ``` pub fn ConstantFP::fpext( self : ConstantFP, @@ -1439,29 +1499,31 @@ pub fn ConstantFP::fpext( /// **Note**: It will raise `FPToUIInstTypeMismatch` if the source is not a floating-point type. /// The conversion truncates towards zero (similar to C cast). /// -/// ```mbt test -/// let ctx = Context::new() -/// -/// // Test positive float to unsigned integer -/// let f32_3_7 = ctx.getConstFloat(3.7) -/// let i32_3 = f32_3_7.fptoui(ctx.getInt32Ty()) -/// assert_eq(i32_3.getValueAsInt64(), 3) -/// -/// // Test zero conversion -/// let f64_0 = ctx.getConstDouble(0.0) -/// let i64_0 = f64_0.fptoui(ctx.getInt64Ty()) -/// assert_eq(i64_0.getValueAsInt64(), 0) -/// -/// // Test large float to i8 (overflow behavior) -/// let f32_1000 = ctx.getConstFloat(1000.0) -/// let i8_overflow = f32_1000.fptoui(ctx.getInt8Ty()) -/// // The value will be truncated to fit in i8 range (1000 in i8 is -24) -/// assert_eq(i8_overflow.getValueAsInt64(), -24) -/// -/// // Test fractional part truncation -/// let f64_9_9 = ctx.getConstDouble(9.9) -/// let i32_9 = f64_9_9.fptoui(ctx.getInt32Ty()) -/// assert_eq(i32_9.getValueAsInt64(), 9) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// +/// // Test positive float to unsigned integer +/// let f32_3_7 = ctx.getConstFloat(3.7) +/// let i32_3 = f32_3_7.fptoui(ctx.getInt32Ty()) +/// assert_eq(i32_3.getValueAsInt64(), 3) +/// +/// // Test zero conversion +/// let f64_0 = ctx.getConstDouble(0.0) +/// let i64_0 = f64_0.fptoui(ctx.getInt64Ty()) +/// assert_eq(i64_0.getValueAsInt64(), 0) +/// +/// // Test large float to i8 (overflow behavior) +/// let f32_1000 = ctx.getConstFloat(1000.0) +/// let i8_overflow = f32_1000.fptoui(ctx.getInt8Ty()) +/// // The value will be truncated to fit in i8 range (1000 in i8 is -24) +/// assert_eq(i8_overflow.getValueAsInt64(), -24) +/// +/// // Test fractional part truncation +/// let f64_9_9 = ctx.getConstDouble(9.9) +/// let i32_9 = f64_9_9.fptoui(ctx.getInt32Ty()) +/// assert_eq(i32_9.getValueAsInt64(), 9) +/// } /// ``` pub fn ConstantFP::fptoui( self : ConstantFP, @@ -1482,28 +1544,30 @@ pub fn ConstantFP::fptoui( /// **Note**: It will raise `FPToSIInstTypeMismatch` if the source is not a floating-point type. /// The conversion truncates towards zero (similar to C cast). /// -/// ```mbt test -/// let ctx = Context::new() -/// -/// // Test positive float to signed integer -/// let f32_3_7 = ctx.getConstFloat(3.7) -/// let i32_3 = f32_3_7.fptosi(ctx.getInt32Ty()) -/// assert_eq(i32_3.getValueAsInt64(), 3) -/// -/// // Test negative float to signed integer -/// let f64_m5_2 = ctx.getConstDouble(-5.2) -/// let i64_m5 = f64_m5_2.fptosi(ctx.getInt64Ty()) -/// assert_eq(i64_m5.getValueAsInt64(), -5) -/// -/// // Test zero conversion -/// let f32_0 = ctx.getConstFloat(0.0) -/// let i16_0 = f32_0.fptosi(ctx.getInt16Ty()) -/// assert_eq(i16_0.getValueAsInt64(), 0) -/// -/// // Test fractional part truncation -/// let f64_m9_9 = ctx.getConstDouble(-9.9) -/// let i32_m9 = f64_m9_9.fptosi(ctx.getInt32Ty()) -/// assert_eq(i32_m9.getValueAsInt64(), -9) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// +/// // Test positive float to signed integer +/// let f32_3_7 = ctx.getConstFloat(3.7) +/// let i32_3 = f32_3_7.fptosi(ctx.getInt32Ty()) +/// assert_eq(i32_3.getValueAsInt64(), 3) +/// +/// // Test negative float to signed integer +/// let f64_m5_2 = ctx.getConstDouble(-5.2) +/// let i64_m5 = f64_m5_2.fptosi(ctx.getInt64Ty()) +/// assert_eq(i64_m5.getValueAsInt64(), -5) +/// +/// // Test zero conversion +/// let f32_0 = ctx.getConstFloat(0.0) +/// let i16_0 = f32_0.fptosi(ctx.getInt16Ty()) +/// assert_eq(i16_0.getValueAsInt64(), 0) +/// +/// // Test fractional part truncation +/// let f64_m9_9 = ctx.getConstDouble(-9.9) +/// let i32_m9 = f64_m9_9.fptosi(ctx.getInt32Ty()) +/// assert_eq(i32_m9.getValueAsInt64(), -9) +/// } /// ``` pub fn ConstantFP::fptosi( self : ConstantFP, @@ -1521,28 +1585,30 @@ pub fn ConstantFP::fptosi( /// or if the cast is invalid. It will raise `BitCastOnlyAcceptPrimitiveTypes` if the source /// is not a primitive type. /// -/// ```mbt test -/// let ctx = Context::new() -/// -/// // Test f32 to i32 bitcast -/// let f32_2_0 = ctx.getConstFloat(2.0) -/// let i32_bits = f32_2_0.bitcast(ctx.getInt32Ty()) -/// guard i32_bits.asConstantEnum() is ConstantInt(i32_bits) -/// assert_eq(i32_bits.getValueAsInt64(), 0x40000000) // 2.0f bit pattern -/// -/// // Test f64 to i64 bitcast -/// let f64_2_0 = ctx.getConstDouble(2.0) -/// let i64_bits = f64_2_0.bitcast(ctx.getInt64Ty()) -/// guard i64_bits.asConstantEnum() is ConstantInt(i64_bits) -/// assert_eq(i64_bits.getValueAsInt64(), 0x4000000000000000L) // 2.0 bit pattern -/// -/// // Test f32 to f32 (same type should error) -/// let f32_val = ctx.getConstFloat(1.0) -/// assert_true((try? f32_val.bitcast(ctx.getFloatTy())) is Err(_)) -/// -/// // Test error case: different bit widths -/// let f64_val = ctx.getConstDouble(42.0) -/// assert_true((try? f64_val.bitcast(ctx.getInt32Ty())) is Err(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// +/// // Test f32 to i32 bitcast +/// let f32_2_0 = ctx.getConstFloat(2.0) +/// let i32_bits = f32_2_0.bitcast(ctx.getInt32Ty()) +/// guard i32_bits.asConstantEnum() is ConstantInt(i32_bits) +/// assert_eq(i32_bits.getValueAsInt64(), 0x40000000) // 2.0f bit pattern +/// +/// // Test f64 to i64 bitcast +/// let f64_2_0 = ctx.getConstDouble(2.0) +/// let i64_bits = f64_2_0.bitcast(ctx.getInt64Ty()) +/// guard i64_bits.asConstantEnum() is ConstantInt(i64_bits) +/// assert_eq(i64_bits.getValueAsInt64(), 0x4000000000000000L) // 2.0 bit pattern +/// +/// // Test f32 to f32 (same type should error) +/// let f32_val = ctx.getConstFloat(1.0) +/// assert_true((try? f32_val.bitcast(ctx.getFloatTy())) is Err(_)) +/// +/// // Test error case: different bit widths +/// let f64_val = ctx.getConstDouble(42.0) +/// assert_true((try? f64_val.bitcast(ctx.getInt32Ty())) is Err(_)) +/// } /// ``` pub fn ConstantFP::bitcast( self : ConstantFP, @@ -2458,18 +2524,20 @@ pub impl Show for ConstantVector with output(self, logger) { /// /// Represents a constant struct value in LLVM IR. /// -/// ```mbt test -/// let ctx = Context::new() -/// let i32ty = ctx.getInt32Ty() -/// let f32ty = ctx.getFloatTy() -/// let sty = ctx.getStructType([i32ty, f32ty]) -/// let i32_val = ctx.getConstInt32(42) -/// let f32_val = ctx.getConstFloat(3.14) -/// let struct_val = ConstantStruct::new(sty, [i32_val, f32_val]) -/// inspect( -/// struct_val, -/// content="{ i32, float } { i32 42, float 0x40091EB860000000 }", -/// ) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let i32ty = ctx.getInt32Ty() +/// let f32ty = ctx.getFloatTy() +/// let sty = ctx.getStructType([i32ty, f32ty]) +/// let i32_val = ctx.getConstInt32(42) +/// let f32_val = ctx.getConstFloat(3.14) +/// let struct_val = ConstantStruct::new(sty, [i32_val, f32_val]) +/// inspect( +/// struct_val, +/// content="{ i32, float } { i32 42, float 0x40091EB860000000 }", +/// ) +/// } /// ``` pub struct ConstantStruct { // Unique identifier @@ -2528,17 +2596,22 @@ pub fn ConstantStruct::getElement( /// This is equivalent to LLVM's `extractvalue` instruction for constant structs. /// The indices specify a path through nested aggregate types. /// -/// ```mbt test -/// let ctx = Context::new() -/// let i32ty = ctx.getInt32Ty() -/// let f32ty = ctx.getFloatTy() -/// let sty = ctx.getStructType([i32ty, f32ty]) -/// let i32_val = ctx.getConstInt32(42) -/// let f32_val = ctx.getConstFloat(3.14) -/// let struct_val = ConstantStruct::new(sty, [i32_val, f32_val]) -/// inspect(struct_val.extractValue([0]), content="Some(i32 42)") -/// inspect(struct_val.extractValue([1]), content="Some(float 0x40091EB860000000)") -/// inspect(struct_val.extractValue([2]), content="None") // Out of bounds +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let i32ty = ctx.getInt32Ty() +/// let f32ty = ctx.getFloatTy() +/// let sty = ctx.getStructType([i32ty, f32ty]) +/// let i32_val = ctx.getConstInt32(42) +/// let f32_val = ctx.getConstFloat(3.14) +/// let struct_val = ConstantStruct::new(sty, [i32_val, f32_val]) +/// inspect(struct_val.extractValue([0]), content="Some(i32 42)") +/// inspect( +/// struct_val.extractValue([1]), +/// content="Some(float 0x40091EB860000000)", +/// ) +/// inspect(struct_val.extractValue([2]), content="None") // Out of bounds +/// } /// ``` pub fn ConstantStruct::extractValue( self : ConstantStruct, @@ -2568,21 +2641,23 @@ pub fn ConstantStruct::extractValue( /// This is equivalent to LLVM's `insertvalue` instruction for constant structs. /// Returns a new ConstantStruct with the value inserted at the specified path. /// -/// ```mbt test -/// let ctx = Context::new() -/// let i32ty = ctx.getInt32Ty() -/// let f32ty = ctx.getFloatTy() -/// let sty = ctx.getStructType([i32ty, f32ty]) -/// let i32_val = ctx.getConstInt32(42) -/// let f32_val = ctx.getConstFloat(3.14) -/// let struct_val = ConstantStruct::new(sty, [i32_val, f32_val]) -/// -/// // Insert new value at index 0 -/// let new_i32_val = ctx.getConstInt32(100) -/// guard struct_val.insertValue([0], new_i32_val) is Some(new_struct) -/// -/// // Verify the new value was inserted -/// assert_true(new_struct.extractValue([0]) is Some(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let i32ty = ctx.getInt32Ty() +/// let f32ty = ctx.getFloatTy() +/// let sty = ctx.getStructType([i32ty, f32ty]) +/// let i32_val = ctx.getConstInt32(42) +/// let f32_val = ctx.getConstFloat(3.14) +/// let struct_val = ConstantStruct::new(sty, [i32_val, f32_val]) +/// +/// // Insert new value at index 0 +/// let new_i32_val = ctx.getConstInt32(100) +/// guard struct_val.insertValue([0], new_i32_val) is Some(new_struct) +/// +/// // Verify the new value was inserted +/// assert_true(new_struct.extractValue([0]) is Some(_)) +/// } /// ``` /// // TODO: not correct pub fn ConstantStruct::insertValue( diff --git a/IR/Context.mbt b/IR/Context.mbt index 6becde6..caebb9e 100644 --- a/IR/Context.mbt +++ b/IR/Context.mbt @@ -105,10 +105,12 @@ pub fn Context::createBuilder(self : Context) -> IRBuilder { /// /// - See LLVM: `Type::getHalfTy`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let half_ty = ctx.getHalfTy() -/// inspect(half_ty, content="half") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let half_ty = ctx.getHalfTy() +/// inspect(half_ty, content="half") +/// } /// ``` pub fn Context::getHalfTy(self : Context) -> HalfType { self.pimpl.unwrap().half_ty @@ -119,10 +121,12 @@ pub fn Context::getHalfTy(self : Context) -> HalfType { /// /// - See LLVM: `Type::getBFloatTy`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let bfloat_ty = ctx.getBFloatTy() -/// inspect(bfloat_ty, content="bfloat") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let bfloat_ty = ctx.getBFloatTy() +/// inspect(bfloat_ty, content="bfloat") +/// } /// ``` pub fn Context::getBFloatTy(self : Context) -> BFloatType { self.pimpl.unwrap().bfloat_ty @@ -133,10 +137,12 @@ pub fn Context::getBFloatTy(self : Context) -> BFloatType { /// /// - See LLVM: `Type::getFloatTy`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let f32ty = ctx.getFloatTy() -/// inspect(f32ty, content="float") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let f32ty = ctx.getFloatTy() +/// inspect(f32ty, content="float") +/// } /// ``` pub fn Context::getFloatTy(self : Context) -> FloatType { self.pimpl.unwrap().float_ty @@ -147,10 +153,12 @@ pub fn Context::getFloatTy(self : Context) -> FloatType { /// /// - See LLVM: `Type::getDoubleTy`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let doubletype = ctx.getDoubleTy() -/// inspect(doubletype, content="double") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let doubletype = ctx.getDoubleTy() +/// inspect(doubletype, content="double") +/// } /// ``` pub fn Context::getDoubleTy(self : Context) -> DoubleType { self.pimpl.unwrap().double_ty @@ -161,10 +169,12 @@ pub fn Context::getDoubleTy(self : Context) -> DoubleType { /// /// - See LLVM: `Type::getFP128Ty`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let fp128ty = ctx.getFP128Ty() -/// inspect(fp128ty, content="fp128") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let fp128ty = ctx.getFP128Ty() +/// inspect(fp128ty, content="fp128") +/// } /// ``` pub fn Context::getFP128Ty(self : Context) -> FP128Type { self.pimpl.unwrap().fp128_ty @@ -175,10 +185,12 @@ pub fn Context::getFP128Ty(self : Context) -> FP128Type { /// /// - See LLVM: `Type::getVoidTy`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let voidty = ctx.getVoidTy() -/// inspect(voidty, content="void") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let voidty = ctx.getVoidTy() +/// inspect(voidty, content="void") +/// } /// ``` pub fn Context::getVoidTy(self : Context) -> VoidType { self.pimpl.unwrap().void_ty @@ -201,10 +213,12 @@ pub fn Context::getMetadataTy(self : Context) -> MetadataType { /// /// - See LLVM: `Type::getTokenTy`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let tokenty = ctx.getTokenTy() -/// inspect(tokenty, content="token") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let tokenty = ctx.getTokenTy() +/// inspect(tokenty, content="token") +/// } /// ``` pub fn Context::getTokenTy(self : Context) -> TokenType { self.pimpl.unwrap().token_ty @@ -250,11 +264,13 @@ pub fn Context::getInt64Ty(self : Context) -> Int64Type { /// After LLVM17, typed pointer has been deprecated. Therefore in /// Moonbit Aether framework, all pointer type is opaque. /// -/// ```mbt test -/// let ctx = Context::new() -/// inspect(ctx.getPtrTy(), content="ptr") -/// let addressSpace = AddressSpace::new(1) -/// inspect(ctx.getPtrTy(addressSpace~), content="ptr") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// inspect(ctx.getPtrTy(), content="ptr") +/// let addressSpace = AddressSpace::new(1) +/// inspect(ctx.getPtrTy(addressSpace~), content="ptr") +/// } /// ``` pub fn Context::getPtrTy( self : Context, @@ -280,13 +296,15 @@ pub fn Context::getPtrTy( /// /// - See LLVM: `FunctionType::get`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let voidty = ctx.getVoidTy() -/// let i32ty = ctx.getInt32Ty() -/// let f64ty = ctx.getDoubleTy() -/// let fty = ctx.getFunctionType(voidty, [i32ty, f64ty]) -/// inspect(fty, content="void (i32, double)") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let voidty = ctx.getVoidTy() +/// let i32ty = ctx.getInt32Ty() +/// let f64ty = ctx.getDoubleTy() +/// let fty = ctx.getFunctionType(voidty, [i32ty, f64ty]) +/// inspect(fty, content="void (i32, double)") +/// } /// ``` pub fn Context::getFunctionType( self : Context, @@ -308,20 +326,22 @@ pub fn Context::getFunctionType( /// /// - See LLVM: `StructType::create`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let i32ty = ctx.getInt32Ty() -/// let f32ty = ctx.getFloatTy() -/// let f64ty = ctx.getDoubleTy() -/// let sty = ctx.getStructType([i32ty, f32ty, f64ty], name="foo") -/// inspect(sty.full_info(), content="%foo = type { i32, float, double }") -/// -/// // Cannot create a ananymous struct type with empty elements. -/// assert_true((try? ctx.getStructType([])) is Err(_)) -/// -/// // Cannot create a struct which has same name with other struct. -/// // the `foo` struct is already created. -/// assert_true((try? ctx.getStructType([], name="foo")) is Err(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let i32ty = ctx.getInt32Ty() +/// let f32ty = ctx.getFloatTy() +/// let f64ty = ctx.getDoubleTy() +/// let sty = ctx.getStructType([i32ty, f32ty, f64ty], name="foo") +/// inspect(sty.full_info(), content="%foo = type { i32, float, double }") +/// +/// // Cannot create a ananymous struct type with empty elements. +/// assert_true((try? ctx.getStructType([])) is Err(_)) +/// +/// // Cannot create a struct which has same name with other struct. +/// // the `foo` struct is already created. +/// assert_true((try? ctx.getStructType([], name="foo")) is Err(_)) +/// } /// ``` pub fn Context::getStructType( self : Context, @@ -338,13 +358,15 @@ pub fn Context::getStructType( /// /// LLVM Cpp version has no this method, since llvm-cpp allow duplicated struct type names. /// -/// ```mbt test -/// let ctx = Context::new() -/// let i32ty = ctx.getInt32Ty() -/// let f32ty = ctx.getFloatTy() -/// let _ = ctx.getStructType([i32ty, f32ty], name="foo") -/// let sty = ctx.getStructTypeByName("foo").unwrap() -/// inspect(sty.full_info(), content="%foo = type { i32, float }") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let i32ty = ctx.getInt32Ty() +/// let f32ty = ctx.getFloatTy() +/// let _ = ctx.getStructType([i32ty, f32ty], name="foo") +/// let sty = ctx.getStructTypeByName("foo").unwrap() +/// inspect(sty.full_info(), content="%foo = type { i32, float }") +/// } /// ``` pub fn Context::getStructTypeByName(self : Self, name : String) -> StructType? { self.pimpl.unwrap().namedStructTypes.get(name) @@ -360,13 +382,15 @@ pub fn Context::getStructTypeByName(self : Self, name : String) -> StructType? { /// /// - See LLVM: `ArrayType::get`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let i32ty = ctx.getInt32Ty() -/// let arrty = ctx.getArrayType(i32ty, 16) -/// inspect(arrty, content="[16 x i32]") -/// inspect(arrty.getElementType(), content="i32") -/// assert_eq(arrty.getElementCount(), 16) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let i32ty = ctx.getInt32Ty() +/// let arrty = ctx.getArrayType(i32ty, 16) +/// inspect(arrty, content="[16 x i32]") +/// inspect(arrty.getElementType(), content="i32") +/// assert_eq(arrty.getElementCount(), 16) +/// } /// ``` pub fn Context::getArrayType( self : Context, @@ -384,11 +408,13 @@ pub fn Context::getArrayType( /// /// - See LLVM: `VectorType::get`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let i32ty = ctx.getInt32Ty() -/// let fixedVecTy = ctx.getFixedVectorType(i32ty, 32) -/// inspect(fixedVecTy, content="<32 x i32>") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let i32ty = ctx.getInt32Ty() +/// let fixedVecTy = ctx.getFixedVectorType(i32ty, 32) +/// inspect(fixedVecTy, content="<32 x i32>") +/// } /// ``` pub fn Context::getFixedVectorType( self : Context, @@ -406,11 +432,13 @@ pub fn Context::getFixedVectorType( /// /// - See LLVM: `ScalableVectorType::get`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let i32ty = ctx.getInt32Ty() -/// let scalableVecTy = ctx.getScalableVectorType(i32ty, 16) -/// inspect(scalableVecTy, content="") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let i32ty = ctx.getInt32Ty() +/// let scalableVecTy = ctx.getScalableVectorType(i32ty, 16) +/// inspect(scalableVecTy, content="") +/// } /// ``` pub fn Context::getScalableVectorType( self : Context, @@ -425,11 +453,13 @@ pub fn Context::getScalableVectorType( /// /// - See LLVM: `ConstantInt::get`. /// -/// ```mbt test -/// let ctx = Context::new() -/// inspect(ctx.getConstInt8(0), content="i8 0") -/// inspect(ctx.getConstInt8(1), content="i8 1") -/// inspect(ctx.getConstInt8(-1), content="i8 -1") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// inspect(ctx.getConstInt8(0), content="i8 0") +/// inspect(ctx.getConstInt8(1), content="i8 1") +/// inspect(ctx.getConstInt8(-1), content="i8 -1") +/// } /// ``` pub fn Context::getConstInt8(self : Context, value : Int) -> ConstantInt { let i8val = Int8::from(value) @@ -441,11 +471,13 @@ pub fn Context::getConstInt8(self : Context, value : Int) -> ConstantInt { /// /// - See LLVM: `ConstantInt::get`. /// -/// ```mbt test -/// let ctx = Context::new() -/// inspect(ctx.getConstInt16(0), content="i16 0") -/// inspect(ctx.getConstInt16(1), content="i16 1") -/// inspect(ctx.getConstInt16(-1), content="i16 -1") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// inspect(ctx.getConstInt16(0), content="i16 0") +/// inspect(ctx.getConstInt16(1), content="i16 1") +/// inspect(ctx.getConstInt16(-1), content="i16 -1") +/// } /// ``` pub fn Context::getConstInt16(self : Context, value : Int16) -> ConstantInt { ConstantInt::new(self.getInt16Ty(), value.to_int64()) @@ -456,11 +488,13 @@ pub fn Context::getConstInt16(self : Context, value : Int16) -> ConstantInt { /// /// - See LLVM: `ConstantInt::get`. /// -/// ```mbt test -/// let ctx = Context::new() -/// inspect(ctx.getConstInt32(0), content="i32 0") -/// inspect(ctx.getConstInt32(1), content="i32 1") -/// inspect(ctx.getConstInt32(-1), content="i32 -1") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// inspect(ctx.getConstInt32(0), content="i32 0") +/// inspect(ctx.getConstInt32(1), content="i32 1") +/// inspect(ctx.getConstInt32(-1), content="i32 -1") +/// } /// ``` pub fn Context::getConstInt32(self : Context, value : Int) -> ConstantInt { ConstantInt::new(self.getInt32Ty(), value.to_int64()) @@ -471,11 +505,13 @@ pub fn Context::getConstInt32(self : Context, value : Int) -> ConstantInt { /// /// - See LLVM: `ConstantInt::get`. /// -/// ```mbt test -/// let ctx = Context::new() -/// inspect(ctx.getConstInt64(0), content="i64 0") -/// inspect(ctx.getConstInt64(1), content="i64 1") -/// inspect(ctx.getConstInt64(-1), content="i64 -1") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// inspect(ctx.getConstInt64(0), content="i64 0") +/// inspect(ctx.getConstInt64(1), content="i64 1") +/// inspect(ctx.getConstInt64(-1), content="i64 -1") +/// } /// ``` pub fn Context::getConstInt64(self : Context, value : Int64) -> ConstantInt { ConstantInt::new(self.getInt64Ty(), value) @@ -486,9 +522,11 @@ pub fn Context::getConstInt64(self : Context, value : Int64) -> ConstantInt { /// /// - See LLVM: `ConstantInt::getTrue`. /// -/// ```mbt test -/// let ctx = Context::new() -/// inspect(ctx.getConstTrue(), content="i1 true") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// inspect(ctx.getConstTrue(), content="i1 true") +/// } /// ``` pub fn Context::getConstTrue(self : Context) -> ConstantInt { ConstantInt::new(self.getInt1Ty(), 1) @@ -499,9 +537,11 @@ pub fn Context::getConstTrue(self : Context) -> ConstantInt { /// /// - See LLVM: `ConstantInt::getFalse`. /// -/// ```mbt test -/// let ctx = Context::new() -/// inspect(ctx.getConstFalse(), content="i1 false") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// inspect(ctx.getConstFalse(), content="i1 false") +/// } /// ``` pub fn Context::getConstFalse(self : Context) -> ConstantInt { ConstantInt::new(self.getInt1Ty(), 0) @@ -512,10 +552,12 @@ pub fn Context::getConstFalse(self : Context) -> ConstantInt { /// /// - See LLVM: `ConstantInt::get`. /// -/// ```mbt test -/// let ctx = Context::new() -/// inspect(ctx.getConstBool(true), content="i1 true") -/// inspect(ctx.getConstBool(false), content="i1 false") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// inspect(ctx.getConstBool(true), content="i1 true") +/// inspect(ctx.getConstBool(false), content="i1 false") +/// } /// ``` pub fn Context::getConstBool(self : Context, b : Bool) -> ConstantInt { ConstantInt::new(self.getInt1Ty(), b.to_int64()) @@ -526,12 +568,14 @@ pub fn Context::getConstBool(self : Context, b : Bool) -> ConstantInt { /// /// - See LLVM: `ConstantFP::get`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let one = ctx.getConstFloat(1.0) -/// let two = ctx.getConstFloat(2.0) -/// inspect(one, content="float 0x3FF0000000000000") -/// inspect(two, content="float 0x4000000000000000") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let one = ctx.getConstFloat(1.0) +/// let two = ctx.getConstFloat(2.0) +/// inspect(one, content="float 0x3FF0000000000000") +/// inspect(two, content="float 0x4000000000000000") +/// } /// ``` pub fn Context::getConstFloat(self : Context, value : Float) -> ConstantFP { ConstantFP::new(self.getFloatTy(), value.to_double()) @@ -542,12 +586,14 @@ pub fn Context::getConstFloat(self : Context, value : Float) -> ConstantFP { /// /// - See LLVM: `ConstantFP::get`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let one = ctx.getConstDouble(1.0) -/// let two = ctx.getConstDouble(2.0) -/// inspect(one, content="double 0x3FF0000000000000") -/// inspect(two, content="double 0x4000000000000000") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let one = ctx.getConstDouble(1.0) +/// let two = ctx.getConstDouble(2.0) +/// inspect(one, content="double 0x3FF0000000000000") +/// inspect(two, content="double 0x4000000000000000") +/// } /// ``` pub fn Context::getConstDouble(self : Context, value : Double) -> ConstantFP { ConstantFP::new(self.getDoubleTy(), value) @@ -562,12 +608,14 @@ pub fn Context::getConstDouble(self : Context, value : Double) -> ConstantFP { /// /// - `isNegative`: If true, create a negative zero constant. /// -/// ```mbt test -/// let ctx = Context::new() -/// let zero = ctx.getConstZeroFloat() -/// let neg_zero = ctx.getConstZeroFloat(isNegative=true) -/// inspect(zero, content="float 0x0") -/// inspect(neg_zero, content="float 0x8000000000000000") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let zero = ctx.getConstZeroFloat() +/// let neg_zero = ctx.getConstZeroFloat(isNegative=true) +/// inspect(zero, content="float 0x0") +/// inspect(neg_zero, content="float 0x8000000000000000") +/// } /// ``` pub fn Context::getConstZeroFloat( self : Context, @@ -589,12 +637,14 @@ pub fn Context::getConstZeroFloat( /// /// - `isNegative`: If true, create a negative zero constant. /// -/// ```mbt test -/// let ctx = Context::new() -/// let zero = ctx.getConstZeroDouble() -/// let neg_zero = ctx.getConstZeroDouble(isNegative=true) -/// inspect(zero, content="double 0x0") -/// inspect(neg_zero, content="double 0x8000000000000000") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let zero = ctx.getConstZeroDouble() +/// let neg_zero = ctx.getConstZeroDouble(isNegative=true) +/// inspect(zero, content="double 0x0") +/// inspect(neg_zero, content="double 0x8000000000000000") +/// } /// ``` pub fn Context::getConstZeroDouble( self : Context, @@ -616,12 +666,14 @@ pub fn Context::getConstZeroDouble( /// /// - `isNegative`: If true, create a negative zero constant. /// -/// ```mbt test -/// let ctx = Context::new() -/// let nan = ctx.getConstNaNDouble() -/// let neg_nan = ctx.getConstNaNDouble(isNegative=true) -/// inspect(nan, content="double 0x7FF8000000000000") -/// inspect(neg_nan, content="double 0xFFF8000000000000") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let nan = ctx.getConstNaNDouble() +/// let neg_nan = ctx.getConstNaNDouble(isNegative=true) +/// inspect(nan, content="double 0x7FF8000000000000") +/// inspect(neg_nan, content="double 0xFFF8000000000000") +/// } /// ``` pub fn Context::getConstNaNFloat( self : Context, @@ -643,12 +695,14 @@ pub fn Context::getConstNaNFloat( /// /// - `isNegative`: If true, create a negative NaN constant. /// -/// ```mbt test -/// let ctx = Context::new() -/// let nan = ctx.getConstQNaNFloat() -/// let neg_nan = ctx.getConstQNaNFloat(isNegative=true) -/// inspect(nan, content="float 0x7FF8000000000000") -/// inspect(neg_nan, content="float 0xFFF8000000000000") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let nan = ctx.getConstQNaNFloat() +/// let neg_nan = ctx.getConstQNaNFloat(isNegative=true) +/// inspect(nan, content="float 0x7FF8000000000000") +/// inspect(neg_nan, content="float 0xFFF8000000000000") +/// } /// ``` pub fn Context::getConstQNaNFloat( self : Context, @@ -670,12 +724,14 @@ pub fn Context::getConstQNaNFloat( /// /// - `isNegative`: If true, create a negative NaN constant. /// -/// ```mbt test -/// let ctx = Context::new() -/// let nan = ctx.getConstSNaNFloat() -/// let neg_nan = ctx.getConstSNaNFloat(isNegative=true) -/// inspect(nan, content="float 0x7FF4000000000000") -/// inspect(neg_nan, content="float 0xFFF4000000000000") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let nan = ctx.getConstSNaNFloat() +/// let neg_nan = ctx.getConstSNaNFloat(isNegative=true) +/// inspect(nan, content="float 0x7FF4000000000000") +/// inspect(neg_nan, content="float 0xFFF4000000000000") +/// } /// ``` pub fn Context::getConstSNaNFloat( self : Context, @@ -697,12 +753,14 @@ pub fn Context::getConstSNaNFloat( /// /// - `isNegative`: If true, create a negative Infinity constant. /// -/// ```mbt test -/// let ctx = Context::new() -/// let inf = ctx.getConstInfFloat() -/// let neg_inf = ctx.getConstInfFloat(isNegative=true) -/// inspect(inf, content="float 0x7FF0000000000000") -/// inspect(neg_inf, content="float 0xFFF0000000000000") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let inf = ctx.getConstInfFloat() +/// let neg_inf = ctx.getConstInfFloat(isNegative=true) +/// inspect(inf, content="float 0x7FF0000000000000") +/// inspect(neg_inf, content="float 0xFFF0000000000000") +/// } /// ``` pub fn Context::getConstInfFloat( self : Context, @@ -724,12 +782,14 @@ pub fn Context::getConstInfFloat( /// /// - `isNegative`: If true, create a negative NaN constant. /// -/// ```mbt test -/// let ctx = Context::new() -/// let nan = ctx.getConstNaNDouble() -/// let neg_nan = ctx.getConstNaNDouble(isNegative=true) -/// inspect(nan, content="double 0x7FF8000000000000") -/// inspect(neg_nan, content="double 0xFFF8000000000000") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let nan = ctx.getConstNaNDouble() +/// let neg_nan = ctx.getConstNaNDouble(isNegative=true) +/// inspect(nan, content="double 0x7FF8000000000000") +/// inspect(neg_nan, content="double 0xFFF8000000000000") +/// } /// ``` pub fn Context::getConstNaNDouble( self : Context, @@ -751,12 +811,14 @@ pub fn Context::getConstNaNDouble( /// /// - `isNegative`: If true, create a negative NaN constant. /// -/// ```mbt test -/// let ctx = Context::new() -/// let nan = ctx.getConstQNaNDouble() -/// let neg_nan = ctx.getConstQNaNDouble(isNegative=true) -/// inspect(nan, content="double 0x7FF8000000000000") -/// inspect(neg_nan, content="double 0xFFF8000000000000") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let nan = ctx.getConstQNaNDouble() +/// let neg_nan = ctx.getConstQNaNDouble(isNegative=true) +/// inspect(nan, content="double 0x7FF8000000000000") +/// inspect(neg_nan, content="double 0xFFF8000000000000") +/// } /// ``` pub fn Context::getConstQNaNDouble( self : Context, @@ -778,12 +840,14 @@ pub fn Context::getConstQNaNDouble( /// /// - `isNegative`: If true, create a negative NaN constant. /// -/// ```mbt test -/// let ctx = Context::new() -/// let nan = ctx.getConstSNaNDouble() -/// let neg_nan = ctx.getConstSNaNDouble(isNegative=true) -/// inspect(nan, content="double 0x7FF4000000000000") -/// inspect(neg_nan, content="double 0xFFF4000000000000") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let nan = ctx.getConstSNaNDouble() +/// let neg_nan = ctx.getConstSNaNDouble(isNegative=true) +/// inspect(nan, content="double 0x7FF4000000000000") +/// inspect(neg_nan, content="double 0xFFF4000000000000") +/// } /// ``` pub fn Context::getConstSNaNDouble( self : Context, @@ -805,12 +869,14 @@ pub fn Context::getConstSNaNDouble( /// /// - `isNegative`: If true, create a negative Infinity constant. /// -/// ```mbt test -/// let ctx = Context::new() -/// let inf = ctx.getConstInfDouble() -/// let neg_inf = ctx.getConstInfDouble(isNegative=true) -/// inspect(inf, content="double 0x7FF0000000000000") -/// inspect(neg_inf, content="double 0xFFF0000000000000") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let inf = ctx.getConstInfDouble() +/// let neg_inf = ctx.getConstInfDouble(isNegative=true) +/// inspect(inf, content="double 0x7FF0000000000000") +/// inspect(neg_inf, content="double 0xFFF0000000000000") +/// } /// ``` pub fn Context::getConstInfDouble( self : Context, @@ -833,11 +899,13 @@ pub fn Context::getConstInfDouble( /// - Core does not support `int8` currently, hence the type /// of parameter `data` is `Array[Int]`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let data : Array[Int] = [42, 63, 77, 89] -/// let arr = ctx.getConstInt8Array(data) -/// inspect(arr, content="[4 x i8] [i8 42, i8 63, i8 77, i8 89]") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let data : Array[Int] = [42, 63, 77, 89] +/// let arr = ctx.getConstInt8Array(data) +/// inspect(arr, content="[4 x i8] [i8 42, i8 63, i8 77, i8 89]") +/// } /// ``` pub fn Context::getConstInt8Array( self : Context, @@ -852,11 +920,13 @@ pub fn Context::getConstInt8Array( /// /// - See LLVM: `ConstantDataArray::get`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let data : Array[Int16] = [42, 63, 77, 89] -/// let arr = ctx.getConstInt16Array(data) -/// inspect(arr, content="[4 x i16] [i16 42, i16 63, i16 77, i16 89]") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let data : Array[Int16] = [42, 63, 77, 89] +/// let arr = ctx.getConstInt16Array(data) +/// inspect(arr, content="[4 x i16] [i16 42, i16 63, i16 77, i16 89]") +/// } /// ``` pub fn Context::getConstInt16Array( self : Context, @@ -871,11 +941,13 @@ pub fn Context::getConstInt16Array( /// /// - See LLVM: `ConstantDataArray::get`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let data : Array[Int] = [42, 63, 77, 89] -/// let arr = ctx.getConstInt32Array(data) -/// inspect(arr, content="[4 x i32] [i32 42, i32 63, i32 77, i32 89]") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let data : Array[Int] = [42, 63, 77, 89] +/// let arr = ctx.getConstInt32Array(data) +/// inspect(arr, content="[4 x i32] [i32 42, i32 63, i32 77, i32 89]") +/// } /// ``` pub fn Context::getConstInt32Array( self : Context, @@ -890,11 +962,13 @@ pub fn Context::getConstInt32Array( /// /// - See LLVM: `ConstantDataArray::get`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let data : Array[Int64] = [42, 63, 77, 89] -/// let arr = ctx.getConstInt64Array(data) -/// inspect(arr, content="[4 x i64] [i64 42, i64 63, i64 77, i64 89]") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let data : Array[Int64] = [42, 63, 77, 89] +/// let arr = ctx.getConstInt64Array(data) +/// inspect(arr, content="[4 x i64] [i64 42, i64 63, i64 77, i64 89]") +/// } /// ``` pub fn Context::getConstInt64Array( self : Context, @@ -909,11 +983,13 @@ pub fn Context::getConstInt64Array( /// /// - See LLVM: `ConstantDataArray::get`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let data : Array[Byte] = [42, 63, 77, 89] -/// let arr = ctx.getConstUInt8Array(data) -/// inspect(arr, content="[4 x i8] [i8 42, i8 63, i8 77, i8 89]") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let data : Array[Byte] = [42, 63, 77, 89] +/// let arr = ctx.getConstUInt8Array(data) +/// inspect(arr, content="[4 x i8] [i8 42, i8 63, i8 77, i8 89]") +/// } /// ``` pub fn Context::getConstUInt8Array( self : Context, @@ -929,11 +1005,13 @@ pub fn Context::getConstUInt8Array( /// /// - See LLVM: `ConstantDataArray::get`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let data : Array[UInt16] = [42, 63, 77, 89] -/// let arr = ctx.getConstUInt16Array(data) -/// inspect(arr, content="[4 x i16] [i16 42, i16 63, i16 77, i16 89]") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let data : Array[UInt16] = [42, 63, 77, 89] +/// let arr = ctx.getConstUInt16Array(data) +/// inspect(arr, content="[4 x i16] [i16 42, i16 63, i16 77, i16 89]") +/// } /// ``` pub fn Context::getConstUInt16Array( self : Context, @@ -949,11 +1027,13 @@ pub fn Context::getConstUInt16Array( /// /// - See LLVM: `ConstantDataArray::get`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let data : Array[UInt] = [42, 63, 77, 89] -/// let arr = ctx.getConstUInt32Array(data) -/// inspect(arr, content="[4 x i32] [i32 42, i32 63, i32 77, i32 89]") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let data : Array[UInt] = [42, 63, 77, 89] +/// let arr = ctx.getConstUInt32Array(data) +/// inspect(arr, content="[4 x i32] [i32 42, i32 63, i32 77, i32 89]") +/// } /// ``` pub fn Context::getConstUInt32Array( self : Context, @@ -969,11 +1049,13 @@ pub fn Context::getConstUInt32Array( /// /// - See LLVM: `ConstantDataArray::get`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let data : Array[UInt64] = [42, 63, 77, 89] -/// let arr = ctx.getConstUInt64Array(data) -/// inspect(arr, content="[4 x i64] [i64 42, i64 63, i64 77, i64 89]") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let data : Array[UInt64] = [42, 63, 77, 89] +/// let arr = ctx.getConstUInt64Array(data) +/// inspect(arr, content="[4 x i64] [i64 42, i64 63, i64 77, i64 89]") +/// } /// ``` pub fn Context::getConstUInt64Array( self : Context, @@ -989,14 +1071,16 @@ pub fn Context::getConstUInt64Array( /// /// - See LLVM: `ConstantDataArray::get`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let data : Array[Float] = [1.0, 2.0] -/// let arr = ctx.getConstFloatArray(data) -/// inspect( -/// arr, -/// content="[2 x float] [float 0x3FF0000000000000, float 0x4000000000000000]", -/// ) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let data : Array[Float] = [1.0, 2.0] +/// let arr = ctx.getConstFloatArray(data) +/// inspect( +/// arr, +/// content="[2 x float] [float 0x3FF0000000000000, float 0x4000000000000000]", +/// ) +/// } /// ``` pub fn Context::getConstFloatArray( self : Context, @@ -1012,14 +1096,16 @@ pub fn Context::getConstFloatArray( /// /// - See LLVM: `ConstantDataArray::get`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let data : Array[Double] = [1.0, 2.0] -/// let arr = ctx.getConstDoubleArray(data) -/// inspect( -/// arr, -/// content="[2 x double] [double 0x3FF0000000000000, double 0x4000000000000000]", -/// ) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let data : Array[Double] = [1.0, 2.0] +/// let arr = ctx.getConstDoubleArray(data) +/// inspect( +/// arr, +/// content="[2 x double] [double 0x3FF0000000000000, double 0x4000000000000000]", +/// ) +/// } /// ``` pub fn Context::getConstDoubleArray( self : Context, @@ -1053,11 +1139,13 @@ pub fn Context::getConstArray( /// - Core does not support `int8` currently, hence the type /// of parameter `data` is `Array[Int]`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let data : Array[Int] = [42, 63, 77, 89] -/// let arr = ctx.getConstInt8Vector(data) -/// inspect(arr, content="<4 x i8> ") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let data : Array[Int] = [42, 63, 77, 89] +/// let arr = ctx.getConstInt8Vector(data) +/// inspect(arr, content="<4 x i8> ") +/// } /// ``` pub fn Context::getConstInt8Vector( self : Context, @@ -1073,11 +1161,13 @@ pub fn Context::getConstInt8Vector( /// /// - See LLVM: `ConstantDataVector::get`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let data : Array[Int16] = [42, 63, 77, 89] -/// let arr = ctx.getConstInt16Vector(data) -/// inspect(arr, content="<4 x i16> ") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let data : Array[Int16] = [42, 63, 77, 89] +/// let arr = ctx.getConstInt16Vector(data) +/// inspect(arr, content="<4 x i16> ") +/// } /// ``` pub fn Context::getConstInt16Vector( self : Context, @@ -1093,11 +1183,13 @@ pub fn Context::getConstInt16Vector( /// /// - See LLVM: `ConstantDataVector::get`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let data : Array[Int] = [42, 63, 77, 89] -/// let arr = ctx.getConstInt32Vector(data) -/// inspect(arr, content="<4 x i32> ") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let data : Array[Int] = [42, 63, 77, 89] +/// let arr = ctx.getConstInt32Vector(data) +/// inspect(arr, content="<4 x i32> ") +/// } /// ``` pub fn Context::getConstInt32Vector( self : Context, @@ -1113,11 +1205,13 @@ pub fn Context::getConstInt32Vector( /// /// - See LLVM: `ConstantDataVector::get`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let data : Array[Int64] = [42, 63, 77, 89] -/// let arr = ctx.getConstInt64Vector(data) -/// inspect(arr, content="<4 x i64> ") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let data : Array[Int64] = [42, 63, 77, 89] +/// let arr = ctx.getConstInt64Vector(data) +/// inspect(arr, content="<4 x i64> ") +/// } /// ``` pub fn Context::getConstInt64Vector( self : Context, @@ -1133,11 +1227,13 @@ pub fn Context::getConstInt64Vector( /// /// - See LLVM: `ConstantDataVector::get`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let data : Array[Byte] = [42, 63, 77, 89] -/// let arr = ctx.getConstUInt8Vector(data) -/// inspect(arr, content="<4 x i8> ") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let data : Array[Byte] = [42, 63, 77, 89] +/// let arr = ctx.getConstUInt8Vector(data) +/// inspect(arr, content="<4 x i8> ") +/// } /// ``` pub fn Context::getConstUInt8Vector( self : Context, @@ -1152,11 +1248,13 @@ pub fn Context::getConstUInt8Vector( /// /// - See LLVM: `ConstantDataVector::get`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let data : Array[UInt16] = [42, 63, 77, 89] -/// let arr = ctx.getConstUInt16Vector(data) -/// inspect(arr, content="<4 x i16> ") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let data : Array[UInt16] = [42, 63, 77, 89] +/// let arr = ctx.getConstUInt16Vector(data) +/// inspect(arr, content="<4 x i16> ") +/// } /// ``` pub fn Context::getConstUInt16Vector( self : Context, @@ -1171,11 +1269,13 @@ pub fn Context::getConstUInt16Vector( /// /// - See LLVM: `ConstantDataVector::get`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let data : Array[UInt] = [42, 63, 77, 89] -/// let arr = ctx.getConstUInt32Vector(data) -/// inspect(arr, content="<4 x i32> ") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let data : Array[UInt] = [42, 63, 77, 89] +/// let arr = ctx.getConstUInt32Vector(data) +/// inspect(arr, content="<4 x i32> ") +/// } /// ``` pub fn Context::getConstUInt32Vector( self : Context, @@ -1190,11 +1290,13 @@ pub fn Context::getConstUInt32Vector( /// /// - See LLVM: `ConstantDataVector::get`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let data : Array[UInt64] = [42, 63, 77, 89] -/// let arr = ctx.getConstUInt64Vector(data) -/// inspect(arr, content="<4 x i64> ") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let data : Array[UInt64] = [42, 63, 77, 89] +/// let arr = ctx.getConstUInt64Vector(data) +/// inspect(arr, content="<4 x i64> ") +/// } /// ``` pub fn Context::getConstUInt64Vector( self : Context, @@ -1209,14 +1311,16 @@ pub fn Context::getConstUInt64Vector( /// /// - See LLVM: `ConstantDataVector::get`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let data : Array[Float] = [1.0, 2.0] -/// let arr = ctx.getConstFloatVector(data) -/// inspect( -/// arr, -/// content="<2 x float> ", -/// ) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let data : Array[Float] = [1.0, 2.0] +/// let arr = ctx.getConstFloatVector(data) +/// inspect( +/// arr, +/// content="<2 x float> ", +/// ) +/// } /// ``` pub fn Context::getConstFloatVector( self : Context, @@ -1231,14 +1335,16 @@ pub fn Context::getConstFloatVector( /// /// - See LLVM: `ConstantDataVector::get`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let data : Array[Double] = [1.0, 2.0] -/// let arr = ctx.getConstDoubleVector(data) -/// inspect( -/// arr, -/// content="<2 x double> ", -/// ) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let data : Array[Double] = [1.0, 2.0] +/// let arr = ctx.getConstDoubleVector(data) +/// inspect( +/// arr, +/// content="<2 x double> ", +/// ) +/// } /// ``` pub fn Context::getConstDoubleVector( self : Context, diff --git a/IR/DataLayout.mbt b/IR/DataLayout.mbt index 77af33d..b4272f6 100644 --- a/IR/DataLayout.mbt +++ b/IR/DataLayout.mbt @@ -85,22 +85,24 @@ pub fn DataLayout::getEndian(self : DataLayout) -> Endian { /// /// **Examples:** /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let datalayout = mod.getDataLayout() +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let datalayout = mod.getDataLayout() /// -/// // Basic types -/// let i32ty = ctx.getInt32Ty() -/// assert_eq(datalayout.getTypeAllocSize(i32ty), 4) +/// // Basic types +/// let i32ty = ctx.getInt32Ty() +/// assert_eq(datalayout.getTypeAllocSize(i32ty), 4) /// -/// // Array types -/// let arrty = ctx.getArrayType(i32ty, 10) -/// assert_eq(datalayout.getTypeAllocSize(arrty), 40) // 4 * 10 +/// // Array types +/// let arrty = ctx.getArrayType(i32ty, 10) +/// assert_eq(datalayout.getTypeAllocSize(arrty), 40) // 4 * 10 /// -/// // Struct types with alignment -/// let struct_ty = ctx.getStructType([ctx.getInt8Ty(), i32ty]) -/// assert_eq(datalayout.getTypeAllocSize(struct_ty), 8) // 1 + 3 padding + 4 +/// // Struct types with alignment +/// let struct_ty = ctx.getStructType([ctx.getInt8Ty(), i32ty]) +/// assert_eq(datalayout.getTypeAllocSize(struct_ty), 8) // 1 + 3 padding + 4 +/// } /// ``` /// pub fn DataLayout::getTypeAllocSize(self : Self, ty : &Type) -> Int { @@ -234,29 +236,31 @@ fn DataLayout::getAlignment(self : DataLayout, ty : &Type) -> Align { /// /// **Examples:** /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let datalayout = mod.getDataLayout() -/// let i8ty = ctx.getInt8Ty() -/// let i32ty = ctx.getInt32Ty() -/// let i64ty = ctx.getInt64Ty() +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let datalayout = mod.getDataLayout() +/// let i8ty = ctx.getInt8Ty() +/// let i32ty = ctx.getInt32Ty() +/// let i64ty = ctx.getInt64Ty() /// -/// // Non-packed struct: { i8, i32, i64 } -/// let normal_struct = ctx.getStructType([i8ty, i32ty, i64ty]) -/// assert_eq(datalayout.getStructTypeOffset(normal_struct, 0), 0) // i8 -/// assert_eq(datalayout.getStructTypeOffset(normal_struct, 1), 4) // i32, aligned -/// assert_eq(datalayout.getStructTypeOffset(normal_struct, 2), 8) // i64, aligned +/// // Non-packed struct: { i8, i32, i64 } +/// let normal_struct = ctx.getStructType([i8ty, i32ty, i64ty]) +/// assert_eq(datalayout.getStructTypeOffset(normal_struct, 0), 0) // i8 +/// assert_eq(datalayout.getStructTypeOffset(normal_struct, 1), 4) // i32, aligned +/// assert_eq(datalayout.getStructTypeOffset(normal_struct, 2), 8) // i64, aligned /// -/// // Packed struct: packed { i8, i32, i64 } -/// let packed_struct = ctx.getStructType([i8ty, i32ty, i64ty], isPacked=true) -/// assert_eq(datalayout.getStructTypeOffset(packed_struct, 0), 0) // i8 -/// assert_eq(datalayout.getStructTypeOffset(packed_struct, 1), 1) // i32, no padding -/// assert_eq(datalayout.getStructTypeOffset(packed_struct, 2), 5) // i64, no padding +/// // Packed struct: packed { i8, i32, i64 } +/// let packed_struct = ctx.getStructType([i8ty, i32ty, i64ty], isPacked=true) +/// assert_eq(datalayout.getStructTypeOffset(packed_struct, 0), 0) // i8 +/// assert_eq(datalayout.getStructTypeOffset(packed_struct, 1), 1) // i32, no padding +/// assert_eq(datalayout.getStructTypeOffset(packed_struct, 2), 5) // i64, no padding /// -/// // Invalid indices return 0 -/// assert_eq(datalayout.getStructTypeOffset(normal_struct, -1), 0) -/// assert_eq(datalayout.getStructTypeOffset(normal_struct, 10), 0) +/// // Invalid indices return 0 +/// assert_eq(datalayout.getStructTypeOffset(normal_struct, -1), 0) +/// assert_eq(datalayout.getStructTypeOffset(normal_struct, 10), 0) +/// } /// ``` /// pub fn DataLayout::getStructTypeOffset( diff --git a/IR/Function.mbt b/IR/Function.mbt index 709cdc0..96d47d7 100644 --- a/IR/Function.mbt +++ b/IR/Function.mbt @@ -7,17 +7,19 @@ /// /// - See `llvm::Argument`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let prog = ctx.addModule("demo") -/// let i32ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32ty, [i32ty, i32ty]) -/// let f = prog.addFunction(fty, "add") -/// let arg0 = f.getArg(0).unwrap() -/// let arg1 = f.getArg(1).unwrap() -/// inspect(arg0, content="i32 %0") -/// inspect(arg1.getType(), content="i32") -/// assert_true(f.getArg(2) is None) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let prog = ctx.addModule("demo") +/// let i32ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32ty, [i32ty, i32ty]) +/// let f = prog.addFunction(fty, "add") +/// let arg0 = f.getArg(0).unwrap() +/// let arg1 = f.getArg(1).unwrap() +/// inspect(arg0, content="i32 %0") +/// inspect(arg1.getType(), content="i32") +/// assert_true(f.getArg(2) is None) +/// } /// ``` pub struct Argument { // Unique identifier for the argument. @@ -114,22 +116,24 @@ pub impl Value for Argument with getName(self : Argument) -> String? { /// /// - See `llvm::Argument::setName`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let prog = ctx.addModule("demo") -/// let i32ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32ty, [i32ty, i32ty]) -/// let f = prog.addFunction(fty, "add") -/// let arg0 = f.getArg(0).unwrap() -/// let arg1 = f.getArg(1).unwrap() -/// assert_true(f.getArg(2) is None) -/// inspect(arg0, content="i32 %0") -/// inspect(arg1.getType(), content="i32") -/// arg0.setName("lhs") -/// arg1.setName("rhs") -/// inspect(arg0, content="i32 %lhs") -/// inspect(arg1, content="i32 %rhs") -/// assert_true((try? arg1.setName("lhs")) is Err(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let prog = ctx.addModule("demo") +/// let i32ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32ty, [i32ty, i32ty]) +/// let f = prog.addFunction(fty, "add") +/// let arg0 = f.getArg(0).unwrap() +/// let arg1 = f.getArg(1).unwrap() +/// assert_true(f.getArg(2) is None) +/// inspect(arg0, content="i32 %0") +/// inspect(arg1.getType(), content="i32") +/// arg0.setName("lhs") +/// arg1.setName("rhs") +/// inspect(arg0, content="i32 %lhs") +/// inspect(arg1, content="i32 %rhs") +/// assert_true((try? arg1.setName("lhs")) is Err(_)) +/// } /// ``` pub impl Value for Argument with setName(self : Argument, name : String) -> Unit raise LLVMValueError { if name.is_empty() { @@ -263,14 +267,11 @@ fn Function::new( slotTracker: None, } f.symbols.set(name, f) - fty - .params() - .iter2() - .each(fn(i, ty) { + for i, ty in fty.params().iterator2() { let ui = i.reinterpret_as_uint() let arg = Argument::new(ty, ui, f) f.arguments.push(arg) - }) + } f.slotTracker = SlotTracker::new(f) |> Some f } @@ -329,16 +330,26 @@ pub fn Function::isDeclaration(self : Function) -> Bool { ///| pub fn Function::instIter(self : Function) -> Iter[&Instruction] { - letrec f = yield_ => { - for bb in self.basicBlocks { - for i in bb.instIter() { - guard yield_(i) is IterContinue else { return IterEnd } + let mut bb_index = 0 + let mut next_inst : &Instruction? = None + Iterator::new(fn() { + loop next_inst { + Some(inst) => { + next_inst = inst.next() + break Some(inst) + } + None => { + if bb_index >= self.basicBlocks.length() { + break None + } + let bb = self.basicBlocks[bb_index] + bb_index += 1 + let start_inst = bb.firstInst() + next_inst = start_inst + continue start_inst } } - IterContinue - } - - Iter::new(f) + }).iter() } ///| diff --git a/IR/IRBuilder.mbt b/IR/IRBuilder.mbt index 41d3bec..8231c3d 100644 --- a/IR/IRBuilder.mbt +++ b/IR/IRBuilder.mbt @@ -92,18 +92,20 @@ pub fn IRBuilder::getModule(self : IRBuilder) -> Module { /// /// `IRBuilder::createRet` could not return void. use `IRBuilder::createRetVoid` for that purpose. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [i32_ty]) -/// let fval = mod.addFunction(fty, "direct_ret") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg = fval.getArg(0).unwrap() -/// builder.setInsertPoint(bb) -/// let ret = builder.createRet(arg) -/// inspect(ret, content=" ret i32 %0") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [i32_ty]) +/// let fval = mod.addFunction(fty, "direct_ret") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg = fval.getArg(0).unwrap() +/// builder.setInsertPoint(bb) +/// let ret = builder.createRet(arg) +/// inspect(ret, content=" ret i32 %0") +/// } /// ``` pub fn IRBuilder::createRet( self : IRBuilder, @@ -131,17 +133,19 @@ pub fn IRBuilder::createRet( /// /// If you want to return a value, use `IRBuilder::createRet` instead. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let void_ty = ctx.getVoidTy() -/// let fty = ctx.getFunctionType(void_ty, []) -/// let fval = mod.addFunction(fty, "direct_ret") -/// let bb = fval.addBasicBlock(name="entry") -/// builder.setInsertPoint(bb) -/// let ret = builder.createRetVoid() -/// inspect(ret, content=" ret void") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let void_ty = ctx.getVoidTy() +/// let fty = ctx.getFunctionType(void_ty, []) +/// let fval = mod.addFunction(fty, "direct_ret") +/// let bb = fval.addBasicBlock(name="entry") +/// builder.setInsertPoint(bb) +/// let ret = builder.createRetVoid() +/// inspect(ret, content=" ret void") +/// } /// ``` pub fn IRBuilder::createRetVoid(self : IRBuilder) -> &Instruction raise Error { let parent = self.getInsertFunction() @@ -159,18 +163,20 @@ pub fn IRBuilder::createRetVoid(self : IRBuilder) -> &Instruction raise Error { ///| /// Create an Alloca Instruction. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let void_ty = ctx.getVoidTy() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(void_ty, []) -/// let fval = mod.addFunction(fty, "foo") -/// let bb = fval.addBasicBlock(name="entry") -/// builder.setInsertPoint(bb) -/// let inst = builder.createAlloca(i32_ty, name="var1") -/// inspect(inst, content=" %var1 = alloca i32, align 4") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let void_ty = ctx.getVoidTy() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(void_ty, []) +/// let fval = mod.addFunction(fty, "foo") +/// let bb = fval.addBasicBlock(name="entry") +/// builder.setInsertPoint(bb) +/// let inst = builder.createAlloca(i32_ty, name="var1") +/// inspect(inst, content=" %var1 = alloca i32, align 4") +/// } /// ``` pub fn IRBuilder::createAlloca( self : IRBuilder, @@ -199,25 +205,27 @@ pub fn IRBuilder::createAlloca( /// /// This creates an integer addition instruction. Both operands must be integer types with the same bitwidth. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "add_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg1 = fval.getArg(0).unwrap() -/// let arg2 = fval.getArg(1).unwrap() -/// builder.setInsertPoint(bb) -/// let add = builder.createAdd(arg1, arg2, name="sum") -/// inspect(add, content=" %sum = add i32 %0, %1") -/// assert_true(add.asValueEnum() is BinaryInst(_)) -/// let one = ctx.getConstInt32(1) -/// let two = ctx.getConstInt32(2) -/// let three = builder.createAdd(one, two) -/// inspect(three, content="i32 3") -/// assert_true(three.asValueEnum() is ConstantInt(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "add_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg1 = fval.getArg(0).unwrap() +/// let arg2 = fval.getArg(1).unwrap() +/// builder.setInsertPoint(bb) +/// let add = builder.createAdd(arg1, arg2, name="sum") +/// inspect(add, content=" %sum = add i32 %0, %1") +/// assert_true(add.asValueEnum() is BinaryInst(_)) +/// let one = ctx.getConstInt32(1) +/// let two = ctx.getConstInt32(2) +/// let three = builder.createAdd(one, two) +/// inspect(three, content="i32 3") +/// assert_true(three.asValueEnum() is ConstantInt(_)) +/// } /// ``` pub fn IRBuilder::createAdd( self : IRBuilder, @@ -275,25 +283,27 @@ pub fn IRBuilder::createAdd( /// /// This creates an integer addition instruction with No Signed Wrap (NSW) flag. If signed overflow occurs, the result is undefined. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "nsw_add_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg1 = fval.getArg(0).unwrap() -/// let arg2 = fval.getArg(1).unwrap() -/// builder.setInsertPoint(bb) -/// let add = builder.createNSWAdd(arg1, arg2, name="sum") -/// inspect(add, content=" %sum = add nsw i32 %0, %1") -/// assert_true(add.asValueEnum() is BinaryInst(_)) -/// let one = ctx.getConstInt32(1) -/// let two = ctx.getConstInt32(2) -/// let three = builder.createNSWAdd(one, two) -/// inspect(three, content="i32 3") -/// assert_true(three.asValueEnum() is ConstantInt(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "nsw_add_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg1 = fval.getArg(0).unwrap() +/// let arg2 = fval.getArg(1).unwrap() +/// builder.setInsertPoint(bb) +/// let add = builder.createNSWAdd(arg1, arg2, name="sum") +/// inspect(add, content=" %sum = add nsw i32 %0, %1") +/// assert_true(add.asValueEnum() is BinaryInst(_)) +/// let one = ctx.getConstInt32(1) +/// let two = ctx.getConstInt32(2) +/// let three = builder.createNSWAdd(one, two) +/// inspect(three, content="i32 3") +/// assert_true(three.asValueEnum() is ConstantInt(_)) +/// } /// ``` pub fn IRBuilder::createNSWAdd( self : IRBuilder, @@ -311,25 +321,27 @@ pub fn IRBuilder::createNSWAdd( /// /// This creates an integer addition instruction with No Unsigned Wrap (NUW) flag. If unsigned overflow occurs, the result is undefined. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "nuw_add_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg1 = fval.getArg(0).unwrap() -/// let arg2 = fval.getArg(1).unwrap() -/// builder.setInsertPoint(bb) -/// let add = builder.createNUWAdd(arg1, arg2, name="sum") -/// inspect(add, content=" %sum = add nuw i32 %0, %1") -/// assert_true(add.asValueEnum() is BinaryInst(_)) -/// let one = ctx.getConstInt32(1) -/// let two = ctx.getConstInt32(2) -/// let three = builder.createNUWAdd(one, two) -/// inspect(three, content="i32 3") -/// assert_true(three.asValueEnum() is ConstantInt(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "nuw_add_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg1 = fval.getArg(0).unwrap() +/// let arg2 = fval.getArg(1).unwrap() +/// builder.setInsertPoint(bb) +/// let add = builder.createNUWAdd(arg1, arg2, name="sum") +/// inspect(add, content=" %sum = add nuw i32 %0, %1") +/// assert_true(add.asValueEnum() is BinaryInst(_)) +/// let one = ctx.getConstInt32(1) +/// let two = ctx.getConstInt32(2) +/// let three = builder.createNUWAdd(one, two) +/// inspect(three, content="i32 3") +/// assert_true(three.asValueEnum() is ConstantInt(_)) +/// } /// ``` pub fn IRBuilder::createNUWAdd( self : IRBuilder, @@ -347,25 +359,27 @@ pub fn IRBuilder::createNUWAdd( /// /// This creates an integer subtraction instruction. Both operands must be integer types with the same bitwidth. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "sub_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg1 = fval.getArg(0).unwrap() -/// let arg2 = fval.getArg(1).unwrap() -/// builder.setInsertPoint(bb) -/// let sub = builder.createSub(arg1, arg2, name="diff") -/// inspect(sub, content=" %diff = sub i32 %0, %1") -/// assert_true(sub.asValueEnum() is BinaryInst(_)) -/// let five = ctx.getConstInt32(5) -/// let two = ctx.getConstInt32(2) -/// let three = builder.createSub(five, two) -/// inspect(three, content="i32 3") -/// assert_true(three.asValueEnum() is ConstantInt(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "sub_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg1 = fval.getArg(0).unwrap() +/// let arg2 = fval.getArg(1).unwrap() +/// builder.setInsertPoint(bb) +/// let sub = builder.createSub(arg1, arg2, name="diff") +/// inspect(sub, content=" %diff = sub i32 %0, %1") +/// assert_true(sub.asValueEnum() is BinaryInst(_)) +/// let five = ctx.getConstInt32(5) +/// let two = ctx.getConstInt32(2) +/// let three = builder.createSub(five, two) +/// inspect(three, content="i32 3") +/// assert_true(three.asValueEnum() is ConstantInt(_)) +/// } /// ``` pub fn IRBuilder::createSub( self : IRBuilder, @@ -423,25 +437,27 @@ pub fn IRBuilder::createSub( /// /// This creates an integer subtraction instruction with No Signed Wrap (NSW) flag. If signed overflow occurs, the result is undefined. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "nsw_sub_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg1 = fval.getArg(0).unwrap() -/// let arg2 = fval.getArg(1).unwrap() -/// builder.setInsertPoint(bb) -/// let sub = builder.createNSWSub(arg1, arg2, name="diff") -/// inspect(sub, content=" %diff = sub nsw i32 %0, %1") -/// assert_true(sub.asValueEnum() is BinaryInst(_)) -/// let five = ctx.getConstInt32(5) -/// let two = ctx.getConstInt32(2) -/// let three = builder.createNSWSub(five, two) -/// inspect(three, content="i32 3") -/// assert_true(three.asValueEnum() is ConstantInt(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "nsw_sub_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg1 = fval.getArg(0).unwrap() +/// let arg2 = fval.getArg(1).unwrap() +/// builder.setInsertPoint(bb) +/// let sub = builder.createNSWSub(arg1, arg2, name="diff") +/// inspect(sub, content=" %diff = sub nsw i32 %0, %1") +/// assert_true(sub.asValueEnum() is BinaryInst(_)) +/// let five = ctx.getConstInt32(5) +/// let two = ctx.getConstInt32(2) +/// let three = builder.createNSWSub(five, two) +/// inspect(three, content="i32 3") +/// assert_true(three.asValueEnum() is ConstantInt(_)) +/// } /// ``` pub fn IRBuilder::createNSWSub( self : IRBuilder, @@ -459,25 +475,27 @@ pub fn IRBuilder::createNSWSub( /// /// This creates an integer subtraction instruction with No Unsigned Wrap (NUW) flag. If unsigned overflow occurs, the result is undefined. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "nuw_sub_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg1 = fval.getArg(0).unwrap() -/// let arg2 = fval.getArg(1).unwrap() -/// builder.setInsertPoint(bb) -/// let sub = builder.createNUWSub(arg1, arg2, name="diff") -/// inspect(sub, content=" %diff = sub nuw i32 %0, %1") -/// assert_true(sub.asValueEnum() is BinaryInst(_)) -/// let five = ctx.getConstInt32(5) -/// let two = ctx.getConstInt32(2) -/// let three = builder.createNUWSub(five, two) -/// inspect(three, content="i32 3") -/// assert_true(three.asValueEnum() is ConstantInt(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "nuw_sub_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg1 = fval.getArg(0).unwrap() +/// let arg2 = fval.getArg(1).unwrap() +/// builder.setInsertPoint(bb) +/// let sub = builder.createNUWSub(arg1, arg2, name="diff") +/// inspect(sub, content=" %diff = sub nuw i32 %0, %1") +/// assert_true(sub.asValueEnum() is BinaryInst(_)) +/// let five = ctx.getConstInt32(5) +/// let two = ctx.getConstInt32(2) +/// let three = builder.createNUWSub(five, two) +/// inspect(three, content="i32 3") +/// assert_true(three.asValueEnum() is ConstantInt(_)) +/// } /// ``` pub fn IRBuilder::createNUWSub( self : IRBuilder, @@ -506,25 +524,27 @@ pub fn IRBuilder::createNeg( /// /// This creates an integer multiplication instruction. Both operands must be integer types with the same bitwidth. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "mul_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg1 = fval.getArg(0).unwrap() -/// let arg2 = fval.getArg(1).unwrap() -/// builder.setInsertPoint(bb) -/// let mul = builder.createMul(arg1, arg2, name="product") -/// inspect(mul, content=" %product = mul i32 %0, %1") -/// assert_true(mul.asValueEnum() is BinaryInst(_)) -/// let three = ctx.getConstInt32(3) -/// let four = ctx.getConstInt32(4) -/// let twelve = builder.createMul(three, four) -/// inspect(twelve, content="i32 12") -/// assert_true(twelve.asValueEnum() is ConstantInt(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "mul_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg1 = fval.getArg(0).unwrap() +/// let arg2 = fval.getArg(1).unwrap() +/// builder.setInsertPoint(bb) +/// let mul = builder.createMul(arg1, arg2, name="product") +/// inspect(mul, content=" %product = mul i32 %0, %1") +/// assert_true(mul.asValueEnum() is BinaryInst(_)) +/// let three = ctx.getConstInt32(3) +/// let four = ctx.getConstInt32(4) +/// let twelve = builder.createMul(three, four) +/// inspect(twelve, content="i32 12") +/// assert_true(twelve.asValueEnum() is ConstantInt(_)) +/// } /// ``` pub fn IRBuilder::createMul( self : IRBuilder, @@ -582,25 +602,27 @@ pub fn IRBuilder::createMul( /// /// This creates an integer multiplication instruction with No Signed Wrap (NSW) flag. If signed overflow occurs, the result is undefined. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "nsw_mul_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg1 = fval.getArg(0).unwrap() -/// let arg2 = fval.getArg(1).unwrap() -/// builder.setInsertPoint(bb) -/// let mul = builder.createNSWMul(arg1, arg2, name="product") -/// inspect(mul, content=" %product = mul nsw i32 %0, %1") -/// assert_true(mul.asValueEnum() is BinaryInst(_)) -/// let three = ctx.getConstInt32(3) -/// let four = ctx.getConstInt32(4) -/// let twelve = builder.createNSWMul(three, four) -/// inspect(twelve, content="i32 12") -/// assert_true(twelve.asValueEnum() is ConstantInt(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "nsw_mul_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg1 = fval.getArg(0).unwrap() +/// let arg2 = fval.getArg(1).unwrap() +/// builder.setInsertPoint(bb) +/// let mul = builder.createNSWMul(arg1, arg2, name="product") +/// inspect(mul, content=" %product = mul nsw i32 %0, %1") +/// assert_true(mul.asValueEnum() is BinaryInst(_)) +/// let three = ctx.getConstInt32(3) +/// let four = ctx.getConstInt32(4) +/// let twelve = builder.createNSWMul(three, four) +/// inspect(twelve, content="i32 12") +/// assert_true(twelve.asValueEnum() is ConstantInt(_)) +/// } /// ``` pub fn IRBuilder::createNSWMul( self : IRBuilder, @@ -618,25 +640,27 @@ pub fn IRBuilder::createNSWMul( /// /// This creates an integer multiplication instruction with No Unsigned Wrap (NUW) flag. If unsigned overflow occurs, the result is undefined. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "nuw_mul_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg1 = fval.getArg(0).unwrap() -/// let arg2 = fval.getArg(1).unwrap() -/// builder.setInsertPoint(bb) -/// let mul = builder.createNUWMul(arg1, arg2, name="product") -/// inspect(mul, content=" %product = mul nuw i32 %0, %1") -/// assert_true(mul.asValueEnum() is BinaryInst(_)) -/// let three = ctx.getConstInt32(3) -/// let four = ctx.getConstInt32(4) -/// let twelve = builder.createNUWMul(three, four) -/// inspect(twelve, content="i32 12") -/// assert_true(twelve.asValueEnum() is ConstantInt(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "nuw_mul_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg1 = fval.getArg(0).unwrap() +/// let arg2 = fval.getArg(1).unwrap() +/// builder.setInsertPoint(bb) +/// let mul = builder.createNUWMul(arg1, arg2, name="product") +/// inspect(mul, content=" %product = mul nuw i32 %0, %1") +/// assert_true(mul.asValueEnum() is BinaryInst(_)) +/// let three = ctx.getConstInt32(3) +/// let four = ctx.getConstInt32(4) +/// let twelve = builder.createNUWMul(three, four) +/// inspect(twelve, content="i32 12") +/// assert_true(twelve.asValueEnum() is ConstantInt(_)) +/// } /// ``` pub fn IRBuilder::createNUWMul( self : IRBuilder, @@ -1200,19 +1224,21 @@ pub fn IRBuilder::createFSub( /// /// This creates a floating-point negation instruction. The operand must be a floating-point type. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let f32_ty = ctx.getFloatTy() -/// let fty = ctx.getFunctionType(f32_ty, [f32_ty]) -/// let fval = mod.addFunction(fty, "fneg_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg = fval.getArg(0).unwrap() -/// builder.setInsertPoint(bb) -/// let fneg = builder.createFNeg(arg, name="neg_value") -/// inspect(fneg, content=" %neg_value = fneg float %0") -/// assert_true(fneg.asValueEnum() is FNegInst(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let f32_ty = ctx.getFloatTy() +/// let fty = ctx.getFunctionType(f32_ty, [f32_ty]) +/// let fval = mod.addFunction(fty, "fneg_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg = fval.getArg(0).unwrap() +/// builder.setInsertPoint(bb) +/// let fneg = builder.createFNeg(arg, name="neg_value") +/// inspect(fneg, content=" %neg_value = fneg float %0") +/// assert_true(fneg.asValueEnum() is FNegInst(_)) +/// } /// ``` pub fn IRBuilder::createFNeg( self : IRBuilder, @@ -1448,25 +1474,27 @@ pub fn IRBuilder::createFRem( /// /// This creates a bitwise AND instruction. Both operands must be integer types with the same bitwidth. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "and_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg1 = fval.getArg(0).unwrap() -/// let arg2 = fval.getArg(1).unwrap() -/// builder.setInsertPoint(bb) -/// let and_result = builder.createAnd(arg1, arg2, name="result") -/// inspect(and_result, content=" %result = and i32 %0, %1") -/// assert_true(and_result.asValueEnum() is BinaryInst(_)) -/// let val1 = ctx.getConstInt32(12) // 1100 in binary -/// let val2 = ctx.getConstInt32(10) // 1010 in binary -/// let result = builder.createAnd(val1, val2) // 1000 in binary = 8 -/// inspect(result, content="i32 8") -/// assert_true(result.asValueEnum() is ConstantInt(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "and_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg1 = fval.getArg(0).unwrap() +/// let arg2 = fval.getArg(1).unwrap() +/// builder.setInsertPoint(bb) +/// let and_result = builder.createAnd(arg1, arg2, name="result") +/// inspect(and_result, content=" %result = and i32 %0, %1") +/// assert_true(and_result.asValueEnum() is BinaryInst(_)) +/// let val1 = ctx.getConstInt32(12) // 1100 in binary +/// let val2 = ctx.getConstInt32(10) // 1010 in binary +/// let result = builder.createAnd(val1, val2) // 1000 in binary = 8 +/// inspect(result, content="i32 8") +/// assert_true(result.asValueEnum() is ConstantInt(_)) +/// } /// ``` pub fn IRBuilder::createAnd( self : IRBuilder, @@ -1516,25 +1544,27 @@ pub fn IRBuilder::createAnd( /// /// This creates a bitwise OR instruction. Both operands must be integer types with the same bitwidth. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "or_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg1 = fval.getArg(0).unwrap() -/// let arg2 = fval.getArg(1).unwrap() -/// builder.setInsertPoint(bb) -/// let or_result = builder.createOr(arg1, arg2, name="result") -/// inspect(or_result, content=" %result = or i32 %0, %1") -/// assert_true(or_result.asValueEnum() is BinaryInst(_)) -/// let val1 = ctx.getConstInt32(12) // 1100 in binary -/// let val2 = ctx.getConstInt32(10) // 1010 in binary -/// let result = builder.createOr(val1, val2) // 1110 in binary = 14 -/// inspect(result, content="i32 14") -/// assert_true(result.asValueEnum() is ConstantInt(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "or_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg1 = fval.getArg(0).unwrap() +/// let arg2 = fval.getArg(1).unwrap() +/// builder.setInsertPoint(bb) +/// let or_result = builder.createOr(arg1, arg2, name="result") +/// inspect(or_result, content=" %result = or i32 %0, %1") +/// assert_true(or_result.asValueEnum() is BinaryInst(_)) +/// let val1 = ctx.getConstInt32(12) // 1100 in binary +/// let val2 = ctx.getConstInt32(10) // 1010 in binary +/// let result = builder.createOr(val1, val2) // 1110 in binary = 14 +/// inspect(result, content="i32 14") +/// assert_true(result.asValueEnum() is ConstantInt(_)) +/// } /// ``` pub fn IRBuilder::createOr( self : IRBuilder, @@ -1584,25 +1614,27 @@ pub fn IRBuilder::createOr( /// /// This creates a bitwise XOR instruction. Both operands must be integer types with the same bitwidth. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "xor_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg1 = fval.getArg(0).unwrap() -/// let arg2 = fval.getArg(1).unwrap() -/// builder.setInsertPoint(bb) -/// let xor_result = builder.createXor(arg1, arg2, name="result") -/// inspect(xor_result, content=" %result = xor i32 %0, %1") -/// assert_true(xor_result.asValueEnum() is BinaryInst(_)) -/// let val1 = ctx.getConstInt32(12) // 1100 in binary -/// let val2 = ctx.getConstInt32(10) // 1010 in binary -/// let result = builder.createXor(val1, val2) // 0110 in binary = 6 -/// inspect(result, content="i32 6") -/// assert_true(result.asValueEnum() is ConstantInt(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "xor_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg1 = fval.getArg(0).unwrap() +/// let arg2 = fval.getArg(1).unwrap() +/// builder.setInsertPoint(bb) +/// let xor_result = builder.createXor(arg1, arg2, name="result") +/// inspect(xor_result, content=" %result = xor i32 %0, %1") +/// assert_true(xor_result.asValueEnum() is BinaryInst(_)) +/// let val1 = ctx.getConstInt32(12) // 1100 in binary +/// let val2 = ctx.getConstInt32(10) // 1010 in binary +/// let result = builder.createXor(val1, val2) // 0110 in binary = 6 +/// inspect(result, content="i32 6") +/// assert_true(result.asValueEnum() is ConstantInt(_)) +/// } /// ``` pub fn IRBuilder::createXor( self : IRBuilder, @@ -1675,25 +1707,27 @@ pub fn IRBuilder::createNot( /// /// This creates a left shift instruction. Both operands must be integer types with the same bitwidth. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "shl_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg1 = fval.getArg(0).unwrap() -/// let arg2 = fval.getArg(1).unwrap() -/// builder.setInsertPoint(bb) -/// let shl_result = builder.createShl(arg1, arg2, name="result") -/// inspect(shl_result, content=" %result = shl i32 %0, %1") -/// assert_true(shl_result.asValueEnum() is BinaryInst(_)) -/// let val = ctx.getConstInt32(5) // 101 in binary -/// let shift = ctx.getConstInt32(2) // shift left by 2 -/// let result = builder.createShl(val, shift) // 10100 in binary = 20 -/// inspect(result, content="i32 20") -/// assert_true(result.asValueEnum() is ConstantInt(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "shl_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg1 = fval.getArg(0).unwrap() +/// let arg2 = fval.getArg(1).unwrap() +/// builder.setInsertPoint(bb) +/// let shl_result = builder.createShl(arg1, arg2, name="result") +/// inspect(shl_result, content=" %result = shl i32 %0, %1") +/// assert_true(shl_result.asValueEnum() is BinaryInst(_)) +/// let val = ctx.getConstInt32(5) // 101 in binary +/// let shift = ctx.getConstInt32(2) // shift left by 2 +/// let result = builder.createShl(val, shift) // 10100 in binary = 20 +/// inspect(result, content="i32 20") +/// assert_true(result.asValueEnum() is ConstantInt(_)) +/// } /// ``` pub fn IRBuilder::createShl( self : IRBuilder, @@ -1752,25 +1786,27 @@ pub fn IRBuilder::createShl( /// /// This creates a logical right shift instruction. Both operands must be integer types with the same bitwidth. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "lshr_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg1 = fval.getArg(0).unwrap() -/// let arg2 = fval.getArg(1).unwrap() -/// builder.setInsertPoint(bb) -/// let lshr_result = builder.createLShr(arg1, arg2, name="result") -/// inspect(lshr_result, content=" %result = lshr i32 %0, %1") -/// assert_true(lshr_result.asValueEnum() is BinaryInst(_)) -/// let twenty = ctx.getConstInt32(20) // 10100 in binary -/// let two = ctx.getConstInt32(2) // shift right by 2 -/// let five = builder.createLShr(twenty, two) // 101 in binary = 5 -/// inspect(five, content="i32 5") -/// assert_true(five.asValueEnum() is ConstantInt(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "lshr_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg1 = fval.getArg(0).unwrap() +/// let arg2 = fval.getArg(1).unwrap() +/// builder.setInsertPoint(bb) +/// let lshr_result = builder.createLShr(arg1, arg2, name="result") +/// inspect(lshr_result, content=" %result = lshr i32 %0, %1") +/// assert_true(lshr_result.asValueEnum() is BinaryInst(_)) +/// let twenty = ctx.getConstInt32(20) // 10100 in binary +/// let two = ctx.getConstInt32(2) // shift right by 2 +/// let five = builder.createLShr(twenty, two) // 101 in binary = 5 +/// inspect(five, content="i32 5") +/// assert_true(five.asValueEnum() is ConstantInt(_)) +/// } /// ``` pub fn IRBuilder::createLShr( self : IRBuilder, @@ -1825,25 +1861,27 @@ pub fn IRBuilder::createLShr( /// /// This creates an arithmetic right shift instruction. Both operands must be integer types with the same bitwidth. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "ashr_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg1 = fval.getArg(0).unwrap() -/// let arg2 = fval.getArg(1).unwrap() -/// builder.setInsertPoint(bb) -/// let ashr_result = builder.createAShr(arg1, arg2, name="result") -/// inspect(ashr_result, content=" %result = ashr i32 %0, %1") -/// assert_true(ashr_result.asValueEnum() is BinaryInst(_)) -/// let twenty = ctx.getConstInt32(20) // 10100 in binary -/// let two = ctx.getConstInt32(2) // shift right by 2 -/// let five = builder.createAShr(twenty, two) // 101 in binary = 5 -/// inspect(five, content="i32 5") -/// assert_true(five.asValueEnum() is ConstantInt(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "ashr_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg1 = fval.getArg(0).unwrap() +/// let arg2 = fval.getArg(1).unwrap() +/// builder.setInsertPoint(bb) +/// let ashr_result = builder.createAShr(arg1, arg2, name="result") +/// inspect(ashr_result, content=" %result = ashr i32 %0, %1") +/// assert_true(ashr_result.asValueEnum() is BinaryInst(_)) +/// let twenty = ctx.getConstInt32(20) // 10100 in binary +/// let two = ctx.getConstInt32(2) // shift right by 2 +/// let five = builder.createAShr(twenty, two) // 101 in binary = 5 +/// inspect(five, content="i32 5") +/// assert_true(five.asValueEnum() is ConstantInt(_)) +/// } /// ``` pub fn IRBuilder::createAShr( self : IRBuilder, @@ -1899,43 +1937,45 @@ pub fn IRBuilder::createAShr( /// 1. `lhs` and `rhs` must be integer types with the same bitwidth. /// 2. Allowed predicates: EQ, NE, SGT, SGE, SLT, SLE, UGT, UGE, ULT, ULE. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "icmp_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg0 = fval.getArg(0).unwrap() -/// let arg1 = fval.getArg(1).unwrap() -/// builder.setInsertPoint(bb) -/// let eq_cmp = builder.createICmp(IntPredicate::EQ, arg0, arg1, name="eq_cmp") -/// inspect(eq_cmp, content=" %eq_cmp = icmp eq i32 %0, %1") -/// assert_true(eq_cmp.asValueEnum() is ICmpInst(_)) -/// let val1 = ctx.getConstInt32(5) -/// let val2 = ctx.getConstInt32(5) -/// let result = builder.createICmpEQ(val1, val2) -/// inspect(result, content="i1 true") -/// assert_true(result.asValueEnum() is ConstantInt(_)) -/// let ne_cmp = builder.createICmpNE(arg0, arg1, name="ne_cmp") -/// inspect(ne_cmp, content=" %ne_cmp = icmp ne i32 %0, %1") -/// let sgt_cmp = builder.createICmpSGT(arg0, arg1, name="sgt_cmp") -/// inspect(sgt_cmp, content=" %sgt_cmp = icmp sgt i32 %0, %1") -/// let sge_cmp = builder.createICmpSGE(arg0, arg1, name="sge_cmp") -/// inspect(sge_cmp, content=" %sge_cmp = icmp sge i32 %0, %1") -/// let slt_cmp = builder.createICmpSLT(arg0, arg1, name="slt_cmp") -/// inspect(slt_cmp, content=" %slt_cmp = icmp slt i32 %0, %1") -/// let sle_cmp = builder.createICmpSLE(arg0, arg1, name="sle_cmp") -/// inspect(sle_cmp, content=" %sle_cmp = icmp sle i32 %0, %1") -/// let ugt_cmp = builder.createICmpUGT(arg0, arg1, name="ugt_cmp") -/// inspect(ugt_cmp, content=" %ugt_cmp = icmp ugt i32 %0, %1") -/// let uge_cmp = builder.createICmpUGE(arg0, arg1, name="uge_cmp") -/// inspect(uge_cmp, content=" %uge_cmp = icmp uge i32 %0, %1") -/// let ult_cmp = builder.createICmpULT(arg0, arg1, name="ult_cmp") -/// inspect(ult_cmp, content=" %ult_cmp = icmp ult i32 %0, %1") -/// let ule_cmp = builder.createICmpULE(arg0, arg1, name="ule_cmp") -/// inspect(ule_cmp, content=" %ule_cmp = icmp ule i32 %0, %1") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "icmp_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg0 = fval.getArg(0).unwrap() +/// let arg1 = fval.getArg(1).unwrap() +/// builder.setInsertPoint(bb) +/// let eq_cmp = builder.createICmp(IntPredicate::EQ, arg0, arg1, name="eq_cmp") +/// inspect(eq_cmp, content=" %eq_cmp = icmp eq i32 %0, %1") +/// assert_true(eq_cmp.asValueEnum() is ICmpInst(_)) +/// let val1 = ctx.getConstInt32(5) +/// let val2 = ctx.getConstInt32(5) +/// let result = builder.createICmpEQ(val1, val2) +/// inspect(result, content="i1 true") +/// assert_true(result.asValueEnum() is ConstantInt(_)) +/// let ne_cmp = builder.createICmpNE(arg0, arg1, name="ne_cmp") +/// inspect(ne_cmp, content=" %ne_cmp = icmp ne i32 %0, %1") +/// let sgt_cmp = builder.createICmpSGT(arg0, arg1, name="sgt_cmp") +/// inspect(sgt_cmp, content=" %sgt_cmp = icmp sgt i32 %0, %1") +/// let sge_cmp = builder.createICmpSGE(arg0, arg1, name="sge_cmp") +/// inspect(sge_cmp, content=" %sge_cmp = icmp sge i32 %0, %1") +/// let slt_cmp = builder.createICmpSLT(arg0, arg1, name="slt_cmp") +/// inspect(slt_cmp, content=" %slt_cmp = icmp slt i32 %0, %1") +/// let sle_cmp = builder.createICmpSLE(arg0, arg1, name="sle_cmp") +/// inspect(sle_cmp, content=" %sle_cmp = icmp sle i32 %0, %1") +/// let ugt_cmp = builder.createICmpUGT(arg0, arg1, name="ugt_cmp") +/// inspect(ugt_cmp, content=" %ugt_cmp = icmp ugt i32 %0, %1") +/// let uge_cmp = builder.createICmpUGE(arg0, arg1, name="uge_cmp") +/// inspect(uge_cmp, content=" %uge_cmp = icmp uge i32 %0, %1") +/// let ult_cmp = builder.createICmpULT(arg0, arg1, name="ult_cmp") +/// inspect(ult_cmp, content=" %ult_cmp = icmp ult i32 %0, %1") +/// let ule_cmp = builder.createICmpULE(arg0, arg1, name="ule_cmp") +/// inspect(ule_cmp, content=" %ule_cmp = icmp ule i32 %0, %1") +/// } /// ``` pub fn IRBuilder::createICmp( self : IRBuilder, @@ -2110,54 +2150,56 @@ pub fn IRBuilder::createICmpSLE( /// 1. `lhs` and `rhs` must be floating-point types with the same bitwidth. /// 2. Allowed predicates: OEQ, OGT, OGE, OLT, OLE, ONE, ORD, UEQ, UGT, UGE, ULT, ULE, UNE. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let f32_ty = ctx.getFloatTy() -/// let fty = ctx.getFunctionType(f32_ty, [f32_ty, f32_ty]) -/// let fval = mod.addFunction(fty, "fcmp_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg0 = fval.getArg(0).unwrap() -/// let arg1 = fval.getArg(1).unwrap() -/// builder.setInsertPoint(bb) -/// let oeq_cmp = builder.createFCmp( -/// FloatPredicate::OEQ, -/// arg0, -/// arg1, -/// name="oeq_cmp", -/// ) -/// inspect(oeq_cmp, content=" %oeq_cmp = fcmp oeq float %0, %1") -/// assert_true(oeq_cmp.asValueEnum() is FCmpInst(_)) -/// let val1 = ctx.getConstFloat(3.14) -/// let val2 = ctx.getConstFloat(3.14) -/// let result = builder.createFCmpOEQ(val1, val2) -/// inspect(result, content="i1 true") -/// assert_true(result.asValueEnum() is ConstantInt(_)) -/// let ogt_cmp = builder.createFCmpOGT(arg0, arg1, name="ogt_cmp") -/// inspect(ogt_cmp, content=" %ogt_cmp = fcmp ogt float %0, %1") -/// let oge_cmp = builder.createFCmpOGE(arg0, arg1, name="oge_cmp") -/// inspect(oge_cmp, content=" %oge_cmp = fcmp oge float %0, %1") -/// let olt_cmp = builder.createFCmpOLT(arg0, arg1, name="olt_cmp") -/// inspect(olt_cmp, content=" %olt_cmp = fcmp olt float %0, %1") -/// let ole_cmp = builder.createFCmpOLE(arg0, arg1, name="ole_cmp") -/// inspect(ole_cmp, content=" %ole_cmp = fcmp ole float %0, %1") -/// let one_cmp = builder.createFCmpONE(arg0, arg1, name="one_cmp") -/// inspect(one_cmp, content=" %one_cmp = fcmp one float %0, %1") -/// let ord_cmp = builder.createFCmpORD(arg0, arg1, name="ord_cmp") -/// inspect(ord_cmp, content=" %ord_cmp = fcmp ord float %0, %1") -/// let ueq_cmp = builder.createFCmpUEQ(arg0, arg1, name="ueq_cmp") -/// inspect(ueq_cmp, content=" %ueq_cmp = fcmp ueq float %0, %1") -/// let ugt_cmp = builder.createFCmpUGT(arg0, arg1, name="ugt_cmp") -/// inspect(ugt_cmp, content=" %ugt_cmp = fcmp ugt float %0, %1") -/// let uge_cmp = builder.createFCmpUGE(arg0, arg1, name="uge_cmp") -/// inspect(uge_cmp, content=" %uge_cmp = fcmp uge float %0, %1") -/// let ult_cmp = builder.createFCmpULT(arg0, arg1, name="ult_cmp") -/// inspect(ult_cmp, content=" %ult_cmp = fcmp ult float %0, %1") -/// let ule_cmp = builder.createFCmpULE(arg0, arg1, name="ule_cmp") -/// inspect(ule_cmp, content=" %ule_cmp = fcmp ule float %0, %1") -/// let une_cmp = builder.createFCmpUNE(arg0, arg1, name="une_cmp") -/// inspect(une_cmp, content=" %une_cmp = fcmp une float %0, %1") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let f32_ty = ctx.getFloatTy() +/// let fty = ctx.getFunctionType(f32_ty, [f32_ty, f32_ty]) +/// let fval = mod.addFunction(fty, "fcmp_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg0 = fval.getArg(0).unwrap() +/// let arg1 = fval.getArg(1).unwrap() +/// builder.setInsertPoint(bb) +/// let oeq_cmp = builder.createFCmp( +/// FloatPredicate::OEQ, +/// arg0, +/// arg1, +/// name="oeq_cmp", +/// ) +/// inspect(oeq_cmp, content=" %oeq_cmp = fcmp oeq float %0, %1") +/// assert_true(oeq_cmp.asValueEnum() is FCmpInst(_)) +/// let val1 = ctx.getConstFloat(3.14) +/// let val2 = ctx.getConstFloat(3.14) +/// let result = builder.createFCmpOEQ(val1, val2) +/// inspect(result, content="i1 true") +/// assert_true(result.asValueEnum() is ConstantInt(_)) +/// let ogt_cmp = builder.createFCmpOGT(arg0, arg1, name="ogt_cmp") +/// inspect(ogt_cmp, content=" %ogt_cmp = fcmp ogt float %0, %1") +/// let oge_cmp = builder.createFCmpOGE(arg0, arg1, name="oge_cmp") +/// inspect(oge_cmp, content=" %oge_cmp = fcmp oge float %0, %1") +/// let olt_cmp = builder.createFCmpOLT(arg0, arg1, name="olt_cmp") +/// inspect(olt_cmp, content=" %olt_cmp = fcmp olt float %0, %1") +/// let ole_cmp = builder.createFCmpOLE(arg0, arg1, name="ole_cmp") +/// inspect(ole_cmp, content=" %ole_cmp = fcmp ole float %0, %1") +/// let one_cmp = builder.createFCmpONE(arg0, arg1, name="one_cmp") +/// inspect(one_cmp, content=" %one_cmp = fcmp one float %0, %1") +/// let ord_cmp = builder.createFCmpORD(arg0, arg1, name="ord_cmp") +/// inspect(ord_cmp, content=" %ord_cmp = fcmp ord float %0, %1") +/// let ueq_cmp = builder.createFCmpUEQ(arg0, arg1, name="ueq_cmp") +/// inspect(ueq_cmp, content=" %ueq_cmp = fcmp ueq float %0, %1") +/// let ugt_cmp = builder.createFCmpUGT(arg0, arg1, name="ugt_cmp") +/// inspect(ugt_cmp, content=" %ugt_cmp = fcmp ugt float %0, %1") +/// let uge_cmp = builder.createFCmpUGE(arg0, arg1, name="uge_cmp") +/// inspect(uge_cmp, content=" %uge_cmp = fcmp uge float %0, %1") +/// let ult_cmp = builder.createFCmpULT(arg0, arg1, name="ult_cmp") +/// inspect(ult_cmp, content=" %ult_cmp = fcmp ult float %0, %1") +/// let ule_cmp = builder.createFCmpULE(arg0, arg1, name="ule_cmp") +/// inspect(ule_cmp, content=" %ule_cmp = fcmp ule float %0, %1") +/// let une_cmp = builder.createFCmpUNE(arg0, arg1, name="une_cmp") +/// inspect(une_cmp, content=" %une_cmp = fcmp une float %0, %1") +/// } /// ``` pub fn IRBuilder::createFCmp( self : IRBuilder, @@ -2384,24 +2426,26 @@ pub fn IRBuilder::createFCmpUNE( /// This creates a truncation instruction that truncates an integer value to a smaller integer type. /// The input value must be an integer type, and the target type must be a smaller integer type. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i64_ty = ctx.getInt64Ty() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [i64_ty]) -/// let fval = mod.addFunction(fty, "trunc_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg = fval.getArg(0).unwrap() -/// builder.setInsertPoint(bb) -/// let trunc = builder.createTrunc(arg, i32_ty, name="truncated") -/// inspect(trunc, content=" %truncated = trunc i64 %0 to i32") -/// assert_true(trunc.asValueEnum() is CastInst(_)) -/// let big_val = ctx.getConstInt64(0x123456789L) -/// let small_val = builder.createTrunc(big_val, i32_ty) -/// inspect(small_val, content="i32 591751049") -/// assert_true(small_val.asValueEnum() is ConstantInt(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i64_ty = ctx.getInt64Ty() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [i64_ty]) +/// let fval = mod.addFunction(fty, "trunc_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg = fval.getArg(0).unwrap() +/// builder.setInsertPoint(bb) +/// let trunc = builder.createTrunc(arg, i32_ty, name="truncated") +/// inspect(trunc, content=" %truncated = trunc i64 %0 to i32") +/// assert_true(trunc.asValueEnum() is CastInst(_)) +/// let big_val = ctx.getConstInt64(0x123456789L) +/// let small_val = builder.createTrunc(big_val, i32_ty) +/// inspect(small_val, content="i32 591751049") +/// assert_true(small_val.asValueEnum() is ConstantInt(_)) +/// } /// ``` pub fn IRBuilder::createTrunc( self : IRBuilder, @@ -2443,24 +2487,26 @@ pub fn IRBuilder::createTrunc( /// This creates a zero extension instruction that extends an integer value to a larger integer type by padding with zeros. /// The input value must be an integer type, and the target type must be a larger integer type. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let i64_ty = ctx.getInt64Ty() -/// let fty = ctx.getFunctionType(i64_ty, [i32_ty]) -/// let fval = mod.addFunction(fty, "zext_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg = fval.getArg(0).unwrap() -/// builder.setInsertPoint(bb) -/// let zext = builder.createZExt(arg, i64_ty, name="extended") -/// inspect(zext, content=" %extended = zext i32 %0 to i64") -/// assert_true(zext.asValueEnum() is CastInst(_)) -/// let small_val = ctx.getConstInt32(42) -/// let big_val = builder.createZExt(small_val, i64_ty) -/// inspect(big_val, content="i64 42") -/// assert_true(big_val.asValueEnum() is ConstantInt(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let i64_ty = ctx.getInt64Ty() +/// let fty = ctx.getFunctionType(i64_ty, [i32_ty]) +/// let fval = mod.addFunction(fty, "zext_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg = fval.getArg(0).unwrap() +/// builder.setInsertPoint(bb) +/// let zext = builder.createZExt(arg, i64_ty, name="extended") +/// inspect(zext, content=" %extended = zext i32 %0 to i64") +/// assert_true(zext.asValueEnum() is CastInst(_)) +/// let small_val = ctx.getConstInt32(42) +/// let big_val = builder.createZExt(small_val, i64_ty) +/// inspect(big_val, content="i64 42") +/// assert_true(big_val.asValueEnum() is ConstantInt(_)) +/// } /// ``` pub fn IRBuilder::createZExt( self : IRBuilder, @@ -2502,24 +2548,26 @@ pub fn IRBuilder::createZExt( /// This creates a sign extension instruction that extends an integer value to a larger integer type by replicating the sign bit. /// The input value must be an integer type, and the target type must be a larger integer type. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let i64_ty = ctx.getInt64Ty() -/// let fty = ctx.getFunctionType(i64_ty, [i32_ty]) -/// let fval = mod.addFunction(fty, "sext_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg = fval.getArg(0).unwrap() -/// builder.setInsertPoint(bb) -/// let sext = builder.createSExt(arg, i64_ty, name="extended") -/// inspect(sext, content=" %extended = sext i32 %0 to i64") -/// assert_true(sext.asValueEnum() is CastInst(_)) -/// let small_val = ctx.getConstInt32(-42) -/// let big_val = builder.createSExt(small_val, i64_ty) -/// inspect(big_val, content="i64 -42") -/// assert_true(big_val.asValueEnum() is ConstantInt(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let i64_ty = ctx.getInt64Ty() +/// let fty = ctx.getFunctionType(i64_ty, [i32_ty]) +/// let fval = mod.addFunction(fty, "sext_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg = fval.getArg(0).unwrap() +/// builder.setInsertPoint(bb) +/// let sext = builder.createSExt(arg, i64_ty, name="extended") +/// inspect(sext, content=" %extended = sext i32 %0 to i64") +/// assert_true(sext.asValueEnum() is CastInst(_)) +/// let small_val = ctx.getConstInt32(-42) +/// let big_val = builder.createSExt(small_val, i64_ty) +/// inspect(big_val, content="i64 -42") +/// assert_true(big_val.asValueEnum() is ConstantInt(_)) +/// } /// ``` pub fn IRBuilder::createSExt( self : IRBuilder, @@ -2561,23 +2609,25 @@ pub fn IRBuilder::createSExt( /// This creates a floating-point truncation instruction that truncates a floating-point value to a smaller floating-point type. /// The input value must be a floating-point type, and the target type must be a smaller floating-point type. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let f64_ty = ctx.getDoubleTy() -/// let f32_ty = ctx.getFloatTy() -/// let fty = ctx.getFunctionType(f32_ty, [f64_ty]) -/// let fval = mod.addFunction(fty, "fptrunc_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg = fval.getArg(0).unwrap() -/// builder.setInsertPoint(bb) -/// let fptrunc = builder.createFPTrunc(arg, f32_ty, name="truncated") -/// inspect(fptrunc, content=" %truncated = fptrunc double %0 to float") -/// assert_true(fptrunc.asValueEnum() is CastInst(_)) -/// let big_val = ctx.getConstDouble(3.14159) -/// let small_val = builder.createFPTrunc(big_val, f32_ty) -/// assert_true(small_val.asValueEnum() is ConstantFP(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let f64_ty = ctx.getDoubleTy() +/// let f32_ty = ctx.getFloatTy() +/// let fty = ctx.getFunctionType(f32_ty, [f64_ty]) +/// let fval = mod.addFunction(fty, "fptrunc_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg = fval.getArg(0).unwrap() +/// builder.setInsertPoint(bb) +/// let fptrunc = builder.createFPTrunc(arg, f32_ty, name="truncated") +/// inspect(fptrunc, content=" %truncated = fptrunc double %0 to float") +/// assert_true(fptrunc.asValueEnum() is CastInst(_)) +/// let big_val = ctx.getConstDouble(3.14159) +/// let small_val = builder.createFPTrunc(big_val, f32_ty) +/// assert_true(small_val.asValueEnum() is ConstantFP(_)) +/// } /// ``` pub fn IRBuilder::createFPTrunc( self : IRBuilder, @@ -2619,19 +2669,21 @@ pub fn IRBuilder::createFPTrunc( /// This creates a floating-point extension instruction that extends a floating-point value to a larger floating-point type. /// The input value must be a floating-point type, and the target type must be a larger floating-point type. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let f32_ty = ctx.getFloatTy() -/// let f64_ty = ctx.getDoubleTy() -/// let fty = ctx.getFunctionType(f64_ty, [f32_ty]) -/// let fval = mod.addFunction(fty, "fpext_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg = fval.getArg(0).unwrap() -/// builder.setInsertPoint(bb) -/// let fpext = builder.createFPExt(arg, f64_ty, name="extended") -/// inspect(fpext, content=" %extended = fpext float %0 to double") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let f32_ty = ctx.getFloatTy() +/// let f64_ty = ctx.getDoubleTy() +/// let fty = ctx.getFunctionType(f64_ty, [f32_ty]) +/// let fval = mod.addFunction(fty, "fpext_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg = fval.getArg(0).unwrap() +/// builder.setInsertPoint(bb) +/// let fpext = builder.createFPExt(arg, f64_ty, name="extended") +/// inspect(fpext, content=" %extended = fpext float %0 to double") +/// } /// ``` pub fn IRBuilder::createFPExt( self : IRBuilder, @@ -2673,23 +2725,25 @@ pub fn IRBuilder::createFPExt( /// This creates an unsigned integer to floating-point conversion instruction that converts an unsigned integer value to a floating-point value. /// The input value must be an integer type, and the target type must be a floating-point type. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let f32_ty = ctx.getFloatTy() -/// let fty = ctx.getFunctionType(f32_ty, [i32_ty]) -/// let fval = mod.addFunction(fty, "uitofp_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg = fval.getArg(0).unwrap() -/// builder.setInsertPoint(bb) -/// let uitofp = builder.createUIToFP(arg, f32_ty, name="converted") -/// inspect(uitofp, content=" %converted = uitofp i32 %0 to float") -/// assert_true(uitofp.asValueEnum() is CastInst(_)) -/// let int_val = ctx.getConstInt32(42) -/// let float_val = builder.createUIToFP(int_val, f32_ty) -/// assert_true(float_val.asValueEnum() is ConstantFP(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let f32_ty = ctx.getFloatTy() +/// let fty = ctx.getFunctionType(f32_ty, [i32_ty]) +/// let fval = mod.addFunction(fty, "uitofp_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg = fval.getArg(0).unwrap() +/// builder.setInsertPoint(bb) +/// let uitofp = builder.createUIToFP(arg, f32_ty, name="converted") +/// inspect(uitofp, content=" %converted = uitofp i32 %0 to float") +/// assert_true(uitofp.asValueEnum() is CastInst(_)) +/// let int_val = ctx.getConstInt32(42) +/// let float_val = builder.createUIToFP(int_val, f32_ty) +/// assert_true(float_val.asValueEnum() is ConstantFP(_)) +/// } /// ``` pub fn IRBuilder::createUIToFP( self : IRBuilder, @@ -2725,24 +2779,26 @@ pub fn IRBuilder::createUIToFP( /// This creates a floating-point to unsigned integer conversion instruction that converts a floating-point value to an unsigned integer. /// The input value must be a floating-point type, and the target type must be an integer type. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let f32_ty = ctx.getFloatTy() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [f32_ty]) -/// let fval = mod.addFunction(fty, "fptoui_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg = fval.getArg(0).unwrap() -/// builder.setInsertPoint(bb) -/// let fptoui = builder.createFPToUI(arg, i32_ty, name="converted") -/// inspect(fptoui, content=" %converted = fptoui float %0 to i32") -/// assert_true(fptoui.asValueEnum() is CastInst(_)) -/// let float_val = ctx.getConstFloat(3.14) -/// let int_val = builder.createFPToUI(float_val, i32_ty) -/// inspect(int_val, content="i32 3") -/// assert_true(int_val.asValueEnum() is ConstantInt(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let f32_ty = ctx.getFloatTy() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [f32_ty]) +/// let fval = mod.addFunction(fty, "fptoui_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg = fval.getArg(0).unwrap() +/// builder.setInsertPoint(bb) +/// let fptoui = builder.createFPToUI(arg, i32_ty, name="converted") +/// inspect(fptoui, content=" %converted = fptoui float %0 to i32") +/// assert_true(fptoui.asValueEnum() is CastInst(_)) +/// let float_val = ctx.getConstFloat(3.14) +/// let int_val = builder.createFPToUI(float_val, i32_ty) +/// inspect(int_val, content="i32 3") +/// assert_true(int_val.asValueEnum() is ConstantInt(_)) +/// } /// ``` pub fn IRBuilder::createFPToUI( self : IRBuilder, @@ -2778,19 +2834,21 @@ pub fn IRBuilder::createFPToUI( /// This creates a signed integer to floating-point conversion instruction that converts a signed integer value to a floating-point value. /// The input value must be an integer type, and the target type must be a floating-point type. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let f32_ty = ctx.getFloatTy() -/// let fty = ctx.getFunctionType(f32_ty, [i32_ty]) -/// let fval = mod.addFunction(fty, "sitofp_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg = fval.getArg(0).unwrap() -/// builder.setInsertPoint(bb) -/// let sitofp = builder.createSIToFP(arg, f32_ty, name="converted") -/// inspect(sitofp, content=" %converted = sitofp i32 %0 to float") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let f32_ty = ctx.getFloatTy() +/// let fty = ctx.getFunctionType(f32_ty, [i32_ty]) +/// let fval = mod.addFunction(fty, "sitofp_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg = fval.getArg(0).unwrap() +/// builder.setInsertPoint(bb) +/// let sitofp = builder.createSIToFP(arg, f32_ty, name="converted") +/// inspect(sitofp, content=" %converted = sitofp i32 %0 to float") +/// } /// ``` pub fn IRBuilder::createSIToFP( self : IRBuilder, @@ -2826,19 +2884,21 @@ pub fn IRBuilder::createSIToFP( /// This creates a floating-point to signed integer conversion instruction that converts a floating-point value to a signed integer. /// The input value must be a floating-point type, and the target type must be an integer type. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let f32_ty = ctx.getFloatTy() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [f32_ty]) -/// let fval = mod.addFunction(fty, "fptosi_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg = fval.getArg(0).unwrap() -/// builder.setInsertPoint(bb) -/// let fptosi = builder.createFPToSI(arg, i32_ty, name="converted") -/// inspect(fptosi, content=" %converted = fptosi float %0 to i32") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let f32_ty = ctx.getFloatTy() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [f32_ty]) +/// let fval = mod.addFunction(fty, "fptosi_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg = fval.getArg(0).unwrap() +/// builder.setInsertPoint(bb) +/// let fptosi = builder.createFPToSI(arg, i32_ty, name="converted") +/// inspect(fptosi, content=" %converted = fptosi float %0 to i32") +/// } /// ``` pub fn IRBuilder::createFPToSI( self : IRBuilder, @@ -2874,19 +2934,21 @@ pub fn IRBuilder::createFPToSI( /// This creates an integer to pointer conversion instruction that converts an integer value to a pointer. /// The input value must be an integer type, and the target type must be a pointer type. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i64_ty = ctx.getInt64Ty() -/// let ptr_ty = ctx.getPtrTy() -/// let fty = ctx.getFunctionType(ptr_ty, [i64_ty]) -/// let fval = mod.addFunction(fty, "inttoptr_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg = fval.getArg(0).unwrap() -/// builder.setInsertPoint(bb) -/// let inttoptr = builder.createIntToPtr(arg, name="ptr") -/// inspect(inttoptr, content=" %ptr = inttoptr i64 %0 to ptr") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i64_ty = ctx.getInt64Ty() +/// let ptr_ty = ctx.getPtrTy() +/// let fty = ctx.getFunctionType(ptr_ty, [i64_ty]) +/// let fval = mod.addFunction(fty, "inttoptr_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg = fval.getArg(0).unwrap() +/// builder.setInsertPoint(bb) +/// let inttoptr = builder.createIntToPtr(arg, name="ptr") +/// inspect(inttoptr, content=" %ptr = inttoptr i64 %0 to ptr") +/// } /// ``` pub fn IRBuilder::createIntToPtr( self : IRBuilder, @@ -2921,19 +2983,21 @@ pub fn IRBuilder::createIntToPtr( /// This creates a pointer to integer conversion instruction that converts a pointer value to an integer. /// The input value must be a pointer type, and the target type must be an integer type. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i64_ty = ctx.getInt64Ty() -/// let ptr_ty = ctx.getPtrTy() -/// let fty = ctx.getFunctionType(i64_ty, [ptr_ty]) -/// let fval = mod.addFunction(fty, "ptrtoint_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg = fval.getArg(0).unwrap() -/// builder.setInsertPoint(bb) -/// let ptrtoint = builder.createPtrToInt(arg, i64_ty, name="int_val") -/// inspect(ptrtoint, content=" %int_val = ptrtoint ptr %0 to i64") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i64_ty = ctx.getInt64Ty() +/// let ptr_ty = ctx.getPtrTy() +/// let fty = ctx.getFunctionType(i64_ty, [ptr_ty]) +/// let fval = mod.addFunction(fty, "ptrtoint_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg = fval.getArg(0).unwrap() +/// builder.setInsertPoint(bb) +/// let ptrtoint = builder.createPtrToInt(arg, i64_ty, name="int_val") +/// inspect(ptrtoint, content=" %int_val = ptrtoint ptr %0 to i64") +/// } /// ``` pub fn IRBuilder::createPtrToInt( self : IRBuilder, @@ -2966,19 +3030,21 @@ pub fn IRBuilder::createPtrToInt( /// This creates a bitcast instruction that converts a value from one type to another without changing the bit representation. /// The source and destination types must have the same bit width. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let f32_ty = ctx.getFloatTy() -/// let fty = ctx.getFunctionType(f32_ty, [i32_ty]) -/// let fval = mod.addFunction(fty, "bitcast_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg = fval.getArg(0).unwrap() -/// builder.setInsertPoint(bb) -/// let bitcast = builder.createBitCast(arg, f32_ty, name="bits") -/// inspect(bitcast, content=" %bits = bitcast i32 %0 to float") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let f32_ty = ctx.getFloatTy() +/// let fty = ctx.getFunctionType(f32_ty, [i32_ty]) +/// let fval = mod.addFunction(fty, "bitcast_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg = fval.getArg(0).unwrap() +/// builder.setInsertPoint(bb) +/// let bitcast = builder.createBitCast(arg, f32_ty, name="bits") +/// inspect(bitcast, content=" %bits = bitcast i32 %0 to float") +/// } /// ``` pub fn IRBuilder::createBitCast( self : IRBuilder, @@ -3029,31 +3095,33 @@ pub fn IRBuilder::createBitCast( /// The pointer must be a pointer type, and all indices must be integer values. /// When inbounds is true, the result is undefined if the computed address is outside the bounds of the allocated object. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let array_ty = ctx.getArrayType(i32_ty, 10) -/// let ptr_ty = ctx.getPtrTy() -/// let fty = ctx.getFunctionType(ctx.getPtrTy(), [ptr_ty]) -/// let fval = mod.addFunction(fty, "gep_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg = fval.getArg(0).unwrap() -/// let zero = ctx.getConstInt32(0) -/// let two = ctx.getConstInt32(2) -/// builder.setInsertPoint(bb) -/// let gep = builder.createGEP( -/// arg, -/// array_ty, -/// [zero, two], -/// name="elem_ptr", -/// inbounds=true, -/// ) -/// inspect( -/// gep, -/// content=" %elem_ptr = getelementptr inbounds [10 x i32], ptr %0, i32 0, i32 2", -/// ) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let array_ty = ctx.getArrayType(i32_ty, 10) +/// let ptr_ty = ctx.getPtrTy() +/// let fty = ctx.getFunctionType(ctx.getPtrTy(), [ptr_ty]) +/// let fval = mod.addFunction(fty, "gep_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg = fval.getArg(0).unwrap() +/// let zero = ctx.getConstInt32(0) +/// let two = ctx.getConstInt32(2) +/// builder.setInsertPoint(bb) +/// let gep = builder.createGEP( +/// arg, +/// array_ty, +/// [zero, two], +/// name="elem_ptr", +/// inbounds=true, +/// ) +/// inspect( +/// gep, +/// content=" %elem_ptr = getelementptr inbounds [10 x i32], ptr %0, i32 0, i32 2", +/// ) +/// } /// ``` pub fn IRBuilder::createGEP( self : IRBuilder, @@ -3107,18 +3175,20 @@ pub fn IRBuilder::createGEP( /// /// This loads a value from memory at the specified pointer. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(ctx.getVoidTy(), []) -/// let fval = mod.addFunction(fty, "load_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// builder.setInsertPoint(bb) -/// let alloca = builder.createAlloca(i32_ty, name="temp") -/// let load = builder.createLoad(i32_ty, alloca, name="val") -/// inspect(load, content=" %val = load i32, ptr %temp, align 4") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(ctx.getVoidTy(), []) +/// let fval = mod.addFunction(fty, "load_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// builder.setInsertPoint(bb) +/// let alloca = builder.createAlloca(i32_ty, name="temp") +/// let load = builder.createLoad(i32_ty, alloca, name="val") +/// inspect(load, content=" %val = load i32, ptr %temp, align 4") +/// } /// ``` pub fn IRBuilder::createLoad( self : IRBuilder, @@ -3169,19 +3239,21 @@ pub fn IRBuilder::createLoad( /// /// This stores a value into memory at the specified pointer. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(ctx.getVoidTy(), []) -/// let fval = mod.addFunction(fty, "store_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// builder.setInsertPoint(bb) -/// let alloca = builder.createAlloca(i32_ty, name="temp") -/// let const_val = ctx.getConstInt32(42) -/// let store = builder.createStore(const_val, alloca) -/// inspect(store, content=" store i32 42, ptr %temp, align 4") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(ctx.getVoidTy(), []) +/// let fval = mod.addFunction(fty, "store_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// builder.setInsertPoint(bb) +/// let alloca = builder.createAlloca(i32_ty, name="temp") +/// let const_val = ctx.getConstInt32(42) +/// let store = builder.createStore(const_val, alloca) +/// inspect(store, content=" store i32 42, ptr %temp, align 4") +/// } /// ``` pub fn IRBuilder::createStore( self : IRBuilder, @@ -3215,18 +3287,20 @@ pub fn IRBuilder::createStore( /// This creates an unconditional branch instruction that transfers control to the specified basic block. /// The destination must be a valid basic block. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let void_ty = ctx.getVoidTy() -/// let fty = ctx.getFunctionType(void_ty, []) -/// let fval = mod.addFunction(fty, "br_demo") -/// let entry_bb = fval.addBasicBlock(name="entry") -/// let target_bb = fval.addBasicBlock(name="target") -/// builder.setInsertPoint(entry_bb) -/// let br = builder.createBr(target_bb) -/// inspect(br, content=" br label %target") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let void_ty = ctx.getVoidTy() +/// let fty = ctx.getFunctionType(void_ty, []) +/// let fval = mod.addFunction(fty, "br_demo") +/// let entry_bb = fval.addBasicBlock(name="entry") +/// let target_bb = fval.addBasicBlock(name="target") +/// builder.setInsertPoint(entry_bb) +/// let br = builder.createBr(target_bb) +/// inspect(br, content=" br label %target") +/// } /// ``` pub fn IRBuilder::createBr( self : Self, @@ -3248,21 +3322,26 @@ pub fn IRBuilder::createBr( /// This creates a conditional branch instruction that transfers control to one of two basic blocks based on a boolean condition. /// The condition must be an i1 (boolean) type, and both destinations must be valid basic blocks. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i1_ty = ctx.getInt1Ty() -/// let void_ty = ctx.getVoidTy() -/// let fty = ctx.getFunctionType(void_ty, [i1_ty]) -/// let fval = mod.addFunction(fty, "cond_br_demo") -/// let entry_bb = fval.addBasicBlock(name="entry") -/// let true_bb = fval.addBasicBlock(name="true_branch") -/// let false_bb = fval.addBasicBlock(name="false_branch") -/// let cond = fval.getArg(0).unwrap() -/// builder.setInsertPoint(entry_bb) -/// let cond_br = builder.createCondBr(cond, true_bb, false_bb) -/// inspect(cond_br, content=" br i1 %0, label %true_branch, label %false_branch") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i1_ty = ctx.getInt1Ty() +/// let void_ty = ctx.getVoidTy() +/// let fty = ctx.getFunctionType(void_ty, [i1_ty]) +/// let fval = mod.addFunction(fty, "cond_br_demo") +/// let entry_bb = fval.addBasicBlock(name="entry") +/// let true_bb = fval.addBasicBlock(name="true_branch") +/// let false_bb = fval.addBasicBlock(name="false_branch") +/// let cond = fval.getArg(0).unwrap() +/// builder.setInsertPoint(entry_bb) +/// let cond_br = builder.createCondBr(cond, true_bb, false_bb) +/// inspect( +/// cond_br, +/// content=" br i1 %0, label %true_branch, label %false_branch", +/// ) +/// } /// ``` pub fn IRBuilder::createCondBr( self : Self, @@ -3293,21 +3372,23 @@ pub fn IRBuilder::createCondBr( /// This creates a select instruction that chooses between two values based on a boolean condition. /// The condition must be an i1 (boolean) type, and both values must have the same type. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i1_ty = ctx.getInt1Ty() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [i1_ty, i32_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "select_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let cond = fval.getArg(0).unwrap() -/// let true_val = fval.getArg(1).unwrap() -/// let false_val = fval.getArg(2).unwrap() -/// builder.setInsertPoint(bb) -/// let select = builder.createSelect(cond, true_val, false_val, name="result") -/// inspect(select, content=" %result = select i1 %0, i32 %1, i32 %2") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i1_ty = ctx.getInt1Ty() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [i1_ty, i32_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "select_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let cond = fval.getArg(0).unwrap() +/// let true_val = fval.getArg(1).unwrap() +/// let false_val = fval.getArg(2).unwrap() +/// builder.setInsertPoint(bb) +/// let select = builder.createSelect(cond, true_val, false_val, name="result") +/// inspect(select, content=" %result = select i1 %0, i32 %1, i32 %2") +/// } /// ``` pub fn IRBuilder::createSelect( self : IRBuilder, @@ -3363,27 +3444,29 @@ pub fn IRBuilder::createSelect( /// The value must be an integer type, and numCases specifies the expected number of cases. /// Use `SwitchInst::addCase` to add individual cases after creation. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let void_ty = ctx.getVoidTy() -/// let fty = ctx.getFunctionType(void_ty, [i32_ty]) -/// let fval = mod.addFunction(fty, "switch_demo") -/// let entry_bb = fval.addBasicBlock(name="entry") -/// let case1_bb = fval.addBasicBlock(name="case1") -/// let default_bb = fval.addBasicBlock(name="default") -/// let value = fval.getArg(0).unwrap() -/// builder.setInsertPoint(entry_bb) -/// let switch = builder.createSwitch(value, default_bb) -/// let case_val = ctx.getConstInt32(42) -/// switch.addCase(case_val, case1_bb) -/// let expect = -/// #| switch i32 %0, label %default [ -/// #| i32 42, label %case1 -/// #| ] -/// inspect(switch, content=expect) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let void_ty = ctx.getVoidTy() +/// let fty = ctx.getFunctionType(void_ty, [i32_ty]) +/// let fval = mod.addFunction(fty, "switch_demo") +/// let entry_bb = fval.addBasicBlock(name="entry") +/// let case1_bb = fval.addBasicBlock(name="case1") +/// let default_bb = fval.addBasicBlock(name="default") +/// let value = fval.getArg(0).unwrap() +/// builder.setInsertPoint(entry_bb) +/// let switch = builder.createSwitch(value, default_bb) +/// let case_val = ctx.getConstInt32(42) +/// switch.addCase(case_val, case1_bb) +/// let expect = +/// #| switch i32 %0, label %default [ +/// #| i32 42, label %case1 +/// #| ] +/// inspect(switch, content=expect) +/// } /// ``` pub fn IRBuilder::createSwitch( self : IRBuilder, @@ -3413,23 +3496,25 @@ pub fn IRBuilder::createSwitch( /// The type specifies the type of the PHI node's result value. /// Use `PHINode::addIncoming` to add incoming values and their corresponding basic blocks. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, []) -/// let fval = mod.addFunction(fty, "phi_demo") -/// let entry_bb = fval.addBasicBlock(name="entry") -/// let block_bb = fval.addBasicBlock(name="block") -/// let merge_bb = fval.addBasicBlock(name="merge") -/// let val1 = ctx.getConstInt32(10) -/// let val2 = ctx.getConstInt32(20) -/// builder.setInsertPoint(merge_bb) -/// let phi = builder.createPHI(i32_ty, name="result") -/// phi.addIncoming(val1, entry_bb) -/// phi.addIncoming(val2, block_bb) -/// inspect(phi, content=" %result = phi i32 [ 10, %entry ], [ 20, %block ]") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, []) +/// let fval = mod.addFunction(fty, "phi_demo") +/// let entry_bb = fval.addBasicBlock(name="entry") +/// let block_bb = fval.addBasicBlock(name="block") +/// let merge_bb = fval.addBasicBlock(name="merge") +/// let val1 = ctx.getConstInt32(10) +/// let val2 = ctx.getConstInt32(20) +/// builder.setInsertPoint(merge_bb) +/// let phi = builder.createPHI(i32_ty, name="result") +/// phi.addIncoming(val1, entry_bb) +/// phi.addIncoming(val2, block_bb) +/// inspect(phi, content=" %result = phi i32 [ 10, %entry ], [ 20, %block ]") +/// } /// ``` pub fn IRBuilder::createPHI( self : IRBuilder, @@ -3454,21 +3539,23 @@ pub fn IRBuilder::createPHI( /// This creates a call instruction that invokes a function with the specified arguments. /// The function must be a valid Function object, and the arguments must match the function's parameter types. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let add_fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) -/// let main_fty = ctx.getFunctionType(i32_ty, []) -/// let add_func = mod.addFunction(add_fty, "add") -/// let main_func = mod.addFunction(main_fty, "main") -/// let bb = main_func.addBasicBlock(name="entry") -/// let arg1 = ctx.getConstInt32(10) -/// let arg2 = ctx.getConstInt32(20) -/// builder.setInsertPoint(bb) -/// let call = builder.createCall(add_func, [arg1, arg2], name="sum") -/// inspect(call, content=" %sum = call i32 @add(i32 10, i32 20)") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let add_fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) +/// let main_fty = ctx.getFunctionType(i32_ty, []) +/// let add_func = mod.addFunction(add_fty, "add") +/// let main_func = mod.addFunction(main_fty, "main") +/// let bb = main_func.addBasicBlock(name="entry") +/// let arg1 = ctx.getConstInt32(10) +/// let arg2 = ctx.getConstInt32(20) +/// builder.setInsertPoint(bb) +/// let call = builder.createCall(add_func, [arg1, arg2], name="sum") +/// inspect(call, content=" %sum = call i32 @add(i32 10, i32 20)") +/// } /// ``` pub fn IRBuilder::createCall( self : IRBuilder, diff --git a/IR/Instruction.mbt b/IR/Instruction.mbt index 4f25721..2ffd923 100644 --- a/IR/Instruction.mbt +++ b/IR/Instruction.mbt @@ -9,18 +9,20 @@ /// /// Use `IRBuilder::createAlloca` to create an `AllocaInst`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let void_ty = ctx.getVoidTy() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(void_ty, []) -/// let fval = mod.addFunction(fty, "foo") -/// let bb = fval.addBasicBlock(name="entry") -/// builder.setInsertPoint(bb) -/// let inst = builder.createAlloca(i32_ty, name="var1") -/// inspect(inst, content=" %var1 = alloca i32, align 4") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let void_ty = ctx.getVoidTy() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(void_ty, []) +/// let fval = mod.addFunction(fty, "foo") +/// let bb = fval.addBasicBlock(name="entry") +/// builder.setInsertPoint(bb) +/// let inst = builder.createAlloca(i32_ty, name="var1") +/// inspect(inst, content=" %var1 = alloca i32, align 4") +/// } /// ``` pub struct AllocaInst { uid : UInt64 @@ -72,20 +74,22 @@ pub impl Value for AllocaInst with getValueBase(self) { ///| /// Get simple representation of the value. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let void_ty = ctx.getVoidTy() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(void_ty, []) -/// let fval = mod.addFunction(fty, "foo") -/// let bb = fval.addBasicBlock(name="entry") -/// builder.setInsertPoint(bb) -/// let inst = builder.createAlloca(i32_ty) -/// inspect(inst.getValueRepr(), content="%0") -/// inst.setName("var1") -/// inspect(inst.getValueRepr(), content="%var1") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let void_ty = ctx.getVoidTy() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(void_ty, []) +/// let fval = mod.addFunction(fty, "foo") +/// let bb = fval.addBasicBlock(name="entry") +/// builder.setInsertPoint(bb) +/// let inst = builder.createAlloca(i32_ty) +/// inspect(inst.getValueRepr(), content="%0") +/// inst.setName("var1") +/// inspect(inst.getValueRepr(), content="%var1") +/// } /// ``` pub impl Value for AllocaInst with getValueRepr(self) { match self.getNameOrSlot() { @@ -107,20 +111,22 @@ pub impl Value for AllocaInst with asValueEnum(self) { /// /// If the instruction has no name, return `None`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let void_ty = ctx.getVoidTy() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(void_ty, []) -/// let fval = mod.addFunction(fty, "foo") -/// let bb = fval.addBasicBlock(name="entry") -/// builder.setInsertPoint(bb) -/// let inst = builder.createAlloca(i32_ty) -/// inspect(inst.getName(), content="None") -/// inst.setName("var1") -/// inspect(inst.getName(), content="Some(\"var1\")") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let void_ty = ctx.getVoidTy() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(void_ty, []) +/// let fval = mod.addFunction(fty, "foo") +/// let bb = fval.addBasicBlock(name="entry") +/// builder.setInsertPoint(bb) +/// let inst = builder.createAlloca(i32_ty) +/// inspect(inst.getName(), content="None") +/// inst.setName("var1") +/// inspect(inst.getName(), content="Some(\"var1\")") +/// } /// ``` pub impl Value for AllocaInst with getName(self) { self.name @@ -134,20 +140,22 @@ pub impl Value for AllocaInst with getName(self) { /// If the name has already been used in the parent function, /// it will raise Error. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let void_ty = ctx.getVoidTy() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(void_ty, []) -/// let fval = mod.addFunction(fty, "foo") -/// let bb = fval.addBasicBlock(name="entry") -/// builder.setInsertPoint(bb) -/// let inst = builder.createAlloca(i32_ty) -/// inspect(inst.getName(), content="None") -/// inst.setName("var1") -/// inspect(inst.getName(), content="Some(\"var1\")") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let void_ty = ctx.getVoidTy() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(void_ty, []) +/// let fval = mod.addFunction(fty, "foo") +/// let bb = fval.addBasicBlock(name="entry") +/// builder.setInsertPoint(bb) +/// let inst = builder.createAlloca(i32_ty) +/// inspect(inst.getName(), content="None") +/// inst.setName("var1") +/// inspect(inst.getName(), content="Some(\"var1\")") +/// } /// ``` pub impl Value for AllocaInst with setName(self, name) { match self.getParent().setSymbol(name, self) { @@ -259,21 +267,23 @@ pub impl Show for AtomicOrdering with output(self, logger) { /// /// Use `IRBuilder::createLoad` to create a `LoadInst`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let ptr_ty = ctx.getPtrTy() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [ptr_ty]) -/// let fval = mod.addFunction(fty, "load_an_integer") -/// let bb = fval.addBasicBlock(name="entry") -/// builder.setInsertPoint(bb) -/// let ptr = fval.getArg(0).unwrap() -/// ptr.setName("arg0") -/// let val = builder.createLoad(i32_ty, ptr, name="val") -/// let _ = builder.createRet(val) -/// inspect(val, content=" %val = load i32, ptr %arg0, align 4") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let ptr_ty = ctx.getPtrTy() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [ptr_ty]) +/// let fval = mod.addFunction(fty, "load_an_integer") +/// let bb = fval.addBasicBlock(name="entry") +/// builder.setInsertPoint(bb) +/// let ptr = fval.getArg(0).unwrap() +/// ptr.setName("arg0") +/// let val = builder.createLoad(i32_ty, ptr, name="val") +/// let _ = builder.createRet(val) +/// inspect(val, content=" %val = load i32, ptr %arg0, align 4") +/// } /// ``` pub(all) struct LoadInst { // --- ValueBase --- @@ -353,21 +363,23 @@ pub impl Value for LoadInst with getValueBase(self) { ///| /// Get simple representation of the value. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let ptr_ty = ctx.getPtrTy() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [ptr_ty]) -/// let fval = mod.addFunction(fty, "load_an_integer") -/// let bb = fval.addBasicBlock(name="entry") -/// builder.setInsertPoint(bb) -/// let ptr = fval.getArg(0).unwrap() -/// let val = builder.createLoad(i32_ty, ptr) -/// inspect(val.getValueRepr(), content="%1") -/// val.setName("val") -/// inspect(val.getValueRepr(), content="%val") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let ptr_ty = ctx.getPtrTy() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [ptr_ty]) +/// let fval = mod.addFunction(fty, "load_an_integer") +/// let bb = fval.addBasicBlock(name="entry") +/// builder.setInsertPoint(bb) +/// let ptr = fval.getArg(0).unwrap() +/// let val = builder.createLoad(i32_ty, ptr) +/// inspect(val.getValueRepr(), content="%1") +/// val.setName("val") +/// inspect(val.getValueRepr(), content="%val") +/// } /// ``` pub impl Value for LoadInst with getValueRepr(self) { match self.getNameOrSlot() { @@ -384,21 +396,23 @@ pub impl Value for LoadInst with getValueRepr(self) { /// /// If the instruction has no name, return `None`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let ptr_ty = ctx.getPtrTy() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [ptr_ty]) -/// let fval = mod.addFunction(fty, "load_an_integer") -/// let bb = fval.addBasicBlock(name="entry") -/// builder.setInsertPoint(bb) -/// let ptr = fval.getArg(0).unwrap() -/// let val = builder.createLoad(i32_ty, ptr) -/// inspect(val.getName(), content="None") -/// val.setName("val") -/// inspect(val.getName(), content="Some(\"val\")") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let ptr_ty = ctx.getPtrTy() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [ptr_ty]) +/// let fval = mod.addFunction(fty, "load_an_integer") +/// let bb = fval.addBasicBlock(name="entry") +/// builder.setInsertPoint(bb) +/// let ptr = fval.getArg(0).unwrap() +/// let val = builder.createLoad(i32_ty, ptr) +/// inspect(val.getName(), content="None") +/// val.setName("val") +/// inspect(val.getName(), content="Some(\"val\")") +/// } /// ``` pub impl Value for LoadInst with getName(self) { self.name @@ -412,21 +426,23 @@ pub impl Value for LoadInst with getName(self) { /// If the name has already been used in the parent function, /// it will raise Error. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let ptr_ty = ctx.getPtrTy() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [ptr_ty]) -/// let fval = mod.addFunction(fty, "load_an_integer") -/// let bb = fval.addBasicBlock(name="entry") -/// builder.setInsertPoint(bb) -/// let ptr = fval.getArg(0).unwrap() -/// let val = builder.createLoad(i32_ty, ptr) -/// inspect(val.getName(), content="None") -/// val.setName("val") -/// inspect(val.getName(), content="Some(\"val\")") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let ptr_ty = ctx.getPtrTy() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [ptr_ty]) +/// let fval = mod.addFunction(fty, "load_an_integer") +/// let bb = fval.addBasicBlock(name="entry") +/// builder.setInsertPoint(bb) +/// let ptr = fval.getArg(0).unwrap() +/// let val = builder.createLoad(i32_ty, ptr) +/// inspect(val.getName(), content="None") +/// val.setName("val") +/// inspect(val.getName(), content="Some(\"val\")") +/// } /// ``` pub impl Value for LoadInst with setName(self, name) { match self.getParent().setSymbol(name, self) { @@ -535,23 +551,25 @@ pub impl Show for LoadInst with output(self, logger) { /// /// Use `IRBuilder::createStore` to create a `StoreInst`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let ptr_ty = ctx.getPtrTy() -/// let i32_ty = ctx.getInt32Ty() -/// let void_ty = ctx.getVoidTy() -/// let fty = ctx.getFunctionType(void_ty, [ptr_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "store_an_integer") -/// let bb = fval.addBasicBlock(name="entry") -/// builder.setInsertPoint(bb) -/// let ptr = fval.getArg(0).unwrap() -/// ptr.setName("arg0") -/// let value = fval.getArg(1).unwrap() -/// value.setName("value") -/// let s = builder.createStore(value, ptr) -/// inspect(s, content=" store i32 %value, ptr %arg0, align 4") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let ptr_ty = ctx.getPtrTy() +/// let i32_ty = ctx.getInt32Ty() +/// let void_ty = ctx.getVoidTy() +/// let fty = ctx.getFunctionType(void_ty, [ptr_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "store_an_integer") +/// let bb = fval.addBasicBlock(name="entry") +/// builder.setInsertPoint(bb) +/// let ptr = fval.getArg(0).unwrap() +/// ptr.setName("arg0") +/// let value = fval.getArg(1).unwrap() +/// value.setName("value") +/// let s = builder.createStore(value, ptr) +/// inspect(s, content=" store i32 %value, ptr %arg0, align 4") +/// } /// ``` pub struct StoreInst { // --- ValueBase --- @@ -614,24 +632,26 @@ fn StoreInst::new( ///| /// Get the value operand of the store instruction. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let ptr_ty = ctx.getPtrTy() -/// let i32_ty = ctx.getInt32Ty() -/// let void_ty = ctx.getVoidTy() -/// let fty = ctx.getFunctionType(void_ty, [ptr_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "store_an_integer") -/// let bb = fval.addBasicBlock(name="entry") -/// builder.setInsertPoint(bb) -/// let ptr = fval.getArg(0).unwrap() -/// ptr.setName("arg0") -/// let val1 = fval.getArg(1).unwrap() -/// let const_42 = ctx.getConstInt32(42) -/// let val2 = builder.createNSWAdd(val1, const_42, name="value") -/// let s = builder.createStore(val2, ptr) -/// inspect(s.getValueOperand(), content=" %value = add nsw i32 %0, 42") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let ptr_ty = ctx.getPtrTy() +/// let i32_ty = ctx.getInt32Ty() +/// let void_ty = ctx.getVoidTy() +/// let fty = ctx.getFunctionType(void_ty, [ptr_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "store_an_integer") +/// let bb = fval.addBasicBlock(name="entry") +/// builder.setInsertPoint(bb) +/// let ptr = fval.getArg(0).unwrap() +/// ptr.setName("arg0") +/// let val1 = fval.getArg(1).unwrap() +/// let const_42 = ctx.getConstInt32(42) +/// let val2 = builder.createNSWAdd(val1, const_42, name="value") +/// let s = builder.createStore(val2, ptr) +/// inspect(s.getValueOperand(), content=" %value = add nsw i32 %0, 42") +/// } /// ``` pub fn StoreInst::getValueOperand(self : StoreInst) -> &Value { self.value @@ -640,19 +660,21 @@ pub fn StoreInst::getValueOperand(self : StoreInst) -> &Value { ///| /// Get the pointer operand of the store instruction. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let void_ty = ctx.getVoidTy() -/// let fty = ctx.getFunctionType(void_ty, []) -/// let fval = mod.addFunction(fty, "store_an_integer") -/// let bb = fval.addBasicBlock(name="entry") -/// builder.setInsertPoint(bb) -/// let alloca = builder.createAlloca(ctx.getInt32Ty(), name="ptr") -/// let const42 = ctx.getConstInt32(42) -/// let s = builder.createStore(const42, alloca) -/// inspect(s.getPointerOperand(), content=" %ptr = alloca i32, align 4") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let void_ty = ctx.getVoidTy() +/// let fty = ctx.getFunctionType(void_ty, []) +/// let fval = mod.addFunction(fty, "store_an_integer") +/// let bb = fval.addBasicBlock(name="entry") +/// builder.setInsertPoint(bb) +/// let alloca = builder.createAlloca(ctx.getInt32Ty(), name="ptr") +/// let const42 = ctx.getConstInt32(42) +/// let s = builder.createStore(const42, alloca) +/// inspect(s.getPointerOperand(), content=" %ptr = alloca i32, align 4") +/// } /// ``` pub fn StoreInst::getPointerOperand(self : StoreInst) -> &Value { self.ptr @@ -1032,30 +1054,32 @@ pub impl Show for FastMathFlag with output(self, logger) { /// /// Use `IRBuilder::createAdd`, `IRBuilder::createSub`, `IRBuilder::createMul`, etc. to create binary instructions. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "binary_ops_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg1 = fval.getArg(0).unwrap() -/// let arg2 = fval.getArg(1).unwrap() -/// builder.setInsertPoint(bb) -/// let add = builder.createAdd(arg1, arg2, name="sum") -/// inspect(add, content=" %sum = add i32 %0, %1") -/// assert_true(add.asValueEnum() is BinaryInst(_)) -/// let sub = builder.createSub(arg1, arg2, name="diff") -/// inspect(sub, content=" %diff = sub i32 %0, %1") -/// let mul = builder.createMul(arg1, arg2, name="product") -/// inspect(mul, content=" %product = mul i32 %0, %1") -/// let and_result = builder.createAnd(arg1, arg2, name="and_result") -/// inspect(and_result, content=" %and_result = and i32 %0, %1") -/// let or_result = builder.createOr(arg1, arg2, name="or_result") -/// inspect(or_result, content=" %or_result = or i32 %0, %1") -/// let xor_result = builder.createXor(arg1, arg2, name="xor_result") -/// inspect(xor_result, content=" %xor_result = xor i32 %0, %1") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "binary_ops_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg1 = fval.getArg(0).unwrap() +/// let arg2 = fval.getArg(1).unwrap() +/// builder.setInsertPoint(bb) +/// let add = builder.createAdd(arg1, arg2, name="sum") +/// inspect(add, content=" %sum = add i32 %0, %1") +/// assert_true(add.asValueEnum() is BinaryInst(_)) +/// let sub = builder.createSub(arg1, arg2, name="diff") +/// inspect(sub, content=" %diff = sub i32 %0, %1") +/// let mul = builder.createMul(arg1, arg2, name="product") +/// inspect(mul, content=" %product = mul i32 %0, %1") +/// let and_result = builder.createAnd(arg1, arg2, name="and_result") +/// inspect(and_result, content=" %and_result = and i32 %0, %1") +/// let or_result = builder.createOr(arg1, arg2, name="or_result") +/// inspect(or_result, content=" %or_result = or i32 %0, %1") +/// let xor_result = builder.createXor(arg1, arg2, name="xor_result") +/// inspect(xor_result, content=" %xor_result = xor i32 %0, %1") +/// } /// ``` pub struct BinaryInst { // --- ValueBase --- @@ -1198,21 +1222,23 @@ pub impl Value for BinaryInst with asValueEnum(self) { ///| /// Get simple representation of the value. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "binary_ops_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg1 = fval.getArg(0).unwrap() -/// let arg2 = fval.getArg(1).unwrap() -/// builder.setInsertPoint(bb) -/// let add = builder.createAdd(arg1, arg2) -/// inspect(add.getValueRepr(), content="%2") -/// add.setName("sum") -/// inspect(add.getValueRepr(), content="%sum") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "binary_ops_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg1 = fval.getArg(0).unwrap() +/// let arg2 = fval.getArg(1).unwrap() +/// builder.setInsertPoint(bb) +/// let add = builder.createAdd(arg1, arg2) +/// inspect(add.getValueRepr(), content="%2") +/// add.setName("sum") +/// inspect(add.getValueRepr(), content="%sum") +/// } /// ``` pub impl Value for BinaryInst with getValueRepr(self) { match self.getNameOrSlot() { @@ -1229,21 +1255,23 @@ pub impl Value for BinaryInst with getValueRepr(self) { /// /// If the instruction has no name, return `None`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "binary_ops_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg1 = fval.getArg(0).unwrap() -/// let arg2 = fval.getArg(1).unwrap() -/// builder.setInsertPoint(bb) -/// let add = builder.createAdd(arg1, arg2) -/// inspect(add.getName(), content="None") -/// add.setName("sum") -/// inspect(add.getName(), content="Some(\"sum\")") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "binary_ops_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg1 = fval.getArg(0).unwrap() +/// let arg2 = fval.getArg(1).unwrap() +/// builder.setInsertPoint(bb) +/// let add = builder.createAdd(arg1, arg2) +/// inspect(add.getName(), content="None") +/// add.setName("sum") +/// inspect(add.getName(), content="Some(\"sum\")") +/// } /// ``` pub impl Value for BinaryInst with getName(self) { self.name @@ -1257,21 +1285,23 @@ pub impl Value for BinaryInst with getName(self) { /// If the name has already been used in the parent function, /// it will raise Error. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "binary_ops_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg1 = fval.getArg(0).unwrap() -/// let arg2 = fval.getArg(1).unwrap() -/// builder.setInsertPoint(bb) -/// let add = builder.createAdd(arg1, arg2) -/// inspect(add.getName(), content="None") -/// add.setName("sum") -/// inspect(add.getName(), content="Some(\"sum\")") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "binary_ops_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg1 = fval.getArg(0).unwrap() +/// let arg2 = fval.getArg(1).unwrap() +/// builder.setInsertPoint(bb) +/// let add = builder.createAdd(arg1, arg2) +/// inspect(add.getName(), content="None") +/// add.setName("sum") +/// inspect(add.getName(), content="Some(\"sum\")") +/// } /// ``` pub impl Value for BinaryInst with setName(self, name) { match self.getParent().setSymbol(name, self) { @@ -1421,26 +1451,28 @@ pub impl Show for IntPredicate with output(self, logger) { /// /// Use `IRBuilder::createICmp` to create an `ICmpInst`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "icmp_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg1 = fval.getArg(0).unwrap() -/// let arg2 = fval.getArg(1).unwrap() -/// builder.setInsertPoint(bb) -/// let eq_cmp = builder.createICmp(EQ, arg1, arg2, name="eq_cmp") -/// inspect(eq_cmp, content=" %eq_cmp = icmp eq i32 %0, %1") -/// assert_true(eq_cmp.asValueEnum() is ICmpInst(_)) -/// let ne_cmp = builder.createICmp(NE, arg1, arg2, name="ne_cmp") -/// inspect(ne_cmp, content=" %ne_cmp = icmp ne i32 %0, %1") -/// let sgt_cmp = builder.createICmp(SGT, arg1, arg2, name="sgt_cmp") -/// inspect(sgt_cmp, content=" %sgt_cmp = icmp sgt i32 %0, %1") -/// let ugt_cmp = builder.createICmp(UGT, arg1, arg2, name="ugt_cmp") -/// inspect(ugt_cmp, content=" %ugt_cmp = icmp ugt i32 %0, %1") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "icmp_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg1 = fval.getArg(0).unwrap() +/// let arg2 = fval.getArg(1).unwrap() +/// builder.setInsertPoint(bb) +/// let eq_cmp = builder.createICmp(EQ, arg1, arg2, name="eq_cmp") +/// inspect(eq_cmp, content=" %eq_cmp = icmp eq i32 %0, %1") +/// assert_true(eq_cmp.asValueEnum() is ICmpInst(_)) +/// let ne_cmp = builder.createICmp(NE, arg1, arg2, name="ne_cmp") +/// inspect(ne_cmp, content=" %ne_cmp = icmp ne i32 %0, %1") +/// let sgt_cmp = builder.createICmp(SGT, arg1, arg2, name="sgt_cmp") +/// inspect(sgt_cmp, content=" %sgt_cmp = icmp sgt i32 %0, %1") +/// let ugt_cmp = builder.createICmp(UGT, arg1, arg2, name="ugt_cmp") +/// inspect(ugt_cmp, content=" %ugt_cmp = icmp ugt i32 %0, %1") +/// } /// ``` pub struct ICmpInst { uid : UInt64 @@ -1509,21 +1541,23 @@ pub impl Value for ICmpInst with asValueEnum(self) { ///| /// Get simple representation of the value. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "icmp_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg1 = fval.getArg(0).unwrap() -/// let arg2 = fval.getArg(1).unwrap() -/// builder.setInsertPoint(bb) -/// let eq_cmp = builder.createICmp(EQ, arg1, arg2) -/// inspect(eq_cmp.getValueRepr(), content="%2") -/// eq_cmp.setName("eq_cmp") -/// inspect(eq_cmp.getValueRepr(), content="%eq_cmp") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "icmp_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg1 = fval.getArg(0).unwrap() +/// let arg2 = fval.getArg(1).unwrap() +/// builder.setInsertPoint(bb) +/// let eq_cmp = builder.createICmp(EQ, arg1, arg2) +/// inspect(eq_cmp.getValueRepr(), content="%2") +/// eq_cmp.setName("eq_cmp") +/// inspect(eq_cmp.getValueRepr(), content="%eq_cmp") +/// } /// ``` pub impl Value for ICmpInst with getValueRepr(self) { match self.getNameOrSlot() { @@ -1540,21 +1574,23 @@ pub impl Value for ICmpInst with getValueRepr(self) { /// /// If the instruction has no name, return `None`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "icmp_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg1 = fval.getArg(0).unwrap() -/// let arg2 = fval.getArg(1).unwrap() -/// builder.setInsertPoint(bb) -/// let eq_cmp = builder.createICmp(EQ, arg1, arg2) -/// inspect(eq_cmp.getName(), content="None") -/// eq_cmp.setName("eq_cmp") -/// inspect(eq_cmp.getName(), content="Some(\"eq_cmp\")") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "icmp_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg1 = fval.getArg(0).unwrap() +/// let arg2 = fval.getArg(1).unwrap() +/// builder.setInsertPoint(bb) +/// let eq_cmp = builder.createICmp(EQ, arg1, arg2) +/// inspect(eq_cmp.getName(), content="None") +/// eq_cmp.setName("eq_cmp") +/// inspect(eq_cmp.getName(), content="Some(\"eq_cmp\")") +/// } /// ``` pub impl Value for ICmpInst with getName(self) { self.name @@ -1568,21 +1604,23 @@ pub impl Value for ICmpInst with getName(self) { /// If the name has already been used in the parent function, /// it will raise Error. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "icmp_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg1 = fval.getArg(0).unwrap() -/// let arg2 = fval.getArg(1).unwrap() -/// builder.setInsertPoint(bb) -/// let eq_cmp = builder.createICmp(EQ, arg1, arg2) -/// inspect(eq_cmp.getName(), content="None") -/// eq_cmp.setName("eq_cmp") -/// inspect(eq_cmp.getName(), content="Some(\"eq_cmp\")") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "icmp_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg1 = fval.getArg(0).unwrap() +/// let arg2 = fval.getArg(1).unwrap() +/// builder.setInsertPoint(bb) +/// let eq_cmp = builder.createICmp(EQ, arg1, arg2) +/// inspect(eq_cmp.getName(), content="None") +/// eq_cmp.setName("eq_cmp") +/// inspect(eq_cmp.getName(), content="Some(\"eq_cmp\")") +/// } /// ``` pub impl Value for ICmpInst with setName(self, name) { match self.getParent().setSymbol(name, self) { @@ -1738,26 +1776,28 @@ pub impl Show for FloatPredicate with output(self, logger) { /// /// Use `IRBuilder::createFCmp` to create an `FCmpInst`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let f32_ty = ctx.getFloatTy() -/// let fty = ctx.getFunctionType(f32_ty, [f32_ty, f32_ty]) -/// let fval = mod.addFunction(fty, "fcmp_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg1 = fval.getArg(0).unwrap() -/// let arg2 = fval.getArg(1).unwrap() -/// builder.setInsertPoint(bb) -/// let oeq_cmp = builder.createFCmp(OEQ, arg1, arg2, name="oeq_cmp") -/// inspect(oeq_cmp, content=" %oeq_cmp = fcmp oeq float %0, %1") -/// assert_true(oeq_cmp.asValueEnum() is FCmpInst(_)) -/// let ogt_cmp = builder.createFCmp(OGT, arg1, arg2, name="ogt_cmp") -/// inspect(ogt_cmp, content=" %ogt_cmp = fcmp ogt float %0, %1") -/// let olt_cmp = builder.createFCmp(OLT, arg1, arg2, name="olt_cmp") -/// inspect(olt_cmp, content=" %olt_cmp = fcmp olt float %0, %1") -/// let uno_cmp = builder.createFCmp(UNO, arg1, arg2, name="uno_cmp") -/// inspect(uno_cmp, content=" %uno_cmp = fcmp uno float %0, %1") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let f32_ty = ctx.getFloatTy() +/// let fty = ctx.getFunctionType(f32_ty, [f32_ty, f32_ty]) +/// let fval = mod.addFunction(fty, "fcmp_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg1 = fval.getArg(0).unwrap() +/// let arg2 = fval.getArg(1).unwrap() +/// builder.setInsertPoint(bb) +/// let oeq_cmp = builder.createFCmp(OEQ, arg1, arg2, name="oeq_cmp") +/// inspect(oeq_cmp, content=" %oeq_cmp = fcmp oeq float %0, %1") +/// assert_true(oeq_cmp.asValueEnum() is FCmpInst(_)) +/// let ogt_cmp = builder.createFCmp(OGT, arg1, arg2, name="ogt_cmp") +/// inspect(ogt_cmp, content=" %ogt_cmp = fcmp ogt float %0, %1") +/// let olt_cmp = builder.createFCmp(OLT, arg1, arg2, name="olt_cmp") +/// inspect(olt_cmp, content=" %olt_cmp = fcmp olt float %0, %1") +/// let uno_cmp = builder.createFCmp(UNO, arg1, arg2, name="uno_cmp") +/// inspect(uno_cmp, content=" %uno_cmp = fcmp uno float %0, %1") +/// } /// ``` pub struct FCmpInst { uid : UInt64 @@ -1817,21 +1857,23 @@ pub impl Value for FCmpInst with getValueBase(self) { ///| /// Get simple representation of the value. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let f32_ty = ctx.getFloatTy() -/// let fty = ctx.getFunctionType(f32_ty, [f32_ty, f32_ty]) -/// let fval = mod.addFunction(fty, "fcmp_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg1 = fval.getArg(0).unwrap() -/// let arg2 = fval.getArg(1).unwrap() -/// builder.setInsertPoint(bb) -/// let oeq_cmp = builder.createFCmp(OEQ, arg1, arg2) -/// inspect(oeq_cmp.getValueRepr(), content="%2") -/// oeq_cmp.setName("oeq_cmp") -/// inspect(oeq_cmp.getValueRepr(), content="%oeq_cmp") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let f32_ty = ctx.getFloatTy() +/// let fty = ctx.getFunctionType(f32_ty, [f32_ty, f32_ty]) +/// let fval = mod.addFunction(fty, "fcmp_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg1 = fval.getArg(0).unwrap() +/// let arg2 = fval.getArg(1).unwrap() +/// builder.setInsertPoint(bb) +/// let oeq_cmp = builder.createFCmp(OEQ, arg1, arg2) +/// inspect(oeq_cmp.getValueRepr(), content="%2") +/// oeq_cmp.setName("oeq_cmp") +/// inspect(oeq_cmp.getValueRepr(), content="%oeq_cmp") +/// } /// ``` pub impl Value for FCmpInst with getValueRepr(self) { match self.getNameOrSlot() { @@ -1853,21 +1895,23 @@ pub impl Value for FCmpInst with asValueEnum(self) { /// /// If the instruction has no name, return `None`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let f32_ty = ctx.getFloatTy() -/// let fty = ctx.getFunctionType(f32_ty, [f32_ty, f32_ty]) -/// let fval = mod.addFunction(fty, "fcmp_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg1 = fval.getArg(0).unwrap() -/// let arg2 = fval.getArg(1).unwrap() -/// builder.setInsertPoint(bb) -/// let oeq_cmp = builder.createFCmp(OEQ, arg1, arg2) -/// inspect(oeq_cmp.getName(), content="None") -/// oeq_cmp.setName("oeq_cmp") -/// inspect(oeq_cmp.getName(), content="Some(\"oeq_cmp\")") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let f32_ty = ctx.getFloatTy() +/// let fty = ctx.getFunctionType(f32_ty, [f32_ty, f32_ty]) +/// let fval = mod.addFunction(fty, "fcmp_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg1 = fval.getArg(0).unwrap() +/// let arg2 = fval.getArg(1).unwrap() +/// builder.setInsertPoint(bb) +/// let oeq_cmp = builder.createFCmp(OEQ, arg1, arg2) +/// inspect(oeq_cmp.getName(), content="None") +/// oeq_cmp.setName("oeq_cmp") +/// inspect(oeq_cmp.getName(), content="Some(\"oeq_cmp\")") +/// } /// ``` pub impl Value for FCmpInst with getName(self) { self.name @@ -1881,21 +1925,23 @@ pub impl Value for FCmpInst with getName(self) { /// If the name has already been used in the parent function, /// it will raise Error. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let f32_ty = ctx.getFloatTy() -/// let fty = ctx.getFunctionType(f32_ty, [f32_ty, f32_ty]) -/// let fval = mod.addFunction(fty, "fcmp_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg1 = fval.getArg(0).unwrap() -/// let arg2 = fval.getArg(1).unwrap() -/// builder.setInsertPoint(bb) -/// let oeq_cmp = builder.createFCmp(OEQ, arg1, arg2) -/// inspect(oeq_cmp.getName(), content="None") -/// oeq_cmp.setName("oeq_cmp") -/// inspect(oeq_cmp.getName(), content="Some(\"oeq_cmp\")") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let f32_ty = ctx.getFloatTy() +/// let fty = ctx.getFunctionType(f32_ty, [f32_ty, f32_ty]) +/// let fval = mod.addFunction(fty, "fcmp_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg1 = fval.getArg(0).unwrap() +/// let arg2 = fval.getArg(1).unwrap() +/// builder.setInsertPoint(bb) +/// let oeq_cmp = builder.createFCmp(OEQ, arg1, arg2) +/// inspect(oeq_cmp.getName(), content="None") +/// oeq_cmp.setName("oeq_cmp") +/// inspect(oeq_cmp.getName(), content="Some(\"oeq_cmp\")") +/// } /// ``` pub impl Value for FCmpInst with setName(self, name) { match self.getParent().setSymbol(name, self) { @@ -2029,25 +2075,27 @@ pub impl Show for CastOps with output(self, logger) { /// /// Use `IRBuilder::createTrunc`, `IRBuilder::createZExt`, `IRBuilder::createSExt`, etc. to create cast instructions. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let i64_ty = ctx.getInt64Ty() -/// let f32_ty = ctx.getFloatTy() -/// let fty = ctx.getFunctionType(i32_ty, [i64_ty]) -/// let fval = mod.addFunction(fty, "cast_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg = fval.getArg(0).unwrap() -/// builder.setInsertPoint(bb) -/// let trunc = builder.createTrunc(arg, i32_ty, name="truncated") -/// inspect(trunc, content=" %truncated = trunc i64 %0 to i32") -/// assert_true(trunc.asValueEnum() is CastInst(_)) -/// let zext = builder.createZExt(trunc, i64_ty, name="extended") -/// inspect(zext, content=" %extended = zext i32 %truncated to i64") -/// let bitcast = builder.createBitCast(trunc, f32_ty, name="bits") -/// inspect(bitcast, content=" %bits = bitcast i32 %truncated to float") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let i64_ty = ctx.getInt64Ty() +/// let f32_ty = ctx.getFloatTy() +/// let fty = ctx.getFunctionType(i32_ty, [i64_ty]) +/// let fval = mod.addFunction(fty, "cast_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg = fval.getArg(0).unwrap() +/// builder.setInsertPoint(bb) +/// let trunc = builder.createTrunc(arg, i32_ty, name="truncated") +/// inspect(trunc, content=" %truncated = trunc i64 %0 to i32") +/// assert_true(trunc.asValueEnum() is CastInst(_)) +/// let zext = builder.createZExt(trunc, i64_ty, name="extended") +/// inspect(zext, content=" %extended = zext i32 %truncated to i64") +/// let bitcast = builder.createBitCast(trunc, f32_ty, name="bits") +/// inspect(bitcast, content=" %bits = bitcast i32 %truncated to float") +/// } /// ``` pub struct CastInst { uid : UInt64 @@ -2402,21 +2450,23 @@ pub impl Value for CastInst with getValueBase(self) { ///| /// Get simple representation of the value. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let i64_ty = ctx.getInt64Ty() -/// let fty = ctx.getFunctionType(i32_ty, [i64_ty]) -/// let fval = mod.addFunction(fty, "cast_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg = fval.getArg(0).unwrap() -/// builder.setInsertPoint(bb) -/// let trunc = builder.createTrunc(arg, i32_ty) -/// inspect(trunc.getValueRepr(), content="%1") -/// trunc.setName("truncated") -/// inspect(trunc.getValueRepr(), content="%truncated") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let i64_ty = ctx.getInt64Ty() +/// let fty = ctx.getFunctionType(i32_ty, [i64_ty]) +/// let fval = mod.addFunction(fty, "cast_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg = fval.getArg(0).unwrap() +/// builder.setInsertPoint(bb) +/// let trunc = builder.createTrunc(arg, i32_ty) +/// inspect(trunc.getValueRepr(), content="%1") +/// trunc.setName("truncated") +/// inspect(trunc.getValueRepr(), content="%truncated") +/// } /// ``` pub impl Value for CastInst with getValueRepr(self) { match self.getNameOrSlot() { @@ -2438,21 +2488,23 @@ pub impl Value for CastInst with asValueEnum(self) { /// /// If the instruction has no name, return `None`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let i64_ty = ctx.getInt64Ty() -/// let fty = ctx.getFunctionType(i32_ty, [i64_ty]) -/// let fval = mod.addFunction(fty, "cast_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg = fval.getArg(0).unwrap() -/// builder.setInsertPoint(bb) -/// let trunc = builder.createTrunc(arg, i32_ty) -/// inspect(trunc.getName(), content="None") -/// trunc.setName("truncated") -/// inspect(trunc.getName(), content="Some(\"truncated\")") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let i64_ty = ctx.getInt64Ty() +/// let fty = ctx.getFunctionType(i32_ty, [i64_ty]) +/// let fval = mod.addFunction(fty, "cast_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg = fval.getArg(0).unwrap() +/// builder.setInsertPoint(bb) +/// let trunc = builder.createTrunc(arg, i32_ty) +/// inspect(trunc.getName(), content="None") +/// trunc.setName("truncated") +/// inspect(trunc.getName(), content="Some(\"truncated\")") +/// } /// ``` pub impl Value for CastInst with getName(self) { self.name @@ -2466,21 +2518,23 @@ pub impl Value for CastInst with getName(self) { /// If the name has already been used in the parent function, /// it will raise Error. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let i64_ty = ctx.getInt64Ty() -/// let fty = ctx.getFunctionType(i32_ty, [i64_ty]) -/// let fval = mod.addFunction(fty, "cast_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg = fval.getArg(0).unwrap() -/// builder.setInsertPoint(bb) -/// let trunc = builder.createTrunc(arg, i32_ty) -/// inspect(trunc.getName(), content="None") -/// trunc.setName("truncated") -/// inspect(trunc.getName(), content="Some(\"truncated\")") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let i64_ty = ctx.getInt64Ty() +/// let fty = ctx.getFunctionType(i32_ty, [i64_ty]) +/// let fval = mod.addFunction(fty, "cast_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg = fval.getArg(0).unwrap() +/// builder.setInsertPoint(bb) +/// let trunc = builder.createTrunc(arg, i32_ty) +/// inspect(trunc.getName(), content="None") +/// trunc.setName("truncated") +/// inspect(trunc.getName(), content="Some(\"truncated\")") +/// } /// ``` pub impl Value for CastInst with setName(self, name) { match self.getParent().setSymbol(name, self) { @@ -2582,32 +2636,34 @@ pub impl Show for CastInst with output(self, logger) { /// /// Use `IRBuilder::createGEP` to create a `GetElementPtrInst`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let array_ty = ctx.getArrayType(i32_ty, 10) -/// let ptr_ty = ctx.getPtrTy() -/// let fty = ctx.getFunctionType(ptr_ty, [ptr_ty]) -/// let fval = mod.addFunction(fty, "gep_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg = fval.getArg(0).unwrap() -/// let zero = ctx.getConstInt32(0) -/// let two = ctx.getConstInt32(2) -/// builder.setInsertPoint(bb) -/// let gep = builder.createGEP( -/// arg, -/// array_ty, -/// [zero, two], -/// name="elem_ptr", -/// inbounds=true, -/// ) -/// inspect( -/// gep, -/// content=" %elem_ptr = getelementptr inbounds [10 x i32], ptr %0, i32 0, i32 2", -/// ) -/// assert_true(gep.asValueEnum() is GetElementPtrInst(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let array_ty = ctx.getArrayType(i32_ty, 10) +/// let ptr_ty = ctx.getPtrTy() +/// let fty = ctx.getFunctionType(ptr_ty, [ptr_ty]) +/// let fval = mod.addFunction(fty, "gep_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg = fval.getArg(0).unwrap() +/// let zero = ctx.getConstInt32(0) +/// let two = ctx.getConstInt32(2) +/// builder.setInsertPoint(bb) +/// let gep = builder.createGEP( +/// arg, +/// array_ty, +/// [zero, two], +/// name="elem_ptr", +/// inbounds=true, +/// ) +/// inspect( +/// gep, +/// content=" %elem_ptr = getelementptr inbounds [10 x i32], ptr %0, i32 0, i32 2", +/// ) +/// assert_true(gep.asValueEnum() is GetElementPtrInst(_)) +/// } /// ``` pub struct GetElementPtrInst { uid : UInt64 @@ -2667,24 +2723,26 @@ pub impl Value for GetElementPtrInst with getValueBase(self) { ///| /// Get simple representation of the value. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let array_ty = ctx.getArrayType(i32_ty, 10) -/// let ptr_ty = ctx.getPtrTy() -/// let fty = ctx.getFunctionType(ptr_ty, [ptr_ty]) -/// let fval = mod.addFunction(fty, "gep_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg = fval.getArg(0).unwrap() -/// let zero = ctx.getConstInt32(0) -/// let two = ctx.getConstInt32(2) -/// builder.setInsertPoint(bb) -/// let gep = builder.createGEP(arg, array_ty, [zero, two]) -/// inspect(gep.getValueRepr(), content="%1") -/// gep.setName("elem_ptr") -/// inspect(gep.getValueRepr(), content="%elem_ptr") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let array_ty = ctx.getArrayType(i32_ty, 10) +/// let ptr_ty = ctx.getPtrTy() +/// let fty = ctx.getFunctionType(ptr_ty, [ptr_ty]) +/// let fval = mod.addFunction(fty, "gep_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg = fval.getArg(0).unwrap() +/// let zero = ctx.getConstInt32(0) +/// let two = ctx.getConstInt32(2) +/// builder.setInsertPoint(bb) +/// let gep = builder.createGEP(arg, array_ty, [zero, two]) +/// inspect(gep.getValueRepr(), content="%1") +/// gep.setName("elem_ptr") +/// inspect(gep.getValueRepr(), content="%elem_ptr") +/// } /// ``` pub impl Value for GetElementPtrInst with getValueRepr(self) { match self.getNameOrSlot() { @@ -2706,24 +2764,26 @@ pub impl Value for GetElementPtrInst with asValueEnum(self) { /// /// If the instruction has no name, return `None`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let array_ty = ctx.getArrayType(i32_ty, 10) -/// let ptr_ty = ctx.getPtrTy() -/// let fty = ctx.getFunctionType(ptr_ty, [ptr_ty]) -/// let fval = mod.addFunction(fty, "gep_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg = fval.getArg(0).unwrap() -/// let zero = ctx.getConstInt32(0) -/// let two = ctx.getConstInt32(2) -/// builder.setInsertPoint(bb) -/// let gep = builder.createGEP(arg, array_ty, [zero, two]) -/// inspect(gep.getName(), content="None") -/// gep.setName("elem_ptr") -/// inspect(gep.getName(), content="Some(\"elem_ptr\")") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let array_ty = ctx.getArrayType(i32_ty, 10) +/// let ptr_ty = ctx.getPtrTy() +/// let fty = ctx.getFunctionType(ptr_ty, [ptr_ty]) +/// let fval = mod.addFunction(fty, "gep_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg = fval.getArg(0).unwrap() +/// let zero = ctx.getConstInt32(0) +/// let two = ctx.getConstInt32(2) +/// builder.setInsertPoint(bb) +/// let gep = builder.createGEP(arg, array_ty, [zero, two]) +/// inspect(gep.getName(), content="None") +/// gep.setName("elem_ptr") +/// inspect(gep.getName(), content="Some(\"elem_ptr\")") +/// } /// ``` pub impl Value for GetElementPtrInst with getName(self) { self.name @@ -2737,24 +2797,26 @@ pub impl Value for GetElementPtrInst with getName(self) { /// If the name has already been used in the parent function, /// it will raise Error. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let array_ty = ctx.getArrayType(i32_ty, 10) -/// let ptr_ty = ctx.getPtrTy() -/// let fty = ctx.getFunctionType(ptr_ty, [ptr_ty]) -/// let fval = mod.addFunction(fty, "gep_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg = fval.getArg(0).unwrap() -/// let zero = ctx.getConstInt32(0) -/// let two = ctx.getConstInt32(2) -/// builder.setInsertPoint(bb) -/// let gep = builder.createGEP(arg, array_ty, [zero, two]) -/// inspect(gep.getName(), content="None") -/// gep.setName("elem_ptr") -/// inspect(gep.getName(), content="Some(\"elem_ptr\")") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let array_ty = ctx.getArrayType(i32_ty, 10) +/// let ptr_ty = ctx.getPtrTy() +/// let fty = ctx.getFunctionType(ptr_ty, [ptr_ty]) +/// let fval = mod.addFunction(fty, "gep_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg = fval.getArg(0).unwrap() +/// let zero = ctx.getConstInt32(0) +/// let two = ctx.getConstInt32(2) +/// builder.setInsertPoint(bb) +/// let gep = builder.createGEP(arg, array_ty, [zero, two]) +/// inspect(gep.getName(), content="None") +/// gep.setName("elem_ptr") +/// inspect(gep.getName(), content="Some(\"elem_ptr\")") +/// } /// ``` pub impl Value for GetElementPtrInst with setName(self, name) { match self.getParent().setSymbol(name, self) { @@ -2859,22 +2921,24 @@ pub impl Show for GetElementPtrInst with output(self, logger) { /// /// Use `IRBuilder::createSelect` to create a `SelectInst`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i1_ty = ctx.getInt1Ty() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [i1_ty, i32_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "select_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let cond = fval.getArg(0).unwrap() -/// let true_val = fval.getArg(1).unwrap() -/// let false_val = fval.getArg(2).unwrap() -/// builder.setInsertPoint(bb) -/// let select = builder.createSelect(cond, true_val, false_val, name="result") -/// inspect(select, content=" %result = select i1 %0, i32 %1, i32 %2") -/// assert_true(select.asValueEnum() is SelectInst(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i1_ty = ctx.getInt1Ty() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [i1_ty, i32_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "select_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let cond = fval.getArg(0).unwrap() +/// let true_val = fval.getArg(1).unwrap() +/// let false_val = fval.getArg(2).unwrap() +/// builder.setInsertPoint(bb) +/// let select = builder.createSelect(cond, true_val, false_val, name="result") +/// inspect(select, content=" %result = select i1 %0, i32 %1, i32 %2") +/// assert_true(select.asValueEnum() is SelectInst(_)) +/// } /// ``` pub struct SelectInst { uid : UInt64 @@ -2947,23 +3011,25 @@ pub impl Value for SelectInst with getValueBase(self) { ///| /// Get simple representation of the value. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i1_ty = ctx.getInt1Ty() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [i1_ty, i32_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "select_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let cond = fval.getArg(0).unwrap() -/// let true_val = fval.getArg(1).unwrap() -/// let false_val = fval.getArg(2).unwrap() -/// builder.setInsertPoint(bb) -/// let select = builder.createSelect(cond, true_val, false_val) -/// inspect(select.getValueRepr(), content="%3") -/// select.setName("result") -/// inspect(select.getValueRepr(), content="%result") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i1_ty = ctx.getInt1Ty() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [i1_ty, i32_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "select_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let cond = fval.getArg(0).unwrap() +/// let true_val = fval.getArg(1).unwrap() +/// let false_val = fval.getArg(2).unwrap() +/// builder.setInsertPoint(bb) +/// let select = builder.createSelect(cond, true_val, false_val) +/// inspect(select.getValueRepr(), content="%3") +/// select.setName("result") +/// inspect(select.getValueRepr(), content="%result") +/// } /// ``` pub impl Value for SelectInst with getValueRepr(self) { match self.getNameOrSlot() { @@ -2985,23 +3051,25 @@ pub impl Value for SelectInst with asValueEnum(self) { /// /// If the instruction has no name, return `None`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i1_ty = ctx.getInt1Ty() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [i1_ty, i32_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "select_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let cond = fval.getArg(0).unwrap() -/// let true_val = fval.getArg(1).unwrap() -/// let false_val = fval.getArg(2).unwrap() -/// builder.setInsertPoint(bb) -/// let select = builder.createSelect(cond, true_val, false_val) -/// inspect(select.getName(), content="None") -/// select.setName("result") -/// inspect(select.getName(), content="Some(\"result\")") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i1_ty = ctx.getInt1Ty() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [i1_ty, i32_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "select_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let cond = fval.getArg(0).unwrap() +/// let true_val = fval.getArg(1).unwrap() +/// let false_val = fval.getArg(2).unwrap() +/// builder.setInsertPoint(bb) +/// let select = builder.createSelect(cond, true_val, false_val) +/// inspect(select.getName(), content="None") +/// select.setName("result") +/// inspect(select.getName(), content="Some(\"result\")") +/// } /// ``` pub impl Value for SelectInst with getName(self) { self.name @@ -3015,23 +3083,25 @@ pub impl Value for SelectInst with getName(self) { /// If the name has already been used in the parent function, /// it will raise Error. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i1_ty = ctx.getInt1Ty() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, [i1_ty, i32_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "select_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let cond = fval.getArg(0).unwrap() -/// let true_val = fval.getArg(1).unwrap() -/// let false_val = fval.getArg(2).unwrap() -/// builder.setInsertPoint(bb) -/// let select = builder.createSelect(cond, true_val, false_val) -/// inspect(select.getName(), content="None") -/// select.setName("result") -/// inspect(select.getName(), content="Some(\"result\")") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i1_ty = ctx.getInt1Ty() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, [i1_ty, i32_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "select_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let cond = fval.getArg(0).unwrap() +/// let true_val = fval.getArg(1).unwrap() +/// let false_val = fval.getArg(2).unwrap() +/// builder.setInsertPoint(bb) +/// let select = builder.createSelect(cond, true_val, false_val) +/// inspect(select.getName(), content="None") +/// select.setName("result") +/// inspect(select.getName(), content="Some(\"result\")") +/// } /// ``` pub impl Value for SelectInst with setName(self, name) { match self.getParent().setSymbol(name, self) { @@ -3133,26 +3203,28 @@ pub impl Show for SelectInst with output(self, logger) { /// /// Use `IRBuilder::createRet` or `IRBuilder::createRetVoid` to create a `ReturnInst`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let void_ty = ctx.getVoidTy() -/// let fty = ctx.getFunctionType(i32_ty, [i32_ty]) -/// let fval = mod.addFunction(fty, "return_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let arg = fval.getArg(0).unwrap() -/// builder.setInsertPoint(bb) -/// let ret = builder.createRet(arg) -/// inspect(ret, content=" ret i32 %0") -/// assert_true(ret.asValueEnum() is ReturnInst(_)) -/// let void_fty = ctx.getFunctionType(void_ty, []) -/// let void_fval = mod.addFunction(void_fty, "void_return_demo") -/// let void_bb = void_fval.addBasicBlock(name="entry") -/// builder.setInsertPoint(void_bb) -/// let void_ret = builder.createRetVoid() -/// inspect(void_ret, content=" ret void") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let void_ty = ctx.getVoidTy() +/// let fty = ctx.getFunctionType(i32_ty, [i32_ty]) +/// let fval = mod.addFunction(fty, "return_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let arg = fval.getArg(0).unwrap() +/// builder.setInsertPoint(bb) +/// let ret = builder.createRet(arg) +/// inspect(ret, content=" ret i32 %0") +/// assert_true(ret.asValueEnum() is ReturnInst(_)) +/// let void_fty = ctx.getFunctionType(void_ty, []) +/// let void_fval = mod.addFunction(void_fty, "void_return_demo") +/// let void_bb = void_fval.addBasicBlock(name="entry") +/// builder.setInsertPoint(void_bb) +/// let void_ret = builder.createRetVoid() +/// inspect(void_ret, content=" ret void") +/// } /// ``` pub struct ReturnInst { uid : UInt64 @@ -3270,25 +3342,30 @@ pub impl Show for ReturnInst with output(self, logger) { /// /// Use `IRBuilder::createBr` for unconditional branches or `IRBuilder::createCondBr` for conditional branches. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i1_ty = ctx.getInt1Ty() -/// let void_ty = ctx.getVoidTy() -/// let fty = ctx.getFunctionType(void_ty, [i1_ty]) -/// let fval = mod.addFunction(fty, "branch_demo") -/// let entry_bb = fval.addBasicBlock(name="entry") -/// let true_bb = fval.addBasicBlock(name="true_branch") -/// let false_bb = fval.addBasicBlock(name="false_branch") -/// let cond = fval.getArg(0).unwrap() -/// builder.setInsertPoint(entry_bb) -/// let cond_br = builder.createCondBr(cond, true_bb, false_bb) -/// inspect(cond_br, content=" br i1 %0, label %true_branch, label %false_branch") -/// assert_true(cond_br.asValueEnum() is BranchInst(_)) -/// builder.setInsertPoint(true_bb) -/// let uncond_br = builder.createBr(false_bb) -/// inspect(uncond_br, content=" br label %false_branch") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i1_ty = ctx.getInt1Ty() +/// let void_ty = ctx.getVoidTy() +/// let fty = ctx.getFunctionType(void_ty, [i1_ty]) +/// let fval = mod.addFunction(fty, "branch_demo") +/// let entry_bb = fval.addBasicBlock(name="entry") +/// let true_bb = fval.addBasicBlock(name="true_branch") +/// let false_bb = fval.addBasicBlock(name="false_branch") +/// let cond = fval.getArg(0).unwrap() +/// builder.setInsertPoint(entry_bb) +/// let cond_br = builder.createCondBr(cond, true_bb, false_bb) +/// inspect( +/// cond_br, +/// content=" br i1 %0, label %true_branch, label %false_branch", +/// ) +/// assert_true(cond_br.asValueEnum() is BranchInst(_)) +/// builder.setInsertPoint(true_bb) +/// let uncond_br = builder.createBr(false_bb) +/// inspect(uncond_br, content=" br label %false_branch") +/// } /// ``` pub struct BranchInst { // --- ValueBase --- @@ -3499,32 +3576,34 @@ pub impl Show for BranchInst with output(self, logger) { /// /// Use `IRBuilder::createSwitch` to create a `SwitchInst`, then use `SwitchInst::addCase` to add individual cases. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let void_ty = ctx.getVoidTy() -/// let fty = ctx.getFunctionType(void_ty, [i32_ty]) -/// let fval = mod.addFunction(fty, "switch_demo") -/// let entry_bb = fval.addBasicBlock(name="entry") -/// let case1_bb = fval.addBasicBlock(name="case1") -/// let case2_bb = fval.addBasicBlock(name="case2") -/// let default_bb = fval.addBasicBlock(name="default") -/// let value = fval.getArg(0).unwrap() -/// builder.setInsertPoint(entry_bb) -/// let switch = builder.createSwitch(value, default_bb) -/// let case_val1 = ctx.getConstInt32(1) -/// let case_val2 = ctx.getConstInt32(2) -/// switch.addCase(case_val1, case1_bb) -/// switch.addCase(case_val2, case2_bb) -/// let expect = -/// #| switch i32 %0, label %default [ -/// #| i32 1, label %case1 -/// #| i32 2, label %case2 -/// #| ] -/// inspect(switch, content=expect) -/// assert_true(switch.asValueEnum() is SwitchInst(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let void_ty = ctx.getVoidTy() +/// let fty = ctx.getFunctionType(void_ty, [i32_ty]) +/// let fval = mod.addFunction(fty, "switch_demo") +/// let entry_bb = fval.addBasicBlock(name="entry") +/// let case1_bb = fval.addBasicBlock(name="case1") +/// let case2_bb = fval.addBasicBlock(name="case2") +/// let default_bb = fval.addBasicBlock(name="default") +/// let value = fval.getArg(0).unwrap() +/// builder.setInsertPoint(entry_bb) +/// let switch = builder.createSwitch(value, default_bb) +/// let case_val1 = ctx.getConstInt32(1) +/// let case_val2 = ctx.getConstInt32(2) +/// switch.addCase(case_val1, case1_bb) +/// switch.addCase(case_val2, case2_bb) +/// let expect = +/// #| switch i32 %0, label %default [ +/// #| i32 1, label %case1 +/// #| i32 2, label %case2 +/// #| ] +/// inspect(switch, content=expect) +/// assert_true(switch.asValueEnum() is SwitchInst(_)) +/// } /// ``` pub struct SwitchInst { uid : UInt64 @@ -3589,31 +3668,33 @@ pub fn SwitchInst::getNumCases(self : Self) -> Int { /// /// Returns `None` if the index is out of bounds. Use `SwitchInst::getNumCases` to get the total number of cases. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let void_ty = ctx.getVoidTy() -/// let fty = ctx.getFunctionType(void_ty, [i32_ty]) -/// let fval = mod.addFunction(fty, "switch_case_demo") -/// let entry_bb = fval.addBasicBlock(name="entry") -/// let case1_bb = fval.addBasicBlock(name="case1") -/// let case2_bb = fval.addBasicBlock(name="case2") -/// let default_bb = fval.addBasicBlock(name="default") -/// let value = fval.getArg(0).unwrap() -/// builder.setInsertPoint(entry_bb) -/// let switch = builder.createSwitch(value, default_bb) -/// let case_val1 = ctx.getConstInt32(1) -/// let case_val2 = ctx.getConstInt32(2) -/// switch.addCase(case_val1, case1_bb) -/// switch.addCase(case_val2, case2_bb) -/// inspect(switch.getNumCases(), content="2") -/// inspect(switch.getCase(0).unwrap().0.getValueRepr(), content="1") -/// inspect(switch.getCase(0).unwrap().1.getValueRepr(), content="%case1") -/// inspect(switch.getCase(1).unwrap().0.getValueRepr(), content="2") -/// inspect(switch.getCase(1).unwrap().1.getValueRepr(), content="%case2") -/// inspect(switch.getCase(2), content="None") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let void_ty = ctx.getVoidTy() +/// let fty = ctx.getFunctionType(void_ty, [i32_ty]) +/// let fval = mod.addFunction(fty, "switch_case_demo") +/// let entry_bb = fval.addBasicBlock(name="entry") +/// let case1_bb = fval.addBasicBlock(name="case1") +/// let case2_bb = fval.addBasicBlock(name="case2") +/// let default_bb = fval.addBasicBlock(name="default") +/// let value = fval.getArg(0).unwrap() +/// builder.setInsertPoint(entry_bb) +/// let switch = builder.createSwitch(value, default_bb) +/// let case_val1 = ctx.getConstInt32(1) +/// let case_val2 = ctx.getConstInt32(2) +/// switch.addCase(case_val1, case1_bb) +/// switch.addCase(case_val2, case2_bb) +/// inspect(switch.getNumCases(), content="2") +/// inspect(switch.getCase(0).unwrap().0.getValueRepr(), content="1") +/// inspect(switch.getCase(0).unwrap().1.getValueRepr(), content="%case1") +/// inspect(switch.getCase(1).unwrap().0.getValueRepr(), content="2") +/// inspect(switch.getCase(1).unwrap().1.getValueRepr(), content="%case2") +/// inspect(switch.getCase(2), content="None") +/// } /// ``` pub fn SwitchInst::getCase( self : Self, @@ -3630,34 +3711,36 @@ pub fn SwitchInst::getCase( /// The case condition must be a constant integer with the same type as the switch condition. /// Will raise `LLVMValueError` if there is a type mismatch between the case condition and switch condition. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let void_ty = ctx.getVoidTy() -/// let fty = ctx.getFunctionType(void_ty, [i32_ty]) -/// let fval = mod.addFunction(fty, "switch_addcase_demo") -/// let entry_bb = fval.addBasicBlock(name="entry") -/// let case1_bb = fval.addBasicBlock(name="case1") -/// let case2_bb = fval.addBasicBlock(name="case2") -/// let case3_bb = fval.addBasicBlock(name="case3") -/// let default_bb = fval.addBasicBlock(name="default") -/// let value = fval.getArg(0).unwrap() -/// builder.setInsertPoint(entry_bb) -/// let switch = builder.createSwitch(value, default_bb) -/// -/// // Add multiple cases -/// let case_val1 = ctx.getConstInt32(1) -/// let case_val2 = ctx.getConstInt32(2) -/// let case_val3 = ctx.getConstInt32(3) -/// switch.addCase(case_val1, case1_bb) -/// switch.addCase(case_val2, case2_bb) -/// switch.addCase(case_val3, case3_bb) -/// inspect(switch.getNumCases(), content="3") -/// assert_true(switch.getCase(0).unwrap().0.getValueRepr() == "1") -/// assert_true(switch.getCase(1).unwrap().0.getValueRepr() == "2") -/// assert_true(switch.getCase(2).unwrap().0.getValueRepr() == "3") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let void_ty = ctx.getVoidTy() +/// let fty = ctx.getFunctionType(void_ty, [i32_ty]) +/// let fval = mod.addFunction(fty, "switch_addcase_demo") +/// let entry_bb = fval.addBasicBlock(name="entry") +/// let case1_bb = fval.addBasicBlock(name="case1") +/// let case2_bb = fval.addBasicBlock(name="case2") +/// let case3_bb = fval.addBasicBlock(name="case3") +/// let default_bb = fval.addBasicBlock(name="default") +/// let value = fval.getArg(0).unwrap() +/// builder.setInsertPoint(entry_bb) +/// let switch = builder.createSwitch(value, default_bb) +/// +/// // Add multiple cases +/// let case_val1 = ctx.getConstInt32(1) +/// let case_val2 = ctx.getConstInt32(2) +/// let case_val3 = ctx.getConstInt32(3) +/// switch.addCase(case_val1, case1_bb) +/// switch.addCase(case_val2, case2_bb) +/// switch.addCase(case_val3, case3_bb) +/// inspect(switch.getNumCases(), content="3") +/// assert_true(switch.getCase(0).unwrap().0.getValueRepr() == "1") +/// assert_true(switch.getCase(1).unwrap().0.getValueRepr() == "2") +/// assert_true(switch.getCase(2).unwrap().0.getValueRepr() == "3") +/// } /// ``` pub fn SwitchInst::addCase( self : Self, @@ -3801,24 +3884,26 @@ pub impl Show for SwitchInst with output(self, logger) { /// /// Use `IRBuilder::createPHI` to create a `PHINode`, then use `PHINode::addIncoming` to add incoming values. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, []) -/// let fval = mod.addFunction(fty, "phi_demo") -/// let entry_bb = fval.addBasicBlock(name="entry") -/// let block_bb = fval.addBasicBlock(name="block") -/// let merge_bb = fval.addBasicBlock(name="merge") -/// let val1 = ctx.getConstInt32(10) -/// let val2 = ctx.getConstInt32(20) -/// builder.setInsertPoint(merge_bb) -/// let phi = builder.createPHI(i32_ty, name="result") -/// phi.addIncoming(val1, entry_bb) -/// phi.addIncoming(val2, block_bb) -/// inspect(phi, content=" %result = phi i32 [ 10, %entry ], [ 20, %block ]") -/// assert_true(phi.asValueEnum() is PHINode(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, []) +/// let fval = mod.addFunction(fty, "phi_demo") +/// let entry_bb = fval.addBasicBlock(name="entry") +/// let block_bb = fval.addBasicBlock(name="block") +/// let merge_bb = fval.addBasicBlock(name="merge") +/// let val1 = ctx.getConstInt32(10) +/// let val2 = ctx.getConstInt32(20) +/// builder.setInsertPoint(merge_bb) +/// let phi = builder.createPHI(i32_ty, name="result") +/// phi.addIncoming(val1, entry_bb) +/// phi.addIncoming(val2, block_bb) +/// inspect(phi, content=" %result = phi i32 [ 10, %entry ], [ 20, %block ]") +/// assert_true(phi.asValueEnum() is PHINode(_)) +/// } /// ``` pub struct PHINode { uid : UInt64 @@ -3850,28 +3935,30 @@ fn PHINode::new(vty : &Type, parent : Function, name~ : String?) -> PHINode { /// /// Returns the total count of incoming value-block pairs added to this PHI node. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, []) -/// let fval = mod.addFunction(fty, "phi_num_demo") -/// let entry_bb = fval.addBasicBlock(name="entry") -/// let block1_bb = fval.addBasicBlock(name="block1") -/// let block2_bb = fval.addBasicBlock(name="block2") -/// let merge_bb = fval.addBasicBlock(name="merge") -/// let val1 = ctx.getConstInt32(10) -/// let val2 = ctx.getConstInt32(20) -/// let val3 = ctx.getConstInt32(30) -/// builder.setInsertPoint(merge_bb) -/// let phi = builder.createPHI(i32_ty, name="result") -/// inspect(phi.getNumIncomingValues(), content="0") -/// phi.addIncoming(val1, entry_bb) -/// inspect(phi.getNumIncomingValues(), content="1") -/// phi.addIncoming(val2, block1_bb) -/// phi.addIncoming(val3, block2_bb) -/// inspect(phi.getNumIncomingValues(), content="3") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, []) +/// let fval = mod.addFunction(fty, "phi_num_demo") +/// let entry_bb = fval.addBasicBlock(name="entry") +/// let block1_bb = fval.addBasicBlock(name="block1") +/// let block2_bb = fval.addBasicBlock(name="block2") +/// let merge_bb = fval.addBasicBlock(name="merge") +/// let val1 = ctx.getConstInt32(10) +/// let val2 = ctx.getConstInt32(20) +/// let val3 = ctx.getConstInt32(30) +/// builder.setInsertPoint(merge_bb) +/// let phi = builder.createPHI(i32_ty, name="result") +/// inspect(phi.getNumIncomingValues(), content="0") +/// phi.addIncoming(val1, entry_bb) +/// inspect(phi.getNumIncomingValues(), content="1") +/// phi.addIncoming(val2, block1_bb) +/// phi.addIncoming(val3, block2_bb) +/// inspect(phi.getNumIncomingValues(), content="3") +/// } /// ``` pub fn PHINode::getNumIncomingValues(self : PHINode) -> Int { self.incomings.length() @@ -3884,25 +3971,27 @@ pub fn PHINode::getNumIncomingValues(self : PHINode) -> Int { /// /// Returns `None` if the index is out of bounds. Use `PHINode::getNumIncomingValues` to get the valid range. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, []) -/// let fval = mod.addFunction(fty, "phi_value_demo") -/// let entry_bb = fval.addBasicBlock(name="entry") -/// let block_bb = fval.addBasicBlock(name="block") -/// let merge_bb = fval.addBasicBlock(name="merge") -/// let val1 = ctx.getConstInt32(10) -/// let val2 = ctx.getConstInt32(20) -/// builder.setInsertPoint(merge_bb) -/// let phi = builder.createPHI(i32_ty, name="result") -/// phi.addIncoming(val1, entry_bb) -/// phi.addIncoming(val2, block_bb) -/// inspect(phi.getIncomingValue(0).unwrap().getValueRepr(), content="10") -/// inspect(phi.getIncomingValue(1).unwrap().getValueRepr(), content="20") -/// inspect(phi.getIncomingValue(2), content="None") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, []) +/// let fval = mod.addFunction(fty, "phi_value_demo") +/// let entry_bb = fval.addBasicBlock(name="entry") +/// let block_bb = fval.addBasicBlock(name="block") +/// let merge_bb = fval.addBasicBlock(name="merge") +/// let val1 = ctx.getConstInt32(10) +/// let val2 = ctx.getConstInt32(20) +/// builder.setInsertPoint(merge_bb) +/// let phi = builder.createPHI(i32_ty, name="result") +/// phi.addIncoming(val1, entry_bb) +/// phi.addIncoming(val2, block_bb) +/// inspect(phi.getIncomingValue(0).unwrap().getValueRepr(), content="10") +/// inspect(phi.getIncomingValue(1).unwrap().getValueRepr(), content="20") +/// inspect(phi.getIncomingValue(2), content="None") +/// } /// ``` pub fn PHINode::getIncomingValue(self : PHINode, idx : Int) -> &Value? { match self.incomings.get(idx) { @@ -3918,25 +4007,27 @@ pub fn PHINode::getIncomingValue(self : PHINode, idx : Int) -> &Value? { /// /// Returns `None` if the index is out of bounds. Use `PHINode::getNumIncomingValues` to get the valid range. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, []) -/// let fval = mod.addFunction(fty, "phi_block_demo") -/// let entry_bb = fval.addBasicBlock(name="entry") -/// let block_bb = fval.addBasicBlock(name="block") -/// let merge_bb = fval.addBasicBlock(name="merge") -/// let val1 = ctx.getConstInt32(10) -/// let val2 = ctx.getConstInt32(20) -/// builder.setInsertPoint(merge_bb) -/// let phi = builder.createPHI(i32_ty, name="result") -/// phi.addIncoming(val1, entry_bb) -/// phi.addIncoming(val2, block_bb) -/// inspect(phi.getIncomingBlock(0).unwrap().getValueRepr(), content="%entry") -/// inspect(phi.getIncomingBlock(1).unwrap().getValueRepr(), content="%block") -/// inspect(phi.getIncomingBlock(2), content="None") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, []) +/// let fval = mod.addFunction(fty, "phi_block_demo") +/// let entry_bb = fval.addBasicBlock(name="entry") +/// let block_bb = fval.addBasicBlock(name="block") +/// let merge_bb = fval.addBasicBlock(name="merge") +/// let val1 = ctx.getConstInt32(10) +/// let val2 = ctx.getConstInt32(20) +/// builder.setInsertPoint(merge_bb) +/// let phi = builder.createPHI(i32_ty, name="result") +/// phi.addIncoming(val1, entry_bb) +/// phi.addIncoming(val2, block_bb) +/// inspect(phi.getIncomingBlock(0).unwrap().getValueRepr(), content="%entry") +/// inspect(phi.getIncomingBlock(1).unwrap().getValueRepr(), content="%block") +/// inspect(phi.getIncomingBlock(2), content="None") +/// } /// ``` pub fn PHINode::getIncomingBlock(self : PHINode, idx : Int) -> BasicBlock? { match self.incomings.get(idx) { @@ -3952,29 +4043,31 @@ pub fn PHINode::getIncomingBlock(self : PHINode, idx : Int) -> BasicBlock? { /// /// Returns `None` if the index is out of bounds. This is a convenience method that returns both the value and block together. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, []) -/// let fval = mod.addFunction(fty, "phi_incoming_demo") -/// let entry_bb = fval.addBasicBlock(name="entry") -/// let block_bb = fval.addBasicBlock(name="block") -/// let merge_bb = fval.addBasicBlock(name="merge") -/// let val1 = ctx.getConstInt32(10) -/// let val2 = ctx.getConstInt32(20) -/// builder.setInsertPoint(merge_bb) -/// let phi = builder.createPHI(i32_ty, name="result") -/// phi.addIncoming(val1, entry_bb) -/// phi.addIncoming(val2, block_bb) -/// let (value0, block0) = phi.getIncoming(0).unwrap() -/// inspect(value0.getValueRepr(), content="10") -/// inspect(block0.getValueRepr(), content="%entry") -/// let (value1, block1) = phi.getIncoming(1).unwrap() -/// inspect(value1.getValueRepr(), content="20") -/// inspect(block1.getValueRepr(), content="%block") -/// inspect(phi.getIncoming(2), content="None") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, []) +/// let fval = mod.addFunction(fty, "phi_incoming_demo") +/// let entry_bb = fval.addBasicBlock(name="entry") +/// let block_bb = fval.addBasicBlock(name="block") +/// let merge_bb = fval.addBasicBlock(name="merge") +/// let val1 = ctx.getConstInt32(10) +/// let val2 = ctx.getConstInt32(20) +/// builder.setInsertPoint(merge_bb) +/// let phi = builder.createPHI(i32_ty, name="result") +/// phi.addIncoming(val1, entry_bb) +/// phi.addIncoming(val2, block_bb) +/// let (value0, block0) = phi.getIncoming(0).unwrap() +/// inspect(value0.getValueRepr(), content="10") +/// inspect(block0.getValueRepr(), content="%entry") +/// let (value1, block1) = phi.getIncoming(1).unwrap() +/// inspect(value1.getValueRepr(), content="20") +/// inspect(block1.getValueRepr(), content="%block") +/// inspect(phi.getIncoming(2), content="None") +/// } /// ``` pub fn PHINode::getIncoming(self : PHINode, idx : Int) -> (&Value, BasicBlock)? { self.incomings.get(idx) @@ -3987,31 +4080,33 @@ pub fn PHINode::getIncoming(self : PHINode, idx : Int) -> (&Value, BasicBlock)? /// /// Returns a copy of the internal array containing all value-block pairs in the order they were added. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, []) -/// let fval = mod.addFunction(fty, "phi_incomings_demo") -/// let entry_bb = fval.addBasicBlock(name="entry") -/// let block1_bb = fval.addBasicBlock(name="block1") -/// let block2_bb = fval.addBasicBlock(name="block2") -/// let merge_bb = fval.addBasicBlock(name="merge") -/// let val1 = ctx.getConstInt32(10) -/// let val2 = ctx.getConstInt32(20) -/// let val3 = ctx.getConstInt32(30) -/// builder.setInsertPoint(merge_bb) -/// let phi = builder.createPHI(i32_ty, name="result") -/// phi.addIncoming(val1, entry_bb) -/// phi.addIncoming(val2, block1_bb) -/// phi.addIncoming(val3, block2_bb) -/// let incomings = phi.getIncomings() -/// inspect(incomings.length(), content="3") -/// inspect(incomings[0].0.getValueRepr(), content="10") -/// inspect(incomings[0].1.getValueRepr(), content="%entry") -/// inspect(incomings[1].0.getValueRepr(), content="20") -/// inspect(incomings[2].0.getValueRepr(), content="30") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, []) +/// let fval = mod.addFunction(fty, "phi_incomings_demo") +/// let entry_bb = fval.addBasicBlock(name="entry") +/// let block1_bb = fval.addBasicBlock(name="block1") +/// let block2_bb = fval.addBasicBlock(name="block2") +/// let merge_bb = fval.addBasicBlock(name="merge") +/// let val1 = ctx.getConstInt32(10) +/// let val2 = ctx.getConstInt32(20) +/// let val3 = ctx.getConstInt32(30) +/// builder.setInsertPoint(merge_bb) +/// let phi = builder.createPHI(i32_ty, name="result") +/// phi.addIncoming(val1, entry_bb) +/// phi.addIncoming(val2, block1_bb) +/// phi.addIncoming(val3, block2_bb) +/// let incomings = phi.getIncomings() +/// inspect(incomings.length(), content="3") +/// inspect(incomings[0].0.getValueRepr(), content="10") +/// inspect(incomings[0].1.getValueRepr(), content="%entry") +/// inspect(incomings[1].0.getValueRepr(), content="20") +/// inspect(incomings[2].0.getValueRepr(), content="30") +/// } /// ``` pub fn PHINode::getIncomings(self : PHINode) -> Array[(&Value, BasicBlock)] { self.incomings @@ -4024,30 +4119,32 @@ pub fn PHINode::getIncomings(self : PHINode) -> Array[(&Value, BasicBlock)] { /// /// Returns an array containing only the values from all incoming value-block pairs, in the order they were added. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, []) -/// let fval = mod.addFunction(fty, "phi_values_demo") -/// let entry_bb = fval.addBasicBlock(name="entry") -/// let block1_bb = fval.addBasicBlock(name="block1") -/// let block2_bb = fval.addBasicBlock(name="block2") -/// let merge_bb = fval.addBasicBlock(name="merge") -/// let val1 = ctx.getConstInt32(10) -/// let val2 = ctx.getConstInt32(20) -/// let val3 = ctx.getConstInt32(30) -/// builder.setInsertPoint(merge_bb) -/// let phi = builder.createPHI(i32_ty, name="result") -/// phi.addIncoming(val1, entry_bb) -/// phi.addIncoming(val2, block1_bb) -/// phi.addIncoming(val3, block2_bb) -/// let values = phi.getIncomingValues() -/// inspect(values.length(), content="3") -/// inspect(values[0].getValueRepr(), content="10") -/// inspect(values[1].getValueRepr(), content="20") -/// inspect(values[2].getValueRepr(), content="30") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, []) +/// let fval = mod.addFunction(fty, "phi_values_demo") +/// let entry_bb = fval.addBasicBlock(name="entry") +/// let block1_bb = fval.addBasicBlock(name="block1") +/// let block2_bb = fval.addBasicBlock(name="block2") +/// let merge_bb = fval.addBasicBlock(name="merge") +/// let val1 = ctx.getConstInt32(10) +/// let val2 = ctx.getConstInt32(20) +/// let val3 = ctx.getConstInt32(30) +/// builder.setInsertPoint(merge_bb) +/// let phi = builder.createPHI(i32_ty, name="result") +/// phi.addIncoming(val1, entry_bb) +/// phi.addIncoming(val2, block1_bb) +/// phi.addIncoming(val3, block2_bb) +/// let values = phi.getIncomingValues() +/// inspect(values.length(), content="3") +/// inspect(values[0].getValueRepr(), content="10") +/// inspect(values[1].getValueRepr(), content="20") +/// inspect(values[2].getValueRepr(), content="30") +/// } /// ``` pub fn PHINode::getIncomingValues(self : PHINode) -> Array[&Value] { self.incomings.map(incoming => incoming.0) @@ -4060,30 +4157,32 @@ pub fn PHINode::getIncomingValues(self : PHINode) -> Array[&Value] { /// /// Returns an array containing only the basic blocks from all incoming value-block pairs, in the order they were added. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, []) -/// let fval = mod.addFunction(fty, "phi_blocks_demo") -/// let entry_bb = fval.addBasicBlock(name="entry") -/// let block1_bb = fval.addBasicBlock(name="block1") -/// let block2_bb = fval.addBasicBlock(name="block2") -/// let merge_bb = fval.addBasicBlock(name="merge") -/// let val1 = ctx.getConstInt32(10) -/// let val2 = ctx.getConstInt32(20) -/// let val3 = ctx.getConstInt32(30) -/// builder.setInsertPoint(merge_bb) -/// let phi = builder.createPHI(i32_ty, name="result") -/// phi.addIncoming(val1, entry_bb) -/// phi.addIncoming(val2, block1_bb) -/// phi.addIncoming(val3, block2_bb) -/// let blocks = phi.getIncomingBlocks() -/// inspect(blocks.length(), content="3") -/// inspect(blocks[0].getValueRepr(), content="%entry") -/// inspect(blocks[1].getValueRepr(), content="%block1") -/// inspect(blocks[2].getValueRepr(), content="%block2") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, []) +/// let fval = mod.addFunction(fty, "phi_blocks_demo") +/// let entry_bb = fval.addBasicBlock(name="entry") +/// let block1_bb = fval.addBasicBlock(name="block1") +/// let block2_bb = fval.addBasicBlock(name="block2") +/// let merge_bb = fval.addBasicBlock(name="merge") +/// let val1 = ctx.getConstInt32(10) +/// let val2 = ctx.getConstInt32(20) +/// let val3 = ctx.getConstInt32(30) +/// builder.setInsertPoint(merge_bb) +/// let phi = builder.createPHI(i32_ty, name="result") +/// phi.addIncoming(val1, entry_bb) +/// phi.addIncoming(val2, block1_bb) +/// phi.addIncoming(val3, block2_bb) +/// let blocks = phi.getIncomingBlocks() +/// inspect(blocks.length(), content="3") +/// inspect(blocks[0].getValueRepr(), content="%entry") +/// inspect(blocks[1].getValueRepr(), content="%block1") +/// inspect(blocks[2].getValueRepr(), content="%block2") +/// } /// ``` pub fn PHINode::getIncomingBlocks(self : PHINode) -> Array[BasicBlock] { self.incomings.map(incoming => incoming.1) @@ -4097,32 +4196,34 @@ pub fn PHINode::getIncomingBlocks(self : PHINode) -> Array[BasicBlock] { /// The value's type must match the PHI node's type. Will raise `LLVMValueError` if there is a type mismatch. /// The basic block represents the predecessor block from which this value flows into the PHI node. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, []) -/// let fval = mod.addFunction(fty, "phi_add_demo") -/// let entry_bb = fval.addBasicBlock(name="entry") -/// let block1_bb = fval.addBasicBlock(name="block1") -/// let block2_bb = fval.addBasicBlock(name="block2") -/// let merge_bb = fval.addBasicBlock(name="merge") -/// let val1 = ctx.getConstInt32(10) -/// let val2 = ctx.getConstInt32(20) -/// let val3 = ctx.getConstInt32(30) -/// builder.setInsertPoint(merge_bb) -/// let phi = builder.createPHI(i32_ty, name="result") -/// inspect(phi.getNumIncomingValues(), content="0") -/// phi.addIncoming(val1, entry_bb) -/// inspect(phi.getNumIncomingValues(), content="1") -/// inspect(phi.getIncomingValue(0).unwrap().getValueRepr(), content="10") -/// inspect(phi.getIncomingBlock(0).unwrap().getValueRepr(), content="%entry") -/// phi.addIncoming(val2, block1_bb) -/// phi.addIncoming(val3, block2_bb) -/// inspect(phi.getNumIncomingValues(), content="3") -/// let expected = " %result = phi i32 [ 10, %entry ], [ 20, %block1 ], [ 30, %block2 ]" -/// inspect(phi, content=expected) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, []) +/// let fval = mod.addFunction(fty, "phi_add_demo") +/// let entry_bb = fval.addBasicBlock(name="entry") +/// let block1_bb = fval.addBasicBlock(name="block1") +/// let block2_bb = fval.addBasicBlock(name="block2") +/// let merge_bb = fval.addBasicBlock(name="merge") +/// let val1 = ctx.getConstInt32(10) +/// let val2 = ctx.getConstInt32(20) +/// let val3 = ctx.getConstInt32(30) +/// builder.setInsertPoint(merge_bb) +/// let phi = builder.createPHI(i32_ty, name="result") +/// inspect(phi.getNumIncomingValues(), content="0") +/// phi.addIncoming(val1, entry_bb) +/// inspect(phi.getNumIncomingValues(), content="1") +/// inspect(phi.getIncomingValue(0).unwrap().getValueRepr(), content="10") +/// inspect(phi.getIncomingBlock(0).unwrap().getValueRepr(), content="%entry") +/// phi.addIncoming(val2, block1_bb) +/// phi.addIncoming(val3, block2_bb) +/// inspect(phi.getNumIncomingValues(), content="3") +/// let expected = " %result = phi i32 [ 10, %entry ], [ 20, %block1 ], [ 30, %block2 ]" +/// inspect(phi, content=expected) +/// } /// ``` pub fn PHINode::addIncoming( self : PHINode, @@ -4147,19 +4248,21 @@ pub impl Value for PHINode with getValueBase(self) { ///| /// Get simple representation of the value. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, []) -/// let fval = mod.addFunction(fty, "phi_demo") -/// let entry_bb = fval.addBasicBlock(name="entry") -/// builder.setInsertPoint(entry_bb) -/// let phi = builder.createPHI(i32_ty) -/// inspect(phi.getValueRepr(), content="%0") -/// phi.setName("result") -/// inspect(phi.getValueRepr(), content="%result") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, []) +/// let fval = mod.addFunction(fty, "phi_demo") +/// let entry_bb = fval.addBasicBlock(name="entry") +/// builder.setInsertPoint(entry_bb) +/// let phi = builder.createPHI(i32_ty) +/// inspect(phi.getValueRepr(), content="%0") +/// phi.setName("result") +/// inspect(phi.getValueRepr(), content="%result") +/// } /// ``` pub impl Value for PHINode with getValueRepr(self) { match self.getNameOrSlot() { @@ -4176,19 +4279,21 @@ pub impl Value for PHINode with getValueRepr(self) { /// /// If the instruction has no name, return `None`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, []) -/// let fval = mod.addFunction(fty, "phi_demo") -/// let entry_bb = fval.addBasicBlock(name="entry") -/// builder.setInsertPoint(entry_bb) -/// let phi = builder.createPHI(i32_ty) -/// inspect(phi.getName(), content="None") -/// phi.setName("result") -/// inspect(phi.getName(), content="Some(\"result\")") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, []) +/// let fval = mod.addFunction(fty, "phi_demo") +/// let entry_bb = fval.addBasicBlock(name="entry") +/// builder.setInsertPoint(entry_bb) +/// let phi = builder.createPHI(i32_ty) +/// inspect(phi.getName(), content="None") +/// phi.setName("result") +/// inspect(phi.getName(), content="Some(\"result\")") +/// } /// ``` pub impl Value for PHINode with getName(self) { self.name @@ -4202,19 +4307,21 @@ pub impl Value for PHINode with getName(self) { /// If the name has already been used in the parent function, /// it will raise Error. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let fty = ctx.getFunctionType(i32_ty, []) -/// let fval = mod.addFunction(fty, "phi_demo") -/// let merge_bb = fval.addBasicBlock(name="merge") -/// builder.setInsertPoint(merge_bb) -/// let phi = builder.createPHI(i32_ty) -/// inspect(phi.getName(), content="None") -/// phi.setName("result") -/// inspect(phi.getName(), content="Some(\"result\")") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let fty = ctx.getFunctionType(i32_ty, []) +/// let fval = mod.addFunction(fty, "phi_demo") +/// let merge_bb = fval.addBasicBlock(name="merge") +/// builder.setInsertPoint(merge_bb) +/// let phi = builder.createPHI(i32_ty) +/// inspect(phi.getName(), content="None") +/// phi.setName("result") +/// inspect(phi.getName(), content="Some(\"result\")") +/// } /// ``` pub impl Value for PHINode with setName(self, name) { match self.getParent().setSymbol(name, self) { @@ -4346,26 +4453,28 @@ pub impl Show for TailCallKind with output(self, logger) { /// /// Use `IRBuilder::createCall` to create a `CallInst`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let add_fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) -/// let main_fty = ctx.getFunctionType(i32_ty, []) -/// let add_func = mod.addFunction(add_fty, "add") -/// let main_func = mod.addFunction(main_fty, "main") -/// let bb = main_func.addBasicBlock(name="entry") -/// let arg1 = ctx.getConstInt32(10) -/// let arg2 = ctx.getConstInt32(20) -/// builder.setInsertPoint(bb) -/// let call = builder.createCall(add_func, [arg1, arg2], name="sum") -/// inspect(call, content=" %sum = call i32 @add(i32 10, i32 20)") -/// assert_true(call.asValueEnum() is CallInst(_)) -/// let void_fty = ctx.getFunctionType(ctx.getVoidTy(), []) -/// let void_func = mod.addFunction(void_fty, "void_func") -/// let void_call = builder.createCall(void_func, []) -/// inspect(void_call, content=" call void @void_func()") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let add_fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) +/// let main_fty = ctx.getFunctionType(i32_ty, []) +/// let add_func = mod.addFunction(add_fty, "add") +/// let main_func = mod.addFunction(main_fty, "main") +/// let bb = main_func.addBasicBlock(name="entry") +/// let arg1 = ctx.getConstInt32(10) +/// let arg2 = ctx.getConstInt32(20) +/// builder.setInsertPoint(bb) +/// let call = builder.createCall(add_func, [arg1, arg2], name="sum") +/// inspect(call, content=" %sum = call i32 @add(i32 10, i32 20)") +/// assert_true(call.asValueEnum() is CallInst(_)) +/// let void_fty = ctx.getFunctionType(ctx.getVoidTy(), []) +/// let void_func = mod.addFunction(void_fty, "void_func") +/// let void_call = builder.createCall(void_func, []) +/// inspect(void_call, content=" call void @void_func()") +/// } /// ``` pub struct CallInst { uid : UInt64 @@ -4514,23 +4623,25 @@ pub impl Value for CallInst with asValueEnum(self) { ///| /// Get simple representation of the value. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let add_fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) -/// let main_fty = ctx.getFunctionType(i32_ty, []) -/// let add_func = mod.addFunction(add_fty, "add") -/// let main_func = mod.addFunction(main_fty, "main") -/// let bb = main_func.addBasicBlock(name="entry") -/// let arg1 = ctx.getConstInt32(10) -/// let arg2 = ctx.getConstInt32(20) -/// builder.setInsertPoint(bb) -/// let call = builder.createCall(add_func, [arg1, arg2]) -/// inspect(call.getValueRepr(), content="%0") -/// call.setName("sum") -/// inspect(call.getValueRepr(), content="%sum") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let add_fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) +/// let main_fty = ctx.getFunctionType(i32_ty, []) +/// let add_func = mod.addFunction(add_fty, "add") +/// let main_func = mod.addFunction(main_fty, "main") +/// let bb = main_func.addBasicBlock(name="entry") +/// let arg1 = ctx.getConstInt32(10) +/// let arg2 = ctx.getConstInt32(20) +/// builder.setInsertPoint(bb) +/// let call = builder.createCall(add_func, [arg1, arg2]) +/// inspect(call.getValueRepr(), content="%0") +/// call.setName("sum") +/// inspect(call.getValueRepr(), content="%sum") +/// } /// ``` pub impl Value for CallInst with getValueRepr(self) { if self.vty.asTypeEnum() is VoidType(_) { @@ -4550,23 +4661,25 @@ pub impl Value for CallInst with getValueRepr(self) { /// /// If the instruction has no name, return `None`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let add_fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) -/// let main_fty = ctx.getFunctionType(i32_ty, []) -/// let add_func = mod.addFunction(add_fty, "add") -/// let main_func = mod.addFunction(main_fty, "main") -/// let bb = main_func.addBasicBlock(name="entry") -/// let arg1 = ctx.getConstInt32(10) -/// let arg2 = ctx.getConstInt32(20) -/// builder.setInsertPoint(bb) -/// let call = builder.createCall(add_func, [arg1, arg2]) -/// inspect(call.getName(), content="None") -/// call.setName("sum") -/// inspect(call.getName(), content="Some(\"sum\")") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let add_fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) +/// let main_fty = ctx.getFunctionType(i32_ty, []) +/// let add_func = mod.addFunction(add_fty, "add") +/// let main_func = mod.addFunction(main_fty, "main") +/// let bb = main_func.addBasicBlock(name="entry") +/// let arg1 = ctx.getConstInt32(10) +/// let arg2 = ctx.getConstInt32(20) +/// builder.setInsertPoint(bb) +/// let call = builder.createCall(add_func, [arg1, arg2]) +/// inspect(call.getName(), content="None") +/// call.setName("sum") +/// inspect(call.getName(), content="Some(\"sum\")") +/// } /// ``` pub impl Value for CallInst with getName(self) { self.name @@ -4595,23 +4708,25 @@ pub impl Value for CallInst with getNameOrSlot(self) { /// If the name has already been used in the parent function, /// it will raise Error. Cannot set name for CallInst with void return type. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let add_fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) -/// let main_fty = ctx.getFunctionType(i32_ty, []) -/// let add_func = mod.addFunction(add_fty, "add") -/// let main_func = mod.addFunction(main_fty, "main") -/// let bb = main_func.addBasicBlock(name="entry") -/// let arg1 = ctx.getConstInt32(10) -/// let arg2 = ctx.getConstInt32(20) -/// builder.setInsertPoint(bb) -/// let call = builder.createCall(add_func, [arg1, arg2]) -/// inspect(call.getName(), content="None") -/// call.setName("sum") -/// inspect(call.getName(), content="Some(\"sum\")") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let add_fty = ctx.getFunctionType(i32_ty, [i32_ty, i32_ty]) +/// let main_fty = ctx.getFunctionType(i32_ty, []) +/// let add_func = mod.addFunction(add_fty, "add") +/// let main_func = mod.addFunction(main_fty, "main") +/// let bb = main_func.addBasicBlock(name="entry") +/// let arg1 = ctx.getConstInt32(10) +/// let arg2 = ctx.getConstInt32(20) +/// builder.setInsertPoint(bb) +/// let call = builder.createCall(add_func, [arg1, arg2]) +/// inspect(call.getName(), content="None") +/// call.setName("sum") +/// inspect(call.getName(), content="Some(\"sum\")") +/// } /// ``` pub impl Value for CallInst with setName(self, name) { if self.vty.asTypeEnum() is VoidType(_) { @@ -4775,20 +4890,22 @@ pub impl Show for CallInst with output(self, logger) { /// /// Use `IRBuilder::createExtractValue` to create an `ExtractValueInst`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let struct_ty = ctx.getStructType([i32_ty, i32_ty]) -/// let fty = ctx.getFunctionType(i32_ty, [struct_ty]) -/// let fval = mod.addFunction(fty, "extractvalue_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let aggregate = fval.getArg(0).unwrap() -/// builder.setInsertPoint(bb) -/// let extract = builder.createExtractValue(aggregate, [0], name="field") -/// inspect(extract, content=" %field = extractvalue { i32, i32 } %0, 0") -/// assert_true(extract.asValueEnum() is ExtractValueInst(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let struct_ty = ctx.getStructType([i32_ty, i32_ty]) +/// let fty = ctx.getFunctionType(i32_ty, [struct_ty]) +/// let fval = mod.addFunction(fty, "extractvalue_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let aggregate = fval.getArg(0).unwrap() +/// builder.setInsertPoint(bb) +/// let extract = builder.createExtractValue(aggregate, [0], name="field") +/// inspect(extract, content=" %field = extractvalue { i32, i32 } %0, 0") +/// assert_true(extract.asValueEnum() is ExtractValueInst(_)) +/// } /// ``` pub struct ExtractValueInst { uid : UInt64 @@ -4854,21 +4971,23 @@ pub impl Value for ExtractValueInst with getValueBase(self) { ///| /// Get simple representation of the value. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let struct_ty = ctx.getStructType([i32_ty, i32_ty]) -/// let fty = ctx.getFunctionType(i32_ty, [struct_ty]) -/// let fval = mod.addFunction(fty, "extractvalue_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let aggregate = fval.getArg(0).unwrap() -/// builder.setInsertPoint(bb) -/// let extract = builder.createExtractValue(aggregate, [0]) -/// inspect(extract.getValueRepr(), content="%1") -/// extract.setName("field") -/// inspect(extract.getValueRepr(), content="%field") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let struct_ty = ctx.getStructType([i32_ty, i32_ty]) +/// let fty = ctx.getFunctionType(i32_ty, [struct_ty]) +/// let fval = mod.addFunction(fty, "extractvalue_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let aggregate = fval.getArg(0).unwrap() +/// builder.setInsertPoint(bb) +/// let extract = builder.createExtractValue(aggregate, [0]) +/// inspect(extract.getValueRepr(), content="%1") +/// extract.setName("field") +/// inspect(extract.getValueRepr(), content="%field") +/// } /// ``` pub impl Value for ExtractValueInst with getValueRepr(self) { match self.getNameOrSlot() { @@ -4890,21 +5009,23 @@ pub impl Value for ExtractValueInst with asValueEnum(self) { /// /// If the instruction has no name, return `None`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let struct_ty = ctx.getStructType([i32_ty, i32_ty]) -/// let fty = ctx.getFunctionType(i32_ty, [struct_ty]) -/// let fval = mod.addFunction(fty, "extractvalue_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let aggregate = fval.getArg(0).unwrap() -/// builder.setInsertPoint(bb) -/// let extract = builder.createExtractValue(aggregate, [0]) -/// inspect(extract.getName(), content="None") -/// extract.setName("field") -/// inspect(extract.getName(), content="Some(\"field\")") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let struct_ty = ctx.getStructType([i32_ty, i32_ty]) +/// let fty = ctx.getFunctionType(i32_ty, [struct_ty]) +/// let fval = mod.addFunction(fty, "extractvalue_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let aggregate = fval.getArg(0).unwrap() +/// builder.setInsertPoint(bb) +/// let extract = builder.createExtractValue(aggregate, [0]) +/// inspect(extract.getName(), content="None") +/// extract.setName("field") +/// inspect(extract.getName(), content="Some(\"field\")") +/// } /// ``` pub impl Value for ExtractValueInst with getName(self) { self.name @@ -4918,21 +5039,23 @@ pub impl Value for ExtractValueInst with getName(self) { /// If the name has already been used in the parent function, /// it will raise Error. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let struct_ty = ctx.getStructType([i32_ty, i32_ty]) -/// let fty = ctx.getFunctionType(i32_ty, [struct_ty]) -/// let fval = mod.addFunction(fty, "extractvalue_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let aggregate = fval.getArg(0).unwrap() -/// builder.setInsertPoint(bb) -/// let extract = builder.createExtractValue(aggregate, [0]) -/// inspect(extract.getName(), content="None") -/// extract.setName("field") -/// inspect(extract.getName(), content="Some(\"field\")") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let struct_ty = ctx.getStructType([i32_ty, i32_ty]) +/// let fty = ctx.getFunctionType(i32_ty, [struct_ty]) +/// let fval = mod.addFunction(fty, "extractvalue_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let aggregate = fval.getArg(0).unwrap() +/// builder.setInsertPoint(bb) +/// let extract = builder.createExtractValue(aggregate, [0]) +/// inspect(extract.getName(), content="None") +/// extract.setName("field") +/// inspect(extract.getName(), content="Some(\"field\")") +/// } /// ``` pub impl Value for ExtractValueInst with setName(self, name) { match self.getParent().setSymbol(name, self) { @@ -5035,26 +5158,28 @@ pub impl Show for ExtractValueInst with output(self, logger) { /// /// Use `IRBuilder::createInsertValue` to create an `InsertValueInst`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let struct_ty = ctx.getStructType([i32_ty, i32_ty]) -/// let fty = ctx.getFunctionType(struct_ty, [struct_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "insertvalue_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let aggregate = fval.getArg(0).unwrap() -/// let new_value = fval.getArg(1).unwrap() -/// builder.setInsertPoint(bb) -/// let insert = builder.createInsertValue( -/// aggregate, -/// new_value, -/// [1], -/// name="updated", -/// ) -/// inspect(insert, content=" %updated = insertvalue { i32, i32 } %0, i32 %1, 1") -/// assert_true(insert.asValueEnum() is InsertValueInst(_)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let struct_ty = ctx.getStructType([i32_ty, i32_ty]) +/// let fty = ctx.getFunctionType(struct_ty, [struct_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "insertvalue_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let aggregate = fval.getArg(0).unwrap() +/// let new_value = fval.getArg(1).unwrap() +/// builder.setInsertPoint(bb) +/// let insert = builder.createInsertValue( +/// aggregate, +/// new_value, +/// [1], +/// name="updated", +/// ) +/// inspect(insert, content=" %updated = insertvalue { i32, i32 } %0, i32 %1, 1") +/// assert_true(insert.asValueEnum() is InsertValueInst(_)) +/// } /// ``` pub struct InsertValueInst { uid : UInt64 @@ -5136,22 +5261,24 @@ pub impl Value for InsertValueInst with asValueEnum(self) { ///| /// Get simple representation of the value. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let struct_ty = ctx.getStructType([i32_ty, i32_ty]) -/// let fty = ctx.getFunctionType(struct_ty, [struct_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "insertvalue_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let aggregate = fval.getArg(0).unwrap() -/// let new_value = fval.getArg(1).unwrap() -/// builder.setInsertPoint(bb) -/// let insert = builder.createInsertValue(aggregate, new_value, [1]) -/// inspect(insert.getValueRepr(), content="%2") -/// insert.setName("updated") -/// inspect(insert.getValueRepr(), content="%updated") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let struct_ty = ctx.getStructType([i32_ty, i32_ty]) +/// let fty = ctx.getFunctionType(struct_ty, [struct_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "insertvalue_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let aggregate = fval.getArg(0).unwrap() +/// let new_value = fval.getArg(1).unwrap() +/// builder.setInsertPoint(bb) +/// let insert = builder.createInsertValue(aggregate, new_value, [1]) +/// inspect(insert.getValueRepr(), content="%2") +/// insert.setName("updated") +/// inspect(insert.getValueRepr(), content="%updated") +/// } /// ``` pub impl Value for InsertValueInst with getValueRepr(self) { match self.getNameOrSlot() { @@ -5168,22 +5295,24 @@ pub impl Value for InsertValueInst with getValueRepr(self) { /// /// If the instruction has no name, return `None`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let struct_ty = ctx.getStructType([i32_ty, i32_ty]) -/// let fty = ctx.getFunctionType(struct_ty, [struct_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "insertvalue_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let aggregate = fval.getArg(0).unwrap() -/// let new_value = fval.getArg(1).unwrap() -/// builder.setInsertPoint(bb) -/// let insert = builder.createInsertValue(aggregate, new_value, [1]) -/// inspect(insert.getName(), content="None") -/// insert.setName("updated") -/// inspect(insert.getName(), content="Some(\"updated\")") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let struct_ty = ctx.getStructType([i32_ty, i32_ty]) +/// let fty = ctx.getFunctionType(struct_ty, [struct_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "insertvalue_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let aggregate = fval.getArg(0).unwrap() +/// let new_value = fval.getArg(1).unwrap() +/// builder.setInsertPoint(bb) +/// let insert = builder.createInsertValue(aggregate, new_value, [1]) +/// inspect(insert.getName(), content="None") +/// insert.setName("updated") +/// inspect(insert.getName(), content="Some(\"updated\")") +/// } /// ``` pub impl Value for InsertValueInst with getName(self) { self.name @@ -5197,22 +5326,24 @@ pub impl Value for InsertValueInst with getName(self) { /// If the name has already been used in the parent function, /// it will raise Error. /// -/// ```mbt test -/// let ctx = Context::new() -/// let mod = ctx.addModule("demo") -/// let builder = ctx.createBuilder() -/// let i32_ty = ctx.getInt32Ty() -/// let struct_ty = ctx.getStructType([i32_ty, i32_ty]) -/// let fty = ctx.getFunctionType(struct_ty, [struct_ty, i32_ty]) -/// let fval = mod.addFunction(fty, "insertvalue_demo") -/// let bb = fval.addBasicBlock(name="entry") -/// let aggregate = fval.getArg(0).unwrap() -/// let new_value = fval.getArg(1).unwrap() -/// builder.setInsertPoint(bb) -/// let insert = builder.createInsertValue(aggregate, new_value, [1]) -/// inspect(insert.getName(), content="None") -/// insert.setName("updated") -/// inspect(insert.getName(), content="Some(\"updated\")") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let mod = ctx.addModule("demo") +/// let builder = ctx.createBuilder() +/// let i32_ty = ctx.getInt32Ty() +/// let struct_ty = ctx.getStructType([i32_ty, i32_ty]) +/// let fty = ctx.getFunctionType(struct_ty, [struct_ty, i32_ty]) +/// let fval = mod.addFunction(fty, "insertvalue_demo") +/// let bb = fval.addBasicBlock(name="entry") +/// let aggregate = fval.getArg(0).unwrap() +/// let new_value = fval.getArg(1).unwrap() +/// builder.setInsertPoint(bb) +/// let insert = builder.createInsertValue(aggregate, new_value, [1]) +/// inspect(insert.getName(), content="None") +/// insert.setName("updated") +/// inspect(insert.getName(), content="Some(\"updated\")") +/// } /// ``` pub impl Value for InsertValueInst with setName(self, name) { match self.getParent().setSymbol(name, self) { diff --git a/IR/Type.mbt b/IR/Type.mbt index 2248402..1111300 100644 --- a/IR/Type.mbt +++ b/IR/Type.mbt @@ -474,17 +474,19 @@ impl Type with tryAsAbstractTypeEnum(self) -> AbstractTypeEnum? { ///| /// Collection of Int1Type, Int8Type, Int16Type, Int32Type, Int64Type /// -/// ```mbt test -/// let ctx = Context::new() -/// let i8ty : &IntegerType = ctx.getInt8Ty() -/// assert_eq(i8ty.getBitWidth(), 8) -/// inspect(i8ty.getExtendedType().unwrap(), content="i16") -/// assert_eq(i8ty.getBitMask(), 0xFF) -/// assert_eq(i8ty.getExtendedType().unwrap().getSignBit(), 0x8000) -/// let i32ty = i8ty.getExtendedType().unwrap().getExtendedType().unwrap() -/// inspect(i32ty, content="i32") -/// guard i32ty.asIntegerTypeEnum() is Int32Type(i32ty) -/// inspect(i32ty, content="i32") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let i8ty : &IntegerType = ctx.getInt8Ty() +/// assert_eq(i8ty.getBitWidth(), 8) +/// inspect(i8ty.getExtendedType().unwrap(), content="i16") +/// assert_eq(i8ty.getBitMask(), 0xFF) +/// assert_eq(i8ty.getExtendedType().unwrap().getSignBit(), 0x8000) +/// let i32ty = i8ty.getExtendedType().unwrap().getExtendedType().unwrap() +/// inspect(i32ty, content="i32") +/// guard i32ty.asIntegerTypeEnum() is Int32Type(i32ty) +/// inspect(i32ty, content="i32") +/// } /// ``` pub trait IntegerType: PrimitiveType { asIntegerTypeEnum(Self) -> IntegerTypeEnum @@ -981,9 +983,11 @@ pub impl PrimitiveType for FP128Type with asPrimitiveTypeEnum(self) -> Primitive /// /// - See LLVM: `Type::getInt1Ty`. /// -/// ```mbt test -/// let ctx = Context::new() -/// inspect(ctx.getInt1Ty(), content="i1") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// inspect(ctx.getInt1Ty(), content="i1") +/// } /// ``` pub struct Int1Type { ctx : Context @@ -1028,9 +1032,11 @@ pub impl PrimitiveType for Int1Type with asPrimitiveTypeEnum(self) -> PrimitiveT /// /// - See LLVM: `Type::getInt8Ty`. /// -/// ```mbt test -/// let ctx = Context::new() -/// inspect(ctx.getInt8Ty(), content="i8") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// inspect(ctx.getInt8Ty(), content="i8") +/// } /// ``` pub struct Int8Type { ctx : Context @@ -1080,9 +1086,11 @@ pub impl PrimitiveType for Int8Type with asPrimitiveTypeEnum(self) -> PrimitiveT /// /// - See LLVM: `Type::getInt16Ty`. /// -/// ```mbt test -/// let ctx = Context::new() -/// inspect(ctx.getInt16Ty(), content="i16") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// inspect(ctx.getInt16Ty(), content="i16") +/// } /// ``` pub struct Int16Type { ctx : Context @@ -1132,9 +1140,11 @@ pub impl PrimitiveType for Int16Type with asPrimitiveTypeEnum(self) -> Primitive /// /// - See LLVM: `Type::getInt32Ty`. /// -/// ```mbt test -/// let ctx = Context::new() -/// inspect(ctx.getInt32Ty(), content="i32") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// inspect(ctx.getInt32Ty(), content="i32") +/// } /// ``` pub struct Int32Type { ctx : Context @@ -1184,9 +1194,11 @@ pub impl PrimitiveType for Int32Type with asPrimitiveTypeEnum(self) -> Primitive /// /// - See LLVM: `Type::getInt64Ty`. /// -/// ```mbt test -/// let ctx = Context::new() -/// inspect(ctx.getInt64Ty(), content="i64") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// inspect(ctx.getInt64Ty(), content="i64") +/// } /// ``` pub struct Int64Type { ctx : Context @@ -1237,10 +1249,12 @@ pub struct VoidType { /// /// - See LLVM: `Type::getVoidTy`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let voidty = ctx.getVoidTy() -/// inspect(voidty, content="void") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let voidty = ctx.getVoidTy() +/// inspect(voidty, content="void") +/// } /// ``` fn VoidType::new(ctx : Context) -> VoidType { VoidType::{ ctx, } @@ -1281,10 +1295,12 @@ pub struct LabelType { /// /// - See LLVM: `Type::getLabelTy`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let labelty = ctx.getLabelTy() -/// inspect(labelty, content="label") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let labelty = ctx.getLabelTy() +/// inspect(labelty, content="label") +/// } /// ``` fn LabelType::new(ctx : Context) -> LabelType { LabelType::{ ctx, } @@ -1324,10 +1340,12 @@ pub struct MetadataType { /// /// - See LLVM: `Type::getMetadataTy`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let metadataty = ctx.getMetadataTy() -/// inspect(metadataty, content="metadata") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let metadataty = ctx.getMetadataTy() +/// inspect(metadataty, content="metadata") +/// } /// ``` fn MetadataType::new(ctx : Context) -> MetadataType { MetadataType::{ ctx, } @@ -1368,10 +1386,12 @@ pub struct TokenType { /// /// - See LLVM: `Type::getTokenTy`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let tokenty = ctx.getTokenTy() -/// inspect(tokenty, content="token") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let tokenty = ctx.getTokenTy() +/// inspect(tokenty, content="token") +/// } /// ``` fn TokenType::new(ctx : Context) -> TokenType { TokenType::{ ctx, } @@ -1406,14 +1426,16 @@ pub impl AbstractType for TokenType with asAbstractTypeEnum(self) -> AbstractTyp /// /// See LLVM: `FunctionType::FunctionType`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let int32ty = ctx.getInt32Ty() -/// let voidty = ctx.getVoidTy() -/// let f32ty = ctx.getFloatTy() -/// let f64ty = ctx.getDoubleTy() -/// let fty = ctx.getFunctionType(voidty, [int32ty, f32ty, f64ty]) -/// inspect(fty, content="void (i32, float, double)") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let int32ty = ctx.getInt32Ty() +/// let voidty = ctx.getVoidTy() +/// let f32ty = ctx.getFloatTy() +/// let f64ty = ctx.getDoubleTy() +/// let fty = ctx.getFunctionType(voidty, [int32ty, f32ty, f64ty]) +/// inspect(fty, content="void (i32, float, double)") +/// } /// ``` pub struct FunctionType { ctx : Context @@ -1535,16 +1557,18 @@ pub impl AbstractType for FunctionType with asAbstractTypeEnum(self) -> Abstract /// /// - See LLVM: `StructType::get`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let i8ty = ctx.getInt8Ty() -/// let i16ty = ctx.getInt16Ty() -/// let i32ty = ctx.getInt32Ty() -/// let f32ty = ctx.getFloatTy() -/// let sty = ctx.getStructType([i32ty, f32ty], name="foo") -/// inspect(sty.full_info(), content="%foo = type { i32, float }") -/// let sty = ctx.getStructType([i8ty, i16ty], name="bar", isPacked=true) -/// inspect(sty.full_info(), content="%bar = type <{ i8, i16 }>") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let i8ty = ctx.getInt8Ty() +/// let i16ty = ctx.getInt16Ty() +/// let i32ty = ctx.getInt32Ty() +/// let f32ty = ctx.getFloatTy() +/// let sty = ctx.getStructType([i32ty, f32ty], name="foo") +/// inspect(sty.full_info(), content="%foo = type { i32, float }") +/// let sty = ctx.getStructType([i8ty, i16ty], name="bar", isPacked=true) +/// inspect(sty.full_info(), content="%bar = type <{ i8, i16 }>") +/// } /// ``` pub struct StructType { ctx : Context @@ -1597,14 +1621,16 @@ fn StructType::new( /// /// - See LLVM: `StructType::isLiteral`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let i32ty = ctx.getInt32Ty() -/// let f32ty = ctx.getFloatTy() -/// let foo = ctx.getStructType([i32ty, f32ty]) -/// let bar = ctx.getStructType([i32ty, f32ty], name="bar") -/// assert_true(foo.isLiteral()) -/// assert_false(bar.isLiteral()) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let i32ty = ctx.getInt32Ty() +/// let f32ty = ctx.getFloatTy() +/// let foo = ctx.getStructType([i32ty, f32ty]) +/// let bar = ctx.getStructType([i32ty, f32ty], name="bar") +/// assert_true(foo.isLiteral()) +/// assert_false(bar.isLiteral()) +/// } /// ``` pub fn StructType::isLiteral(self : StructType) -> Bool { self.name is None @@ -1617,14 +1643,16 @@ pub fn StructType::isLiteral(self : StructType) -> Bool { /// /// - See LLVM: `StructType::isOpaque`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let i32ty = ctx.getInt32Ty() -/// let f32ty = ctx.getFloatTy() -/// let foo = ctx.getStructType([], name="foo") -/// let bar = ctx.getStructType([i32ty, f32ty], name="bar") -/// assert_true(foo.isOpaque()) -/// assert_false(bar.isOpaque()) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let i32ty = ctx.getInt32Ty() +/// let f32ty = ctx.getFloatTy() +/// let foo = ctx.getStructType([], name="foo") +/// let bar = ctx.getStructType([i32ty, f32ty], name="bar") +/// assert_true(foo.isOpaque()) +/// assert_false(bar.isOpaque()) +/// } /// ``` pub fn StructType::isOpaque(self : StructType) -> Bool { self.elements.is_empty() @@ -1825,13 +1853,15 @@ pub impl AggregateType for StructType with asAggregateTypeEnum(self) -> Aggregat /// /// - See LLVM: `ArrayType::get`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let i32ty = ctx.getInt32Ty() -/// let arrty = ctx.getArrayType(i32ty, 16) -/// inspect(arrty, content="[16 x i32]") -/// assert_eq(arrty.getElementCount(), 16) -/// inspect(arrty.getElementType(), content="i32") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let i32ty = ctx.getInt32Ty() +/// let arrty = ctx.getArrayType(i32ty, 16) +/// inspect(arrty, content="[16 x i32]") +/// assert_eq(arrty.getElementCount(), 16) +/// inspect(arrty.getElementType(), content="i32") +/// } /// ``` pub struct ArrayType { ctx : Context @@ -1899,13 +1929,15 @@ pub impl AggregateType for ArrayType with asAggregateTypeEnum(self) -> Aggregate /// /// - See LLVM: `VectorType::get`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let i32ty = ctx.getInt32Ty() -/// let vecty = ctx.getFixedVectorType(i32ty, 16) -/// inspect(vecty, content="<16 x i32>") -/// assert_eq(vecty.getElementCount(), 16) -/// inspect(vecty.getElementType(), content="i32") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let i32ty = ctx.getInt32Ty() +/// let vecty = ctx.getFixedVectorType(i32ty, 16) +/// inspect(vecty, content="<16 x i32>") +/// assert_eq(vecty.getElementCount(), 16) +/// inspect(vecty.getElementType(), content="i32") +/// } /// ``` pub struct VectorType { ctx : Context @@ -1978,13 +2010,15 @@ pub impl AggregateType for VectorType with asAggregateTypeEnum(self) -> Aggregat /// /// - See LLVM: `ScalableVectorType::get`. /// -/// ```mbt test -/// let ctx = Context::new() -/// let f32ty = ctx.getFloatTy() -/// let vecty = ctx.getScalableVectorType(f32ty, 16) -/// inspect(vecty, content="") -/// assert_eq(vecty.getElementCount(), 16) -/// inspect(vecty.getElementType(), content="float") +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// let f32ty = ctx.getFloatTy() +/// let vecty = ctx.getScalableVectorType(f32ty, 16) +/// inspect(vecty, content="") +/// assert_eq(vecty.getElementCount(), 16) +/// inspect(vecty.getElementType(), content="float") +/// } /// ``` pub struct ScalableVectorType { ctx : Context @@ -2071,16 +2105,18 @@ pub fn AddressSpace::new(v : UInt) -> AddressSpace { /// In Moonbit Aether framework, we follow the design of LLVM20, so all pointer is /// also opaque pointer, and will not mark type for pointer. /// -/// ```mbt test -/// let ctx = Context::new() -/// inspect(ctx.getPtrTy(), content="ptr") -/// let addressSpace = AddressSpace::new(0) -/// let ptr = ctx.getPtrTy(addressSpace~) -/// inspect(ptr, content="ptr") -/// let i32ty = ctx.getInt32Ty() -/// assert_true(PointerType::isLoadableOrStorableType(i32ty)) -/// let voidty = ctx.getVoidTy() -/// assert_false(PointerType::isLoadableOrStorableType(voidty)) +/// ```mbt check +/// test { +/// let ctx = Context::new() +/// inspect(ctx.getPtrTy(), content="ptr") +/// let addressSpace = AddressSpace::new(0) +/// let ptr = ctx.getPtrTy(addressSpace~) +/// inspect(ptr, content="ptr") +/// let i32ty = ctx.getInt32Ty() +/// assert_true(PointerType::isLoadableOrStorableType(i32ty)) +/// let voidty = ctx.getVoidTy() +/// assert_false(PointerType::isLoadableOrStorableType(voidty)) +/// } /// ``` pub struct PointerType { ctx : Context diff --git a/moon.mod.json b/moon.mod.json index 7f287ef..955f1dc 100644 --- a/moon.mod.json +++ b/moon.mod.json @@ -2,7 +2,7 @@ "name": "Kaida-Amethyst/MoonLLVM", "version": "0.1.14", "deps": { - "moonbitlang/x": "0.4.31", + "moonbitlang/x": "0.4.38", "Kaida-Amethyst/either": "0.1.0" }, "readme": "README.md", @@ -13,4 +13,4 @@ "llvm" ], "description": "Moonbit version of LLVM, A Tiny, Friendly Companion to LLVM" -} +} \ No newline at end of file