2012-03-12 22:04:27 -05:00
|
|
|
import libc::{c_uint, c_int};
|
2011-12-13 18:25:51 -06:00
|
|
|
import str::sbuf;
|
2011-08-24 07:54:55 -05:00
|
|
|
import lib::llvm::llvm;
|
2012-01-12 10:59:49 -06:00
|
|
|
import syntax::codemap;
|
|
|
|
import codemap::span;
|
2012-02-01 04:04:56 -06:00
|
|
|
import lib::llvm::{ValueRef, TypeRef, BasicBlockRef, BuilderRef, ModuleRef};
|
|
|
|
import lib::llvm::{Opcode, IntPredicate, RealPredicate, True, False,
|
|
|
|
CallConv};
|
2012-02-21 07:20:18 -06:00
|
|
|
import common::*;
|
2011-08-24 07:54:55 -05:00
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn B(cx: block) -> BuilderRef {
|
2012-02-03 02:53:37 -06:00
|
|
|
let b = *cx.fcx.ccx.builder;
|
2011-08-30 07:02:20 -05:00
|
|
|
llvm::LLVMPositionBuilderAtEnd(b, cx.llbb);
|
|
|
|
ret b;
|
|
|
|
}
|
|
|
|
|
2011-09-21 05:40:27 -05:00
|
|
|
// The difference between a block being unreachable and being terminated is
|
|
|
|
// somewhat obscure, and has to do with error checking. When a block is
|
|
|
|
// terminated, we're saying that trying to add any further statements in the
|
|
|
|
// block is an error. On the other hand, if something is unreachable, that
|
|
|
|
// means that the block was terminated in some way that we don't want to check
|
|
|
|
// for (fail/break/ret statements, call to diverging functions, etc), and
|
|
|
|
// further instructions to the block should simply be ignored.
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn RetVoid(cx: block) {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret; }
|
2011-09-02 17:34:58 -05:00
|
|
|
assert (!cx.terminated);
|
2011-08-24 07:54:55 -05:00
|
|
|
cx.terminated = true;
|
2011-12-18 22:32:38 -06:00
|
|
|
llvm::LLVMBuildRetVoid(B(cx));
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn Ret(cx: block, V: ValueRef) {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret; }
|
2011-09-02 17:34:58 -05:00
|
|
|
assert (!cx.terminated);
|
2011-08-24 07:54:55 -05:00
|
|
|
cx.terminated = true;
|
2011-12-18 22:32:38 -06:00
|
|
|
llvm::LLVMBuildRet(B(cx), V);
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn AggregateRet(cx: block, RetVals: [ValueRef]) {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret; }
|
2011-09-02 17:34:58 -05:00
|
|
|
assert (!cx.terminated);
|
2011-08-24 07:54:55 -05:00
|
|
|
cx.terminated = true;
|
2011-10-07 14:05:38 -05:00
|
|
|
unsafe {
|
2012-02-28 22:43:39 -06:00
|
|
|
llvm::LLVMBuildAggregateRet(B(cx), vec::unsafe::to_ptr(RetVals),
|
2012-02-14 02:10:47 -06:00
|
|
|
RetVals.len() as c_uint);
|
2011-10-07 14:05:38 -05:00
|
|
|
}
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn Br(cx: block, Dest: BasicBlockRef) {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret; }
|
2011-09-02 17:34:58 -05:00
|
|
|
assert (!cx.terminated);
|
2011-08-24 07:54:55 -05:00
|
|
|
cx.terminated = true;
|
2011-12-18 22:32:38 -06:00
|
|
|
llvm::LLVMBuildBr(B(cx), Dest);
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn CondBr(cx: block, If: ValueRef, Then: BasicBlockRef,
|
2011-09-21 05:40:27 -05:00
|
|
|
Else: BasicBlockRef) {
|
|
|
|
if cx.unreachable { ret; }
|
2011-09-02 17:34:58 -05:00
|
|
|
assert (!cx.terminated);
|
2011-08-24 07:54:55 -05:00
|
|
|
cx.terminated = true;
|
2011-12-18 22:32:38 -06:00
|
|
|
llvm::LLVMBuildCondBr(B(cx), If, Then, Else);
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn Switch(cx: block, V: ValueRef, Else: BasicBlockRef, NumCases: uint)
|
2011-09-21 05:40:27 -05:00
|
|
|
-> ValueRef {
|
|
|
|
if cx.unreachable { ret _Undef(V); }
|
|
|
|
assert !cx.terminated;
|
2011-08-24 07:54:55 -05:00
|
|
|
cx.terminated = true;
|
2012-01-16 04:21:01 -06:00
|
|
|
ret llvm::LLVMBuildSwitch(B(cx), V, Else, NumCases as c_uint);
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2011-09-21 05:40:27 -05:00
|
|
|
fn AddCase(S: ValueRef, OnVal: ValueRef, Dest: BasicBlockRef) {
|
|
|
|
if llvm::LLVMIsUndef(S) == lib::llvm::True { ret; }
|
|
|
|
llvm::LLVMAddCase(S, OnVal, Dest);
|
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn IndirectBr(cx: block, Addr: ValueRef, NumDests: uint) {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret; }
|
2011-09-02 17:34:58 -05:00
|
|
|
assert (!cx.terminated);
|
2011-08-24 07:54:55 -05:00
|
|
|
cx.terminated = true;
|
2012-01-16 04:21:01 -06:00
|
|
|
llvm::LLVMBuildIndirectBr(B(cx), Addr, NumDests as c_uint);
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2011-09-21 10:46:11 -05:00
|
|
|
// This is a really awful way to get a zero-length c-string, but better (and a
|
|
|
|
// lot more efficient) than doing str::as_buf("", ...) every time.
|
2011-10-28 16:19:17 -05:00
|
|
|
fn noname() -> sbuf unsafe {
|
2011-09-21 10:46:11 -05:00
|
|
|
const cnull: uint = 0u;
|
2011-12-13 18:25:51 -06:00
|
|
|
ret unsafe::reinterpret_cast(ptr::addr_of(cnull));
|
2011-09-21 10:46:11 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn Invoke(cx: block, Fn: ValueRef, Args: [ValueRef],
|
2011-09-21 05:40:27 -05:00
|
|
|
Then: BasicBlockRef, Catch: BasicBlockRef) {
|
|
|
|
if cx.unreachable { ret; }
|
2011-09-02 17:34:58 -05:00
|
|
|
assert (!cx.terminated);
|
2011-08-24 07:54:55 -05:00
|
|
|
cx.terminated = true;
|
2012-02-01 20:52:08 -06:00
|
|
|
#debug["Invoke(%s with arguments (%s))",
|
2012-02-21 07:20:18 -06:00
|
|
|
val_str(cx.ccx().tn, Fn),
|
|
|
|
str::connect(vec::map(Args, {|a|val_str(cx.ccx().tn, a)}),
|
2012-02-01 20:52:08 -06:00
|
|
|
", ")];
|
2011-10-07 14:05:38 -05:00
|
|
|
unsafe {
|
2012-02-28 22:43:39 -06:00
|
|
|
llvm::LLVMBuildInvoke(B(cx), Fn, vec::unsafe::to_ptr(Args),
|
2012-02-14 02:10:47 -06:00
|
|
|
Args.len() as c_uint, Then, Catch,
|
2012-01-10 15:26:21 -06:00
|
|
|
noname());
|
2011-10-07 14:05:38 -05:00
|
|
|
}
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn FastInvoke(cx: block, Fn: ValueRef, Args: [ValueRef],
|
2011-09-21 05:40:27 -05:00
|
|
|
Then: BasicBlockRef, Catch: BasicBlockRef) {
|
|
|
|
if cx.unreachable { ret; }
|
2011-09-07 13:46:53 -05:00
|
|
|
assert (!cx.terminated);
|
|
|
|
cx.terminated = true;
|
2011-10-07 14:05:38 -05:00
|
|
|
unsafe {
|
2012-02-28 22:43:39 -06:00
|
|
|
let v = llvm::LLVMBuildInvoke(B(cx), Fn, vec::unsafe::to_ptr(Args),
|
2012-02-14 02:10:47 -06:00
|
|
|
Args.len() as c_uint,
|
2012-01-16 04:21:01 -06:00
|
|
|
Then, Catch, noname());
|
2012-02-01 04:04:56 -06:00
|
|
|
lib::llvm::SetInstructionCallConv(v, lib::llvm::FastCallConv);
|
2011-10-07 14:05:38 -05:00
|
|
|
}
|
2011-09-07 13:46:53 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn Unreachable(cx: block) {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret; }
|
|
|
|
cx.unreachable = true;
|
|
|
|
if !cx.terminated { llvm::LLVMBuildUnreachable(B(cx)); }
|
|
|
|
}
|
|
|
|
|
|
|
|
fn _Undef(val: ValueRef) -> ValueRef {
|
|
|
|
ret llvm::LLVMGetUndef(val_ty(val));
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Arithmetic */
|
2012-02-17 06:17:40 -06:00
|
|
|
fn Add(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret _Undef(LHS); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildAdd(B(cx), LHS, RHS, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn NSWAdd(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret _Undef(LHS); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildNSWAdd(B(cx), LHS, RHS, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn NUWAdd(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret _Undef(LHS); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildNUWAdd(B(cx), LHS, RHS, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn FAdd(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret _Undef(LHS); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildFAdd(B(cx), LHS, RHS, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn Sub(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret _Undef(LHS); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildSub(B(cx), LHS, RHS, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn NSWSub(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret _Undef(LHS); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildNSWSub(B(cx), LHS, RHS, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn NUWSub(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret _Undef(LHS); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildNUWSub(B(cx), LHS, RHS, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn FSub(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret _Undef(LHS); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildFSub(B(cx), LHS, RHS, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn Mul(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret _Undef(LHS); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildMul(B(cx), LHS, RHS, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn NSWMul(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret _Undef(LHS); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildNSWMul(B(cx), LHS, RHS, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn NUWMul(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret _Undef(LHS); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildNUWMul(B(cx), LHS, RHS, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn FMul(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret _Undef(LHS); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildFMul(B(cx), LHS, RHS, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn UDiv(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret _Undef(LHS); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildUDiv(B(cx), LHS, RHS, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn SDiv(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret _Undef(LHS); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildSDiv(B(cx), LHS, RHS, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn ExactSDiv(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret _Undef(LHS); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildExactSDiv(B(cx), LHS, RHS, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn FDiv(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret _Undef(LHS); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildFDiv(B(cx), LHS, RHS, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn URem(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret _Undef(LHS); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildURem(B(cx), LHS, RHS, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn SRem(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret _Undef(LHS); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildSRem(B(cx), LHS, RHS, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn FRem(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret _Undef(LHS); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildFRem(B(cx), LHS, RHS, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn Shl(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret _Undef(LHS); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildShl(B(cx), LHS, RHS, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn LShr(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret _Undef(LHS); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildLShr(B(cx), LHS, RHS, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn AShr(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret _Undef(LHS); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildAShr(B(cx), LHS, RHS, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn And(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret _Undef(LHS); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildAnd(B(cx), LHS, RHS, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn Or(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret _Undef(LHS); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildOr(B(cx), LHS, RHS, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn Xor(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret _Undef(LHS); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildXor(B(cx), LHS, RHS, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn BinOp(cx: block, Op: Opcode, LHS: ValueRef, RHS: ValueRef) ->
|
2011-09-02 17:34:58 -05:00
|
|
|
ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret _Undef(LHS); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildBinOp(B(cx), Op, LHS, RHS, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn Neg(cx: block, V: ValueRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret _Undef(V); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildNeg(B(cx), V, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn NSWNeg(cx: block, V: ValueRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret _Undef(V); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildNSWNeg(B(cx), V, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn NUWNeg(cx: block, V: ValueRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret _Undef(V); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildNUWNeg(B(cx), V, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
2012-02-17 06:17:40 -06:00
|
|
|
fn FNeg(cx: block, V: ValueRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret _Undef(V); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildFNeg(B(cx), V, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
2011-08-26 17:36:18 -05:00
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn Not(cx: block, V: ValueRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret _Undef(V); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildNot(B(cx), V, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Memory */
|
2012-02-17 06:17:40 -06:00
|
|
|
fn Malloc(cx: block, Ty: TypeRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(T_ptr(T_i8())); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildMalloc(B(cx), Ty, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn ArrayMalloc(cx: block, Ty: TypeRef, Val: ValueRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(T_ptr(T_i8())); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildArrayMalloc(B(cx), Ty, Val, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn Alloca(cx: block, Ty: TypeRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(T_ptr(Ty)); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildAlloca(B(cx), Ty, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn ArrayAlloca(cx: block, Ty: TypeRef, Val: ValueRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(T_ptr(Ty)); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildArrayAlloca(B(cx), Ty, Val, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn Free(cx: block, PointerVal: ValueRef) {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret; }
|
2011-12-18 22:32:38 -06:00
|
|
|
llvm::LLVMBuildFree(B(cx), PointerVal);
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn Load(cx: block, PointerVal: ValueRef) -> ValueRef {
|
2012-02-03 02:53:37 -06:00
|
|
|
let ccx = cx.fcx.ccx;
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable {
|
|
|
|
let ty = val_ty(PointerVal);
|
2012-01-18 05:29:37 -06:00
|
|
|
let eltty = if llvm::LLVMGetTypeKind(ty) == 11 as c_int {
|
2011-10-14 19:00:17 -05:00
|
|
|
llvm::LLVMGetElementType(ty) } else { ccx.int_type };
|
2011-09-21 05:40:27 -05:00
|
|
|
ret llvm::LLVMGetUndef(eltty);
|
|
|
|
}
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildLoad(B(cx), PointerVal, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn Store(cx: block, Val: ValueRef, Ptr: ValueRef) {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret; }
|
2012-02-14 17:21:53 -06:00
|
|
|
#debug["Store %s -> %s",
|
|
|
|
val_str(cx.ccx().tn, Val),
|
|
|
|
val_str(cx.ccx().tn, Ptr)];
|
2011-12-18 22:32:38 -06:00
|
|
|
llvm::LLVMBuildStore(B(cx), Val, Ptr);
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn GEP(cx: block, Pointer: ValueRef, Indices: [ValueRef]) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(T_ptr(T_nil())); }
|
2011-10-07 14:05:38 -05:00
|
|
|
unsafe {
|
2012-02-28 22:43:39 -06:00
|
|
|
ret llvm::LLVMBuildGEP(B(cx), Pointer, vec::unsafe::to_ptr(Indices),
|
2012-02-14 02:10:47 -06:00
|
|
|
Indices.len() as c_uint, noname());
|
2011-10-07 14:05:38 -05:00
|
|
|
}
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2011-10-26 00:23:28 -05:00
|
|
|
// Simple wrapper around GEP that takes an array of ints and wraps them
|
|
|
|
// in C_i32()
|
2012-02-17 06:17:40 -06:00
|
|
|
fn GEPi(cx: block, base: ValueRef, ixs: [int]) -> ValueRef {
|
2011-10-26 00:23:28 -05:00
|
|
|
let v: [ValueRef] = [];
|
|
|
|
for i: int in ixs { v += [C_i32(i as i32)]; }
|
|
|
|
ret InBoundsGEP(cx, base, v);
|
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn InBoundsGEP(cx: block, Pointer: ValueRef, Indices: [ValueRef]) ->
|
2011-09-02 17:34:58 -05:00
|
|
|
ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(T_ptr(T_nil())); }
|
2011-10-07 14:05:38 -05:00
|
|
|
unsafe {
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildInBoundsGEP(B(cx), Pointer,
|
2012-02-28 22:43:39 -06:00
|
|
|
vec::unsafe::to_ptr(Indices),
|
2012-02-14 02:10:47 -06:00
|
|
|
Indices.len() as c_uint,
|
2012-01-16 04:21:01 -06:00
|
|
|
noname());
|
2011-10-07 14:05:38 -05:00
|
|
|
}
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn StructGEP(cx: block, Pointer: ValueRef, Idx: uint) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(T_ptr(T_nil())); }
|
2012-01-16 04:21:01 -06:00
|
|
|
ret llvm::LLVMBuildStructGEP(B(cx), Pointer, Idx as c_uint, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn GlobalString(cx: block, _Str: sbuf) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(T_ptr(T_i8())); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildGlobalString(B(cx), _Str, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn GlobalStringPtr(cx: block, _Str: sbuf) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(T_ptr(T_i8())); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildGlobalStringPtr(B(cx), _Str, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Casts */
|
2012-02-17 06:17:40 -06:00
|
|
|
fn Trunc(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildTrunc(B(cx), Val, DestTy, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn ZExt(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildZExt(B(cx), Val, DestTy, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn SExt(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildSExt(B(cx), Val, DestTy, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn FPToUI(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildFPToUI(B(cx), Val, DestTy, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn FPToSI(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildFPToSI(B(cx), Val, DestTy, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn UIToFP(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildUIToFP(B(cx), Val, DestTy, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn SIToFP(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildSIToFP(B(cx), Val, DestTy, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn FPTrunc(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildFPTrunc(B(cx), Val, DestTy, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn FPExt(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildFPExt(B(cx), Val, DestTy, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn PtrToInt(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildPtrToInt(B(cx), Val, DestTy, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn IntToPtr(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildIntToPtr(B(cx), Val, DestTy, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn BitCast(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildBitCast(B(cx), Val, DestTy, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn ZExtOrBitCast(cx: block, Val: ValueRef, DestTy: TypeRef) ->
|
2011-09-02 17:34:58 -05:00
|
|
|
ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildZExtOrBitCast(B(cx), Val, DestTy, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn SExtOrBitCast(cx: block, Val: ValueRef, DestTy: TypeRef) ->
|
2011-09-02 17:34:58 -05:00
|
|
|
ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildSExtOrBitCast(B(cx), Val, DestTy, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn TruncOrBitCast(cx: block, Val: ValueRef, DestTy: TypeRef) ->
|
2011-09-02 17:34:58 -05:00
|
|
|
ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildTruncOrBitCast(B(cx), Val, DestTy, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn Cast(cx: block, Op: Opcode, Val: ValueRef, DestTy: TypeRef,
|
2011-09-02 17:34:58 -05:00
|
|
|
_Name: sbuf) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildCast(B(cx), Op, Val, DestTy, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn PointerCast(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildPointerCast(B(cx), Val, DestTy, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn IntCast(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildIntCast(B(cx), Val, DestTy, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn FPCast(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildFPCast(B(cx), Val, DestTy, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Comparisons */
|
2012-02-17 06:17:40 -06:00
|
|
|
fn ICmp(cx: block, Op: IntPredicate, LHS: ValueRef, RHS: ValueRef)
|
2012-02-01 04:04:56 -06:00
|
|
|
-> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(T_i1()); }
|
2012-01-16 04:21:01 -06:00
|
|
|
ret llvm::LLVMBuildICmp(B(cx), Op as c_uint, LHS, RHS, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn FCmp(cx: block, Op: RealPredicate, LHS: ValueRef, RHS: ValueRef)
|
2012-02-01 04:04:56 -06:00
|
|
|
-> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(T_i1()); }
|
2012-01-16 04:21:01 -06:00
|
|
|
ret llvm::LLVMBuildFCmp(B(cx), Op as c_uint, LHS, RHS, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Miscellaneous instructions */
|
2012-02-17 06:17:40 -06:00
|
|
|
fn EmptyPhi(cx: block, Ty: TypeRef) -> ValueRef {
|
2011-09-23 14:13:50 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(Ty); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildPhi(B(cx), Ty, noname());
|
2011-09-23 14:13:50 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn Phi(cx: block, Ty: TypeRef, vals: [ValueRef], bbs: [BasicBlockRef])
|
2011-09-12 04:27:30 -05:00
|
|
|
-> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(Ty); }
|
2012-02-14 02:10:47 -06:00
|
|
|
assert vals.len() == bbs.len();
|
2011-09-23 14:13:50 -05:00
|
|
|
let phi = EmptyPhi(cx, Ty);
|
2011-10-07 14:05:38 -05:00
|
|
|
unsafe {
|
2012-02-28 22:43:39 -06:00
|
|
|
llvm::LLVMAddIncoming(phi, vec::unsafe::to_ptr(vals),
|
|
|
|
vec::unsafe::to_ptr(bbs),
|
2012-02-14 02:10:47 -06:00
|
|
|
vals.len() as c_uint);
|
2011-10-07 14:05:38 -05:00
|
|
|
ret phi;
|
|
|
|
}
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2011-09-23 16:20:19 -05:00
|
|
|
fn AddIncomingToPhi(phi: ValueRef, val: ValueRef, bb: BasicBlockRef) {
|
2011-09-21 05:40:27 -05:00
|
|
|
if llvm::LLVMIsUndef(phi) == lib::llvm::True { ret; }
|
2011-10-28 16:19:17 -05:00
|
|
|
unsafe {
|
2011-12-13 18:25:51 -06:00
|
|
|
let valptr = unsafe::reinterpret_cast(ptr::addr_of(val));
|
|
|
|
let bbptr = unsafe::reinterpret_cast(ptr::addr_of(bb));
|
2012-01-18 05:29:37 -06:00
|
|
|
llvm::LLVMAddIncoming(phi, valptr, bbptr, 1 as c_uint);
|
2011-10-28 16:19:17 -05:00
|
|
|
}
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn _UndefReturn(cx: block, Fn: ValueRef) -> ValueRef {
|
2012-02-03 02:53:37 -06:00
|
|
|
let ccx = cx.fcx.ccx;
|
2011-09-21 05:40:27 -05:00
|
|
|
let ty = val_ty(Fn);
|
2012-01-18 05:29:37 -06:00
|
|
|
let retty = if llvm::LLVMGetTypeKind(ty) == 8 as c_int {
|
2011-10-14 19:00:17 -05:00
|
|
|
llvm::LLVMGetReturnType(ty) } else { ccx.int_type };
|
2011-09-21 05:40:27 -05:00
|
|
|
ret llvm::LLVMGetUndef(retty);
|
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn add_span_comment(bcx: block, sp: span, text: str) {
|
2012-02-21 07:20:18 -06:00
|
|
|
let ccx = bcx.ccx();
|
2012-01-12 10:59:49 -06:00
|
|
|
if (!ccx.sess.opts.no_asm_comments) {
|
|
|
|
let s = text + " (" + codemap::span_to_str(sp, ccx.sess.codemap)
|
|
|
|
+ ")";
|
2011-12-22 19:53:53 -06:00
|
|
|
log(debug, s);
|
2011-12-18 22:32:38 -06:00
|
|
|
add_comment(bcx, s);
|
2011-11-14 16:03:20 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn add_comment(bcx: block, text: str) {
|
2012-02-21 07:20:18 -06:00
|
|
|
let ccx = bcx.ccx();
|
2012-01-12 10:59:49 -06:00
|
|
|
if (!ccx.sess.opts.no_asm_comments) {
|
2011-12-06 16:02:06 -06:00
|
|
|
let sanitized = str::replace(text, "$", "");
|
|
|
|
let comment_text = "; " + sanitized;
|
2012-02-01 04:04:56 -06:00
|
|
|
let asm = str::as_buf(comment_text, {|c|
|
|
|
|
str::as_buf("", {|e|
|
|
|
|
llvm::LLVMConstInlineAsm(T_fn([], T_void()), c, e,
|
|
|
|
False, False)
|
|
|
|
})
|
|
|
|
});
|
2011-11-14 16:03:20 -06:00
|
|
|
Call(bcx, asm, []);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn Call(cx: block, Fn: ValueRef, Args: [ValueRef]) -> ValueRef {
|
2011-10-25 15:13:55 -05:00
|
|
|
if cx.unreachable { ret _UndefReturn(cx, Fn); }
|
2011-10-07 14:05:38 -05:00
|
|
|
unsafe {
|
2012-02-28 22:43:39 -06:00
|
|
|
ret llvm::LLVMBuildCall(B(cx), Fn, vec::unsafe::to_ptr(Args),
|
2012-02-14 02:10:47 -06:00
|
|
|
Args.len() as c_uint, noname());
|
2011-10-07 14:05:38 -05:00
|
|
|
}
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn FastCall(cx: block, Fn: ValueRef, Args: [ValueRef]) -> ValueRef {
|
2011-10-25 15:13:55 -05:00
|
|
|
if cx.unreachable { ret _UndefReturn(cx, Fn); }
|
2011-10-07 14:05:38 -05:00
|
|
|
unsafe {
|
2012-02-28 22:43:39 -06:00
|
|
|
let v = llvm::LLVMBuildCall(B(cx), Fn, vec::unsafe::to_ptr(Args),
|
2012-02-14 02:10:47 -06:00
|
|
|
Args.len() as c_uint, noname());
|
2012-02-01 04:04:56 -06:00
|
|
|
lib::llvm::SetInstructionCallConv(v, lib::llvm::FastCallConv);
|
2011-10-07 14:05:38 -05:00
|
|
|
ret v;
|
|
|
|
}
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn CallWithConv(cx: block, Fn: ValueRef, Args: [ValueRef],
|
2012-02-01 04:04:56 -06:00
|
|
|
Conv: CallConv) -> ValueRef {
|
2011-10-25 15:13:55 -05:00
|
|
|
if cx.unreachable { ret _UndefReturn(cx, Fn); }
|
2011-10-07 14:05:38 -05:00
|
|
|
unsafe {
|
2012-02-28 22:43:39 -06:00
|
|
|
let v = llvm::LLVMBuildCall(B(cx), Fn, vec::unsafe::to_ptr(Args),
|
2012-02-14 02:10:47 -06:00
|
|
|
Args.len() as c_uint, noname());
|
2012-02-01 04:04:56 -06:00
|
|
|
lib::llvm::SetInstructionCallConv(v, Conv);
|
2011-10-07 14:05:38 -05:00
|
|
|
ret v;
|
|
|
|
}
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn Select(cx: block, If: ValueRef, Then: ValueRef, Else: ValueRef) ->
|
2011-09-02 17:34:58 -05:00
|
|
|
ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret _Undef(Then); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildSelect(B(cx), If, Then, Else, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn VAArg(cx: block, list: ValueRef, Ty: TypeRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(Ty); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildVAArg(B(cx), list, Ty, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn ExtractElement(cx: block, VecVal: ValueRef, Index: ValueRef) ->
|
2011-09-02 17:34:58 -05:00
|
|
|
ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(T_nil()); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildExtractElement(B(cx), VecVal, Index, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn InsertElement(cx: block, VecVal: ValueRef, EltVal: ValueRef,
|
2011-09-21 05:40:27 -05:00
|
|
|
Index: ValueRef) {
|
|
|
|
if cx.unreachable { ret; }
|
2011-12-18 22:32:38 -06:00
|
|
|
llvm::LLVMBuildInsertElement(B(cx), VecVal, EltVal, Index, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn ShuffleVector(cx: block, V1: ValueRef, V2: ValueRef,
|
2011-09-21 05:40:27 -05:00
|
|
|
Mask: ValueRef) {
|
|
|
|
if cx.unreachable { ret; }
|
2011-12-18 22:32:38 -06:00
|
|
|
llvm::LLVMBuildShuffleVector(B(cx), V1, V2, Mask, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn ExtractValue(cx: block, AggVal: ValueRef, Index: uint) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(T_nil()); }
|
2012-01-16 04:21:01 -06:00
|
|
|
ret llvm::LLVMBuildExtractValue(B(cx), AggVal, Index as c_uint, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn InsertValue(cx: block, AggVal: ValueRef, EltVal: ValueRef,
|
2011-09-21 05:40:27 -05:00
|
|
|
Index: uint) {
|
|
|
|
if cx.unreachable { ret; }
|
2012-01-16 04:21:01 -06:00
|
|
|
llvm::LLVMBuildInsertValue(B(cx), AggVal, EltVal, Index as c_uint,
|
|
|
|
noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn IsNull(cx: block, Val: ValueRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(T_i1()); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildIsNull(B(cx), Val, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn IsNotNull(cx: block, Val: ValueRef) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(T_i1()); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildIsNotNull(B(cx), Val, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn PtrDiff(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
|
2012-02-03 02:53:37 -06:00
|
|
|
let ccx = cx.fcx.ccx;
|
2011-10-14 19:00:17 -05:00
|
|
|
if cx.unreachable { ret llvm::LLVMGetUndef(ccx.int_type); }
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildPtrDiff(B(cx), LHS, RHS, noname());
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn Trap(cx: block) {
|
2011-09-21 05:40:27 -05:00
|
|
|
if cx.unreachable { ret; }
|
2011-08-30 07:02:20 -05:00
|
|
|
let b = B(cx);
|
|
|
|
let BB: BasicBlockRef = llvm::LLVMGetInsertBlock(b);
|
2011-08-24 07:54:55 -05:00
|
|
|
let FN: ValueRef = llvm::LLVMGetBasicBlockParent(BB);
|
|
|
|
let M: ModuleRef = llvm::LLVMGetGlobalParent(FN);
|
2011-09-21 10:46:11 -05:00
|
|
|
let T: ValueRef = str::as_buf("llvm.trap", {|buf|
|
|
|
|
llvm::LLVMGetNamedFunction(M, buf)
|
|
|
|
});
|
2011-08-24 07:54:55 -05:00
|
|
|
assert (T as int != 0);
|
|
|
|
let Args: [ValueRef] = [];
|
2011-10-07 14:05:38 -05:00
|
|
|
unsafe {
|
2012-02-28 22:43:39 -06:00
|
|
|
llvm::LLVMBuildCall(b, T, vec::unsafe::to_ptr(Args),
|
2012-02-14 02:10:47 -06:00
|
|
|
Args.len() as c_uint, noname());
|
2011-10-07 14:05:38 -05:00
|
|
|
}
|
2011-08-24 07:54:55 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn LandingPad(cx: block, Ty: TypeRef, PersFn: ValueRef,
|
2011-09-07 13:58:49 -05:00
|
|
|
NumClauses: uint) -> ValueRef {
|
2011-09-21 05:40:27 -05:00
|
|
|
assert !cx.terminated && !cx.unreachable;
|
2012-01-16 04:21:01 -06:00
|
|
|
ret llvm::LLVMBuildLandingPad(B(cx), Ty, PersFn,
|
|
|
|
NumClauses as c_uint, noname());
|
2011-09-07 13:58:49 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn SetCleanup(_cx: block, LandingPad: ValueRef) {
|
2011-09-07 13:58:49 -05:00
|
|
|
llvm::LLVMSetCleanup(LandingPad, lib::llvm::True);
|
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn Resume(cx: block, Exn: ValueRef) -> ValueRef {
|
2011-09-07 16:28:02 -05:00
|
|
|
assert (!cx.terminated);
|
|
|
|
cx.terminated = true;
|
2011-12-18 22:32:38 -06:00
|
|
|
ret llvm::LLVMBuildResume(B(cx), Exn);
|
2011-09-07 16:28:02 -05:00
|
|
|
}
|
|
|
|
|
2011-08-24 07:54:55 -05:00
|
|
|
//
|
|
|
|
// Local Variables:
|
|
|
|
// mode: rust
|
|
|
|
// fill-column: 78;
|
|
|
|
// indent-tabs-mode: nil
|
|
|
|
// c-basic-offset: 4
|
|
|
|
// buffer-file-coding-system: utf-8-unix
|
|
|
|
// End:
|
|
|
|
//
|