WIP: add codegen parameters.

Author: maleadt

base/reflection.jl

@@ -493,8 +493,29 @@ function uncompressed_ast(m::Method, s::CodeInfo)
     return s
 end
 
+# this type mirrors jl_cgparams_t (documented in julia.h)
+immutable CodegenParams
+    cached::Cint
+
+    runtime::Cint
+    exceptions::Cint
+    track_allocations::Cint
+    code_coverage::Cint
+    static_alloc::Cint
+    dynamic_alloc::Cint
+
+    CodegenParams(;cached::Bool=true,
+                   runtime::Int=1, exceptions::Int=1,
+                   track_allocations::Int=1, code_coverage::Int=1,
+                   static_alloc::Int=1, dynamic_alloc::Int=1) =
+        new(Cint(cached),
+            Cint(runtime), Cint(exceptions),
+            Cint(track_allocations), Cint(code_coverage),
+            Cint(static_alloc), Cint(dynamic_alloc))
+end
+
 # Printing code representations in IR and assembly
-function _dump_function(f::ANY, t::ANY, native::Bool, wrapper::Bool, strip_ir_metadata::Bool, dump_module::Bool, syntax::Symbol=:att)
+function _dump_function(f::ANY, t::ANY, native::Bool, wrapper::Bool, strip_ir_metadata::Bool, dump_module::Bool, syntax::Symbol=:att, optimize::Bool=true, params::CodegenParams=CodegenParams())
     ccall(:jl_is_in_pure_context, Bool, ()) && error("code reflection cannot be used from generated functions")
     if isa(f, Core.Builtin)
         throw(ArgumentError("argument is not a generic function"))
@@ -509,17 +530,17 @@ function _dump_function(f::ANY, t::ANY, native::Bool, wrapper::Bool, strip_ir_me
     meth = func_for_method_checked(meth, tt)
     linfo = ccall(:jl_specializations_get_linfo, Ref{Core.MethodInstance}, (Any, Any, Any), meth, tt, env)
     # get the code for it
-    return _dump_function(linfo, native, wrapper, strip_ir_metadata, dump_module, syntax)
+    return _dump_function(linfo, native, wrapper, strip_ir_metadata, dump_module, syntax, optimize, params)
 end
 
-function _dump_function(linfo::Core.MethodInstance, native::Bool, wrapper::Bool, strip_ir_metadata::Bool, dump_module::Bool, syntax::Symbol=:att)
+function _dump_function(linfo::Core.MethodInstance, native::Bool, wrapper::Bool, strip_ir_metadata::Bool, dump_module::Bool, syntax::Symbol=:att, optimize::Bool=true, params::CodegenParams=CodegenParams())
     if syntax != :att && syntax != :intel
         throw(ArgumentError("'syntax' must be either :intel or :att"))
     end
     if native
-        llvmf = ccall(:jl_get_llvmf_decl, Ptr{Void}, (Any, Bool), linfo, wrapper)
+        llvmf = ccall(:jl_get_llvmf_decl, Ptr{Void}, (Any, Bool, CodegenParams), linfo, wrapper, params)
     else
-        llvmf = ccall(:jl_get_llvmf_defn, Ptr{Void}, (Any, Bool), linfo, wrapper)
+        llvmf = ccall(:jl_get_llvmf_defn, Ptr{Void}, (Any, Bool, Bool, CodegenParams), linfo, wrapper, optimize, params)
     end
     if llvmf == C_NULL
         error("could not compile the specified method")

src/alloc.c

@@ -457,7 +457,7 @@ STATIC_INLINE jl_value_t *jl_call_staged(jl_svec_t *sparam_vals, jl_method_insta
     fptr.fptr = generator->fptr;
     fptr.jlcall_api = generator->jlcall_api;
     if (__unlikely(fptr.fptr == NULL || fptr.jlcall_api == 0)) {
-        void *F = jl_compile_linfo(generator, (jl_code_info_t*)generator->inferred).functionObject;
+        void *F = jl_compile_linfo(generator, (jl_code_info_t*)generator->inferred, &jl_default_cgparams).functionObject;
         fptr = jl_generate_fptr(generator, F);
     }
     assert(jl_svec_len(generator->def->sparam_syms) == jl_svec_len(sparam_vals));

src/cgutils.cpp

@@ -26,6 +26,25 @@ static Value *prepare_call(Value *Callee)
 }
 
 
+// --- feature checks ---
+
+// require a feature to be allowed and enabled
+#define JL_FEAT_REQUIRE(ctx, feature) \
+    if ((ctx)->params->feature < 1) \
+        jl_errorf("%s for %s:%d requires the " #feature " language feature, which is disabled or not allowed", \
+                  __FUNCTION__, (ctx)->file.str().c_str(), *(ctx)->line);
+
+// require a feature to be allowed, and branch on whether it is enabled
+#define JL_FEAT_TEST(ctx, feature) \
+    _feat_test(ctx, __FUNCTION__, (ctx)->params->feature, #feature)
+static inline bool _feat_test(jl_codectx_t* ctx, const char *caller, int featval, const char *featname) {
+    if (featval < 0)
+        jl_errorf("%s for %s requires the %s language feature, which is not allowed",
+                  caller, ctx->file.str().c_str(), *ctx->line, featname);
+    return (featval > 0);
+}
+
+
 // --- string constants ---
 static StringMap<GlobalVariable*> stringConstants;
 static Value *stringConstPtr(IRBuilder<> &builder, const std::string &txt)
@@ -660,11 +679,20 @@ static void error_unless(Value *cond, const std::string &msg, jl_codectx_t *ctx)
 static void raise_exception(Value *exc, jl_codectx_t *ctx,
                             BasicBlock *contBB=nullptr)
 {
+    if (!JL_FEAT_TEST(ctx, exceptions)) {
+        llvm::Value *Trap = Intrinsic::getDeclaration(jl_Module, Intrinsic::trap);
+        CallInst *TrapCall = builder.CreateCall(Trap);
+        TrapCall->setDoesNotReturn();
+        TrapCall->setDoesNotThrow();
+    } else {
+        JL_FEAT_REQUIRE(ctx, runtime);
 #if JL_LLVM_VERSION >= 30700
-    builder.CreateCall(prepare_call(jlthrow_func), { exc });
+        builder.CreateCall(prepare_call(jlthrow_func), { exc });
 #else
-    builder.CreateCall(prepare_call(jlthrow_func), exc);
+        builder.CreateCall(prepare_call(jlthrow_func), exc);
 #endif
+    }
+
     builder.CreateUnreachable();
     if (!contBB) {
         contBB = BasicBlock::Create(jl_LLVMContext, "after_throw", ctx->f);
@@ -1566,6 +1594,9 @@ static void emit_cpointercheck(const jl_cgval_t &x, const std::string &msg, jl_c
 // allocation for known size object
 static Value *emit_allocobj(jl_codectx_t *ctx, size_t static_size, Value *jt)
 {
+    JL_FEAT_REQUIRE(ctx, dynamic_alloc);
+    JL_FEAT_REQUIRE(ctx, runtime);
+
     int osize;
     int offset = jl_gc_classify_pools(static_size, &osize);
     Value *ptls_ptr = emit_bitcast(ctx->ptlsStates, T_pint8);