Prefixed const methods with "const" instead of "c"

[rust.git] / src / librustc_codegen_llvm / mir / place.rs

diff --git a/src/librustc_codegen_llvm/mir/place.rs b/src/librustc_codegen_llvm/mir/place.rs
index b34eea0ce1c1da50704787b30a6eaf4274bf8c16..b0740008995ed7b75841305d8c81d5fd34a83e17 100644 (file)
--- a/src/librustc_codegen_llvm/mir/place.rs
+++ b/src/librustc_codegen_llvm/mir/place.rs
@@ -68,7 +68,7 @@ pub fn from_const_alloc(
 
         let llval = unsafe { LLVMConstInBoundsGEP(
             consts::bitcast(base_addr, bx.cx().i8p()),
-            &bx.cx().c_usize(offset.bytes()),
+            &bx.cx().const_usize(offset.bytes()),
             1,
         )};
         let llval = consts::bitcast(llval, bx.cx().ptr_to(layout.llvm_type(bx.cx())));
@@ -102,7 +102,7 @@ pub fn len(&self, cx: &CodegenCx<'ll, 'tcx>) -> &'ll Value {
                 assert_eq!(count, 0);
                 self.llextra.unwrap()
             } else {
-                cx.c_usize(count)
+                cx.const_usize(count)
             }
         } else {
             bug!("unexpected layout `{:#?}` in PlaceRef::len", self.layout)
@@ -247,7 +247,7 @@ pub fn project_field(
 
         let meta = self.llextra;
 
-        let unaligned_offset = cx.c_usize(offset.bytes());
+        let unaligned_offset = cx.const_usize(offset.bytes());
 
         // Get the alignment of the field
         let (_, unsized_align) = glue::size_and_align_of_dst(bx, field.ty, meta);
@@ -258,7 +258,7 @@ pub fn project_field(
         //   (unaligned offset + (align - 1)) & -align
 
         // Calculate offset
-        let align_sub_1 = bx.sub(unsized_align, cx.c_usize(1u64));
+        let align_sub_1 = bx.sub(unsized_align, cx.const_usize(1u64));
         let offset = bx.and(bx.add(unaligned_offset, align_sub_1),
         bx.neg(unsized_align));
 
@@ -288,14 +288,14 @@ pub fn codegen_get_discr(
     ) -> &'ll Value {
         let cast_to = bx.cx().layout_of(cast_to).immediate_llvm_type(bx.cx());
         if self.layout.abi.is_uninhabited() {
-            return bx.cx().c_undef(cast_to);
+            return bx.cx().const_undef(cast_to);
         }
         match self.layout.variants {
             layout::Variants::Single { index } => {
                 let discr_val = self.layout.ty.ty_adt_def().map_or(
                     index.as_u32() as u128,
                     |def| def.discriminant_for_variant(bx.cx().tcx, index).val);
-                return bx.cx().c_uint_big(cast_to, discr_val);
+                return bx.cx().const_uint_big(cast_to, discr_val);
             }
             layout::Variants::Tagged { .. } |
             layout::Variants::NicheFilling { .. } => {},
@@ -327,22 +327,22 @@ pub fn codegen_get_discr(
                     // FIXME(eddyb) Check the actual primitive type here.
                     let niche_llval = if niche_start == 0 {
                         // HACK(eddyb) Using `c_null` as it works on all types.
-                        bx.cx().c_null(niche_llty)
+                        bx.cx().const_null(niche_llty)
                     } else {
-                        bx.cx().c_uint_big(niche_llty, niche_start)
+                        bx.cx().const_uint_big(niche_llty, niche_start)
                     };
                     bx.select(bx.icmp(IntPredicate::IntEQ, lldiscr, niche_llval),
-                        bx.cx().c_uint(cast_to, niche_variants.start().as_u32() as u64),
-                        bx.cx().c_uint(cast_to, dataful_variant.as_u32() as u64))
+                        bx.cx().const_uint(cast_to, niche_variants.start().as_u32() as u64),
+                        bx.cx().const_uint(cast_to, dataful_variant.as_u32() as u64))
                 } else {
                     // Rebase from niche values to discriminant values.
                     let delta = niche_start.wrapping_sub(niche_variants.start().as_u32() as u128);
-                    let lldiscr = bx.sub(lldiscr, bx.cx().c_uint_big(niche_llty, delta));
+                    let lldiscr = bx.sub(lldiscr, bx.cx().const_uint_big(niche_llty, delta));
                     let lldiscr_max =
-                        bx.cx().c_uint(niche_llty, niche_variants.end().as_u32() as u64);
+                        bx.cx().const_uint(niche_llty, niche_variants.end().as_u32() as u64);
                     bx.select(bx.icmp(IntPredicate::IntULE, lldiscr, lldiscr_max),
                         bx.intcast(lldiscr, cast_to, false),
-                        bx.cx().c_uint(cast_to, dataful_variant.as_u32() as u64))
+                        bx.cx().const_uint(cast_to, dataful_variant.as_u32() as u64))
                 }
             }
         }
