Widen i128 constant storage

Status	File	+	-
M	`src/codegen/isel.rs`	3	2
M	`src/ir/builder.rs`	7	3
M	`src/ir/inst.rs`	3	3
M	`src/ir/lower.rs`	27	22
M	`src/opt/bce.rs`	1	1
M	`src/opt/const_arg.rs`	1	1
M	`src/opt/const_fold.rs`	41	32
M	`src/opt/const_prop.rs`	3	2
M	`src/opt/cse.rs`	15	15
M	`src/opt/dep_analysis.rs`	2	2
M	`src/opt/gvn.rs`	14	14
M	`src/opt/loop_utils.rs`	1	1
M	`src/opt/peel.rs`	1	1
M	`src/opt/return_prop.rs`	1	1
M	`src/opt/strength_reduce.rs`	4	2
M	`src/opt/unroll.rs`	4	4
M	`src/opt/vectorize.rs`	1	1
A	`tests/fixtures/integer16_wide_values.f90`	12	0
M	`tests/i128_ir.rs`	28	0

src/codegen/isel.rsmodified

              if let Some(idx) = indices.first() {
                  let idx_vreg = ctx.lookup_vreg(*idx);
                  let tmp = mf.new_vreg(RegClass::Gp64);
 -                emit_const_int(mf, mb, tmp, elem_size, IntWidth::I64);
 +                emit_const_int(mf, mb, tmp, elem_size as i128, IntWidth::I64);
                  let scaled = mf.new_vreg(RegClass::Gp64);
                  mf.block_mut(mb).insts.push(MachineInst {
                      opcode: ArmOpcode::Mul,
  /// Emit a constant integer using movz/movk sequence.
  /// Respects width: 32-bit values mask to 32 bits and only emit shifts 0/16.
 -fn emit_const_int(mf: &mut MachineFunction, mb: MBlockId, dest: VRegId, val: i64, width: IntWidth) {
 +fn emit_const_int(mf: &mut MachineFunction, mb: MBlockId, dest: VRegId, val: i128, width: IntWidth) {
 +    debug_assert!(width != IntWidth::I128, "backend should reject i128 before isel");
      let is_32 = matches!(width, IntWidth::I8 | IntWidth::I16 | IntWidth::I32);
      // Mask to the appropriate width to prevent sign-extension artifacts.
      let uval = if is_32 { (val as u32) as u64 } else { val as u64 };

src/ir/builder.rsmodified

      // ---- Constants ----
 -    pub fn const_int(&mut self, value: i64, width: IntWidth) -> ValueId {
 +    pub fn const_int(&mut self, value: i128, width: IntWidth) -> ValueId {
          self.emit(InstKind::ConstInt(value, width), IrType::Int(width))
+     }
      pub fn const_i32(&mut self, value: i32) -> ValueId {
 -        self.const_int(value as i64, IntWidth::I32)
 +        self.const_int(value as i128, IntWidth::I32)
+     }
      pub fn const_i64(&mut self, value: i64) -> ValueId {
 -        self.const_int(value, IntWidth::I64)
 +        self.const_int(value as i128, IntWidth::I64)
 +    }
++
 +    pub fn const_i128(&mut self, value: i128) -> ValueId {
 +        self.const_int(value, IntWidth::I128)
+     }
      pub fn const_float(&mut self, value: f64, width: FloatWidth) -> ValueId {

src/ir/inst.rsmodified

  #[derive(Debug, Clone)]
  pub enum InstKind {
      // ---- Constants ----
 -    ConstInt(i64, IntWidth),
 +    ConstInt(i128, IntWidth),
      ConstFloat(f64, FloatWidth),
      ConstBool(bool),
      ConstString(Vec<u8>),
  #[derive(Debug, Clone)]
  pub enum GlobalInit {
      Zero,
 -    Int(i64),
 +    Int(i128),
      Float(f64),
      String(Vec<u8>),
      /// Array literal: a sequence of per-element initializers of
      /// constructors. The Vec's length is the array's total element
      /// count (product of dims); shorter initializers are padded
      /// with Zero at lowering time.
 -    IntArray(Vec<i64>),
 +    IntArray(Vec<i128>),
      FloatArray(Vec<f64>),
+ }

src/ir/lower.rsmodified

  ///   2. `[(expr, i = lo, hi[, step])]` implied-do iterator
  ///   3. `reshape(constructor, shape)` reshape of (1) or (2)
  ///
 -/// Each path produces a flat list of `i64` (for integer types)
 +/// Each path produces a flat list of `i128` (for integer types)
  /// or `f64` (for float types) of length `total`. Shorter lists
  /// are zero-padded; longer lists return `None` (a future Maj-3
  /// fix will add a proper diagnostic for shape-mismatch errors).
          while (out.len() as i64) < total { out.push(0.0); }
          Some(GlobalInit::FloatArray(out))
      } else {
 -        let mut out: Vec<i64> = scalars.iter().map(|s| match s {
 +        let mut out: Vec<i128> = scalars.iter().map(|s| match s {
              ConstScalar::Int(i) => *i,
 -            ConstScalar::Float(f) => *f as i64,
 +            ConstScalar::Float(f) => *f as i128,
          }).collect();
          while (out.len() as i64) < total { out.push(0); }
          Some(GlobalInit::IntArray(out))
  /// global address + load.
  fn materialize_const_scalar(b: &mut FuncBuilder, c: ConstScalar, target: &IrType) -> ValueId {
      match (c, target) {
 -        (ConstScalar::Int(i), IrType::Int(IntWidth::I128)) => b.const_int(i, IntWidth::I128),
 -        (ConstScalar::Int(i), IrType::Int(IntWidth::I64)) => b.const_i64(i),
 +        (ConstScalar::Int(i), IrType::Int(IntWidth::I128)) => b.const_i128(i),
 +        (ConstScalar::Int(i), IrType::Int(IntWidth::I64)) => b.const_i64(i as i64),
          (ConstScalar::Int(i), IrType::Int(_)) => b.const_i32(i as i32),
          (ConstScalar::Int(i), IrType::Bool) => b.const_bool(i != 0),
          (ConstScalar::Int(i), IrType::Float(FloatWidth::F64)) => b.const_f64(i as f64),
          (ConstScalar::Int(i), IrType::Float(FloatWidth::F32)) => b.const_f32(i as f32),
          (ConstScalar::Float(f), IrType::Float(FloatWidth::F64)) => b.const_f64(f),
          (ConstScalar::Float(f), IrType::Float(FloatWidth::F32)) => b.const_f32(f as f32),
 -        (ConstScalar::Float(f), IrType::Int(IntWidth::I128)) => b.const_int(f as i64, IntWidth::I128),
 +        (ConstScalar::Float(f), IrType::Int(IntWidth::I128)) => b.const_i128(f as i128),
          (ConstScalar::Float(f), IrType::Int(IntWidth::I64)) => b.const_i64(f as i64),
          (ConstScalar::Float(f), IrType::Int(_)) => b.const_i32(f as i32),
          // Fallback — emit a zero of the target's class.
  fn clamp_const_to_type(v: ConstScalar, target: &IrType) -> ConstScalar {
      match (v, target) {
          (ConstScalar::Int(i), IrType::Int(IntWidth::I8)) => {
 -            ConstScalar::Int((i as i8) as i64)
 +            ConstScalar::Int((i as i8) as i128)
+         }
          (ConstScalar::Int(i), IrType::Int(IntWidth::I16)) => {
 -            ConstScalar::Int((i as i16) as i64)
 +            ConstScalar::Int((i as i16) as i128)
+         }
          (ConstScalar::Int(i), IrType::Int(IntWidth::I32)) => {
 -            ConstScalar::Int((i as i32) as i64)
 +            ConstScalar::Int((i as i32) as i128)
 +        }
 +        (ConstScalar::Int(i), IrType::Int(IntWidth::I64)) => {
 +            ConstScalar::Int((i as i64) as i128)
+         }
          (ConstScalar::Int(i), IrType::Bool) => {
              ConstScalar::Int(if i != 0 { 1 } else { 0 })
  /// used for real/double precision.
  #[derive(Debug, Clone, Copy)]
  enum ConstScalar {
 -    Int(i64),
 +    Int(i128),
      Float(f64),
+ }
  ) -> Option<ConstScalar> {
      use crate::ast::expr::{UnaryOp, BinaryOp};
      match &e.node {
 -        Expr::IntegerLiteral { text, .. } => text.parse::<i64>().ok().map(ConstScalar::Int),
 +        Expr::IntegerLiteral { text, .. } => text.parse::<i128>().ok().map(ConstScalar::Int),
          Expr::RealLiteral { text, .. } => {
              text.replace('d', "e").replace('D', "E").parse::<f64>().ok().map(ConstScalar::Float)
+         }
+                     }
                      BinaryOp::Pow => {
                          // Integer power with non-negative exponent.
 -                        if r < 0 || r > i32::MAX as i64 { return None; }
 -                        let mut acc: i64 = 1;
 +                        if r < 0 || r > i32::MAX as i128 { return None; }
 +                        let mut acc: i128 = 1;
                          for _ in 0..r { acc = acc.wrapping_mul(l); }
                          Some(ConstScalar::Int(acc))
+                     }
                                  by_ref: false,
                                  char_kind: CharKind::None,
                                  derived_type: None,
 -                                inline_const: Some(ConstScalar::Int(cv)),
 +                                inline_const: Some(ConstScalar::Int(cv as i128)),
                              });
                              installed_from.insert(local_key, mod_key);
+                         }
  ) -> ValueId {
      match &expr.node {
          Expr::IntegerLiteral { text, kind, .. } => {
 -            let val: i64 = text.parse().unwrap_or(0);
              let kind = kind.as_deref();
              if kind == Some("16") {
 -                b.const_int(val, IntWidth::I128)
 -            } else if kind == Some("8")
 -                || val > i32::MAX as i64
 -                || val < i32::MIN as i64
 -            {
 -                b.const_i64(val)
 +                b.const_i128(text.parse::<i128>().unwrap_or(0))
              } else {
 -                b.const_i32(val as i32)
 +                let val: i64 = text.parse().unwrap_or(0);
 +                if kind == Some("8")
 +                    || val > i32::MAX as i64
 +                    || val < i32::MIN as i64
 +                {
 +                    b.const_i64(val)
 +                } else {
 +                    b.const_i32(val as i32)
 +                }
+             }
+         }
          Expr::RealLiteral { text, .. } => {

src/opt/bce.rsmodified

  fn resolve_int_scalar(func: &Function, value: ValueId) -> Option<i64> {
      let kind = find_inst_kind(func, value)?;
      match kind {
 -        InstKind::ConstInt(v, _) => Some(*v),
 +        InstKind::ConstInt(v, _) => i64::try_from(*v).ok(),
          InstKind::IntExtend(src, _, _) | InstKind::IntTrunc(src, _) => {
              resolve_int_scalar(func, *src)
+         }

src/opt/const_arg.rsmodified

  #[derive(Debug, Clone, Copy, PartialEq, Eq)]
  enum ScalarConst {
 -    Int(i64, IntWidth),
 +    Int(i128, IntWidth),
      Float(u64, FloatWidth),
      Bool(bool),
+ }

src/opt/const_fold.rsmodified

  /// Compile-time constant value, normalized for folding.
  #[derive(Debug, Clone, Copy)]
  enum Const {
 -    Int(i64, IntWidth),
 +    Int(i128, IntWidth),
      Float(f64, FloatWidth),
      Bool(bool),
+ }
+     }
+ }
 -/// Sign-extend `v` from `bits` to a full i64. Used so that comparisons
 +/// Sign-extend `v` from `bits` to a full i128. Used so that comparisons
  /// and arithmetic on narrower integer types match hardware behavior.
 -fn sext(v: i64, bits: u32) -> i64 {
 -    if bits >= 64 { v }
 +fn sext(v: i128, bits: u32) -> i128 {
 +    if bits >= 128 { v }
      else {
 -        let shift = 64 - bits;
 +        let shift = 128 - bits;
          (v << shift) >> shift
+     }
+ }
 -/// Mask `v` down to `bits` low bits. The IR stores integers as i64 but
 +/// Mask `v` down to `bits` low bits. The IR stores integers as i128 but
  /// arithmetic must wrap at the declared width.
 -fn mask(v: i64, bits: u32) -> i64 {
 -    if bits >= 64 { v }
 -    else { v & ((1i64 << bits) - 1) }
 +fn mask(v: i128, bits: u32) -> i128 {
 +    if bits >= 128 { v }
 +    else { v & ((1i128 << bits) - 1) }
+ }
  /// Truncate-then-sign-extend a wide arithmetic result back to its
 -/// declared width, normalized to a sign-extended i64.
 -fn norm(v: i64, w: IntWidth) -> i64 {
 +/// declared width, normalized to a sign-extended i128.
 +fn norm(v: i128, w: IntWidth) -> i128 {
      sext(mask(v, w.bits()), w.bits())
+ }
 +fn signed_min(w: IntWidth) -> i128 {
 +    match w {
 +        IntWidth::I8 => i8::MIN as i128,
 +        IntWidth::I16 => i16::MIN as i128,
 +        IntWidth::I32 => i32::MIN as i128,
 +        IntWidth::I64 => i64::MIN as i128,
 +        IntWidth::I128 => i128::MIN,
 +    }
 +}
++
  /// Round an `f64`-stored value to the precision of its declared
  /// `FloatWidth`. Audit B-3: used as defense in depth in `FCmp` and
  /// `FloatToInt` so that those folds don't silently miscompute when
+         }
          InstKind::IDiv(a, b) => {
              if let (Some(Const::Int(av, _)), Some(Const::Int(bv, _))) = (get(a), get(b)) {
 -                if bv == 0 { return None; } // leave divide-by-zero to runtime
 -                // i64::MIN / -1 also overflows; bail to keep behavior identical.
 -                if av == i64::MIN && bv == -1 { return None; }
                  if let IrType::Int(w) = ty {
 +                    if bv == 0 { return None; } // leave divide-by-zero to runtime
 +                    if av == signed_min(*w) && bv == -1 { return None; }
                      return Some(InstKind::ConstInt(norm(av / bv, *w), *w));
+                 }
+             }
+         }
          InstKind::IMod(a, b) => {
              if let (Some(Const::Int(av, _)), Some(Const::Int(bv, _))) = (get(a), get(b)) {
 -                if bv == 0 { return None; }
 -                if av == i64::MIN && bv == -1 { return None; }
                  if let IrType::Int(w) = ty {
 +                    if bv == 0 { return None; }
 +                    if av == signed_min(*w) && bv == -1 { return None; }
                      return Some(InstKind::ConstInt(norm(av % bv, *w), *w));
+                 }
+             }
          InstKind::Shl(a, b) => {
              if let (Some(Const::Int(av, _)), Some(Const::Int(bv, _))) = (get(a), get(b)) {
                  if let IrType::Int(w) = ty {
 -                    let bits = w.bits() as i64;
 +                    let bits = w.bits() as i128;
                      if (0..bits).contains(&bv) {
                          return Some(InstKind::ConstInt(
                              norm(av.wrapping_shl(bv as u32), *w),
          InstKind::LShr(a, b) => {
              if let (Some(Const::Int(av, _)), Some(Const::Int(bv, _))) = (get(a), get(b)) {
                  if let IrType::Int(w) = ty {
 -                    let bits = w.bits() as i64;
 +                    let bits = w.bits() as i128;
                      if (0..bits).contains(&bv) {
 -                        let unsigned = (mask(av, w.bits()) as u64) >> (bv as u32);
 -                        return Some(InstKind::ConstInt(norm(unsigned as i64, *w), *w));
 +                        let unsigned = (mask(av, w.bits()) as u128) >> (bv as u32);
 +                        return Some(InstKind::ConstInt(norm(unsigned as i128, *w), *w));
+                     }
                      return None;
+                 }
          InstKind::AShr(a, b) => {
              if let (Some(Const::Int(av, _)), Some(Const::Int(bv, _))) = (get(a), get(b)) {
                  if let IrType::Int(w) = ty {
 -                    let bits = w.bits() as i64;
 +                    let bits = w.bits() as i128;
                      if (0..bits).contains(&bv) {
                          let signed = sext(av, w.bits()) >> (bv as u32);
                          return Some(InstKind::ConstInt(norm(signed, *w), *w));
          // produce a wrong-width constant if we kept reading from `w`.
          InstKind::PopCount(a) => {
              if let (Some(Const::Int(av, src_w)), IrType::Int(out_w)) = (get(a), ty) {
 -                let val = mask(av, src_w.bits()) as u64;
 -                return Some(InstKind::ConstInt(norm(val.count_ones() as i64, *out_w), *out_w));
 +                let val = mask(av, src_w.bits()) as u128;
 +                return Some(InstKind::ConstInt(norm(val.count_ones() as i128, *out_w), *out_w));
+             }
              None
+         }
          InstKind::CountLeadingZeros(a) => {
              if let (Some(Const::Int(av, src_w)), IrType::Int(out_w)) = (get(a), ty) {
                  let bits = src_w.bits();
 -                let val = mask(av, bits) as u64;
 +                let val = mask(av, bits) as u128;
                  let lz = if val == 0 {
 -                    bits as i64
 +                    bits as i128
                  } else {
 -                    (val.leading_zeros() as i64) - (64 - bits as i64)
 +                    (val.leading_zeros() as i128) - (128 - bits as i128)
                  };
                  return Some(InstKind::ConstInt(norm(lz, *out_w), *out_w));
+             }
          InstKind::CountTrailingZeros(a) => {
              if let (Some(Const::Int(av, src_w)), IrType::Int(out_w)) = (get(a), ty) {
                  let bits = src_w.bits();
 -                let val = mask(av, bits) as u64;
 -                let tz = if val == 0 { bits as i64 } else { val.trailing_zeros() as i64 };
 +                let val = mask(av, bits) as u128;
 +                let tz = if val == 0 { bits as i128 } else { val.trailing_zeros() as i128 };
                  return Some(InstKind::ConstInt(norm(tz, *out_w), *out_w));
+             }
              None
                      IntWidth::I16 => i16::MIN as f64,
                      IntWidth::I32 => i32::MIN as f64,
                      IntWidth::I64 => i64::MIN as f64,
 -                    IntWidth::I128 => i64::MIN as f64,
 +                    IntWidth::I128 => return None,
                  };
                  let hi = match w {
                      IntWidth::I8  => i8::MAX  as f64,
                      IntWidth::I16 => i16::MAX as f64,
                      IntWidth::I32 => i32::MAX as f64,
                      IntWidth::I64 => i64::MAX as f64,
 -                    IntWidth::I128 => i64::MAX as f64,
 +                    IntWidth::I128 => return None,
                  };
                  if truncd < lo || truncd > hi { return None; }
 -                return Some(InstKind::ConstInt(norm(truncd as i64, *w), *w));
 +                return Some(InstKind::ConstInt(norm(truncd as i128, *w), *w));
+             }
              None
+         }
+ }
  fn fold_int_bin<F>(a: Option<Const>, b: Option<Const>, ty: &IrType, op: F) -> Option<InstKind>
 -where F: FnOnce(i64, i64) -> i64
 +where F: FnOnce(i128, i128) -> i128
+ {
      if let (Some(Const::Int(av, _)), Some(Const::Int(bv, _))) = (a, b) {
          if let IrType::Int(w) = ty {

src/opt/const_prop.rsmodified

              InstKind::ConstInt(v, w) => {
                  let bits = w.bits();
                  let signed = if bits >= 64 {
 -                    *v
 +                    i64::try_from(*v).ok()?
                  } else {
                      let shift = 64 - bits;
 -                    (*v << shift) >> shift
 +                    let narrow = i64::try_from(*v).ok()?;
 +                    (narrow << shift) >> shift
                  };
                  Some(Const::Int(signed, *w))
+             }

src/opt/cse.rsmodified

      tag: u32,
      operands: Vec<ValueId>,
      /// Auxiliary integer (used for things like comparison op, bitwidth, etc.)
 -    aux: i64,
 +    aux: i128,
      /// Optional name for instructions whose value depends on a
      /// symbol (currently only `GlobalAddr`). Audit Med-2: a hashed
      /// aux risked theoretical SipHash13 collisions merging two
  /// Build a canonical key for an instruction. Returns `None` if the
  /// instruction is impure or otherwise not a CSE candidate.
  fn key_of(inst: &Inst) -> Option<Key> {
 -    let mk = |tag: u32, ops: Vec<ValueId>, aux: i64| -> Option<Key> {
 +    let mk = |tag: u32, ops: Vec<ValueId>, aux: i128| -> Option<Key> {
          Some(Key { tag, operands: ops, aux, name: None, ty: inst.ty.clone() })
      };
      let mk_named = |tag: u32, name: String| -> Option<Key> {
          InstKind::ConstInt(v, w)   => {
              let bits = w.bits();
              // Sign-extend at width: low `bits` bits → i64 sign-extended.
 -            let signed = if bits >= 64 {
 +            let signed = if bits >= 128 {
                  *v
              } else {
 -                let shift = 64 - bits;
 +                let shift = 128 - bits;
                  (*v << shift) >> shift
              };
              mk(1, vec![], signed)
+         }
 -        InstKind::ConstFloat(v, _) => mk(2, vec![], v.to_bits() as i64),
 +        InstKind::ConstFloat(v, _) => mk(2, vec![], v.to_bits() as i128),
          InstKind::ConstBool(b)     => mk(3, vec![], if *b { 1 } else { 0 }),
          // Integer arithmetic --------------------------------------------
          // Comparisons ---------------------------------------------------
          InstKind::ICmp(op, a, b) => {
 -            let aux = *op as i64;
 +            let aux = *op as i128;
              let ops = match op { CmpOp::Eq | CmpOp::Ne => canon(*a, *b), _ => vec![*a, *b] };
              mk(30, ops, aux)
+         }
          InstKind::FCmp(op, a, b) => {
 -            let aux = *op as i64;
 +            let aux = *op as i128;
              let ops = match op { CmpOp::Eq | CmpOp::Ne => canon(*a, *b), _ => vec![*a, *b] };
              mk(31, ops, aux)
+         }
          InstKind::PopCount(a)           => mk(59, vec![*a], 0),
          // Conversions ---------------------------------------------------
 -        InstKind::IntToFloat(v, fw)     => mk(60, vec![*v], fw.bits() as i64),
 -        InstKind::FloatToInt(v, w)      => mk(61, vec![*v], w.bits() as i64),
 -        InstKind::FloatExtend(v, fw)    => mk(62, vec![*v], fw.bits() as i64),
 -        InstKind::FloatTrunc(v, fw)     => mk(63, vec![*v], fw.bits() as i64),
 -        InstKind::IntExtend(v, w, sgn)  => mk(64, vec![*v], (w.bits() as i64) | ((*sgn as i64) << 32)),
 -        InstKind::IntTrunc(v, w)        => mk(65, vec![*v], w.bits() as i64),
 +        InstKind::IntToFloat(v, fw)     => mk(60, vec![*v], fw.bits() as i128),
 +        InstKind::FloatToInt(v, w)      => mk(61, vec![*v], w.bits() as i128),
 +        InstKind::FloatExtend(v, fw)    => mk(62, vec![*v], fw.bits() as i128),
 +        InstKind::FloatTrunc(v, fw)     => mk(63, vec![*v], fw.bits() as i128),
 +        InstKind::IntExtend(v, w, sgn)  => mk(64, vec![*v], (w.bits() as i128) | ((*sgn as i128) << 32)),
 +        InstKind::IntTrunc(v, w)        => mk(65, vec![*v], w.bits() as i128),
          // Address arithmetic --------------------------------------------
          InstKind::GetElementPtr(base, idxs) => {
+         }
          // Aggregates ----------------------------------------------------
 -        InstKind::ExtractField(agg, i) => mk(80, vec![*agg], *i as i64),
 +        InstKind::ExtractField(agg, i) => mk(80, vec![*agg], *i as i128),
          // InsertField produces a new aggregate value — pure but rarely
          // duplicate; include for completeness.
 -        InstKind::InsertField(agg, i, v) => mk(81, vec![*agg, *v], *i as i64),
 +        InstKind::InsertField(agg, i, v) => mk(81, vec![*agg, *v], *i as i128),
          // Impure / not handled ------------------------------------------
          InstKind::Load(..)

src/opt/dep_analysis.rsmodified

      // Find the instruction that defines this value.
      let inst = find_inst(func, val)?;
      match &inst.kind {
 -        InstKind::ConstInt(c, _) => Some(AffineExpr::from_const(*c)),
 +        InstKind::ConstInt(c, _) => i64::try_from(*c).ok().map(AffineExpr::from_const),
          InstKind::IAdd(a, b) => {
              let ea = extract_affine(func, *a, ivs)?;
  fn resolve_const(func: &Function, vid: ValueId) -> Option<i64> {
      let inst = find_inst(func, vid)?;
 -    if let InstKind::ConstInt(c, _) = &inst.kind { Some(*c) } else { None }
 +    if let InstKind::ConstInt(c, _) = &inst.kind { i64::try_from(*c).ok() } else { None }
+ }
  fn find_inst(func: &Function, vid: ValueId) -> Option<&Inst> {

src/opt/gvn.rsmodified

  struct Key {
      tag: u32,
      operands: Vec<ValueId>,
 -    aux: i64,
 +    aux: i128,
      name: Option<String>,
      ty: IrType,
+ }
      pure_calls: &[PureCallPolicy],
      wrapper_values: &HashMap<ValueId, ValueId>,
  ) -> Option<Key> {
 -    let mk = |tag: u32, ops: Vec<ValueId>, aux: i64| -> Option<Key> {
 +    let mk = |tag: u32, ops: Vec<ValueId>, aux: i128| -> Option<Key> {
          Some(Key { tag, operands: ops, aux, name: None, ty: inst.ty.clone() })
      };
      let mk_named = |tag: u32, name: String| -> Option<Key> {
          InstKind::FSqrt(a)    => mk(16, vec![remap(*a)], 0),
          InstKind::FPow(a, b)  => mk(17, vec![remap(*a), remap(*b)], 0),
          InstKind::ICmp(op, a, b) => {
 -            let op_val = *op as i64;
 +            let op_val = *op as i128;
              match op {
                  CmpOp::Eq | CmpOp::Ne => mk(20, canon(remap(*a), remap(*b)), op_val),
                  _ => mk(20, vec![remap(*a), remap(*b)], op_val),
+             }
+         }
 -        InstKind::FCmp(op, a, b) => mk(21, vec![remap(*a), remap(*b)], *op as i64),
 +        InstKind::FCmp(op, a, b) => mk(21, vec![remap(*a), remap(*b)], *op as i128),
          InstKind::And(a, b) => mk(30, canon(remap(*a), remap(*b)), 0),
          InstKind::Or(a, b)  => mk(31, canon(remap(*a), remap(*b)), 0),
          InstKind::Not(a)    => mk(32, vec![remap(*a)], 0),
          InstKind::CountTrailingZeros(a) => mk(48, vec![remap(*a)], 0),
          InstKind::PopCount(a)           => mk(49, vec![remap(*a)], 0),
          // Conversions.
 -        InstKind::IntToFloat(a, w)   => mk(50, vec![remap(*a)], w.bits() as i64),
 -        InstKind::FloatToInt(a, w)   => mk(51, vec![remap(*a)], w.bits() as i64),
 -        InstKind::FloatExtend(a, w)  => mk(52, vec![remap(*a)], w.bits() as i64),
 -        InstKind::FloatTrunc(a, w)   => mk(53, vec![remap(*a)], w.bits() as i64),
 -        InstKind::IntExtend(a, w, s) => mk(54, vec![remap(*a)], w.bits() as i64 * if *s { 1 } else { -1 }),
 -        InstKind::IntTrunc(a, w)     => mk(55, vec![remap(*a)], w.bits() as i64),
 +        InstKind::IntToFloat(a, w)   => mk(50, vec![remap(*a)], w.bits() as i128),
 +        InstKind::FloatToInt(a, w)   => mk(51, vec![remap(*a)], w.bits() as i128),
 +        InstKind::FloatExtend(a, w)  => mk(52, vec![remap(*a)], w.bits() as i128),
 +        InstKind::FloatTrunc(a, w)   => mk(53, vec![remap(*a)], w.bits() as i128),
 +        InstKind::IntExtend(a, w, s) => mk(54, vec![remap(*a)], (w.bits() as i128) * if *s { 1 } else { -1 }),
 +        InstKind::IntTrunc(a, w)     => mk(55, vec![remap(*a)], w.bits() as i128),
          // Constants.
 -        InstKind::ConstInt(v, w)   => mk(60, vec![], *v * 100 + w.bits() as i64),
 -        InstKind::ConstFloat(v, w) => mk(61, vec![], ((*v).to_bits() as i64) ^ (w.bits() as i64)),
 -        InstKind::ConstBool(v)     => mk(62, vec![], *v as i64),
 +        InstKind::ConstInt(v, w)   => mk(60, vec![], *v * 100 + w.bits() as i128),
 +        InstKind::ConstFloat(v, w) => mk(61, vec![], ((*v).to_bits() as i128) ^ (w.bits() as i128)),
 +        InstKind::ConstBool(v)     => mk(62, vec![], *v as i128),
          // GlobalAddr.
          InstKind::GlobalAddr(name) => mk_named(70, name.clone()),
          // GEP.
                      PureArgPolicy::Unsupported => return None,
+                 }
+             }
 -            mk(90, ops, *idx as i64)
 +            mk(90, ops, *idx as i128)
+         }
          // Impure: loads, stores, runtime calls, external calls, alloca — not GVN candidates.
          InstKind::Load(..) | InstKind::Store(..) | InstKind::Alloca(..)

src/opt/loop_utils.rsmodified


         for inst in &block.insts {
             if inst.id == vid {
                 if let InstKind::ConstInt(v, _) = inst.kind {
-                    return Some(v);
+                    return i64::try_from(v).ok();
                 }
                 return None;
             }

src/opt/peel.rsmodified

      };
      func.block_mut(clone_latch).insts.push(Inst {
          id: next_init_id,
 -        kind: InstKind::ConstInt(init_const + stride, iv_width),
 +        kind: InstKind::ConstInt((init_const + stride) as i128, iv_width),
          ty: iv_ty.clone(),
          span: dummy_span,
      });

src/opt/return_prop.rsmodified

  #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
  enum ScalarConst {
 -    Int(i64, IntWidth),
 +    Int(i128, IntWidth),
      Float(u64, FloatWidth),
      Bool(bool),
+ }

src/opt/strength_reduce.rsmodified

      for block in &func.blocks {
          for inst in &block.insts {
              if let InstKind::ConstInt(v, w) = inst.kind {
 -                consts.insert(inst.id, (sext(v, w.bits()), w));
 +                if let Ok(v) = i64::try_from(v) {
 +                    consts.insert(inst.id, (sext(v, w.bits()), w));
 +                }
+             }
+         }
+     }
                          let span = func.blocks[bi].insts[ii].span;
                          func.blocks[bi].insts.insert(ii, Inst {
                              id: kid,
 -                            kind: InstKind::ConstInt(k as i64, int_w),
 +                            kind: InstKind::ConstInt(k as i128, int_w),
                              ty: IrType::Int(int_w),
                              span,
                          });

src/opt/unroll.rsmodified

                  if bi == 0 {
                      let iv_inst = Inst {
                          id: iv_const_id,
 -                        kind: InstKind::ConstInt(iv_val, iv_width),
 +                        kind: InstKind::ConstInt(iv_val as i128, iv_width),
                          ty: shape.iv_ty.clone(),
                          span: dummy_span(),
                      };
          let lo_val = f.next_value_id();
          f.block_mut(entry_id).insts.push(Inst {
              id: lo_val, ty: IrType::Int(IntWidth::I64), span: span(),
 -            kind: InstKind::ConstInt(lo, IntWidth::I64),
 +            kind: InstKind::ConstInt(lo as i128, IntWidth::I64),
          });
          // alloca for the "array" (just a slot we store into)
          let alloca_val = f.next_value_id();
          let hi_val = f.next_value_id();
          f.block_mut(header_id).insts.push(Inst {
              id: hi_val, ty: IrType::Int(IntWidth::I64), span: span(),
 -            kind: InstKind::ConstInt(hi, IntWidth::I64),
 +            kind: InstKind::ConstInt(hi as i128, IntWidth::I64),
          });
          // %cmp = icmp.sle %i, hi
          let cmp_val = f.next_value_id();
          assert_eq!(f.blocks.len(), 6, "expected entry + 4 iter blocks + exit");
          // Each iteration block has a ConstInt for that iteration's IV value.
 -        let all_iv_consts: Vec<i64> = f.blocks.iter()
 +        let all_iv_consts: Vec<i128> = f.blocks.iter()
              .flat_map(|b| b.insts.iter())
              .filter_map(|i| if let InstKind::ConstInt(v, _) = i.kind { Some(v) } else { None })
              .collect();

src/opt/vectorize.rsmodified

      func.register_type(id, ty.clone());
      func.block_mut(block_id).insts.push(Inst {
          id,
 -        kind: InstKind::ConstInt(value, IntWidth::I64),
 +        kind: InstKind::ConstInt(value as i128, IntWidth::I64),
          ty,
          span,
      });

tests/fixtures/integer16_wide_values.f90added

 +module integer16_wide_values_mod
 +  implicit none
 +  integer(16), save :: big_global = 9223372036854775808_16
 +end module integer16_wide_values_mod
++
 +program integer16_wide_values
 +  use integer16_wide_values_mod
 +  implicit none
 +  integer(16) :: big_local
++
 +  big_local = 170141183460469231731687303715884105727_16
 +end program integer16_wide_values

tests/i128_ir.rsmodified

          ir
      );
+ }
++
 +#[test]
 +fn integer16_preserves_values_beyond_i64_in_ir_and_globals() {
 +    let ir = capture_text(
 +        CaptureRequest {
 +            input: fixture("integer16_wide_values.f90"),
 +            requested: BTreeSet::from([Stage::Ir]),
 +            opt_level: OptLevel::O0,
 +        },
 +        Stage::Ir,
 +    );
++
 +    assert!(
 +        ir.contains("9223372036854775808"),
 +        "raw IR should preserve the wide kind-16 global initializer:\n{}",
 +        ir
 +    );
 +    assert!(
 +        ir.contains("170141183460469231731687303715884105727"),
 +        "raw IR should preserve the wide kind-16 local constant:\n{}",
 +        ir
 +    );
 +    assert!(
 +        ir.contains("const_int 170141183460469231731687303715884105727 : i128"),
 +        "raw IR should materialize wide local literals as i128 constants:\n{}",
 +        ir
 +    );
 +}

fortrangoingonforty/armfortas / `5d82427`

19 changed files

`@@ -45,7 +45,7 @@` pub fn resolve_const_int(func: &Function, vid: ValueId) -> Option<i64> {
45	45	for inst in &block.insts {
46	46	if inst.id == vid {
47	47	if let InstKind::ConstInt(v, _) = inst.kind {
48		- return Some(v);
	48	+ return i64::try_from(v).ok();
49	49	}
50	50	return None;
51	51	}