}
fn run_cfail_test(config: &config, props: &TestProps, testfile: &Path) {
- let ProcRes = compile_test(config, props, testfile);
+ let proc_res = compile_test(config, props, testfile);
- if ProcRes.status.success() {
- fatal_ProcRes(~"compile-fail test compiled successfully!", &ProcRes);
+ if proc_res.status.success() {
+ fatal_ProcRes(~"compile-fail test compiled successfully!", &proc_res);
}
- check_correct_failure_status(&ProcRes);
+ check_correct_failure_status(&proc_res);
let expected_errors = errors::load_errors(testfile);
if !expected_errors.is_empty() {
if !props.error_patterns.is_empty() {
fatal(~"both error pattern and expected errors specified");
}
- check_expected_errors(expected_errors, testfile, &ProcRes);
+ check_expected_errors(expected_errors, testfile, &proc_res);
} else {
- check_error_patterns(props, testfile, &ProcRes);
+ check_error_patterns(props, testfile, &proc_res);
}
}
fn run_rfail_test(config: &config, props: &TestProps, testfile: &Path) {
- let ProcRes = if !config.jit {
- let ProcRes = compile_test(config, props, testfile);
+ let proc_res = if !config.jit {
+ let proc_res = compile_test(config, props, testfile);
- if !ProcRes.status.success() {
- fatal_ProcRes(~"compilation failed!", &ProcRes);
+ if !proc_res.status.success() {
+ fatal_ProcRes(~"compilation failed!", &proc_res);
}
exec_compiled_test(config, props, testfile)
// The value our Makefile configures valgrind to return on failure
static VALGRIND_ERR: int = 100;
- if ProcRes.status.matches_exit_status(VALGRIND_ERR) {
- fatal_ProcRes(~"run-fail test isn't valgrind-clean!", &ProcRes);
+ if proc_res.status.matches_exit_status(VALGRIND_ERR) {
+ fatal_ProcRes(~"run-fail test isn't valgrind-clean!", &proc_res);
}
- check_correct_failure_status(&ProcRes);
- check_error_patterns(props, testfile, &ProcRes);
+ check_correct_failure_status(&proc_res);
+ check_error_patterns(props, testfile, &proc_res);
}
-fn check_correct_failure_status(ProcRes: &ProcRes) {
+fn check_correct_failure_status(proc_res: &ProcRes) {
// The value the rust runtime returns on failure
static RUST_ERR: int = 101;
- if !ProcRes.status.matches_exit_status(RUST_ERR) {
+ if !proc_res.status.matches_exit_status(RUST_ERR) {
fatal_ProcRes(
- format!("failure produced the wrong error: {}", ProcRes.status),
- ProcRes);
+ format!("failure produced the wrong error: {}", proc_res.status),
+ proc_res);
}
}
fn run_rpass_test(config: &config, props: &TestProps, testfile: &Path) {
if !config.jit {
- let mut ProcRes = compile_test(config, props, testfile);
+ let mut proc_res = compile_test(config, props, testfile);
- if !ProcRes.status.success() {
- fatal_ProcRes(~"compilation failed!", &ProcRes);
+ if !proc_res.status.success() {
+ fatal_ProcRes(~"compilation failed!", &proc_res);
}
- ProcRes = exec_compiled_test(config, props, testfile);
+ proc_res = exec_compiled_test(config, props, testfile);
- if !ProcRes.status.success() {
- fatal_ProcRes(~"test run failed!", &ProcRes);
+ if !proc_res.status.success() {
+ fatal_ProcRes(~"test run failed!", &proc_res);
}
} else {
- let ProcRes = jit_test(config, props, testfile);
+ let proc_res = jit_test(config, props, testfile);
- if !ProcRes.status.success() { fatal_ProcRes(~"jit failed!", &ProcRes); }
+ if !proc_res.status.success() { fatal_ProcRes(~"jit failed!", &proc_res); }
}
}
let mut round = 0;
while round < rounds {
logv(config, format!("pretty-printing round {}", round));
- let ProcRes = print_source(config, testfile, srcs[round].clone());
+ let proc_res = print_source(config, testfile, srcs[round].clone());
- if !ProcRes.status.success() {
+ if !proc_res.status.success() {
fatal_ProcRes(format!("pretty-printing failed in round {}", round),
- &ProcRes);
+ &proc_res);
}
- let ProcRes{ stdout, .. } = ProcRes;
+ let ProcRes{ stdout, .. } = proc_res;
srcs.push(stdout);
round += 1;
}
compare_source(expected, actual);
// Finally, let's make sure it actually appears to remain valid code
- let ProcRes = typecheck_source(config, props, testfile, actual);
+ let proc_res = typecheck_source(config, props, testfile, actual);
- if !ProcRes.status.success() {
- fatal_ProcRes(~"pretty-printed source does not typecheck", &ProcRes);
+ if !proc_res.status.success() {
+ fatal_ProcRes(~"pretty-printed source does not typecheck", &proc_res);
}
return;
let mut cmds = props.debugger_cmds.connect("\n");
// compile test file (it shoud have 'compile-flags:-g' in the header)
- let mut ProcRes = compile_test(config, props, testfile);
- if !ProcRes.status.success() {
- fatal_ProcRes(~"compilation failed!", &ProcRes);
+ let mut proc_res = compile_test(config, props, testfile);
+ if !proc_res.status.success() {
+ fatal_ProcRes(~"compilation failed!", &proc_res);
}
let exe_file = make_exe_name(config, testfile);
- let mut ProcArgs;
+ let mut proc_args;
match config.target {
~"arm-linux-androideabi" => {
cmdline
};
- ProcRes = ProcRes {status: status,
+ proc_res = ProcRes {status: status,
stdout: out,
stderr: err,
cmdline: cmdline};
let debugger_opts = ~[~"-quiet", ~"-batch", ~"-nx",
"-command=" + debugger_script.as_str().unwrap().to_owned(),
exe_file.as_str().unwrap().to_owned()];
- ProcArgs = ProcArgs {prog: debugger(), args: debugger_opts};
- ProcRes = compose_and_run(config, testfile, ProcArgs, ~[], "", None);
+ proc_args = ProcArgs {prog: debugger(), args: debugger_opts};
+ proc_res = compose_and_run(config, testfile, proc_args, ~[], "", None);
}
}
- if !ProcRes.status.success() {
+ if !proc_res.status.success() {
fatal(~"gdb failed to execute");
}
let num_check_lines = check_lines.len();
// check if each line in props.check_lines appears in the
// output (in order)
let mut i = 0u;
- for line in ProcRes.stdout.lines() {
+ for line in proc_res.stdout.lines() {
let mut rest = line.trim();
let mut first = true;
let mut failed = false;
}
if i != num_check_lines {
fatal_ProcRes(format!("line not found in debugger output: {}",
- check_lines[i]), &ProcRes);
+ check_lines[i]), &proc_res);
}
}
fn check_error_patterns(props: &TestProps,
testfile: &Path,
- ProcRes: &ProcRes) {
+ proc_res: &ProcRes) {
if props.error_patterns.is_empty() {
fatal(~"no error pattern specified in " + testfile.display().as_maybe_owned().as_slice());
}
- if ProcRes.status.success() {
+ if proc_res.status.success() {
fatal(~"process did not return an error status");
}
let mut next_err_pat = &props.error_patterns[next_err_idx];
let mut done = false;
let output_to_check = if props.check_stdout {
- ProcRes.stdout + ProcRes.stderr
+ proc_res.stdout + proc_res.stderr
} else {
- ProcRes.stderr.clone()
+ proc_res.stderr.clone()
};
for line in output_to_check.lines() {
if line.contains(*next_err_pat) {
props.error_patterns.slice(next_err_idx, props.error_patterns.len());
if missing_patterns.len() == 1u {
fatal_ProcRes(format!("error pattern '{}' not found!",
- missing_patterns[0]), ProcRes);
+ missing_patterns[0]), proc_res);
} else {
for pattern in missing_patterns.iter() {
error(format!("error pattern '{}' not found!", *pattern));
}
- fatal_ProcRes(~"multiple error patterns not found", ProcRes);
+ fatal_ProcRes(~"multiple error patterns not found", proc_res);
}
}
fn check_expected_errors(expected_errors: ~[errors::ExpectedError],
testfile: &Path,
- ProcRes: &ProcRes) {
+ proc_res: &ProcRes) {
// true if we found the error in question
let mut found_flags = vec::from_elem(
expected_errors.len(), false);
- if ProcRes.status.success() {
+ if proc_res.status.success() {
fatal(~"process did not return an error status");
}
// filename:line1:col1: line2:col2: *warning:* msg
// where line1:col1: is the starting point, line2:col2:
// is the ending point, and * represents ANSI color codes.
- for line in ProcRes.stderr.lines() {
+ for line in proc_res.stderr.lines() {
let mut was_expected = false;
for (i, ee) in expected_errors.iter().enumerate() {
if !found_flags[i] {
if !was_expected && is_compiler_error_or_warning(line) {
fatal_ProcRes(format!("unexpected compiler error or warning: '{}'",
line),
- ProcRes);
+ proc_res);
}
}
if !flag {
let ee = &expected_errors[i];
fatal_ProcRes(format!("expected {} on line {} not found: {}",
- ee.kind, ee.line, ee.msg), ProcRes);
+ ee.kind, ee.line, ee.msg), proc_res);
}
}
}
fn fatal(err: ~str) -> ! { error(err); fail!(); }
-fn fatal_ProcRes(err: ~str, ProcRes: &ProcRes) -> ! {
+fn fatal_ProcRes(err: ~str, proc_res: &ProcRes) -> ! {
print!("\n\
error: {}\n\
command: {}\n\
{}\n\
------------------------------------------\n\
\n",
- err, ProcRes.cmdline, ProcRes.stdout, ProcRes.stderr);
+ err, proc_res.cmdline, proc_res.stdout, proc_res.stderr);
fail!();
}
let bitcodefile = output_base_name(config, testfile).with_extension("bc");
let bitcodefile = append_suffix_to_stem(&bitcodefile, "clang");
let testcc = testfile.with_extension("cc");
- let ProcArgs = ProcArgs {
+ let proc_args = ProcArgs {
// FIXME (#9639): This needs to handle non-utf8 paths
prog: config.clang_path.get_ref().as_str().unwrap().to_owned(),
args: ~[~"-c",
~"-o", bitcodefile.as_str().unwrap().to_owned(),
testcc.as_str().unwrap().to_owned() ]
};
- compose_and_run(config, testfile, ProcArgs, ~[], "", None)
+ compose_and_run(config, testfile, proc_args, ~[], "", None)
}
fn extract_function_from_bitcode(config: &config, _props: &TestProps,
let bitcodefile = append_suffix_to_stem(&bitcodefile, suffix);
let extracted_bc = append_suffix_to_stem(&bitcodefile, "extract");
let prog = config.llvm_bin_path.get_ref().join("llvm-extract");
- let ProcArgs = ProcArgs {
+ let proc_args = ProcArgs {
// FIXME (#9639): This needs to handle non-utf8 paths
prog: prog.as_str().unwrap().to_owned(),
args: ~["-func=" + fname,
"-o=" + extracted_bc.as_str().unwrap(),
bitcodefile.as_str().unwrap().to_owned() ]
};
- compose_and_run(config, testfile, ProcArgs, ~[], "", None)
+ compose_and_run(config, testfile, proc_args, ~[], "", None)
}
fn disassemble_extract(config: &config, _props: &TestProps,
let extracted_bc = append_suffix_to_stem(&bitcodefile, "extract");
let extracted_ll = extracted_bc.with_extension("ll");
let prog = config.llvm_bin_path.get_ref().join("llvm-dis");
- let ProcArgs = ProcArgs {
+ let proc_args = ProcArgs {
// FIXME (#9639): This needs to handle non-utf8 paths
prog: prog.as_str().unwrap().to_owned(),
args: ~["-o=" + extracted_ll.as_str().unwrap(),
extracted_bc.as_str().unwrap().to_owned() ]
};
- compose_and_run(config, testfile, ProcArgs, ~[], "", None)
+ compose_and_run(config, testfile, proc_args, ~[], "", None)
}
fatal(~"missing --clang-path");
}
- let mut ProcRes = compile_test_and_save_bitcode(config, props, testfile);
- if !ProcRes.status.success() {
- fatal_ProcRes(~"compilation failed!", &ProcRes);
+ let mut proc_res = compile_test_and_save_bitcode(config, props, testfile);
+ if !proc_res.status.success() {
+ fatal_ProcRes(~"compilation failed!", &proc_res);
}
- ProcRes = extract_function_from_bitcode(config, props, "test", testfile, "");
- if !ProcRes.status.success() {
- fatal_ProcRes(~"extracting 'test' function failed", &ProcRes);
+ proc_res = extract_function_from_bitcode(config, props, "test", testfile, "");
+ if !proc_res.status.success() {
+ fatal_ProcRes(~"extracting 'test' function failed", &proc_res);
}
- ProcRes = disassemble_extract(config, props, testfile, "");
- if !ProcRes.status.success() {
- fatal_ProcRes(~"disassembling extract failed", &ProcRes);
+ proc_res = disassemble_extract(config, props, testfile, "");
+ if !proc_res.status.success() {
+ fatal_ProcRes(~"disassembling extract failed", &proc_res);
}
- let mut ProcRes = compile_cc_with_clang_and_save_bitcode(config, props, testfile);
- if !ProcRes.status.success() {
- fatal_ProcRes(~"compilation failed!", &ProcRes);
+ let mut proc_res = compile_cc_with_clang_and_save_bitcode(config, props, testfile);
+ if !proc_res.status.success() {
+ fatal_ProcRes(~"compilation failed!", &proc_res);
}
- ProcRes = extract_function_from_bitcode(config, props, "test", testfile, "clang");
- if !ProcRes.status.success() {
- fatal_ProcRes(~"extracting 'test' function failed", &ProcRes);
+ proc_res = extract_function_from_bitcode(config, props, "test", testfile, "clang");
+ if !proc_res.status.success() {
+ fatal_ProcRes(~"extracting 'test' function failed", &proc_res);
}
- ProcRes = disassemble_extract(config, props, testfile, "clang");
- if !ProcRes.status.success() {
- fatal_ProcRes(~"disassembling extract failed", &ProcRes);
+ proc_res = disassemble_extract(config, props, testfile, "clang");
+ if !proc_res.status.success() {
+ fatal_ProcRes(~"disassembling extract failed", &proc_res);
}
let base = output_base_name(config, testfile);
// (a1*b1 + a0*b0 - (a1-b0)*(b1-a0)) * base +
// a0*b0
let half_len = cmp::max(s_len, o_len) / 2;
- let (sHi, sLo) = cut_at(self, half_len);
- let (oHi, oLo) = cut_at(other, half_len);
+ let (s_hi, s_lo) = cut_at(self, half_len);
+ let (o_hi, o_lo) = cut_at(other, half_len);
- let ll = sLo * oLo;
- let hh = sHi * oHi;
+ let ll = s_lo * o_lo;
+ let hh = s_hi * o_hi;
let mm = {
- let (s1, n1) = sub_sign(sHi, sLo);
- let (s2, n2) = sub_sign(oHi, oLo);
+ let (s1, n1) = sub_sign(s_hi, s_lo);
+ let (s2, n2) = sub_sign(o_hi, o_lo);
match (s1, s2) {
(Equal, _) | (_, Equal) => hh + ll,
(Less, Greater) | (Greater, Less) => hh + ll + (n1 * n2),
#[test]
fn test_add() {
for elm in sum_triples.iter() {
- let (aVec, bVec, cVec) = *elm;
- let a = BigUint::from_slice(aVec);
- let b = BigUint::from_slice(bVec);
- let c = BigUint::from_slice(cVec);
+ let (a_vec, b_vec, c_vec) = *elm;
+ let a = BigUint::from_slice(a_vec);
+ let b = BigUint::from_slice(b_vec);
+ let c = BigUint::from_slice(c_vec);
assert!(a + b == c);
assert!(b + a == c);
#[test]
fn test_sub() {
for elm in sum_triples.iter() {
- let (aVec, bVec, cVec) = *elm;
- let a = BigUint::from_slice(aVec);
- let b = BigUint::from_slice(bVec);
- let c = BigUint::from_slice(cVec);
+ let (a_vec, b_vec, c_vec) = *elm;
+ let a = BigUint::from_slice(a_vec);
+ let b = BigUint::from_slice(b_vec);
+ let c = BigUint::from_slice(c_vec);
assert!(c - a == b);
assert!(c - b == a);
#[test]
fn test_mul() {
for elm in mul_triples.iter() {
- let (aVec, bVec, cVec) = *elm;
- let a = BigUint::from_slice(aVec);
- let b = BigUint::from_slice(bVec);
- let c = BigUint::from_slice(cVec);
+ let (a_vec, b_vec, c_vec) = *elm;
+ let a = BigUint::from_slice(a_vec);
+ let b = BigUint::from_slice(b_vec);
+ let c = BigUint::from_slice(c_vec);
assert!(a * b == c);
assert!(b * a == c);
}
for elm in div_rem_quadruples.iter() {
- let (aVec, bVec, cVec, dVec) = *elm;
- let a = BigUint::from_slice(aVec);
- let b = BigUint::from_slice(bVec);
- let c = BigUint::from_slice(cVec);
- let d = BigUint::from_slice(dVec);
+ let (a_vec, b_vec, c_vec, d_vec) = *elm;
+ let a = BigUint::from_slice(a_vec);
+ let b = BigUint::from_slice(b_vec);
+ let c = BigUint::from_slice(c_vec);
+ let d = BigUint::from_slice(d_vec);
assert!(a == b * c + d);
assert!(a == c * b + d);
#[test]
fn test_div_rem() {
for elm in mul_triples.iter() {
- let (aVec, bVec, cVec) = *elm;
- let a = BigUint::from_slice(aVec);
- let b = BigUint::from_slice(bVec);
- let c = BigUint::from_slice(cVec);
+ let (a_vec, b_vec, c_vec) = *elm;
+ let a = BigUint::from_slice(a_vec);
+ let b = BigUint::from_slice(b_vec);
+ let c = BigUint::from_slice(c_vec);
if !a.is_zero() {
assert_eq!(c.div_rem(&a), (b.clone(), Zero::zero()));
}
for elm in div_rem_quadruples.iter() {
- let (aVec, bVec, cVec, dVec) = *elm;
- let a = BigUint::from_slice(aVec);
- let b = BigUint::from_slice(bVec);
- let c = BigUint::from_slice(cVec);
- let d = BigUint::from_slice(dVec);
+ let (a_vec, b_vec, c_vec, d_vec) = *elm;
+ let a = BigUint::from_slice(a_vec);
+ let b = BigUint::from_slice(b_vec);
+ let c = BigUint::from_slice(c_vec);
+ let d = BigUint::from_slice(d_vec);
if !b.is_zero() { assert!(a.div_rem(&b) == (c, d)); }
}
#[test]
fn test_add() {
for elm in sum_triples.iter() {
- let (aVec, bVec, cVec) = *elm;
- let a = BigInt::from_slice(Plus, aVec);
- let b = BigInt::from_slice(Plus, bVec);
- let c = BigInt::from_slice(Plus, cVec);
+ let (a_vec, b_vec, c_vec) = *elm;
+ let a = BigInt::from_slice(Plus, a_vec);
+ let b = BigInt::from_slice(Plus, b_vec);
+ let c = BigInt::from_slice(Plus, c_vec);
assert!(a + b == c);
assert!(b + a == c);
#[test]
fn test_sub() {
for elm in sum_triples.iter() {
- let (aVec, bVec, cVec) = *elm;
- let a = BigInt::from_slice(Plus, aVec);
- let b = BigInt::from_slice(Plus, bVec);
- let c = BigInt::from_slice(Plus, cVec);
+ let (a_vec, b_vec, c_vec) = *elm;
+ let a = BigInt::from_slice(Plus, a_vec);
+ let b = BigInt::from_slice(Plus, b_vec);
+ let c = BigInt::from_slice(Plus, c_vec);
assert!(c - a == b);
assert!(c - b == a);
#[test]
fn test_mul() {
for elm in mul_triples.iter() {
- let (aVec, bVec, cVec) = *elm;
- let a = BigInt::from_slice(Plus, aVec);
- let b = BigInt::from_slice(Plus, bVec);
- let c = BigInt::from_slice(Plus, cVec);
+ let (a_vec, b_vec, c_vec) = *elm;
+ let a = BigInt::from_slice(Plus, a_vec);
+ let b = BigInt::from_slice(Plus, b_vec);
+ let c = BigInt::from_slice(Plus, c_vec);
assert!(a * b == c);
assert!(b * a == c);
}
for elm in div_rem_quadruples.iter() {
- let (aVec, bVec, cVec, dVec) = *elm;
- let a = BigInt::from_slice(Plus, aVec);
- let b = BigInt::from_slice(Plus, bVec);
- let c = BigInt::from_slice(Plus, cVec);
- let d = BigInt::from_slice(Plus, dVec);
+ let (a_vec, b_vec, c_vec, d_vec) = *elm;
+ let a = BigInt::from_slice(Plus, a_vec);
+ let b = BigInt::from_slice(Plus, b_vec);
+ let c = BigInt::from_slice(Plus, c_vec);
+ let d = BigInt::from_slice(Plus, d_vec);
assert!(a == b * c + d);
assert!(a == c * b + d);
}
for elm in mul_triples.iter() {
- let (aVec, bVec, cVec) = *elm;
- let a = BigInt::from_slice(Plus, aVec);
- let b = BigInt::from_slice(Plus, bVec);
- let c = BigInt::from_slice(Plus, cVec);
+ let (a_vec, b_vec, c_vec) = *elm;
+ let a = BigInt::from_slice(Plus, a_vec);
+ let b = BigInt::from_slice(Plus, b_vec);
+ let c = BigInt::from_slice(Plus, c_vec);
if !a.is_zero() { check(&c, &a, &b, &Zero::zero()); }
if !b.is_zero() { check(&c, &b, &a, &Zero::zero()); }
}
for elm in div_rem_quadruples.iter() {
- let (aVec, bVec, cVec, dVec) = *elm;
- let a = BigInt::from_slice(Plus, aVec);
- let b = BigInt::from_slice(Plus, bVec);
- let c = BigInt::from_slice(Plus, cVec);
- let d = BigInt::from_slice(Plus, dVec);
+ let (a_vec, b_vec, c_vec, d_vec) = *elm;
+ let a = BigInt::from_slice(Plus, a_vec);
+ let b = BigInt::from_slice(Plus, b_vec);
+ let c = BigInt::from_slice(Plus, c_vec);
+ let d = BigInt::from_slice(Plus, d_vec);
if !b.is_zero() {
check(&a, &b, &c, &d);
check_sub(&a.neg(), &b.neg(), q, &r.neg());
}
for elm in mul_triples.iter() {
- let (aVec, bVec, cVec) = *elm;
- let a = BigInt::from_slice(Plus, aVec);
- let b = BigInt::from_slice(Plus, bVec);
- let c = BigInt::from_slice(Plus, cVec);
+ let (a_vec, b_vec, c_vec) = *elm;
+ let a = BigInt::from_slice(Plus, a_vec);
+ let b = BigInt::from_slice(Plus, b_vec);
+ let c = BigInt::from_slice(Plus, c_vec);
if !a.is_zero() { check(&c, &a, &b, &Zero::zero()); }
if !b.is_zero() { check(&c, &b, &a, &Zero::zero()); }
}
for elm in div_rem_quadruples.iter() {
- let (aVec, bVec, cVec, dVec) = *elm;
- let a = BigInt::from_slice(Plus, aVec);
- let b = BigInt::from_slice(Plus, bVec);
- let c = BigInt::from_slice(Plus, cVec);
- let d = BigInt::from_slice(Plus, dVec);
+ let (a_vec, b_vec, c_vec, d_vec) = *elm;
+ let a = BigInt::from_slice(Plus, a_vec);
+ let b = BigInt::from_slice(Plus, b_vec);
+ let c = BigInt::from_slice(Plus, c_vec);
+ let d = BigInt::from_slice(Plus, d_vec);
if !b.is_zero() {
check(&a, &b, &c, &d);
pub fn WriteOutputFile(
sess: Session,
- Target: lib::llvm::TargetMachineRef,
- PM: lib::llvm::PassManagerRef,
- M: ModuleRef,
- Output: &Path,
- FileType: lib::llvm::FileType) {
+ target: lib::llvm::TargetMachineRef,
+ pm: lib::llvm::PassManagerRef,
+ m: ModuleRef,
+ output: &Path,
+ file_type: lib::llvm::FileType) {
unsafe {
- Output.with_c_str(|Output| {
+ output.with_c_str(|output| {
let result = llvm::LLVMRustWriteOutputFile(
- Target, PM, M, Output, FileType);
+ target, pm, m, output, file_type);
if !result {
llvm_err(sess, ~"could not write output");
}
})
}
- let OptLevel = match sess.opts.optimize {
+ let opt_level = match sess.opts.optimize {
session::No => lib::llvm::CodeGenLevelNone,
session::Less => lib::llvm::CodeGenLevelLess,
session::Default => lib::llvm::CodeGenLevelDefault,
(sess.targ_cfg.os == abi::OsMacos &&
sess.targ_cfg.arch == abi::X86_64);
- let tm = sess.targ_cfg.target_strs.target_triple.with_c_str(|T| {
- sess.opts.cg.target_cpu.with_c_str(|CPU| {
- target_feature(&sess).with_c_str(|Features| {
+ let tm = sess.targ_cfg.target_strs.target_triple.with_c_str(|t| {
+ sess.opts.cg.target_cpu.with_c_str(|cpu| {
+ target_feature(&sess).with_c_str(|features| {
llvm::LLVMRustCreateTargetMachine(
- T, CPU, Features,
+ t, cpu, features,
lib::llvm::CodeModelDefault,
lib::llvm::RelocPIC,
- OptLevel,
+ opt_level,
true,
use_softfp,
no_fp_elim
if !sess.opts.cg.no_prepopulate_passes {
llvm::LLVMRustAddAnalysisPasses(tm, fpm, llmod);
llvm::LLVMRustAddAnalysisPasses(tm, mpm, llmod);
- populate_llvm_passes(fpm, mpm, llmod, OptLevel);
+ populate_llvm_passes(fpm, mpm, llmod, opt_level);
}
for pass in sess.opts.cg.passes.iter() {
}
}
-pub fn SetInstructionCallConv(Instr: ValueRef, CC: CallConv) {
+pub fn SetInstructionCallConv(instr: ValueRef, cc: CallConv) {
unsafe {
- llvm::LLVMSetInstructionCallConv(Instr, CC as c_uint);
+ llvm::LLVMSetInstructionCallConv(instr, cc as c_uint);
}
}
-pub fn SetFunctionCallConv(Fn: ValueRef, CC: CallConv) {
+pub fn SetFunctionCallConv(fn_: ValueRef, cc: CallConv) {
unsafe {
- llvm::LLVMSetFunctionCallConv(Fn, CC as c_uint);
+ llvm::LLVMSetFunctionCallConv(fn_, cc as c_uint);
}
}
-pub fn SetLinkage(Global: ValueRef, Link: Linkage) {
+pub fn SetLinkage(global: ValueRef, link: Linkage) {
unsafe {
- llvm::LLVMSetLinkage(Global, Link as c_uint);
+ llvm::LLVMSetLinkage(global, link as c_uint);
}
}
-pub fn SetUnnamedAddr(Global: ValueRef, Unnamed: bool) {
+pub fn SetUnnamedAddr(global: ValueRef, unnamed: bool) {
unsafe {
- llvm::LLVMSetUnnamedAddr(Global, Unnamed as Bool);
+ llvm::LLVMSetUnnamedAddr(global, unnamed as Bool);
}
}
}
}
-pub fn ConstICmp(Pred: IntPredicate, V1: ValueRef, V2: ValueRef) -> ValueRef {
+pub fn ConstICmp(pred: IntPredicate, v1: ValueRef, v2: ValueRef) -> ValueRef {
unsafe {
- llvm::LLVMConstICmp(Pred as c_ushort, V1, V2)
+ llvm::LLVMConstICmp(pred as c_ushort, v1, v2)
}
}
-pub fn ConstFCmp(Pred: RealPredicate, V1: ValueRef, V2: ValueRef) -> ValueRef {
+pub fn ConstFCmp(pred: RealPredicate, v1: ValueRef, v2: ValueRef) -> ValueRef {
unsafe {
- llvm::LLVMConstFCmp(Pred as c_ushort, V1, V2)
+ llvm::LLVMConstFCmp(pred as c_ushort, v1, v2)
}
}
-pub fn SetFunctionAttribute(Fn: ValueRef, attr: Attribute) {
+pub fn SetFunctionAttribute(fn_: ValueRef, attr: Attribute) {
unsafe {
- llvm::LLVMAddFunctionAttr(Fn, attr as c_uint)
+ llvm::LLVMAddFunctionAttr(fn_, attr as c_uint)
}
}
/* Memory-managed object interface to type handles. */
}
}
-pub fn target_data_res(TD: TargetDataRef) -> target_data_res {
+pub fn target_data_res(td: TargetDataRef) -> target_data_res {
target_data_res {
- TD: TD
+ TD: td
}
}
}
}
-pub fn pass_manager_res(PM: PassManagerRef) -> pass_manager_res {
+pub fn pass_manager_res(pm: PassManagerRef) -> pass_manager_res {
pass_manager_res {
- PM: PM
+ PM: pm
}
}
}
}
-pub fn section_iter_res(SI: SectionIteratorRef) -> section_iter_res {
+pub fn section_iter_res(si: SectionIteratorRef) -> section_iter_res {
section_iter_res {
- SI: SI
+ SI: si
}
}
debug!("Asm Constraints: {:?}", constraints);
- let numOutputs = outputs.len();
+ let num_outputs = outputs.len();
// Depending on how many outputs we have, the return type is different
- let output_type = if numOutputs == 0 {
+ let output_type = if num_outputs == 0 {
Type::void()
- } else if numOutputs == 1 {
+ } else if num_outputs == 1 {
output_types[0]
} else {
Type::struct_(output_types, false)
});
// Again, based on how many outputs we have
- if numOutputs == 1 {
+ if num_outputs == 1 {
Store(bcx, r, *outputs.get(0));
} else {
for (i, o) in outputs.iter().enumerate() {
B(cx).ret_void();
}
-pub fn Ret(cx: &Block, V: ValueRef) {
+pub fn Ret(cx: &Block, v: ValueRef) {
if cx.unreachable.get() { return; }
check_not_terminated(cx);
terminate(cx, "Ret");
- B(cx).ret(V);
+ B(cx).ret(v);
}
-pub fn AggregateRet(cx: &Block, RetVals: &[ValueRef]) {
+pub fn AggregateRet(cx: &Block, ret_vals: &[ValueRef]) {
if cx.unreachable.get() { return; }
check_not_terminated(cx);
terminate(cx, "AggregateRet");
- B(cx).aggregate_ret(RetVals);
+ B(cx).aggregate_ret(ret_vals);
}
-pub fn Br(cx: &Block, Dest: BasicBlockRef) {
+pub fn Br(cx: &Block, dest: BasicBlockRef) {
if cx.unreachable.get() { return; }
check_not_terminated(cx);
terminate(cx, "Br");
- B(cx).br(Dest);
+ B(cx).br(dest);
}
pub fn CondBr(cx: &Block,
- If: ValueRef,
- Then: BasicBlockRef,
- Else: BasicBlockRef) {
+ if_: ValueRef,
+ then: BasicBlockRef,
+ else_: BasicBlockRef) {
if cx.unreachable.get() { return; }
check_not_terminated(cx);
terminate(cx, "CondBr");
- B(cx).cond_br(If, Then, Else);
+ B(cx).cond_br(if_, then, else_);
}
-pub fn Switch(cx: &Block, V: ValueRef, Else: BasicBlockRef, NumCases: uint)
+pub fn Switch(cx: &Block, v: ValueRef, else_: BasicBlockRef, num_cases: uint)
-> ValueRef {
- if cx.unreachable.get() { return _Undef(V); }
+ if cx.unreachable.get() { return _Undef(v); }
check_not_terminated(cx);
terminate(cx, "Switch");
- B(cx).switch(V, Else, NumCases)
+ B(cx).switch(v, else_, num_cases)
}
-pub fn AddCase(S: ValueRef, OnVal: ValueRef, Dest: BasicBlockRef) {
+pub fn AddCase(s: ValueRef, on_val: ValueRef, dest: BasicBlockRef) {
unsafe {
- if llvm::LLVMIsUndef(S) == lib::llvm::True { return; }
- llvm::LLVMAddCase(S, OnVal, Dest);
+ if llvm::LLVMIsUndef(s) == lib::llvm::True { return; }
+ llvm::LLVMAddCase(s, on_val, dest);
}
}
-pub fn IndirectBr(cx: &Block, Addr: ValueRef, NumDests: uint) {
+pub fn IndirectBr(cx: &Block, addr: ValueRef, num_dests: uint) {
if cx.unreachable.get() { return; }
check_not_terminated(cx);
terminate(cx, "IndirectBr");
- B(cx).indirect_br(Addr, NumDests);
+ B(cx).indirect_br(addr, num_dests);
}
pub fn Invoke(cx: &Block,
- Fn: ValueRef,
- Args: &[ValueRef],
- Then: BasicBlockRef,
- Catch: BasicBlockRef,
+ fn_: ValueRef,
+ args: &[ValueRef],
+ then: BasicBlockRef,
+ catch: BasicBlockRef,
attributes: &[(uint, lib::llvm::Attribute)])
-> ValueRef {
if cx.unreachable.get() {
check_not_terminated(cx);
terminate(cx, "Invoke");
debug!("Invoke({} with arguments ({}))",
- cx.val_to_str(Fn),
- Args.map(|a| cx.val_to_str(*a)).connect(", "));
- B(cx).invoke(Fn, Args, Then, Catch, attributes)
+ cx.val_to_str(fn_),
+ args.map(|a| cx.val_to_str(*a)).connect(", "));
+ B(cx).invoke(fn_, args, then, catch, attributes)
}
pub fn Unreachable(cx: &Block) {
}
/* Arithmetic */
-pub fn Add(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
- if cx.unreachable.get() { return _Undef(LHS); }
- B(cx).add(LHS, RHS)
+pub fn Add(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+ if cx.unreachable.get() { return _Undef(lhs); }
+ B(cx).add(lhs, rhs)
}
-pub fn NSWAdd(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
- if cx.unreachable.get() { return _Undef(LHS); }
- B(cx).nswadd(LHS, RHS)
+pub fn NSWAdd(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+ if cx.unreachable.get() { return _Undef(lhs); }
+ B(cx).nswadd(lhs, rhs)
}
-pub fn NUWAdd(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
- if cx.unreachable.get() { return _Undef(LHS); }
- B(cx).nuwadd(LHS, RHS)
+pub fn NUWAdd(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+ if cx.unreachable.get() { return _Undef(lhs); }
+ B(cx).nuwadd(lhs, rhs)
}
-pub fn FAdd(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
- if cx.unreachable.get() { return _Undef(LHS); }
- B(cx).fadd(LHS, RHS)
+pub fn FAdd(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+ if cx.unreachable.get() { return _Undef(lhs); }
+ B(cx).fadd(lhs, rhs)
}
-pub fn Sub(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
- if cx.unreachable.get() { return _Undef(LHS); }
- B(cx).sub(LHS, RHS)
+pub fn Sub(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+ if cx.unreachable.get() { return _Undef(lhs); }
+ B(cx).sub(lhs, rhs)
}
-pub fn NSWSub(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
- if cx.unreachable.get() { return _Undef(LHS); }
- B(cx).nswsub(LHS, RHS)
+pub fn NSWSub(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+ if cx.unreachable.get() { return _Undef(lhs); }
+ B(cx).nswsub(lhs, rhs)
}
-pub fn NUWSub(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
- if cx.unreachable.get() { return _Undef(LHS); }
- B(cx).nuwsub(LHS, RHS)
+pub fn NUWSub(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+ if cx.unreachable.get() { return _Undef(lhs); }
+ B(cx).nuwsub(lhs, rhs)
}
-pub fn FSub(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
- if cx.unreachable.get() { return _Undef(LHS); }
- B(cx).fsub(LHS, RHS)
+pub fn FSub(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+ if cx.unreachable.get() { return _Undef(lhs); }
+ B(cx).fsub(lhs, rhs)
}
-pub fn Mul(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
- if cx.unreachable.get() { return _Undef(LHS); }
- B(cx).mul(LHS, RHS)
+pub fn Mul(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+ if cx.unreachable.get() { return _Undef(lhs); }
+ B(cx).mul(lhs, rhs)
}
-pub fn NSWMul(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
- if cx.unreachable.get() { return _Undef(LHS); }
- B(cx).nswmul(LHS, RHS)
+pub fn NSWMul(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+ if cx.unreachable.get() { return _Undef(lhs); }
+ B(cx).nswmul(lhs, rhs)
}
-pub fn NUWMul(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
- if cx.unreachable.get() { return _Undef(LHS); }
- B(cx).nuwmul(LHS, RHS)
+pub fn NUWMul(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+ if cx.unreachable.get() { return _Undef(lhs); }
+ B(cx).nuwmul(lhs, rhs)
}
-pub fn FMul(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
- if cx.unreachable.get() { return _Undef(LHS); }
- B(cx).fmul(LHS, RHS)
+pub fn FMul(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+ if cx.unreachable.get() { return _Undef(lhs); }
+ B(cx).fmul(lhs, rhs)
}
-pub fn UDiv(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
- if cx.unreachable.get() { return _Undef(LHS); }
- B(cx).udiv(LHS, RHS)
+pub fn UDiv(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+ if cx.unreachable.get() { return _Undef(lhs); }
+ B(cx).udiv(lhs, rhs)
}
-pub fn SDiv(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
- if cx.unreachable.get() { return _Undef(LHS); }
- B(cx).sdiv(LHS, RHS)
+pub fn SDiv(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+ if cx.unreachable.get() { return _Undef(lhs); }
+ B(cx).sdiv(lhs, rhs)
}
-pub fn ExactSDiv(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
- if cx.unreachable.get() { return _Undef(LHS); }
- B(cx).exactsdiv(LHS, RHS)
+pub fn ExactSDiv(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+ if cx.unreachable.get() { return _Undef(lhs); }
+ B(cx).exactsdiv(lhs, rhs)
}
-pub fn FDiv(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
- if cx.unreachable.get() { return _Undef(LHS); }
- B(cx).fdiv(LHS, RHS)
+pub fn FDiv(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+ if cx.unreachable.get() { return _Undef(lhs); }
+ B(cx).fdiv(lhs, rhs)
}
-pub fn URem(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
- if cx.unreachable.get() { return _Undef(LHS); }
- B(cx).urem(LHS, RHS)
+pub fn URem(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+ if cx.unreachable.get() { return _Undef(lhs); }
+ B(cx).urem(lhs, rhs)
}
-pub fn SRem(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
- if cx.unreachable.get() { return _Undef(LHS); }
- B(cx).srem(LHS, RHS)
+pub fn SRem(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+ if cx.unreachable.get() { return _Undef(lhs); }
+ B(cx).srem(lhs, rhs)
}
-pub fn FRem(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
- if cx.unreachable.get() { return _Undef(LHS); }
- B(cx).frem(LHS, RHS)
+pub fn FRem(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+ if cx.unreachable.get() { return _Undef(lhs); }
+ B(cx).frem(lhs, rhs)
}
-pub fn Shl(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
- if cx.unreachable.get() { return _Undef(LHS); }
- B(cx).shl(LHS, RHS)
+pub fn Shl(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+ if cx.unreachable.get() { return _Undef(lhs); }
+ B(cx).shl(lhs, rhs)
}
-pub fn LShr(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
- if cx.unreachable.get() { return _Undef(LHS); }
- B(cx).lshr(LHS, RHS)
+pub fn LShr(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+ if cx.unreachable.get() { return _Undef(lhs); }
+ B(cx).lshr(lhs, rhs)
}
-pub fn AShr(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
- if cx.unreachable.get() { return _Undef(LHS); }
- B(cx).ashr(LHS, RHS)
+pub fn AShr(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+ if cx.unreachable.get() { return _Undef(lhs); }
+ B(cx).ashr(lhs, rhs)
}
-pub fn And(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
- if cx.unreachable.get() { return _Undef(LHS); }
- B(cx).and(LHS, RHS)
+pub fn And(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+ if cx.unreachable.get() { return _Undef(lhs); }
+ B(cx).and(lhs, rhs)
}
-pub fn Or(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
- if cx.unreachable.get() { return _Undef(LHS); }
- B(cx).or(LHS, RHS)
+pub fn Or(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+ if cx.unreachable.get() { return _Undef(lhs); }
+ B(cx).or(lhs, rhs)
}
-pub fn Xor(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
- if cx.unreachable.get() { return _Undef(LHS); }
- B(cx).xor(LHS, RHS)
+pub fn Xor(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+ if cx.unreachable.get() { return _Undef(lhs); }
+ B(cx).xor(lhs, rhs)
}
-pub fn BinOp(cx: &Block, Op: Opcode, LHS: ValueRef, RHS: ValueRef)
+pub fn BinOp(cx: &Block, op: Opcode, lhs: ValueRef, rhs: ValueRef)
-> ValueRef {
- if cx.unreachable.get() { return _Undef(LHS); }
- B(cx).binop(Op, LHS, RHS)
+ if cx.unreachable.get() { return _Undef(lhs); }
+ B(cx).binop(op, lhs, rhs)
}
-pub fn Neg(cx: &Block, V: ValueRef) -> ValueRef {
- if cx.unreachable.get() { return _Undef(V); }
- B(cx).neg(V)
+pub fn Neg(cx: &Block, v: ValueRef) -> ValueRef {
+ if cx.unreachable.get() { return _Undef(v); }
+ B(cx).neg(v)
}
-pub fn NSWNeg(cx: &Block, V: ValueRef) -> ValueRef {
- if cx.unreachable.get() { return _Undef(V); }
- B(cx).nswneg(V)
+pub fn NSWNeg(cx: &Block, v: ValueRef) -> ValueRef {
+ if cx.unreachable.get() { return _Undef(v); }
+ B(cx).nswneg(v)
}
-pub fn NUWNeg(cx: &Block, V: ValueRef) -> ValueRef {
- if cx.unreachable.get() { return _Undef(V); }
- B(cx).nuwneg(V)
+pub fn NUWNeg(cx: &Block, v: ValueRef) -> ValueRef {
+ if cx.unreachable.get() { return _Undef(v); }
+ B(cx).nuwneg(v)
}
-pub fn FNeg(cx: &Block, V: ValueRef) -> ValueRef {
- if cx.unreachable.get() { return _Undef(V); }
- B(cx).fneg(V)
+pub fn FNeg(cx: &Block, v: ValueRef) -> ValueRef {
+ if cx.unreachable.get() { return _Undef(v); }
+ B(cx).fneg(v)
}
-pub fn Not(cx: &Block, V: ValueRef) -> ValueRef {
- if cx.unreachable.get() { return _Undef(V); }
- B(cx).not(V)
+pub fn Not(cx: &Block, v: ValueRef) -> ValueRef {
+ if cx.unreachable.get() { return _Undef(v); }
+ B(cx).not(v)
}
/* Memory */
-pub fn Malloc(cx: &Block, Ty: Type) -> ValueRef {
+pub fn Malloc(cx: &Block, ty: Type) -> ValueRef {
unsafe {
if cx.unreachable.get() { return llvm::LLVMGetUndef(Type::i8p().to_ref()); }
- B(cx).malloc(Ty)
+ B(cx).malloc(ty)
}
}
-pub fn ArrayMalloc(cx: &Block, Ty: Type, Val: ValueRef) -> ValueRef {
+pub fn ArrayMalloc(cx: &Block, ty: Type, val: ValueRef) -> ValueRef {
unsafe {
if cx.unreachable.get() { return llvm::LLVMGetUndef(Type::i8p().to_ref()); }
- B(cx).array_malloc(Ty, Val)
+ B(cx).array_malloc(ty, val)
}
}
-pub fn Alloca(cx: &Block, Ty: Type, name: &str) -> ValueRef {
+pub fn Alloca(cx: &Block, ty: Type, name: &str) -> ValueRef {
unsafe {
- if cx.unreachable.get() { return llvm::LLVMGetUndef(Ty.ptr_to().to_ref()); }
- AllocaFcx(cx.fcx, Ty, name)
+ if cx.unreachable.get() { return llvm::LLVMGetUndef(ty.ptr_to().to_ref()); }
+ AllocaFcx(cx.fcx, ty, name)
}
}
-pub fn AllocaFcx(fcx: &FunctionContext, Ty: Type, name: &str) -> ValueRef {
+pub fn AllocaFcx(fcx: &FunctionContext, ty: Type, name: &str) -> ValueRef {
let b = fcx.ccx.builder();
b.position_before(fcx.alloca_insert_pt.get().unwrap());
- b.alloca(Ty, name)
+ b.alloca(ty, name)
}
-pub fn ArrayAlloca(cx: &Block, Ty: Type, Val: ValueRef) -> ValueRef {
+pub fn ArrayAlloca(cx: &Block, ty: Type, val: ValueRef) -> ValueRef {
unsafe {
- if cx.unreachable.get() { return llvm::LLVMGetUndef(Ty.ptr_to().to_ref()); }
+ if cx.unreachable.get() { return llvm::LLVMGetUndef(ty.ptr_to().to_ref()); }
let b = cx.fcx.ccx.builder();
b.position_before(cx.fcx.alloca_insert_pt.get().unwrap());
- b.array_alloca(Ty, Val)
+ b.array_alloca(ty, val)
}
}
-pub fn Free(cx: &Block, PointerVal: ValueRef) {
+pub fn Free(cx: &Block, pointer_val: ValueRef) {
if cx.unreachable.get() { return; }
- B(cx).free(PointerVal)
+ B(cx).free(pointer_val)
}
-pub fn Load(cx: &Block, PointerVal: ValueRef) -> ValueRef {
+pub fn Load(cx: &Block, pointer_val: ValueRef) -> ValueRef {
unsafe {
let ccx = cx.fcx.ccx;
if cx.unreachable.get() {
- let ty = val_ty(PointerVal);
+ let ty = val_ty(pointer_val);
let eltty = if ty.kind() == lib::llvm::Array {
ty.element_type()
} else {
};
return llvm::LLVMGetUndef(eltty.to_ref());
}
- B(cx).load(PointerVal)
+ B(cx).load(pointer_val)
}
}
-pub fn VolatileLoad(cx: &Block, PointerVal: ValueRef) -> ValueRef {
+pub fn VolatileLoad(cx: &Block, pointer_val: ValueRef) -> ValueRef {
unsafe {
if cx.unreachable.get() { return llvm::LLVMGetUndef(Type::nil().to_ref()); }
- B(cx).volatile_load(PointerVal)
+ B(cx).volatile_load(pointer_val)
}
}
-pub fn AtomicLoad(cx: &Block, PointerVal: ValueRef, order: AtomicOrdering) -> ValueRef {
+pub fn AtomicLoad(cx: &Block, pointer_val: ValueRef, order: AtomicOrdering) -> ValueRef {
unsafe {
let ccx = cx.fcx.ccx;
if cx.unreachable.get() {
return llvm::LLVMGetUndef(ccx.int_type.to_ref());
}
- B(cx).atomic_load(PointerVal, order)
+ B(cx).atomic_load(pointer_val, order)
}
}
-pub fn LoadRangeAssert(cx: &Block, PointerVal: ValueRef, lo: c_ulonglong,
+pub fn LoadRangeAssert(cx: &Block, pointer_val: ValueRef, lo: c_ulonglong,
hi: c_ulonglong, signed: lib::llvm::Bool) -> ValueRef {
if cx.unreachable.get() {
let ccx = cx.fcx.ccx;
- let ty = val_ty(PointerVal);
+ let ty = val_ty(pointer_val);
let eltty = if ty.kind() == lib::llvm::Array {
ty.element_type()
} else {
llvm::LLVMGetUndef(eltty.to_ref())
}
} else {
- B(cx).load_range_assert(PointerVal, lo, hi, signed)
+ B(cx).load_range_assert(pointer_val, lo, hi, signed)
}
}
-pub fn Store(cx: &Block, Val: ValueRef, Ptr: ValueRef) {
+pub fn Store(cx: &Block, val: ValueRef, ptr: ValueRef) {
if cx.unreachable.get() { return; }
- B(cx).store(Val, Ptr)
+ B(cx).store(val, ptr)
}
-pub fn VolatileStore(cx: &Block, Val: ValueRef, Ptr: ValueRef) {
+pub fn VolatileStore(cx: &Block, val: ValueRef, ptr: ValueRef) {
if cx.unreachable.get() { return; }
- B(cx).volatile_store(Val, Ptr)
+ B(cx).volatile_store(val, ptr)
}
-pub fn AtomicStore(cx: &Block, Val: ValueRef, Ptr: ValueRef, order: AtomicOrdering) {
+pub fn AtomicStore(cx: &Block, val: ValueRef, ptr: ValueRef, order: AtomicOrdering) {
if cx.unreachable.get() { return; }
- B(cx).atomic_store(Val, Ptr, order)
+ B(cx).atomic_store(val, ptr, order)
}
-pub fn GEP(cx: &Block, Pointer: ValueRef, Indices: &[ValueRef]) -> ValueRef {
+pub fn GEP(cx: &Block, pointer: ValueRef, indices: &[ValueRef]) -> ValueRef {
unsafe {
if cx.unreachable.get() { return llvm::LLVMGetUndef(Type::nil().ptr_to().to_ref()); }
- B(cx).gep(Pointer, Indices)
+ B(cx).gep(pointer, indices)
}
}
}
}
-pub fn InBoundsGEP(cx: &Block, Pointer: ValueRef, Indices: &[ValueRef]) -> ValueRef {
+pub fn InBoundsGEP(cx: &Block, pointer: ValueRef, indices: &[ValueRef]) -> ValueRef {
unsafe {
if cx.unreachable.get() { return llvm::LLVMGetUndef(Type::nil().ptr_to().to_ref()); }
- B(cx).inbounds_gep(Pointer, Indices)
+ B(cx).inbounds_gep(pointer, indices)
}
}
-pub fn StructGEP(cx: &Block, Pointer: ValueRef, Idx: uint) -> ValueRef {
+pub fn StructGEP(cx: &Block, pointer: ValueRef, idx: uint) -> ValueRef {
unsafe {
if cx.unreachable.get() { return llvm::LLVMGetUndef(Type::nil().ptr_to().to_ref()); }
- B(cx).struct_gep(Pointer, Idx)
+ B(cx).struct_gep(pointer, idx)
}
}
-pub fn GlobalString(cx: &Block, _Str: *c_char) -> ValueRef {
+pub fn GlobalString(cx: &Block, _str: *c_char) -> ValueRef {
unsafe {
if cx.unreachable.get() { return llvm::LLVMGetUndef(Type::i8p().to_ref()); }
- B(cx).global_string(_Str)
+ B(cx).global_string(_str)
}
}
-pub fn GlobalStringPtr(cx: &Block, _Str: *c_char) -> ValueRef {
+pub fn GlobalStringPtr(cx: &Block, _str: *c_char) -> ValueRef {
unsafe {
if cx.unreachable.get() { return llvm::LLVMGetUndef(Type::i8p().to_ref()); }
- B(cx).global_string_ptr(_Str)
+ B(cx).global_string_ptr(_str)
}
}
/* Casts */
-pub fn Trunc(cx: &Block, Val: ValueRef, DestTy: Type) -> ValueRef {
+pub fn Trunc(cx: &Block, val: ValueRef, dest_ty: Type) -> ValueRef {
unsafe {
- if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
- B(cx).trunc(Val, DestTy)
+ if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+ B(cx).trunc(val, dest_ty)
}
}
-pub fn ZExt(cx: &Block, Val: ValueRef, DestTy: Type) -> ValueRef {
+pub fn ZExt(cx: &Block, val: ValueRef, dest_ty: Type) -> ValueRef {
unsafe {
- if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
- B(cx).zext(Val, DestTy)
+ if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+ B(cx).zext(val, dest_ty)
}
}
-pub fn SExt(cx: &Block, Val: ValueRef, DestTy: Type) -> ValueRef {
+pub fn SExt(cx: &Block, val: ValueRef, dest_ty: Type) -> ValueRef {
unsafe {
- if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
- B(cx).sext(Val, DestTy)
+ if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+ B(cx).sext(val, dest_ty)
}
}
-pub fn FPToUI(cx: &Block, Val: ValueRef, DestTy: Type) -> ValueRef {
+pub fn FPToUI(cx: &Block, val: ValueRef, dest_ty: Type) -> ValueRef {
unsafe {
- if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
- B(cx).fptoui(Val, DestTy)
+ if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+ B(cx).fptoui(val, dest_ty)
}
}
-pub fn FPToSI(cx: &Block, Val: ValueRef, DestTy: Type) -> ValueRef {
+pub fn FPToSI(cx: &Block, val: ValueRef, dest_ty: Type) -> ValueRef {
unsafe {
- if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
- B(cx).fptosi(Val, DestTy)
+ if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+ B(cx).fptosi(val, dest_ty)
}
}
-pub fn UIToFP(cx: &Block, Val: ValueRef, DestTy: Type) -> ValueRef {
+pub fn UIToFP(cx: &Block, val: ValueRef, dest_ty: Type) -> ValueRef {
unsafe {
- if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
- B(cx).uitofp(Val, DestTy)
+ if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+ B(cx).uitofp(val, dest_ty)
}
}
-pub fn SIToFP(cx: &Block, Val: ValueRef, DestTy: Type) -> ValueRef {
+pub fn SIToFP(cx: &Block, val: ValueRef, dest_ty: Type) -> ValueRef {
unsafe {
- if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
- B(cx).sitofp(Val, DestTy)
+ if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+ B(cx).sitofp(val, dest_ty)
}
}
-pub fn FPTrunc(cx: &Block, Val: ValueRef, DestTy: Type) -> ValueRef {
+pub fn FPTrunc(cx: &Block, val: ValueRef, dest_ty: Type) -> ValueRef {
unsafe {
- if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
- B(cx).fptrunc(Val, DestTy)
+ if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+ B(cx).fptrunc(val, dest_ty)
}
}
-pub fn FPExt(cx: &Block, Val: ValueRef, DestTy: Type) -> ValueRef {
+pub fn FPExt(cx: &Block, val: ValueRef, dest_ty: Type) -> ValueRef {
unsafe {
- if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
- B(cx).fpext(Val, DestTy)
+ if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+ B(cx).fpext(val, dest_ty)
}
}
-pub fn PtrToInt(cx: &Block, Val: ValueRef, DestTy: Type) -> ValueRef {
+pub fn PtrToInt(cx: &Block, val: ValueRef, dest_ty: Type) -> ValueRef {
unsafe {
- if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
- B(cx).ptrtoint(Val, DestTy)
+ if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+ B(cx).ptrtoint(val, dest_ty)
}
}
-pub fn IntToPtr(cx: &Block, Val: ValueRef, DestTy: Type) -> ValueRef {
+pub fn IntToPtr(cx: &Block, val: ValueRef, dest_ty: Type) -> ValueRef {
unsafe {
- if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
- B(cx).inttoptr(Val, DestTy)
+ if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+ B(cx).inttoptr(val, dest_ty)
}
}
-pub fn BitCast(cx: &Block, Val: ValueRef, DestTy: Type) -> ValueRef {
+pub fn BitCast(cx: &Block, val: ValueRef, dest_ty: Type) -> ValueRef {
unsafe {
- if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
- B(cx).bitcast(Val, DestTy)
+ if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+ B(cx).bitcast(val, dest_ty)
}
}
-pub fn ZExtOrBitCast(cx: &Block, Val: ValueRef, DestTy: Type) -> ValueRef {
+pub fn ZExtOrBitCast(cx: &Block, val: ValueRef, dest_ty: Type) -> ValueRef {
unsafe {
- if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
- B(cx).zext_or_bitcast(Val, DestTy)
+ if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+ B(cx).zext_or_bitcast(val, dest_ty)
}
}
-pub fn SExtOrBitCast(cx: &Block, Val: ValueRef, DestTy: Type) -> ValueRef {
+pub fn SExtOrBitCast(cx: &Block, val: ValueRef, dest_ty: Type) -> ValueRef {
unsafe {
- if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
- B(cx).sext_or_bitcast(Val, DestTy)
+ if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+ B(cx).sext_or_bitcast(val, dest_ty)
}
}
-pub fn TruncOrBitCast(cx: &Block, Val: ValueRef, DestTy: Type) -> ValueRef {
+pub fn TruncOrBitCast(cx: &Block, val: ValueRef, dest_ty: Type) -> ValueRef {
unsafe {
- if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
- B(cx).trunc_or_bitcast(Val, DestTy)
+ if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+ B(cx).trunc_or_bitcast(val, dest_ty)
}
}
-pub fn Cast(cx: &Block, Op: Opcode, Val: ValueRef, DestTy: Type, _: *u8)
+pub fn Cast(cx: &Block, op: Opcode, val: ValueRef, dest_ty: Type, _: *u8)
-> ValueRef {
unsafe {
- if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
- B(cx).cast(Op, Val, DestTy)
+ if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+ B(cx).cast(op, val, dest_ty)
}
}
-pub fn PointerCast(cx: &Block, Val: ValueRef, DestTy: Type) -> ValueRef {
+pub fn PointerCast(cx: &Block, val: ValueRef, dest_ty: Type) -> ValueRef {
unsafe {
- if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
- B(cx).pointercast(Val, DestTy)
+ if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+ B(cx).pointercast(val, dest_ty)
}
}
-pub fn IntCast(cx: &Block, Val: ValueRef, DestTy: Type) -> ValueRef {
+pub fn IntCast(cx: &Block, val: ValueRef, dest_ty: Type) -> ValueRef {
unsafe {
- if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
- B(cx).intcast(Val, DestTy)
+ if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+ B(cx).intcast(val, dest_ty)
}
}
-pub fn FPCast(cx: &Block, Val: ValueRef, DestTy: Type) -> ValueRef {
+pub fn FPCast(cx: &Block, val: ValueRef, dest_ty: Type) -> ValueRef {
unsafe {
- if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
- B(cx).fpcast(Val, DestTy)
+ if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+ B(cx).fpcast(val, dest_ty)
}
}
/* Comparisons */
-pub fn ICmp(cx: &Block, Op: IntPredicate, LHS: ValueRef, RHS: ValueRef)
+pub fn ICmp(cx: &Block, op: IntPredicate, lhs: ValueRef, rhs: ValueRef)
-> ValueRef {
unsafe {
if cx.unreachable.get() { return llvm::LLVMGetUndef(Type::i1().to_ref()); }
- B(cx).icmp(Op, LHS, RHS)
+ B(cx).icmp(op, lhs, rhs)
}
}
-pub fn FCmp(cx: &Block, Op: RealPredicate, LHS: ValueRef, RHS: ValueRef)
+pub fn FCmp(cx: &Block, op: RealPredicate, lhs: ValueRef, rhs: ValueRef)
-> ValueRef {
unsafe {
if cx.unreachable.get() { return llvm::LLVMGetUndef(Type::i1().to_ref()); }
- B(cx).fcmp(Op, LHS, RHS)
+ B(cx).fcmp(op, lhs, rhs)
}
}
/* Miscellaneous instructions */
-pub fn EmptyPhi(cx: &Block, Ty: Type) -> ValueRef {
+pub fn EmptyPhi(cx: &Block, ty: Type) -> ValueRef {
unsafe {
- if cx.unreachable.get() { return llvm::LLVMGetUndef(Ty.to_ref()); }
- B(cx).empty_phi(Ty)
+ if cx.unreachable.get() { return llvm::LLVMGetUndef(ty.to_ref()); }
+ B(cx).empty_phi(ty)
}
}
-pub fn Phi(cx: &Block, Ty: Type, vals: &[ValueRef], bbs: &[BasicBlockRef]) -> ValueRef {
+pub fn Phi(cx: &Block, ty: Type, vals: &[ValueRef], bbs: &[BasicBlockRef]) -> ValueRef {
unsafe {
- if cx.unreachable.get() { return llvm::LLVMGetUndef(Ty.to_ref()); }
- B(cx).phi(Ty, vals, bbs)
+ if cx.unreachable.get() { return llvm::LLVMGetUndef(ty.to_ref()); }
+ B(cx).phi(ty, vals, bbs)
}
}
}
}
-pub fn _UndefReturn(cx: &Block, Fn: ValueRef) -> ValueRef {
+pub fn _UndefReturn(cx: &Block, fn_: ValueRef) -> ValueRef {
unsafe {
let ccx = cx.fcx.ccx;
- let ty = val_ty(Fn);
+ let ty = val_ty(fn_);
let retty = if ty.kind() == lib::llvm::Integer {
ty.return_type()
} else {
B(cx).inline_asm_call(asm, cons, inputs, output, volatile, alignstack, dia)
}
-pub fn Call(cx: &Block, Fn: ValueRef, Args: &[ValueRef],
+pub fn Call(cx: &Block, fn_: ValueRef, args: &[ValueRef],
attributes: &[(uint, lib::llvm::Attribute)]) -> ValueRef {
- if cx.unreachable.get() { return _UndefReturn(cx, Fn); }
- B(cx).call(Fn, Args, attributes)
+ if cx.unreachable.get() { return _UndefReturn(cx, fn_); }
+ B(cx).call(fn_, args, attributes)
}
-pub fn CallWithConv(cx: &Block, Fn: ValueRef, Args: &[ValueRef], Conv: CallConv,
+pub fn CallWithConv(cx: &Block, fn_: ValueRef, args: &[ValueRef], conv: CallConv,
attributes: &[(uint, lib::llvm::Attribute)]) -> ValueRef {
- if cx.unreachable.get() { return _UndefReturn(cx, Fn); }
- B(cx).call_with_conv(Fn, Args, Conv, attributes)
+ if cx.unreachable.get() { return _UndefReturn(cx, fn_); }
+ B(cx).call_with_conv(fn_, args, conv, attributes)
}
pub fn AtomicFence(cx: &Block, order: AtomicOrdering) {
B(cx).atomic_fence(order)
}
-pub fn Select(cx: &Block, If: ValueRef, Then: ValueRef, Else: ValueRef) -> ValueRef {
- if cx.unreachable.get() { return _Undef(Then); }
- B(cx).select(If, Then, Else)
+pub fn Select(cx: &Block, if_: ValueRef, then: ValueRef, else_: ValueRef) -> ValueRef {
+ if cx.unreachable.get() { return _Undef(then); }
+ B(cx).select(if_, then, else_)
}
-pub fn VAArg(cx: &Block, list: ValueRef, Ty: Type) -> ValueRef {
+pub fn VAArg(cx: &Block, list: ValueRef, ty: Type) -> ValueRef {
unsafe {
- if cx.unreachable.get() { return llvm::LLVMGetUndef(Ty.to_ref()); }
- B(cx).va_arg(list, Ty)
+ if cx.unreachable.get() { return llvm::LLVMGetUndef(ty.to_ref()); }
+ B(cx).va_arg(list, ty)
}
}
-pub fn ExtractElement(cx: &Block, VecVal: ValueRef, Index: ValueRef) -> ValueRef {
+pub fn ExtractElement(cx: &Block, vec_val: ValueRef, index: ValueRef) -> ValueRef {
unsafe {
if cx.unreachable.get() { return llvm::LLVMGetUndef(Type::nil().to_ref()); }
- B(cx).extract_element(VecVal, Index)
+ B(cx).extract_element(vec_val, index)
}
}
-pub fn InsertElement(cx: &Block, VecVal: ValueRef, EltVal: ValueRef,
- Index: ValueRef) -> ValueRef {
+pub fn InsertElement(cx: &Block, vec_val: ValueRef, elt_val: ValueRef,
+ index: ValueRef) -> ValueRef {
unsafe {
if cx.unreachable.get() { return llvm::LLVMGetUndef(Type::nil().to_ref()); }
- B(cx).insert_element(VecVal, EltVal, Index)
+ B(cx).insert_element(vec_val, elt_val, index)
}
}
-pub fn ShuffleVector(cx: &Block, V1: ValueRef, V2: ValueRef,
- Mask: ValueRef) -> ValueRef {
+pub fn ShuffleVector(cx: &Block, v1: ValueRef, v2: ValueRef,
+ mask: ValueRef) -> ValueRef {
unsafe {
if cx.unreachable.get() { return llvm::LLVMGetUndef(Type::nil().to_ref()); }
- B(cx).shuffle_vector(V1, V2, Mask)
+ B(cx).shuffle_vector(v1, v2, mask)
}
}
-pub fn VectorSplat(cx: &Block, NumElts: uint, EltVal: ValueRef) -> ValueRef {
+pub fn VectorSplat(cx: &Block, num_elts: uint, elt_val: ValueRef) -> ValueRef {
unsafe {
if cx.unreachable.get() { return llvm::LLVMGetUndef(Type::nil().to_ref()); }
- B(cx).vector_splat(NumElts, EltVal)
+ B(cx).vector_splat(num_elts, elt_val)
}
}
-pub fn ExtractValue(cx: &Block, AggVal: ValueRef, Index: uint) -> ValueRef {
+pub fn ExtractValue(cx: &Block, agg_val: ValueRef, index: uint) -> ValueRef {
unsafe {
if cx.unreachable.get() { return llvm::LLVMGetUndef(Type::nil().to_ref()); }
- B(cx).extract_value(AggVal, Index)
+ B(cx).extract_value(agg_val, index)
}
}
-pub fn InsertValue(cx: &Block, AggVal: ValueRef, EltVal: ValueRef, Index: uint) -> ValueRef {
+pub fn InsertValue(cx: &Block, agg_val: ValueRef, elt_val: ValueRef, index: uint) -> ValueRef {
unsafe {
if cx.unreachable.get() { return llvm::LLVMGetUndef(Type::nil().to_ref()); }
- B(cx).insert_value(AggVal, EltVal, Index)
+ B(cx).insert_value(agg_val, elt_val, index)
}
}
-pub fn IsNull(cx: &Block, Val: ValueRef) -> ValueRef {
+pub fn IsNull(cx: &Block, val: ValueRef) -> ValueRef {
unsafe {
if cx.unreachable.get() { return llvm::LLVMGetUndef(Type::i1().to_ref()); }
- B(cx).is_null(Val)
+ B(cx).is_null(val)
}
}
-pub fn IsNotNull(cx: &Block, Val: ValueRef) -> ValueRef {
+pub fn IsNotNull(cx: &Block, val: ValueRef) -> ValueRef {
unsafe {
if cx.unreachable.get() { return llvm::LLVMGetUndef(Type::i1().to_ref()); }
- B(cx).is_not_null(Val)
+ B(cx).is_not_null(val)
}
}
-pub fn PtrDiff(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
+pub fn PtrDiff(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
unsafe {
let ccx = cx.fcx.ccx;
if cx.unreachable.get() { return llvm::LLVMGetUndef(ccx.int_type.to_ref()); }
- B(cx).ptrdiff(LHS, RHS)
+ B(cx).ptrdiff(lhs, rhs)
}
}
B(cx).trap();
}
-pub fn LandingPad(cx: &Block, Ty: Type, PersFn: ValueRef,
- NumClauses: uint) -> ValueRef {
+pub fn LandingPad(cx: &Block, ty: Type, pers_fn: ValueRef,
+ num_clauses: uint) -> ValueRef {
check_not_terminated(cx);
assert!(!cx.unreachable.get());
- B(cx).landing_pad(Ty, PersFn, NumClauses)
+ B(cx).landing_pad(ty, pers_fn, num_clauses)
}
-pub fn SetCleanup(cx: &Block, LandingPad: ValueRef) {
- B(cx).set_cleanup(LandingPad)
+pub fn SetCleanup(cx: &Block, landing_pad: ValueRef) {
+ B(cx).set_cleanup(landing_pad)
}
-pub fn Resume(cx: &Block, Exn: ValueRef) -> ValueRef {
+pub fn Resume(cx: &Block, exn: ValueRef) -> ValueRef {
check_not_terminated(cx);
terminate(cx, "Resume");
- B(cx).resume(Exn)
+ B(cx).resume(exn)
}
// Atomic Operations
}
}
- pub fn neg(&self, V: ValueRef) -> ValueRef {
+ pub fn neg(&self, v: ValueRef) -> ValueRef {
self.count_insn("neg");
unsafe {
- llvm::LLVMBuildNeg(self.llbuilder, V, noname())
+ llvm::LLVMBuildNeg(self.llbuilder, v, noname())
}
}
- pub fn nswneg(&self, V: ValueRef) -> ValueRef {
+ pub fn nswneg(&self, v: ValueRef) -> ValueRef {
self.count_insn("nswneg");
unsafe {
- llvm::LLVMBuildNSWNeg(self.llbuilder, V, noname())
+ llvm::LLVMBuildNSWNeg(self.llbuilder, v, noname())
}
}
- pub fn nuwneg(&self, V: ValueRef) -> ValueRef {
+ pub fn nuwneg(&self, v: ValueRef) -> ValueRef {
self.count_insn("nuwneg");
unsafe {
- llvm::LLVMBuildNUWNeg(self.llbuilder, V, noname())
+ llvm::LLVMBuildNUWNeg(self.llbuilder, v, noname())
}
}
- pub fn fneg(&self, V: ValueRef) -> ValueRef {
+ pub fn fneg(&self, v: ValueRef) -> ValueRef {
self.count_insn("fneg");
unsafe {
- llvm::LLVMBuildFNeg(self.llbuilder, V, noname())
+ llvm::LLVMBuildFNeg(self.llbuilder, v, noname())
}
}
- pub fn not(&self, V: ValueRef) -> ValueRef {
+ pub fn not(&self, v: ValueRef) -> ValueRef {
self.count_insn("not");
unsafe {
- llvm::LLVMBuildNot(self.llbuilder, V, noname())
+ llvm::LLVMBuildNot(self.llbuilder, v, noname())
}
}
}
}
- pub fn global_string(&self, _Str: *c_char) -> ValueRef {
+ pub fn global_string(&self, _str: *c_char) -> ValueRef {
self.count_insn("globalstring");
unsafe {
- llvm::LLVMBuildGlobalString(self.llbuilder, _Str, noname())
+ llvm::LLVMBuildGlobalString(self.llbuilder, _str, noname())
}
}
- pub fn global_string_ptr(&self, _Str: *c_char) -> ValueRef {
+ pub fn global_string_ptr(&self, _str: *c_char) -> ValueRef {
self.count_insn("globalstringptr");
unsafe {
- llvm::LLVMBuildGlobalStringPtr(self.llbuilder, _Str, noname())
+ llvm::LLVMBuildGlobalStringPtr(self.llbuilder, _str, noname())
}
}
pub fn vector_splat(&self, num_elts: uint, elt: ValueRef) -> ValueRef {
unsafe {
let elt_ty = val_ty(elt);
- let Undef = llvm::LLVMGetUndef(Type::vector(&elt_ty, num_elts as u64).to_ref());
- let vec = self.insert_element(Undef, elt, C_i32(0));
- self.shuffle_vector(vec, Undef, C_null(Type::vector(&Type::i32(), num_elts as u64)))
+ let undef = llvm::LLVMGetUndef(Type::vector(&elt_ty, num_elts as u64).to_ref());
+ let vec = self.insert_element(undef, elt, C_i32(0));
+ self.shuffle_vector(vec, undef, C_null(Type::vector(&Type::i32(), num_elts as u64)))
}
}
pub fn trap(&self) {
unsafe {
- let BB: BasicBlockRef = llvm::LLVMGetInsertBlock(self.llbuilder);
- let FN: ValueRef = llvm::LLVMGetBasicBlockParent(BB);
- let M: ModuleRef = llvm::LLVMGetGlobalParent(FN);
- let T: ValueRef = "llvm.trap".with_c_str(|buf| {
- llvm::LLVMGetNamedFunction(M, buf)
+ let bb: BasicBlockRef = llvm::LLVMGetInsertBlock(self.llbuilder);
+ let fn_: ValueRef = llvm::LLVMGetBasicBlockParent(bb);
+ let m: ModuleRef = llvm::LLVMGetGlobalParent(fn_);
+ let t: ValueRef = "llvm.trap".with_c_str(|buf| {
+ llvm::LLVMGetNamedFunction(m, buf)
});
- assert!((T as int != 0));
+ assert!((t as int != 0));
let args: &[ValueRef] = [];
self.count_insn("trap");
llvm::LLVMBuildCall(
- self.llbuilder, T, args.as_ptr(), args.len() as c_uint, noname());
+ self.llbuilder, t, args.as_ptr(), args.len() as c_uint, noname());
}
}
}
}
-pub fn BuilderRef_res(B: BuilderRef) -> BuilderRef_res {
+pub fn BuilderRef_res(b: BuilderRef) -> BuilderRef_res {
BuilderRef_res {
- B: B
+ B: b
}
}
}
}
-pub fn C_named_struct(T: Type, elts: &[ValueRef]) -> ValueRef {
+pub fn C_named_struct(t: Type, elts: &[ValueRef]) -> ValueRef {
unsafe {
- llvm::LLVMConstNamedStruct(T.to_ref(), elts.as_ptr(), elts.len() as c_uint)
+ llvm::LLVMConstNamedStruct(t.to_ref(), elts.as_ptr(), elts.len() as c_uint)
}
}
is_local: bool) -> (ValueRef, bool) {
let map_list = |exprs: &[@ast::Expr]| {
exprs.iter().map(|&e| const_expr(cx, e, is_local))
- .fold((~[], true), |(L, all_inlineable), (val, inlineable)| {
- (vec::append_one(L, val), all_inlineable && inlineable)
+ .fold((~[], true), |(l, all_inlineable), (val, inlineable)| {
+ (vec::append_one(l, val), all_inlineable && inlineable)
})
};
unsafe {
sp: Span,
fail_str: InternedString)
-> &'a Block<'a> {
- let V_fail_str = C_cstr(bcx.ccx(), fail_str);
+ let v_fail_str = C_cstr(bcx.ccx(), fail_str);
let _icx = push_ctxt("trans_fail_value");
let ccx = bcx.ccx();
let sess = bcx.sess();
let loc = sess.parse_sess.cm.lookup_char_pos(sp.lo);
- let V_filename = C_cstr(bcx.ccx(),
+ let v_filename = C_cstr(bcx.ccx(),
token::intern_and_get_ident(loc.file.name));
- let V_line = loc.line as int;
- let V_str = PointerCast(bcx, V_fail_str, Type::i8p());
- let V_filename = PointerCast(bcx, V_filename, Type::i8p());
- let args = ~[V_str, V_filename, C_int(ccx, V_line)];
+ let v_line = loc.line as int;
+ let v_str = PointerCast(bcx, v_fail_str, Type::i8p());
+ let v_filename = PointerCast(bcx, v_filename, Type::i8p());
+ let args = ~[v_str, v_filename, C_int(ccx, v_line)];
let did = langcall(bcx, Some(sp), "", FailFnLangItem);
let bcx = callee::trans_lang_call(bcx, did, args, Some(expr::Ignore)).bcx;
Unreachable(bcx);
let mut g = self.H6;
let mut h = self.H7;
- let mut W = [0u32, ..64];
+ let mut w = [0u32, ..64];
// Sha-512 and Sha-256 use basically the same calculations which are implemented
// by these macros. Inlining the calculations seems to result in better generated code.
macro_rules! schedule_round( ($t:expr) => (
- W[$t] = sigma1(W[$t - 2]) + W[$t - 7] + sigma0(W[$t - 15]) + W[$t - 16];
+ w[$t] = sigma1(w[$t - 2]) + w[$t - 7] + sigma0(w[$t - 15]) + w[$t - 16];
)
)
($A:ident, $B:ident, $C:ident, $D:ident,
$E:ident, $F:ident, $G:ident, $H:ident, $K:ident, $t:expr) => (
{
- $H += sum1($E) + ch($E, $F, $G) + $K[$t] + W[$t];
+ $H += sum1($E) + ch($E, $F, $G) + $K[$t] + w[$t];
$D += $H;
$H += sum0($A) + maj($A, $B, $C);
}
)
)
- read_u32v_be(W.mut_slice(0, 16), data);
+ read_u32v_be(w.mut_slice(0, 16), data);
// Putting the message schedule inside the same loop as the round calculations allows for
// the compiler to generate better code.
* println!("base64 output: {}", hello_str);
* let res = hello_str.from_base64();
* if res.is_ok() {
- * let optBytes = str::from_utf8_owned(res.unwrap());
- * if optBytes.is_some() {
- * println!("decoded from base64: {}", optBytes.unwrap());
+ * let opt_bytes = str::from_utf8_owned(res.unwrap());
+ * if opt_bytes.is_some() {
+ * println!("decoded from base64: {}", opt_bytes.unwrap());
* }
* }
* }
]"
);
- let longTestList = List(~[
+ let long_test_list = List(~[
Boolean(false),
Null,
List(~[String(~"foo\nbar"), Number(3.5)])]);
- assert_eq!(longTestList.to_str(),
+ assert_eq!(long_test_list.to_str(),
~"[false,null,[\"foo\\nbar\",3.5]]");
assert_eq!(
- longTestList.to_pretty_str(),
+ long_test_list.to_pretty_str(),
~"\
[\n \
false,\n \
}"
);
- let complexObj = mk_object([
+ let complex_obj = mk_object([
(~"b", List(~[
mk_object([(~"c", String(~"\x0c\r"))]),
mk_object([(~"d", String(~""))])
]);
assert_eq!(
- complexObj.to_str(),
+ complex_obj.to_str(),
~"{\
\"b\":[\
{\"c\":\"\\f\\r\"},\
}"
);
assert_eq!(
- complexObj.to_pretty_str(),
+ complex_obj.to_pretty_str(),
~"\
{\n \
\"b\": [\n \
);
)
-impl_hash_tuple!(A0 A1 A2 A3 A4 A5 A6 A7)
+impl_hash_tuple!(a0 a1 a2 a3 a4 a5 a6 a7)
impl<'a, S: Writer, T: Hash<S>> Hash<S> for &'a [T] {
#[inline]
impl Writer for UdpStream {
fn write(&mut self, buf: &[u8]) -> IoResult<()> {
- let connectedTo = self.connectedTo;
- self.as_socket(|sock| sock.sendto(buf, connectedTo))
+ let connected_to = self.connectedTo;
+ self.as_socket(|sock| sock.sendto(buf, connected_to))
}
}
fn ziggurat<R:Rng>(
rng: &mut R,
symmetric: bool,
- X: ziggurat_tables::ZigTable,
- F: ziggurat_tables::ZigTable,
+ x_tab: ziggurat_tables::ZigTable,
+ f_tab: ziggurat_tables::ZigTable,
pdf: 'static |f64| -> f64,
zero_case: 'static |&mut R, f64| -> f64)
-> f64 {
// u is either U(-1, 1) or U(0, 1) depending on if this is a
// symmetric distribution or not.
let u = if symmetric {2.0 * f - 1.0} else {f};
- let x = u * X[i];
+ let x = u * x_tab[i];
let test_x = if symmetric {num::abs(x)} else {x};
- // algebraically equivalent to |u| < X[i+1]/X[i] (or u < X[i+1]/X[i])
- if test_x < X[i + 1] {
+ // algebraically equivalent to |u| < x_tab[i+1]/x_tab[i] (or u < x_tab[i+1]/x_tab[i])
+ if test_x < x_tab[i + 1] {
return x;
}
if i == 0 {
return zero_case(rng, u);
}
// algebraically equivalent to f1 + DRanU()*(f0 - f1) < 1
- if F[i + 1] + (F[i] - F[i + 1]) * rng.gen() < pdf(x) {
+ if f_tab[i + 1] + (f_tab[i] - f_tab[i + 1]) * rng.gen() < pdf(x) {
return x;
}
}
#[test]
fn test_sample() {
- let MIN_VAL = 1;
- let MAX_VAL = 100;
+ let min_val = 1;
+ let max_val = 100;
let mut r = rng();
- let vals = range(MIN_VAL, MAX_VAL).to_owned_vec();
+ let vals = range(min_val, max_val).to_owned_vec();
let small_sample = r.sample(vals.iter(), 5);
let large_sample = r.sample(vals.iter(), vals.len() + 5);
assert_eq!(large_sample.len(), vals.len());
assert!(small_sample.iter().all(|e| {
- **e >= MIN_VAL && **e <= MAX_VAL
+ **e >= min_val && **e <= max_val
}));
}
for i in range(0, len) {
let mut swapped = false;
for j in range(1, len-i) {
- let classA = *comb[j-1].ref1();
- let classB = *comb[j].ref1();
- if classA != 0 && classB != 0 && classA > classB {
+ let class_a = *comb[j-1].ref1();
+ let class_b = *comb[j].ref1();
+ if class_a != 0 && class_b != 0 && class_a > class_b {
comb.swap(j-1, j);
swapped = true;
}
let repl = ~"دولة الكويت";
let a = ~"ประเ";
- let A = ~"دولة الكويتทศไทย中华";
- assert_eq!(data.replace(a, repl), A);
+ let a2 = ~"دولة الكويتทศไทย中华";
+ assert_eq!(data.replace(a, repl), a2);
}
#[test]
let repl = ~"دولة الكويت";
let b = ~"ะเ";
- let B = ~"ปรدولة الكويتทศไทย中华";
- assert_eq!(data.replace(b, repl), B);
+ let b2 = ~"ปรدولة الكويتทศไทย中华";
+ assert_eq!(data.replace(b, repl), b2);
}
#[test]
let repl = ~"دولة الكويت";
let c = ~"中华";
- let C = ~"ประเทศไทยدولة الكويت";
- assert_eq!(data.replace(c, repl), C);
+ let c2 = ~"ประเทศไทยدولة الكويت";
+ assert_eq!(data.replace(c, repl), c2);
}
#[test]
* wait() is equivalent to wait_on(0).
*/
pub fn wait_on(&self, condvar_id: uint) {
- let mut WaitEnd = None;
+ let mut wait_end = None;
let mut out_of_bounds = None;
// Release lock, 'atomically' enqueuing ourselves in so doing.
unsafe {
}
// Create waiter nobe, and enqueue ourself to
// be woken up by a signaller.
- WaitEnd = Some(state.blocked[condvar_id].wait_end());
+ wait_end = Some(state.blocked[condvar_id].wait_end());
} else {
out_of_bounds = Some(state.blocked.len());
}
// signaller already sent -- I mean 'unconditionally' in contrast
// with acquire().)
(|| {
- let _ = WaitEnd.take_unwrap().recv();
+ let _ = wait_end.take_unwrap().recv();
}).finally(|| {
// Reacquire the condvar.
match self.order {
for _ in range(0, skip) { s.push_char(' '); }
let orig = fm.get_line(*lines.lines.get(0) as int);
for pos in range(0u, left-skip) {
- let curChar = orig[pos] as char;
+ let cur_char = orig[pos] as char;
// Whenever a tab occurs on the previous line, we insert one on
// the error-point-squiggly-line as well (instead of a space).
// That way the squiggly line will usually appear in the correct
// position.
- match curChar {
+ match cur_char {
'\t' => s.push_char('\t'),
_ => s.push_char(' '),
};
let n = toks.len();
assert_eq!(n, szs.len());
let mut i = left;
- let mut L = lim;
+ let mut l = lim;
let mut s = ~"[";
- while i != right && L != 0u {
- L -= 1u;
+ while i != right && l != 0u {
+ l -= 1u;
if i != left {
s.push_str(", ");
}
self.right %= self.buf_len;
assert!((self.right != self.left));
}
- pub fn advance_left(&mut self, x: Token, L: int) -> io::IoResult<()> {
+ pub fn advance_left(&mut self, x: Token, l: int) -> io::IoResult<()> {
debug!("advnce_left ~[{},{}], sizeof({})={}", self.left, self.right,
- self.left, L);
- if L >= 0 {
- let ret = self.print(x.clone(), L);
+ self.left, l);
+ if l >= 0 {
+ let ret = self.print(x.clone(), l);
match x {
Break(b) => self.left_total += b.blank_space,
String(_, len) => {
- assert_eq!(len, L); self.left_total += len;
+ assert_eq!(len, l); self.left_total += len;
}
_ => ()
}
}
write!(self.out, "{}", s)
}
- pub fn print(&mut self, x: Token, L: int) -> io::IoResult<()> {
- debug!("print {} {} (remaining line space={})", tok_str(x.clone()), L,
+ pub fn print(&mut self, x: Token, l: int) -> io::IoResult<()> {
+ debug!("print {} {} (remaining line space={})", tok_str(x.clone()), l,
self.space);
debug!("{}", buf_str(self.token.clone(),
self.size.clone(),
6));
match x {
Begin(b) => {
- if L > self.space {
+ if l > self.space {
let col = self.margin - self.space + b.offset;
debug!("print Begin -> push broken block at col {}", col);
self.print_stack.push(PrintStackElem {
ret
}
Broken(Inconsistent) => {
- if L > self.space {
+ if l > self.space {
debug!("print Break({}+{}) w/ newline in inconsistent",
top.offset, b.offset);
let ret = self.print_newline(top.offset + b.offset);
}
String(s, len) => {
debug!("print String({})", s);
- assert_eq!(L, len);
- // assert!(L <= space);
+ assert_eq!(l, len);
+ // assert!(l <= space);
self.space -= len;
self.print_str(s)
}
projects / rust.git / commitdiff