src/pointer.rs

   1 use crate::prelude::*;
   2
   3 use cranelift_codegen::ir::immediates::Offset32;
   4
   5 #[derive(Copy, Clone, Debug)]
   6 pub struct Pointer {
   7     base: PointerBase,
   8     offset: Offset32,
   9 }
  10
  11 #[derive(Copy, Clone, Debug)]
  12 pub enum PointerBase {
  13     Addr(Value),
  14     Stack(StackSlot),
  15 }
  16
  17 impl Pointer {
  18     pub fn new(addr: Value) -> Self {
  19         Pointer {
  20             base: PointerBase::Addr(addr),
  21             offset: Offset32::new(0),
  22         }
  23     }
  24
  25     pub fn stack_slot(stack_slot: StackSlot) -> Self {
  26         Pointer {
  27             base: PointerBase::Stack(stack_slot),
  28             offset: Offset32::new(0),
  29         }
  30     }
  31
  32     pub fn const_addr<'a, 'tcx>(fx: &mut FunctionCx<'a, 'tcx, impl Backend>, addr: i64) -> Self {
  33         let addr = fx.bcx.ins().iconst(fx.pointer_type, addr);
  34         Pointer {
  35             base: PointerBase::Addr(addr),
  36             offset: Offset32::new(0),
  37         }
  38     }
  39
  40     pub fn base_and_offset(self) -> (PointerBase, Offset32) {
  41         (self.base, self.offset)
  42     }
  43
  44     pub fn get_addr<'a, 'tcx>(self, fx: &mut FunctionCx<'a, 'tcx, impl Backend>) -> Value {
  45         match self.base {
  46             PointerBase::Addr(base_addr) => {
  47                 let offset: i64 = self.offset.into();
  48                 if offset == 0 {
  49                     base_addr
  50                 } else {
  51                     fx.bcx.ins().iadd_imm(base_addr, offset)
  52                 }
  53             }
  54             PointerBase::Stack(stack_slot) => fx.bcx.ins().stack_addr(fx.pointer_type, stack_slot, self.offset),
  55         }
  56     }
  57
  58     pub fn offset<'a, 'tcx>(
  59         self,
  60         fx: &mut FunctionCx<'a, 'tcx, impl Backend>,
  61         extra_offset: Offset32,
  62     ) -> Self {
  63         self.offset_i64(fx, extra_offset.into())
  64     }
  65
  66     pub fn offset_i64<'a, 'tcx>(
  67         self,
  68         fx: &mut FunctionCx<'a, 'tcx, impl Backend>,
  69         extra_offset: i64,
  70     ) -> Self {
  71         if let Some(new_offset) = self.offset.try_add_i64(extra_offset) {
  72             Pointer {
  73                 base: self.base,
  74                 offset: new_offset,
  75             }
  76         } else {
  77             let base_offset: i64 = self.offset.into();
  78             if let Some(new_offset) = base_offset.checked_add(extra_offset){
  79                 let base_addr = match self.base {
  80                     PointerBase::Addr(addr) => addr,
  81                     PointerBase::Stack(stack_slot) => fx.bcx.ins().stack_addr(fx.pointer_type, stack_slot, 0),
  82                 };
  83                 let addr = fx.bcx.ins().iadd_imm(base_addr, new_offset);
  84                 Pointer {
  85                     base: PointerBase::Addr(addr),
  86                     offset: Offset32::new(0),
  87                 }
  88             } else {
  89                 panic!("self.offset ({}) + extra_offset ({}) not representable in i64", base_offset, extra_offset);
  90             }
  91         }
  92     }
  93
  94     pub fn offset_value<'a, 'tcx>(
  95         self,
  96         fx: &mut FunctionCx<'a, 'tcx, impl Backend>,
  97         extra_offset: Value,
  98     ) -> Self {
  99         match self.base {
 100             PointerBase::Addr(addr) => Pointer {
 101                 base: PointerBase::Addr(fx.bcx.ins().iadd(addr, extra_offset)),
 102                 offset: self.offset,
 103             },
 104             PointerBase::Stack(stack_slot) => {
 105                 let base_addr = fx.bcx.ins().stack_addr(fx.pointer_type, stack_slot, self.offset);
 106                 Pointer {
 107                     base: PointerBase::Addr(fx.bcx.ins().iadd(base_addr, extra_offset)),
 108                     offset: Offset32::new(0),
 109                 }
 110             }
 111         }
 112     }
 113
 114     pub fn load<'a, 'tcx>(
 115         self,
 116         fx: &mut FunctionCx<'a, 'tcx, impl Backend>,
 117         ty: Type,
 118         flags: MemFlags,
 119     ) -> Value {
 120         match self.base {
 121             PointerBase::Addr(base_addr) => fx.bcx.ins().load(ty, flags, base_addr, self.offset),
 122             PointerBase::Stack(stack_slot) => if ty == types::I128 || ty.is_vector() {
 123                 // WORKAROUND for stack_load.i128 and stack_load.iXxY not being implemented
 124                 let base_addr = fx.bcx.ins().stack_addr(fx.pointer_type, stack_slot, 0);
 125                 fx.bcx.ins().load(ty, flags, base_addr, self.offset)
 126             } else {
 127                 fx.bcx.ins().stack_load(ty, stack_slot, self.offset)
 128             }
 129         }
 130     }
 131
 132     pub fn store<'a, 'tcx>(
 133         self,
 134         fx: &mut FunctionCx<'a, 'tcx, impl Backend>,
 135         value: Value,
 136         flags: MemFlags,
 137     ) {
 138         match self.base {
 139             PointerBase::Addr(base_addr) => {
 140                 fx.bcx.ins().store(flags, value, base_addr, self.offset);
 141             }
 142             PointerBase::Stack(stack_slot) => {
 143                 let val_ty = fx.bcx.func.dfg.value_type(value);
 144                 if val_ty == types::I128 || val_ty.is_vector() {
 145                     // WORKAROUND for stack_store.i128 and stack_store.iXxY not being implemented
 146                     let base_addr = fx.bcx.ins().stack_addr(fx.pointer_type, stack_slot, 0);
 147                     fx.bcx.ins().store(flags, value, base_addr, self.offset);
 148                 } else {
 149                     fx.bcx.ins().stack_store(value, stack_slot, self.offset);
 150                 }
 151             }
 152         }
 153     }
 154 }