From d3cb25d5d1ede9d9ef06db6c30cd8448ed425127 Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Mon, 22 Nov 2010 16:27:00 -0800 Subject: Check and translate 'as' cast-operator, lower target-specific types, reindent rustc.rs, enable uint test. --- src/Makefile | 1 + src/comp/driver/rustc.rs | 171 ++++++++++++++++++++++++--------------------- src/comp/driver/session.rs | 31 +++++++- src/comp/middle/trans.rs | 52 +++++++++++++- src/comp/middle/typeck.rs | 55 +++++++++++++++ 5 files changed, 229 insertions(+), 81 deletions(-) (limited to 'src') diff --git a/src/Makefile b/src/Makefile index 9a4d1383..74f0dbd1 100644 --- a/src/Makefile +++ b/src/Makefile @@ -533,6 +533,7 @@ TEST_XFAILS_SELF := $(filter-out \ lazy-init.rs \ multiline-comment.rs \ return-nil.rs \ + uint.rs \ unit.rs \ while-and-do-while.rs \ ), \ diff --git a/src/comp/driver/rustc.rs b/src/comp/driver/rustc.rs index baf00780..9c0b2484 100644 --- a/src/comp/driver/rustc.rs +++ b/src/comp/driver/rustc.rs @@ -5,6 +5,7 @@ import front.token; import middle.trans; import middle.resolve; import middle.typeck; +import util.common; import std.option; import std.option.some; @@ -13,18 +14,18 @@ import std._str; import std._vec; impure fn compile_input(session.session sess, str input, str output) { - auto p = parser.new_parser(sess, 0, input); - auto crate = parser.parse_crate(p); - crate = resolve.resolve_crate(sess, crate); - crate = typeck.check_crate(sess, crate); - trans.trans_crate(sess, crate, output); + auto p = parser.new_parser(sess, 0, input); + auto crate = parser.parse_crate(p); + crate = resolve.resolve_crate(sess, crate); + crate = typeck.check_crate(sess, crate); + trans.trans_crate(sess, crate, output); } fn warn_wrong_compiler() { - log "This is the rust 'self-hosted' compiler."; - log "The one written in rust."; - log "It does nothing yet, it's a placeholder."; - log "You want rustboot, the compiler next door."; + log "This is the rust 'self-hosted' compiler."; + log "The one written in rust."; + log "It does nothing yet, it's a placeholder."; + log "You want rustboot, the compiler next door."; } fn usage(session.session sess, str argv0) { @@ -38,81 +39,95 @@ fn usage(session.session sess, str argv0) { log ""; } +fn get_os() -> session.os { + auto s = std.os.target_os(); + if (_str.eq(s, "win32")) { ret session.os_win32; } + if (_str.eq(s, "macos")) { ret session.os_macos; } + if (_str.eq(s, "linux")) { ret session.os_linux; } +} + impure fn main(vec[str] args) { - auto sess = session.session(); - let option.t[str] input_file = none[str]; - let option.t[str] output_file = none[str]; - let bool do_warn = true; + // FIXME: don't hard-wire this. + auto target_cfg = rec(os = get_os(), + arch = session.arch_x86, + int_type = common.ty_i32, + uint_type = common.ty_u32, + float_type = common.ty_f64 ); + + auto sess = session.session(target_cfg); + let option.t[str] input_file = none[str]; + let option.t[str] output_file = none[str]; + let bool do_warn = true; - auto i = 1u; - auto len = _vec.len[str](args); + auto i = 1u; + auto len = _vec.len[str](args); - // FIXME: a getopt module would be nice. - while (i < len) { - auto arg = args.(i); - if (_str.byte_len(arg) > 0u && arg.(0) == '-' as u8) { - if (_str.eq(arg, "-nowarn")) { - do_warn = false; - } else { - // FIXME: rust could use an elif construct. - if (_str.eq(arg, "-o")) { - if (i+1u < len) { - output_file = some(args.(i+1u)); - i += 1u; - } else { - usage(sess, args.(0)); - sess.err("-o requires an argument"); - } - } else { - if (_str.eq(arg, "-h")) { - usage(sess, args.(0)); - } else { - usage(sess, args.(0)); - sess.err("unrecognized option: " + arg); - } - } - } - } else { - alt (input_file) { - case (some[str](_)) { - usage(sess, args.(0)); - sess.err("multiple inputs provided"); - } - case (none[str]) { - input_file = some[str](arg); - } - } - // FIXME: dummy node to work around typestate mis-wiring bug. - i = i; - } - i += 1u; - } + // FIXME: a getopt module would be nice. + while (i < len) { + auto arg = args.(i); + if (_str.byte_len(arg) > 0u && arg.(0) == '-' as u8) { + if (_str.eq(arg, "-nowarn")) { + do_warn = false; + } else { + // FIXME: rust could use an elif construct. + if (_str.eq(arg, "-o")) { + if (i+1u < len) { + output_file = some(args.(i+1u)); + i += 1u; + } else { + usage(sess, args.(0)); + sess.err("-o requires an argument"); + } + } else { + if (_str.eq(arg, "-h")) { + usage(sess, args.(0)); + } else { + usage(sess, args.(0)); + sess.err("unrecognized option: " + arg); + } + } + } + } else { + alt (input_file) { + case (some[str](_)) { + usage(sess, args.(0)); + sess.err("multiple inputs provided"); + } + case (none[str]) { + input_file = some[str](arg); + } + } + // FIXME: dummy node to work around typestate mis-wiring bug. + i = i; + } + i += 1u; + } - if (do_warn) { - warn_wrong_compiler(); - } + if (do_warn) { + warn_wrong_compiler(); + } - alt (input_file) { - case (none[str]) { - usage(sess, args.(0)); - sess.err("no input filename"); - } - case (some[str](?ifile)) { - alt (output_file) { - case (none[str]) { - let vec[str] parts = _str.split(ifile, '.' as u8); - parts = _vec.pop[str](parts); - parts += ".bc"; - auto ofile = _str.concat(parts); - compile_input(sess, ifile, ofile); - } - case (some[str](?ofile)) { - compile_input(sess, ifile, ofile); - } - } - } - } + alt (input_file) { + case (none[str]) { + usage(sess, args.(0)); + sess.err("no input filename"); + } + case (some[str](?ifile)) { + alt (output_file) { + case (none[str]) { + let vec[str] parts = _str.split(ifile, '.' as u8); + parts = _vec.pop[str](parts); + parts += ".bc"; + auto ofile = _str.concat(parts); + compile_input(sess, ifile, ofile); + } + case (some[str](?ofile)) { + compile_input(sess, ifile, ofile); + } + } + } + } } diff --git a/src/comp/driver/session.rs b/src/comp/driver/session.rs index 831c6439..e23dbeed 100644 --- a/src/comp/driver/session.rs +++ b/src/comp/driver/session.rs @@ -1,7 +1,31 @@ import util.common.span; +import util.common.ty_mach; import std._uint; -obj session() { +tag os { + os_win32; + os_macos; + os_linux; +} + +tag arch { + arch_x86; + arch_x64; + arch_arm; +} + +type cfg = rec(os os, + arch arch, + ty_mach int_type, + ty_mach uint_type, + ty_mach float_type); + +obj session(cfg targ) { + + fn get_targ_cfg() -> cfg { + ret targ; + } + fn span_err(span sp, str msg) { log #fmt("%s:%u:%u:%u:%u: error: %s", sp.filename, @@ -16,6 +40,11 @@ obj session() { fail; } + fn bug(str msg) { + log #fmt("error: internal compiler error %s", msg); + fail; + } + fn unimpl(str msg) { log #fmt("error: unimplemented %s", msg); fail; diff --git a/src/comp/middle/trans.rs b/src/comp/middle/trans.rs index 6b45ad85..9bc1f19c 100644 --- a/src/comp/middle/trans.rs +++ b/src/comp/middle/trans.rs @@ -551,18 +551,36 @@ impure fn trans_lit(@block_ctxt cx, &ast.lit lit) -> result { } } -fn node_type(@crate_ctxt cx, &ast.ann a) -> TypeRef { +fn target_type(@crate_ctxt cx, @typeck.ty t) -> @typeck.ty { + alt (t.struct) { + case (typeck.ty_int) { + auto tm = typeck.ty_machine(cx.sess.get_targ_cfg().int_type); + ret @rec(struct=tm with *t); + } + case (typeck.ty_uint) { + auto tm = typeck.ty_machine(cx.sess.get_targ_cfg().uint_type); + ret @rec(struct=tm with *t); + } + } + ret t; +} + +fn node_ann_type(@crate_ctxt cx, &ast.ann a) -> @typeck.ty { alt (a) { case (ast.ann_none) { log "missing type annotation"; fail; } case (ast.ann_type(?t)) { - ret type_of(cx, t); + ret target_type(cx, t); } } } +fn node_type(@crate_ctxt cx, &ast.ann a) -> TypeRef { + ret type_of(cx, node_ann_type(cx, a)); +} + impure fn trans_unary(@block_ctxt cx, ast.unop op, &ast.expr e, &ast.ann a) -> result { @@ -962,6 +980,36 @@ impure fn trans_expr(@block_ctxt cx, &ast.expr e) -> result { args_res._0.build.FastCall(f_res._0.val, llargs)); } + case (ast.expr_cast(?e, _, ?ann)) { + auto e_res = trans_expr(cx, *e); + auto llsrctype = val_ty(e_res.val); + auto t = node_ann_type(cx.fcx.ccx, ann); + auto lldsttype = type_of(cx.fcx.ccx, t); + if (!typeck.type_is_fp(t)) { + if (llvm.LLVMGetIntTypeWidth(lldsttype) > + llvm.LLVMGetIntTypeWidth(llsrctype)) { + if (typeck.type_is_signed(t)) { + // Widening signed cast. + e_res.val = + e_res.bcx.build.SExtOrBitCast(e_res.val, + lldsttype); + } else { + // Widening unsigned cast. + e_res.val = + e_res.bcx.build.ZExtOrBitCast(e_res.val, + lldsttype); + } + } else { + // Narrowing cast. + e_res.val = + e_res.bcx.build.TruncOrBitCast(e_res.val, + lldsttype); + } + } else { + cx.fcx.ccx.sess.unimpl("fp cast"); + } + ret e_res; + } } cx.fcx.ccx.sess.unimpl("expr variant in trans_expr"); fail; diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs index e6c7a9da..7bdbd9e9 100644 --- a/src/comp/middle/typeck.rs +++ b/src/comp/middle/typeck.rs @@ -391,6 +391,44 @@ fn mode_is_alias(ast.mode m) -> bool { } } +fn type_is_scalar(@ty t) -> bool { + alt (t.struct) { + case (ty_bool) { ret true; } + case (ty_int) { ret true; } + case (ty_uint) { ret true; } + case (ty_machine(_)) { ret true; } + case (ty_char) { ret true; } + } + ret false; +} + +fn type_is_fp(@ty t) -> bool { + alt (t.struct) { + case (ty_machine(?tm)) { + alt (tm) { + case (common.ty_f32) { ret true; } + case (common.ty_f64) { ret true; } + } + } + } + ret false; +} + +fn type_is_signed(@ty t) -> bool { + alt (t.struct) { + case (ty_int) { ret true; } + case (ty_machine(?tm)) { + alt (tm) { + case (common.ty_i8) { ret true; } + case (common.ty_i16) { ret true; } + case (common.ty_i32) { ret true; } + case (common.ty_i64) { ret true; } + } + } + } + ret false; +} + fn plain_ty(&sty st) -> @ty { ret @rec(struct=st, cname=none[str]); } @@ -873,6 +911,23 @@ fn check_expr(&fn_ctxt fcx, @ast.expr expr) -> @ast.expr { ast.ann_type(ret_t))); } + case (ast.expr_cast(?e, ?t, _)) { + auto e_1 = check_expr(fcx, e); + auto t_1 = ast_ty_to_ty_crate(fcx.ccx, t); + // FIXME: there are more forms of cast to support, eventually. + if (! (type_is_scalar(expr_ty(e_1)) && + type_is_scalar(t_1))) { + fcx.ccx.sess.span_err(expr.span, + "non-scalar cast: " + + ty_to_str(expr_ty(e_1)) + + " as " + + ty_to_str(t_1)); + } + ret @fold.respan[ast.expr_](expr.span, + ast.expr_cast(e_1, t, + ast.ann_type(t_1))); + } + case (_) { // TODO ret expr; -- cgit v1.2.3