@@ -364,7 +364,7 @@ pub fn codegen_set_discr(&self, bx: &Builder<'a, 'll, 'tcx>, variant_index: Vari
                     .discriminant_for_variant(bx.tcx(), variant_index)
                     .val;
                 bx.store(
-                    bx.cx().c_uint_big(ptr.layout.llvm_type(bx.cx()), to),
+                    bx.cx().const_uint_big(ptr.layout.llvm_type(bx.cx()), to),
                     ptr.llval,
                     ptr.align);
             }
@@ -380,10 +380,10 @@ pub fn codegen_set_discr(&self, bx: &Builder<'a, 'll, 'tcx>, variant_index: Vari
                         // Issue #34427: As workaround for LLVM bug on ARM,
                         // use memset of 0 before assigning niche value.
                         let llptr = bx.pointercast(self.llval, bx.cx().ptr_to(bx.cx().i8()));
-                        let fill_byte = bx.cx().c_u8(0);
+                        let fill_byte = bx.cx().const_u8(0);
                         let (size, align) = self.layout.size_and_align();
-                        let size = bx.cx().c_usize(size.bytes());
-                        let align = bx.cx().c_u32(align.abi() as u32);
+                        let size = bx.cx().const_usize(size.bytes());
+                        let align = bx.cx().const_u32(align.abi() as u32);
                         base::call_memset(bx, llptr, fill_byte, size, align, false);
                     }
 
@@ -395,9 +395,9 @@ pub fn codegen_set_discr(&self, bx: &Builder<'a, 'll, 'tcx>, variant_index: Vari
                     // FIXME(eddyb) Check the actual primitive type here.
                     let niche_llval = if niche_value == 0 {
                         // HACK(eddyb) Using `c_null` as it works on all types.
-                        bx.cx().c_null(niche_llty)
+                        bx.cx().const_null(niche_llty)
                     } else {
-                        bx.cx().c_uint_big(niche_llty, niche_value)
+                        bx.cx().const_uint_big(niche_llty, niche_value)
                     };
                     OperandValue::Immediate(niche_llval).store(bx, niche);
                 }
@@ -408,7 +408,7 @@ pub fn codegen_set_discr(&self, bx: &Builder<'a, 'll, 'tcx>, variant_index: Vari
     pub fn project_index(&self, bx: &Builder<'a, 'll, 'tcx>, llindex: &'ll Value)
                          -> PlaceRef<'tcx, &'ll Value> {
         PlaceRef {
-            llval: bx.inbounds_gep(self.llval, &[bx.cx().c_usize(0), llindex]),
+            llval: bx.inbounds_gep(self.llval, &[bx.cx().const_usize(0), llindex]),
             llextra: None,
             layout: self.layout.field(bx.cx(), 0),
             align: self.align
@@ -483,7 +483,7 @@ pub fn codegen_place(&mut self,
                         // so we generate an abort
                         let fnname = bx.cx().get_intrinsic(&("llvm.trap"));
                         bx.call(fnname, &[], None);
-                        let llval = bx.cx().c_undef(bx.cx().ptr_to(layout.llvm_type(bx.cx())));
+                        let llval = bx.cx().const_undef(bx.cx().ptr_to(layout.llvm_type(bx.cx())));
                         PlaceRef::new_sized(llval, layout, layout.align)
                     }
                 }
@@ -516,20 +516,20 @@ pub fn codegen_place(&mut self,
                     mir::ProjectionElem::ConstantIndex { offset,
                                                          from_end: false,
                                                          min_length: _ } => {
-                        let lloffset = bx.cx().c_usize(offset as u64);
+                        let lloffset = bx.cx().const_usize(offset as u64);
                         cg_base.project_index(bx, lloffset)
                     }
                     mir::ProjectionElem::ConstantIndex { offset,
                                                          from_end: true,
                                                          min_length: _ } => {
-                        let lloffset = bx.cx().c_usize(offset as u64);
+                        let lloffset = bx.cx().const_usize(offset as u64);
                         let lllen = cg_base.len(bx.cx());
                         let llindex = bx.sub(lllen, lloffset);
                         cg_base.project_index(bx, llindex)
                     }
                     mir::ProjectionElem::Subslice { from, to } => {
                         let mut subslice = cg_base.project_index(bx,
-                            bx.cx().c_usize(from as u64));
+                            bx.cx().const_usize(from as u64));
                         let projected_ty = PlaceTy::Ty { ty: cg_base.layout.ty }
                             .projection_ty(tcx, &projection.elem)
                             .to_ty(bx.tcx());
@@ -537,7 +537,7 @@ pub fn codegen_place(&mut self,
 
                         if subslice.layout.is_unsized() {
                             subslice.llextra = Some(bx.sub(cg_base.llextra.unwrap(),
-                                bx.cx().c_usize((from as u64) + (to as u64))));
+                                bx.cx().const_usize((from as u64) + (to as u64))));
                         }
 
                         // Cast the place pointer type to the new