Use usize in format_args!() and have expansion for 16-bit.

Author: m-ou-se

compiler/rustc_ast_lowering/src/expr.rs

@@ -2129,29 +2129,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         self.arena.alloc(self.expr(sp, hir::ExprKind::Tup(&[])))
     }
 
-    pub(super) fn expr_u64(&mut self, sp: Span, value: u64) -> hir::Expr<'hir> {
-        let lit = self.arena.alloc(hir::Lit {
-            span: sp,
-            node: ast::LitKind::Int(
-                u128::from(value).into(),
-                ast::LitIntType::Unsigned(ast::UintTy::U64),
-            ),
-        });
-        self.expr(sp, hir::ExprKind::Lit(lit))
-    }
-
-    pub(super) fn expr_u32(&mut self, sp: Span, value: u32) -> hir::Expr<'hir> {
-        let lit = self.arena.alloc(hir::Lit {
-            span: sp,
-            node: ast::LitKind::Int(
-                u128::from(value).into(),
-                ast::LitIntType::Unsigned(ast::UintTy::U32),
-            ),
-        });
-        self.expr(sp, hir::ExprKind::Lit(lit))
-    }
-
-    pub(super) fn expr_usize(&mut self, sp: Span, value: u16) -> hir::Expr<'hir> {
+    pub(super) fn expr_usize(&mut self, sp: Span, value: u64) -> hir::Expr<'hir> {
         let lit = self.arena.alloc(hir::Lit {
             span: sp,
             node: ast::LitKind::Int(

compiler/rustc_ast_lowering/src/format.rs

@@ -417,11 +417,7 @@ fn expand_format_args<'hir>(
                 // ```
                 //  Piece::num(4),
                 // ```
-                let i = if ctx.tcx.sess.target.pointer_width >= 64 {
-                    ctx.expr_u64(fmt.span, len as u64)
-                } else {
-                    ctx.expr_u32(fmt.span, len as u32)
-                };
+                let i = ctx.expr_usize(macsp, len as u64);
                 pieces.push(make_piece(ctx, sym::num, i, macsp));
 
                 // ```
@@ -434,11 +430,18 @@ fn expand_format_args<'hir>(
                 // ```
                 //  Piece::num(0xE000_0020_0000_0000),
                 // ```
-                // Or, on <64 bit platforms:
+                // Or, on 32 bit platforms:
                 // ```
                 //  Piece::num(0xE000_0020),
                 //  Piece::num(0x0000_0000),
                 // ```
+                // Or, on 16 bit platforms:
+                // ```
+                //  Piece::num(0xE000),
+                //  Piece::num(0x0020),
+                //  Piece::num(0x0000),
+                //  Piece::num(0x0000),
+                // ```
 
                 let bits = make_format_spec(p, &mut argmap);
 
@@ -455,13 +458,22 @@ fn expand_format_args<'hir>(
                 }
 
                 if ctx.tcx.sess.target.pointer_width >= 64 {
-                    let bits = ctx.expr_u64(fmt.span, bits);
+                    let bits = ctx.expr_usize(macsp, bits);
                     pieces.push(make_piece(ctx, sym::num, bits, macsp));
-                } else {
-                    let high = ctx.expr_u32(fmt.span, (bits >> 32) as u32);
-                    let low = ctx.expr_u32(fmt.span, bits as u32);
+                } else if ctx.tcx.sess.target.pointer_width >= 32 {
+                    let high = ctx.expr_usize(macsp, bits >> 32);
+                    let low = ctx.expr_usize(macsp, bits & 0xFFFF_FFFF);
                     pieces.push(make_piece(ctx, sym::num, high, macsp));
                     pieces.push(make_piece(ctx, sym::num, low, macsp));
+                } else {
+                    let w1 = ctx.expr_usize(macsp, bits >> 48);
+                    let w2 = ctx.expr_usize(macsp, bits >> 32 & 0xFFFF);
+                    let w3 = ctx.expr_usize(macsp, bits >> 16 & 0xFFFF);
+                    let w4 = ctx.expr_usize(macsp, bits & 0xFFFF);
+                    pieces.push(make_piece(ctx, sym::num, w1, macsp));
+                    pieces.push(make_piece(ctx, sym::num, w2, macsp));
+                    pieces.push(make_piece(ctx, sym::num, w3, macsp));
+                    pieces.push(make_piece(ctx, sym::num, w4, macsp));
                 }
 
                 implicit_arg_index = (bits & 0x3FF) + 1;
@@ -476,11 +488,7 @@ fn expand_format_args<'hir>(
     // ```
     //  Piece::num(0),
     // ```
-    let zero = if ctx.tcx.sess.target.pointer_width >= 64 {
-        ctx.expr_u64(fmt.span, 0)
-    } else {
-        ctx.expr_u32(fmt.span, 0)
-    };
+    let zero = ctx.expr_usize(macsp, 0);
     pieces.push(make_piece(ctx, sym::num, zero, macsp));
 
     // ```
@@ -565,7 +573,7 @@ fn expand_format_args<'hir>(
         let elements =
             ctx.arena.alloc_from_iter(argmap.iter().map(|(&(arg_index, ty), placeholder_span)| {
                 if let ArgumentType::Constant(c) = ty {
-                    let arg = ctx.arena.alloc(ctx.expr_usize(macsp, c));
+                    let arg = ctx.arena.alloc(ctx.expr_usize(macsp, c.into()));
                     let arg = ctx.arena.alloc(ctx.expr(
                         macsp,
                         hir::ExprKind::AddrOf(hir::BorrowKind::Ref, hir::Mutability::Not, arg),
@@ -609,7 +617,7 @@ fn expand_format_args<'hir>(
         let args = ctx.arena.alloc_from_iter(argmap.iter().map(
             |(&(arg_index, ty), &placeholder_span)| {
                 if let ArgumentType::Constant(c) = ty {
-                    let arg = ctx.arena.alloc(ctx.expr_usize(macsp, c));
+                    let arg = ctx.arena.alloc(ctx.expr_usize(macsp, c.into()));
                     let arg = ctx.arena.alloc(ctx.expr(
                         macsp,
                         hir::ExprKind::AddrOf(hir::BorrowKind::Ref, hir::Mutability::Not, arg),

library/core/src/fmt/mod.rs

@@ -743,8 +743,11 @@ impl<'a> Arguments<'a> {
                         starts_with_placeholder = true;
                     }
                     has_placeholders = true;
-                    #[cfg(not(target_pointer_width = "64"))]
-                    let _ = template.next(); // Skip second half of placeholder.
+                    // Skip remainder of placeholder:
+                    #[cfg(target_pointer_width = "32")]
+                    let _ = template.next();
+                    #[cfg(target_pointer_width = "16")]
+                    let _ = (template.next(), template.next(), template.next());
                 }
             }
         }
@@ -1701,9 +1704,17 @@ pub fn write(output: &mut dyn Write, fmt: Arguments<'_>) -> Result {
             // Placeholder piece.
             #[cfg(target_pointer_width = "64")]
             let (high, low) = ((n >> 32) as u32, n as u32);
-            #[cfg(not(target_pointer_width = "64"))]
+            #[cfg(target_pointer_width = "32")]
             // SAFETY: We can assume the template is valid.
             let (high, low) = (n as u32, unsafe { template.next().i } as u32);
+            #[cfg(target_pointer_width = "16")]
+            // SAFETY: We can assume the template is valid.
+            let (high, low) = unsafe {
+                (
+                    (n as u32) << 16 | template.next().i as u32,
+                    (template.next().i as u32) << 16 | template.next().i as u32,
+                )
+            };
             let arg_index = (low & 0x3FF) as usize;
             let mut width = (low >> 10 & 0x3FF) as u16;
             let mut precision = (low >> 20 & 0x3FF) as u16;

library/core/src/fmt/rt.rs

@@ -43,10 +43,7 @@ impl<'a> Template<'a> {
 #[lang = "format_piece"]
 #[derive(Copy, Clone)]
 pub union Piece {
-    #[cfg(target_pointer_width = "64")]
-    pub i: u64,
-    #[cfg(not(target_pointer_width = "64"))]
-    pub i: u32,
+    pub i: usize,
     pub p: *const u8,
 }
 
@@ -69,19 +66,10 @@ impl Piece {
         Self { p: s as *const str as *const u8 }
     }
 
-    #[cfg(target_pointer_width = "64")]
     #[rustc_promotable]
     #[stable(feature = "rust1", since = "1.0.0")]
     #[rustc_const_stable(feature = "rust1", since = "1.0.0")]
-    pub const fn num(i: u64) -> Self {
-        Self { i }
-    }
-
-    #[cfg(not(target_pointer_width = "64"))]
-    #[rustc_promotable]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_stable(feature = "rust1", since = "1.0.0")]
-    pub const fn num(i: u32) -> Self {
+    pub const fn num(i: usize) -> Self {
         Self { i }
     }
 }