Skip to content

Commit fc591a4

Browse files
antoyoantoyo
committed
Fix const pointer
1 parent 0c7e3f6 commit fc591a4

File tree

2 files changed

+12
-257
lines changed

2 files changed

+12
-257
lines changed

‎gcc-test-backend/src/main.rs

Lines changed: 7 additions & 255 deletions
Original file line numberDiff line numberDiff line change
@@ -1,260 +1,12 @@
1-
#![feature(const_option, core_intrinsics)]
2-
31
fn main() {
4-
/*test_float!(f64, f64, f64::INFINITY, f64::NEG_INFINITY, f64::NAN);
5-
($modname: ident, $fty: ty, $inf: expr, $neginf: expr, $nan: expr) => {*/
6-
7-
/*assert_eq!((0.0 as f64).min(0.0), 0.0);
8-
assert!((0.0 as f64).min(0.0).is_sign_positive());
9-
assert_eq!((-0.0 as f64).min(-0.0), -0.0);
10-
11-
fn is_sign_neg(num: f64) -> bool {
12-
num.to_bits() & 0x8000_0000_0000_0000 != 0
13-
}
14-
//assert!(is_sign_neg(-0.0_f64));
15-
println!("{:b}", (-0.0_f64).to_bits());
16-
let var = 1.2_f64;
17-
println!("{}", 1.2_f64 == var);*/
18-
19-
/*fn my_float() -> f64 {
20-
-0.0
21-
}
22-
23-
let float = my_float();*/
24-
//println!("{}", (-0.0_f64).to_bits());
25-
26-
// FIXME: seems like the asm is calling comisd which seems to convert -0.0 to 0.
27-
/*assert!((-0.0_f64).to_bits() & 0x8000_0000_0000_0000 != 0);
28-
println!("1");*/
29-
//println!("{}", float);
30-
//std::process::exit(float as i32)
31-
32-
/*assert!((-0.0 as f64).min(-0.0).is_sign_negative());
33-
assert_eq!((9.0 as f64).min(9.0), 9.0);
34-
assert_eq!((-9.0 as f64).min(0.0), -9.0);
35-
assert_eq!((0.0 as f64).min(9.0), 0.0);
36-
assert!((0.0 as f64).min(9.0).is_sign_positive());
37-
assert_eq!((-0.0 as f64).min(9.0), -0.0);
38-
assert!((-0.0 as f64).min(9.0).is_sign_negative());*/
39-
40-
//println!("{}", 9);
41-
//println!("{}", 9.0_f32);
42-
//assert_eq!(-9.0_f32, -9 as f32);
43-
44-
//assert_eq!("1", format!("{:.0}", 1.0f64));
45-
//assert_eq!("9", format!("{:.0}", 9.4f64));
46-
//assert_eq!("10", format!("{:.0}", 9.9f64));
47-
//assert_eq!("9.8", format!("{:.1}", 9.849f64));
48-
//assert_eq!("9.9", format!("{:.1}", 9.851f64));
49-
//assert_eq!("1", format!("{:.0}", 0.5f64));
50-
51-
//assert_eq!(2.3f32.copysign(-1.0), -2.3f32);
52-
/*let f = 9.4f32;
53-
println!("{}", f);*/
54-
//println!("{}", 9.4f32); // FIXME: this is using bytes_in_context(), but gives a wrong value.
55-
56-
/*extern {
57-
//pub fn printf(format: *const i8, ...) -> i32;
58-
pub fn printf(format: *const i8, arg: f64) -> i32;
59-
}
60-
61-
unsafe {
62-
printf(b"Num: %f\n\0" as *const _ as *const _, 9.4f64);
63-
}
64-
println!("{}", 9.4f64);*/
65-
66-
// FIXME: the code seems to be the same when using an integer, but somehow, it doesn't work for
67-
// a float. Could it be related to the fact that floating-points use different registers?
68-
69-
/*let f = 1234567.89f64;
70-
assert_eq!("1.23456789e6", format!("{:e}", f));
71-
println!("{:e}", f);
72-
println!("{:e}", 1234567.89f64);*/
73-
//assert_eq!("1.23456789e6", format!("{:e}", 1234567.89f64));
74-
/*assert_eq!("1.23456789e3", format!("{:e}", 1234.56789f64));
75-
assert_eq!("1.23456789E6", format!("{:E}", 1234567.89f64));
76-
assert_eq!("1.23456789E3", format!("{:E}", 1234.56789f64));
77-
assert_eq!("0.0", format!("{:?}", 0.0f64));
78-
assert_eq!("1.01", format!("{:?}", 1.01f64));*/
79-
80-
/*assert_eq!((-0.0 as f64).min(-9.0), -9.0);
81-
assert_eq!((f64::INFINITY as f64).min(9.0), 9.0);
82-
assert_eq!((9.0 as f64).min(f64::INFINITY), 9.0);
83-
assert_eq!((f64::INFINITY as f64).min(-9.0), -9.0);
84-
assert_eq!((-9.0 as f64).min(f64::INFINITY), -9.0);
85-
assert_eq!((f64::NEG_INFINITY as f64).min(9.0), f64::NEG_INFINITY);
86-
assert_eq!((9.0 as f64).min(f64::NEG_INFINITY), f64::NEG_INFINITY);
87-
assert_eq!((f64::NEG_INFINITY as f64).min(-9.0), f64::NEG_INFINITY);
88-
assert_eq!((-9.0 as f64).min(f64::NEG_INFINITY), f64::NEG_INFINITY);*/
89-
// Cranelift fmin has NaN propagation
90-
//assert_eq!((f64::NAN as f64).min(9.0), 9.0);
91-
//assert_eq!((f64::NAN as f64).min(-9.0), -9.0);
92-
//assert_eq!((9.0 as f64).min(f64::NAN), 9.0);
93-
//assert_eq!((-9.0 as f64).min(f64::NAN), -9.0);
94-
//assert!((f64::NAN as f64).min(f64::NAN).is_nan());
95-
96-
/*let max: f64 = f32::MAX.into();
97-
assert_eq!(max as f32, f32::MAX);
98-
assert!(max.is_normal());
99-
100-
let min: f64 = f32::MIN.into();
101-
assert_eq!(min as f32, f32::MIN);
102-
assert!(min.is_normal());
103-
104-
let min_positive: f64 = f32::MIN_POSITIVE.into();
105-
assert_eq!(min_positive as f32, f32::MIN_POSITIVE);
106-
assert!(min_positive.is_normal());
107-
108-
let epsilon: f64 = f32::EPSILON.into();
109-
assert_eq!(epsilon as f32, f32::EPSILON);
110-
assert!(epsilon.is_normal());
111-
112-
let zero: f64 = (0.0f32).into();
113-
assert_eq!(zero as f32, 0.0f32);
114-
assert!(zero.is_sign_positive());
115-
116-
let neg_zero: f64 = (-0.0f32).into();
117-
assert_eq!(neg_zero as f32, -0.0f32);
118-
assert!(neg_zero.is_sign_negative());
119-
120-
let infinity: f64 = f32::INFINITY.into();
121-
assert_eq!(infinity as f32, f32::INFINITY);
122-
assert!(infinity.is_infinite());
123-
assert!(infinity.is_sign_positive());
124-
125-
let neg_infinity: f64 = f32::NEG_INFINITY.into();
126-
assert_eq!(neg_infinity as f32, f32::NEG_INFINITY);
127-
assert!(neg_infinity.is_infinite());
128-
assert!(neg_infinity.is_sign_negative());
129-
130-
let nan: f64 = f32::NAN.into();
131-
assert!(nan.is_nan());*/
132-
133-
/*use std::convert::TryFrom;
134-
135-
/*let max = <i128>::MAX;
136-
let min = <i128>::MIN;*/
137-
let zero: i128 = 0;
138-
/*let t_max = <u64>::MAX;
139-
let t_min = <u64>::MIN;
140-
assert!(<u64 as TryFrom<i128>>::try_from(max).is_err());
141-
assert!(<u64 as TryFrom<i128>>::try_from(min).is_err());*/
142-
println!("{:?}", i128_to_u64(zero));
143-
assert_eq!(<u64 as TryFrom<i128>>::try_from(zero).unwrap(), zero as u64);
144-
/*assert_eq!(
145-
<u64 as TryFrom<i128>>::try_from(t_max as i128).unwrap(),
146-
t_max as u64
147-
);
148-
assert_eq!(
149-
<u64 as TryFrom<i128>>::try_from(t_min as i128).unwrap(),
150-
t_min as u64
151-
);*/
152-
*/
153-
154-
/*
155-
//let mut num = u128::MAX >> 20;
156-
//let mut num = u128::MAX;
157-
#[inline(never)]
158-
fn two() -> u128 {
159-
2
160-
}
161-
162-
//let mut num = 340282366920938463463374607431768211455_u128 >> two();
163-
let mut num = 340282366920938463463374607431768211455_u128 >> 2;
164-
//let mut num = 340282366920938463463374607431768211455_u128;
165-
//let mut num = 10_u128 >> 2;
166-
const MASK: u128 = 0x80000000000000000000000000000000;
167-
for _ in 0..128 {
168-
if num & MASK == MASK {
169-
print!("1");
170-
}
171-
else {
172-
print!("0");
173-
}
174-
num <<= 1;
175-
}
176-
println!();
177-
*/
178-
179-
/*let mut r = 2 as i128;
180-
assert_eq!(r.pow(2), 4 as i128);
181-
assert_eq!(r.pow(0), 1 as i128);
182-
assert_eq!(r.wrapping_pow(2), 4 as i128);
183-
assert_eq!(r.wrapping_pow(0), 1 as i128);
184-
assert_eq!(r.checked_pow(2), Some(4 as i128));
185-
assert_eq!(r.checked_pow(0), Some(1 as i128));
186-
assert_eq!(r.overflowing_pow(2), (4 as i128, false));
187-
assert_eq!(r.overflowing_pow(0), (1 as i128, false));
188-
assert_eq!(r.saturating_pow(2), 4 as i128);
189-
assert_eq!(r.saturating_pow(0), 1 as i128);
190-
191-
r = i128::MAX;
192-
// use `^` to represent .pow() with no overflow.
193-
// if itest::MAX == 2^j-1, then itest is a `j` bit int,
194-
// so that `itest::MAX*itest::MAX == 2^(2*j)-2^(j+1)+1`,
195-
// thussaturating_pow the overflowing result is exactly 1.
196-
assert_eq!(r.wrapping_pow(2), 1 as i128);
197-
assert_eq!(r.checked_pow(2), None);
198-
assert_eq!(r.overflowing_pow(2), (1 as i128, true));
199-
assert_eq!(r.saturating_pow(2), i128::MAX);
200-
//test for negative exponent.
201-
r = -2 as i128;
202-
assert_eq!(r.pow(2), 4 as i128);
203-
assert_eq!(r.pow(3), -8 as i128);
204-
assert_eq!(r.pow(0), 1 as i128);
205-
assert_eq!(r.wrapping_pow(2), 4 as i128);
206-
assert_eq!(r.wrapping_pow(3), -8 as i128);
207-
assert_eq!(r.wrapping_pow(0), 1 as i128);
208-
assert_eq!(r.checked_pow(2), Some(4 as i128));
209-
assert_eq!(r.checked_pow(3), Some(-8 as i128));
210-
assert_eq!(r.checked_pow(0), Some(1 as i128));
211-
assert_eq!(r.overflowing_pow(2), (4 as i128, false));
212-
assert_eq!(r.overflowing_pow(3), (-8 as i128, false));
213-
assert_eq!(r.overflowing_pow(0), (1 as i128, false));
214-
assert_eq!(r.saturating_pow(2), 4 as i128);
215-
assert_eq!(r.saturating_pow(3), -8 as i128);
216-
assert_eq!(r.saturating_pow(0), 1 as i128);*/
217-
218-
fn max64() -> i128 {
219-
18446744073709551615_i128
220-
//18446744073709551615_u64 as i128
221-
222-
/*println!("{}", u64::MAX);
223-
u64::MAX as i128*/
224-
}
225-
226-
println!("1. {}", max64());
2+
const OPTION: Option<usize> = Some(32);
2273

228-
/*use std::convert::TryFrom;
4+
const REF: Option<&usize> = OPTION.as_ref();
5+
assert_eq!(REF, Some(&32));
2296

230-
fn try_from(u: i128) -> Option<u64> {
231-
let min = u64::MIN as i128;
232-
let max = u64::MAX as i128;
233-
/*println!("{} < {} == {}", u, min, u < min);
234-
println!("{} > {} == {}", u, max, u > max);*/
235-
if u < min || u > max {
236-
None
237-
} else {
238-
Some(u as u64)
239-
}
240-
}
7+
const IS_SOME: bool = OPTION.is_some();
8+
assert!(IS_SOME);
2419

242-
let max = <i128>::MAX;
243-
let min = <i128>::MIN;
244-
let zero: i128 = 0;
245-
let t_max = <u64>::MAX;
246-
let t_min = <u64>::MIN;
247-
assert!(<u64 as TryFrom<i128>>::try_from(max).is_err());
248-
assert!(<u64 as TryFrom<i128>>::try_from(min).is_err());
249-
println!("{:?}", try_from(zero));
250-
println!("{:?}", <u64 as TryFrom<i128>>::try_from(zero));
251-
assert_eq!(<u64 as TryFrom<i128>>::try_from(zero).unwrap(), zero as u64);
252-
assert_eq!(
253-
<u64 as TryFrom<i128>>::try_from(t_max as i128).unwrap(),
254-
t_max as u64
255-
);
256-
assert_eq!(
257-
<u64 as TryFrom<i128>>::try_from(t_min as i128).unwrap(),
258-
t_min as u64
259-
);*/
10+
const IS_NONE: bool = OPTION.is_none();
11+
assert!(!IS_NONE);
26012
}

‎src/common.rs

Lines changed: 5 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -279,9 +279,12 @@ impl<'gcc, 'tcx> ConstMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
279279
self.get_static(def_id)
280280
},
281281
};
282-
let value = self.context.new_array_access(None, base_addr, self.const_usize(ptr.offset.bytes()));
282+
let ptr_type = base_addr.get_type();
283+
let base_addr = self.const_bitcast(base_addr, self.usize_type);
284+
let offset = self.context.new_rvalue_from_long(self.usize_type, ptr.offset.bytes() as i64);
285+
let ptr = self.const_bitcast(base_addr + offset, ptr_type);
286+
let value = ptr.dereference(None);
283287
if layout.value != Pointer {
284-
//unsafe { llvm::LLVMConstPtrToInt(value, ty) }
285288
self.const_bitcast(value.to_rvalue(), ty)
286289
}
287290
else {

0 commit comments

Comments
 (0)