diff --git a/base/boot.jl b/base/boot.jl
index 2545be0b75713..0d07ca8ae7c67 100644
--- a/base/boot.jl
+++ b/base/boot.jl
@@ -139,7 +139,7 @@ export
     StackOverflowError, SegmentationFault, UndefRefError, UndefVarError, TypeError,
     # AST representation
     Expr, GotoNode, LabelNode, LineNumberNode, QuoteNode, TopNode,
-    GlobalRef, NewvarNode, GenSym, Slot, SlotNumber, TypedSlot,
+    GlobalRef, NewvarNode, SSAValue, Slot, SlotNumber, TypedSlot,
     # object model functions
     fieldtype, getfield, setfield!, nfields, throw, tuple, is, ===, isdefined, eval,
     # sizeof    # not exported, to avoid conflicting with Base.sizeof
@@ -283,7 +283,7 @@ _new(:GotoNode, :Int)
 _new(:TopNode, :Symbol)
 _new(:NewvarNode, :SlotNumber)
 _new(:QuoteNode, :ANY)
-_new(:GenSym, :Int)
+_new(:SSAValue, :Int)
 eval(:((::Type{LineNumberNode})(f::Symbol, l::Int) = $(Expr(:new, :LineNumberNode, :f, :l))))
 eval(:((::Type{GlobalRef})(m::Module, s::Symbol) = $(Expr(:new, :GlobalRef, :m, :s))))
 eval(:((::Type{SlotNumber})(n::Int) = $(Expr(:new, :SlotNumber, :n))))
diff --git a/base/inference.jl b/base/inference.jl
index 830c1c26eb143..96bb48402ef83 100644
--- a/base/inference.jl
+++ b/base/inference.jl
@@ -31,9 +31,8 @@ end
 type InferenceState
     atypes #::Type       # type sig
     sp::SimpleVector     # static parameters
-    gensym_types::Array{Any,1} # types of the GenSym's in this function
     label_counter::Int   # index of the current highest label for this function
-    fedbackvars::Dict{GenSym, Bool}
+    fedbackvars::Dict{SSAValue, Bool}
     mod::Module
     currpc::LineNum
     static_typeof::Bool
@@ -52,9 +51,9 @@ type InferenceState
     cur_hand #::Tuple{LineNum, Tuple{LineNum, ...}}
     handler_at::Vector{Any}
     n_handlers::Int
-    # gensym sparsity and restart info
-    gensym_uses::Vector{IntSet}
-    gensym_init::Vector{Any}
+    # ssavalue sparsity and restart info
+    ssavalue_uses::Vector{IntSet}
+    ssavalue_init::Vector{Any}
     # call-graph edges connecting from a caller to a callee (and back)
     # we shouldn't need to iterate edges very often, so we use it to optimize the lookup from edge -> linenum
     # whereas backedges is optimized for iteration
@@ -84,8 +83,8 @@ type InferenceState
         if !isa(linfo.slottypes, Array)
             linfo.slottypes = Any[ Any for i = 1:nslots ]
         end
-        if !isa(linfo.gensymtypes, Array)
-            linfo.gensymtypes = Any[ NF for i = 1:(linfo.gensymtypes::Int) ]
+        if !isa(linfo.ssavaluetypes, Array)
+            linfo.ssavaluetypes = Any[ NF for i = 1:(linfo.ssavaluetypes::Int) ]
         end
 
         n = length(linfo.code)
@@ -135,9 +134,8 @@ type InferenceState
             @assert la == 0 # wrong number of arguments
         end
 
-        gensym_uses = find_gensym_uses(linfo.code)
-        gensym_types = linfo.gensymtypes
-        gensym_init = copy(gensym_types)
+        ssavalue_uses = find_ssavalue_uses(linfo.code)
+        ssavalue_init = copy(linfo.ssavaluetypes)
 
         # exception handlers
         cur_hand = ()
@@ -149,10 +147,10 @@ type InferenceState
 
         inmodule = isdefined(linfo, :def) ? linfo.def.module : current_module() # toplevel thunks are inferred in the current module
         frame = new(
-            atypes, sp, gensym_types, nl, Dict{GenSym, Bool}(), inmodule, 0, false,
+            atypes, sp, nl, Dict{SSAValue, Bool}(), inmodule, 0, false,
             linfo, linfo, la, s, Union{}, W, n,
             cur_hand, handler_at, n_handlers,
-            gensym_uses, gensym_init,
+            ssavalue_uses, ssavalue_init,
             ObjectIdDict(), #Dict{InferenceState, Vector{LineNum}}(),
             Vector{Tuple{InferenceState, Vector{LineNum}}}(),
             false, false, false, optimize, false, nothing)
@@ -1042,8 +1040,8 @@ end
 function abstract_eval(e::ANY, vtypes::VarTable, sv::InferenceState)
     if isa(e,QuoteNode)
         return abstract_eval_constant((e::QuoteNode).value)
-    elseif isa(e,GenSym)
-        return abstract_eval_gensym(e::GenSym, sv)
+    elseif isa(e,SSAValue)
+        return abstract_eval_ssavalue(e::SSAValue, sv)
     elseif isa(e,Slot)
         return vtypes[e.id].typ
     elseif isa(e,TopNode)
@@ -1165,8 +1163,8 @@ function abstract_eval_global(M::Module, s::Symbol)
     return Any
 end
 
-function abstract_eval_gensym(s::GenSym, sv::InferenceState)
-    typ = sv.gensym_types[s.id+1]
+function abstract_eval_ssavalue(s::SSAValue, sv::InferenceState)
+    typ = sv.linfo.ssavaluetypes[s.id+1]
     if typ === NF
         return Bottom
     end
@@ -1181,7 +1179,7 @@ end
 #### handling for statement-position expressions ####
 
 type StateUpdate
-    var::Union{Slot,GenSym}
+    var::Union{Slot,SSAValue}
     vtype
     state::VarTable
 end
@@ -1193,7 +1191,7 @@ function abstract_interpret(e::ANY, vtypes::VarTable, sv::InferenceState)
         t = abstract_eval(e.args[2], vtypes, sv)
         t === Bottom && return ()
         lhs = e.args[1]
-        if isa(lhs,Slot) || isa(lhs,GenSym)
+        if isa(lhs,Slot) || isa(lhs,SSAValue)
             # don't bother for GlobalRef
             return StateUpdate(lhs, VarState(t,false), vtypes)
         end
@@ -1339,16 +1337,16 @@ function label_counter(body)
 end
 genlabel(sv) = LabelNode(sv.label_counter += 1)
 
-function find_gensym_uses(body)
+function find_ssavalue_uses(body)
     uses = IntSet[]
     for line = 1:length(body)
-        find_gensym_uses(body[line], uses, line)
+        find_ssavalue_uses(body[line], uses, line)
     end
     return uses
 end
-function find_gensym_uses(e::ANY, uses, line)
-    if isa(e,GenSym)
-        id = (e::GenSym).id+1
+function find_ssavalue_uses(e::ANY, uses, line)
+    if isa(e,SSAValue)
+        id = (e::SSAValue).id+1
         while length(uses) < id
             push!(uses, IntSet())
         end
@@ -1360,25 +1358,25 @@ function find_gensym_uses(e::ANY, uses, line)
             return
         end
         if head === :(=)
-            if isa(b.args[1],GenSym)
-                id = (b.args[1]::GenSym).id+1
+            if isa(b.args[1],SSAValue)
+                id = (b.args[1]::SSAValue).id+1
                 while length(uses) < id
                     push!(uses, IntSet())
                 end
             end
-            find_gensym_uses(b.args[2], uses, line)
+            find_ssavalue_uses(b.args[2], uses, line)
             return
         end
         for a in b.args
-            find_gensym_uses(a, uses, line)
+            find_ssavalue_uses(a, uses, line)
         end
     end
 end
 
 function newvar!(sv::InferenceState, typ)
-    id = length(sv.gensym_types)
-    push!(sv.gensym_types, typ)
-    return GenSym(id)
+    id = length(sv.linfo.ssavaluetypes)
+    push!(sv.linfo.ssavaluetypes, typ)
+    return SSAValue(id)
 end
 
 # create a specialized LambdaInfo from a method
@@ -1398,8 +1396,8 @@ function unshare_linfo!(li::LambdaInfo)
     if isa(li.slottypes, Array)
         li.slottypes = copy(li.slottypes)
     end
-    if isa(li.gensymtypes, Array)
-        li.gensymtypes = copy(li.gensymtypes)
+    if isa(li.ssavaluetypes, Array)
+        li.ssavaluetypes = copy(li.ssavaluetypes)
     end
     return li
 end
@@ -1540,7 +1538,7 @@ function typeinf_ext(linfo::LambdaInfo)
                 linfo.slotnames = code.slotnames
                 linfo.slottypes = code.slottypes
                 linfo.slotflags = code.slotflags
-                linfo.gensymtypes = code.gensymtypes
+                linfo.ssavaluetypes = code.ssavaluetypes
                 linfo.rettype = code.rettype
                 linfo.pure = code.pure
             end
@@ -1650,15 +1648,15 @@ function typeinf_frame(frame)
                 end
             end
             pc´ = pc+1
-            if isa(changes, StateUpdate) && isa((changes::StateUpdate).var, GenSym)
-                # directly forward changes to a GenSym to the applicable line
+            if isa(changes, StateUpdate) && isa((changes::StateUpdate).var, SSAValue)
+                # directly forward changes to an SSAValue to the applicable line
                 changes = changes::StateUpdate
-                id = (changes.var::GenSym).id + 1
+                id = (changes.var::SSAValue).id + 1
                 new = changes.vtype.typ
-                old = frame.gensym_types[id]
+                old = frame.linfo.ssavaluetypes[id]
                 if old===NF || !(new ⊑ old)
-                    frame.gensym_types[id] = tmerge(old, new)
-                    for r in frame.gensym_uses[id]
+                    frame.linfo.ssavaluetypes[id] = tmerge(old, new)
+                    for r in frame.ssavalue_uses[id]
                         if !is(s[r], ()) # s[r] === () => unreached statement
                             push!(W, r)
                         end
@@ -1689,18 +1687,18 @@ function typeinf_frame(frame)
                     end
                 elseif is(hd, :type_goto)
                     for i = 2:length(stmt.args)
-                        var = stmt.args[i]::GenSym
+                        var = stmt.args[i]::SSAValue
                         # Store types that need to be fed back via type_goto
-                        # in gensym_init. After finishing inference, if any
+                        # in ssavalue_init. After finishing inference, if any
                         # of these types changed, start over with the fed-back
                         # types known from the beginning.
                         # See issue #3821 (using !typeseq instead of !subtype),
                         # and issue #7810.
                         id = var.id+1
-                        vt = frame.gensym_types[id]
-                        ot = frame.gensym_init[id]
+                        vt = frame.linfo.ssavaluetypes[id]
+                        ot = frame.ssavalue_init[id]
                         if ot===NF || !(vt⊑ot && ot⊑vt)
-                            frame.gensym_init[id] = vt
+                            frame.ssavalue_init[id] = vt
                             if get(frame.fedbackvars, var, false)
                                 frame.typegotoredo = true
                             end
@@ -1787,7 +1785,7 @@ function typeinf_frame(frame)
             frame.cur_hand = ()
             frame.handler_at = Any[ () for i=1:n ]
             frame.n_handlers = 0
-            frame.gensym_types[:] = frame.gensym_init
+            frame.linfo.ssavaluetypes[:] = frame.ssavalue_init
             @goto restart_typeinf
         else
             # if a static_typeof was never reached,
@@ -1798,8 +1796,8 @@ function typeinf_frame(frame)
             for (fbvar, seen) in frame.fedbackvars
                 if !seen
                     frame.fedbackvars[fbvar] = true
-                    id = (fbvar::GenSym).id + 1
-                    for r in frame.gensym_uses[id]
+                    id = (fbvar::SSAValue).id + 1
+                    for r in frame.ssavalue_uses[id]
                         if !is(s[r], ()) # s[r] === () => unreached statement
                             push!(W, r)
                         end
@@ -1859,12 +1857,13 @@ function finish(me::InferenceState)
     @assert me.inworkq
 
     # annotate fulltree with type information
-    for i = 1:length(me.gensym_types)
-        if me.gensym_types[i] === NF
-            me.gensym_types[i] = Union{}
+    gt = me.linfo.ssavaluetypes
+    for i = 1:length(gt)
+        if gt[i] === NF
+            gt[i] = Union{}
         end
     end
-    type_annotate!(me.linfo, me.stmt_types, me, me.bestguess, me.nargs)
+    type_annotate!(me.linfo, me.stmt_types, me, me.nargs)
 
     # make sure (meta pure) is stripped from full tree
     ispure = popmeta!(me.linfo.code, :pure)[1]
@@ -1902,7 +1901,7 @@ function finish(me::InferenceState)
         out.slotnames = me.linfo.slotnames
         out.slottypes = me.linfo.slottypes
         out.slotflags = me.linfo.slotflags
-        out.gensymtypes = me.linfo.gensymtypes
+        out.ssavaluetypes = me.linfo.ssavaluetypes
         out.rettype = me.linfo.rettype
         out.pure = me.linfo.pure
     end
@@ -1967,7 +1966,7 @@ function expr_cannot_delete(ex::Expr)
 end
 
 # annotate types of all symbols in AST
-function type_annotate!(linfo::LambdaInfo, states::Array{Any,1}, sv::ANY, rettype::ANY, nargs)
+function type_annotate!(linfo::LambdaInfo, states::Array{Any,1}, sv::ANY, nargs)
     nslots = length(states[1])
     for i = 1:nslots
         linfo.slottypes[i] = Bottom
@@ -2035,8 +2034,8 @@ function _widen_all_consts(x::Expr)
     x
 end
 function widen_all_consts!(linfo::LambdaInfo)
-    for i = 1:length(linfo.gensymtypes)
-        linfo.gensymtypes[i] = widenconst(linfo.gensymtypes[i])
+    for i = 1:length(linfo.ssavaluetypes)
+        linfo.ssavaluetypes[i] = widenconst(linfo.ssavaluetypes[i])
     end
     for i = 1:length(linfo.code)
         linfo.code[i] = _widen_all_consts(linfo.code[i])
@@ -2100,8 +2099,8 @@ function exprtype(x::ANY, sv::InferenceState)
         return sv.linfo.slottypes[x.id]
     elseif isa(x,TypedSlot)
         return (x::Slot).typ
-    elseif isa(x,GenSym)
-        return abstract_eval_gensym(x::GenSym, sv)
+    elseif isa(x,SSAValue)
+        return abstract_eval_ssavalue(x::SSAValue, sv)
     elseif isa(x,TopNode)
         return abstract_eval_global(_topmod(sv), (x::TopNode).name)
     elseif isa(x,Symbol)
@@ -2149,7 +2148,7 @@ function effect_free(e::ANY, sv, allow_volatile::Bool)
     if isa(e,Symbol)
         return allow_volatile
     end
-    if isa(e,Number) || isa(e,AbstractString) || isa(e,GenSym) ||
+    if isa(e,Number) || isa(e,AbstractString) || isa(e,SSAValue) ||
         isa(e,TopNode) || isa(e,QuoteNode) || isa(e,Type) || isa(e,Tuple)
         return true
     end
@@ -2166,7 +2165,7 @@ function effect_free(e::ANY, sv, allow_volatile::Bool)
             return true
         end
         ea = e.args
-        if e.head === :call && !isa(e.args[1], GenSym) && !isa(e.args[1], Slot)
+        if e.head === :call && !isa(e.args[1], SSAValue) && !isa(e.args[1], Slot)
             if is_known_call_p(e, is_pure_builtin, sv)
                 if !allow_volatile
                     if is_known_call(e, arrayref, sv) || is_known_call(e, arraylen, sv)
@@ -2182,7 +2181,7 @@ function effect_free(e::ANY, sv, allow_volatile::Bool)
                             if isa(a,Symbol)
                                 return false
                             end
-                            if isa(a,GenSym)
+                            if isa(a,SSAValue)
                                 typ = widenconst(exprtype(a,sv))
                                 if !isa(typ,DataType) || typ.mutable
                                     return false
@@ -2322,7 +2321,7 @@ function inlineable(f::ANY, ft::ANY, e::Expr, atypes::Vector{Any}, sv::Inference
     end
     for i=1:length(spvals)
         si = spvals[i]
-        if isa(si,Symbol) || isa(si,GenSym) || isa(si,Slot)
+        if isa(si,Symbol) || isa(si,SSAValue) || isa(si,Slot)
             spvals[i] = QuoteNode(si)
         end
     end
@@ -2597,14 +2596,14 @@ function inlineable(f::ANY, ft::ANY, e::Expr, atypes::Vector{Any}, sv::Inference
         unshift!(argexprs2, top_tuple)
     end
 
-    # re-number the GenSyms and copy their type-info to the new ast
-    gensym_types = linfo.gensymtypes
-    if !isempty(gensym_types)
-        incr = length(sv.gensym_types)
+    # re-number the SSAValues and copy their type-info to the new ast
+    ssavalue_types = linfo.ssavaluetypes
+    if !isempty(ssavalue_types)
+        incr = length(sv.linfo.ssavaluetypes)
         if incr != 0
-            body = gensym_increment(body, incr)
+            body = ssavalue_increment(body, incr)
         end
-        append!(sv.gensym_types, gensym_types)
+        append!(sv.linfo.ssavaluetypes, ssavalue_types)
     end
 
     # ok, substitute argument expressions for argument names in the body
@@ -2751,14 +2750,14 @@ function inline_worthy(body::Expr, cost::Integer=1000) # precondition: 0 < cost;
     return false
 end
 
-gensym_increment(body::ANY, incr) = body
-gensym_increment(body::GenSym, incr) = GenSym(body.id + incr)
-function gensym_increment(body::Expr, incr)
+ssavalue_increment(body::ANY, incr) = body
+ssavalue_increment(body::SSAValue, incr) = SSAValue(body.id + incr)
+function ssavalue_increment(body::Expr, incr)
     if body.head === :line
         return body
     end
     for i in 1:length(body.args)
-        body.args[i] = gensym_increment(body.args[i], incr)
+        body.args[i] = ssavalue_increment(body.args[i], incr)
     end
     return body
 end
@@ -2892,7 +2891,7 @@ function inlining_pass(e::Expr, sv, linfo)
         if length(e.args) == 3 && isa(e.args[3],Union{Int32,Int64})
             a1 = e.args[2]
             basenumtype = Union{corenumtype, Main.Base.Complex64, Main.Base.Complex128, Main.Base.Rational}
-            if isa(a1,basenumtype) || ((isa(a1,Symbol) || isa(a1,Slot) || isa(a1,GenSym)) &&
+            if isa(a1,basenumtype) || ((isa(a1,Symbol) || isa(a1,Slot) || isa(a1,SSAValue)) &&
                                        exprtype(a1,sv) ⊑ basenumtype)
                 if e.args[3]==2
                     e.args = Any[GlobalRef(Main.Base,:*), a1, a1]
@@ -3031,24 +3030,24 @@ occurs_undef(var::Int, expr, flags) =
 # remove all single-assigned vars v in "v = x" where x is an argument
 # and not assigned.
 # "sa" is the result of find_sa_vars
-# T: Slot or Gensym
+# T: Slot or SSAValue
 function remove_redundant_temp_vars(linfo, sa, T)
     flags = linfo.slotflags
-    gensym_types = linfo.gensymtypes
+    ssavalue_types = linfo.ssavaluetypes
     bexpr = Expr(:block); bexpr.args = linfo.code
     for (v,init) in sa
         if (isa(init, Slot) && !is_var_assigned(linfo, init::Slot))
             # this transformation is not valid for vars used before def.
             # we need to preserve the point of assignment to know where to
             # throw errors (issue #4645).
-            if T===GenSym || !occurs_undef(v, bexpr, flags)
+            if T===SSAValue || !occurs_undef(v, bexpr, flags)
                 # the transformation is not ideal if the assignment
                 # is present for the auto-unbox functionality
                 # (from inlining improved type inference information)
                 # and this transformation would worsen the type information
                 # everywhere later in the function
                 ityp = isa(init,TypedSlot) ? init.typ : linfo.slottypes[init.id]
-                if ityp ⊑ (T===GenSym ? gensym_types[v+1] : linfo.slottypes[v])
+                if ityp ⊑ (T===SSAValue ? ssavalue_types[v+1] : linfo.slottypes[v])
                     delete_var!(linfo, v, T)
                     slot_replace!(linfo, v, init, T)
                 end
@@ -3069,7 +3068,7 @@ function find_sa_vars(linfo::LambdaInfo)
         e = body[i]
         if isa(e,Expr) && is(e.head,:(=))
             lhs = e.args[1]
-            if isa(lhs, GenSym)
+            if isa(lhs, SSAValue)
                 gss[lhs.id] = e.args[2]
             elseif isa(lhs, Slot)
                 id = lhs.id
@@ -3087,9 +3086,9 @@ function find_sa_vars(linfo::LambdaInfo)
     av, gss
 end
 
-symequal(x::GenSym, y::GenSym) = is(x.id,y.id)
-symequal(x::Slot  , y::Slot)   = is(x.id,y.id)
-symequal(x::ANY   , y::ANY)    = is(x,y)
+symequal(x::SSAValue, y::SSAValue) = is(x.id,y.id)
+symequal(x::Slot    , y::Slot)     = is(x.id,y.id)
+symequal(x::ANY     , y::ANY)      = is(x,y)
 
 function occurs_outside_getfield(linfo::LambdaInfo, e::ANY, sym::ANY,
                                  sv::InferenceState, field_count, field_names)
@@ -3227,7 +3226,7 @@ function alloc_elim_pass!(linfo::LambdaInfo, sv::InferenceState)
     bexpr = Expr(:block); bexpr.args = body
     vs, gs = find_sa_vars(linfo)
     remove_redundant_temp_vars(linfo, vs, Slot)
-    remove_redundant_temp_vars(linfo, gs, GenSym)
+    remove_redundant_temp_vars(linfo, gs, SSAValue)
     i = 1
     while i < length(body)
         e = body[i]
@@ -3236,7 +3235,7 @@ function alloc_elim_pass!(linfo::LambdaInfo, sv::InferenceState)
             continue
         end
         e = e::Expr
-        if e.head === :(=) && (isa(e.args[1], GenSym) ||
+        if e.head === :(=) && (isa(e.args[1], SSAValue) ||
                                (isa(e.args[1],Slot) && haskey(vs, e.args[1].id)))
             var = e.args[1]
             rhs = e.args[2]
@@ -3263,7 +3262,7 @@ function alloc_elim_pass!(linfo::LambdaInfo, sv::InferenceState)
                 for j=1:nv
                     tupelt = tup[j+1]
                     if !(isa(tupelt,Number) || isa(tupelt,AbstractString) ||
-                         isa(tupelt,QuoteNode) || isa(tupelt, GenSym))
+                         isa(tupelt,QuoteNode) || isa(tupelt, SSAValue))
                         insert!(body, i+n_ins, tupelt)
                         n_ins += 1
                     end
@@ -3273,7 +3272,7 @@ function alloc_elim_pass!(linfo::LambdaInfo, sv::InferenceState)
                 for j=1:nv
                     tupelt = tup[j+1]
                     if (isa(tupelt,Number) || isa(tupelt,AbstractString) ||
-                        isa(tupelt,QuoteNode) || isa(tupelt, GenSym))
+                        isa(tupelt,QuoteNode) || isa(tupelt, SSAValue))
                         vals[j] = tupelt
                     else
                         elty = exprtype(tupelt,sv)
@@ -3345,11 +3344,11 @@ function replace_getfield!(linfo::LambdaInfo, e::Expr, tupname, vals, field_name
                     end
                     linfo.slottypes[val.id] = widenconst(a.typ)
                 end
-            elseif isa(val,GenSym)
-                val = val::GenSym
+            elseif isa(val,SSAValue)
+                val = val::SSAValue
                 typ = exprtype(val, sv)
                 if a.typ ⊑ typ && !(typ ⊑ a.typ)
-                    sv.gensym_types[val.id+1] = a.typ
+                    sv.linfo.ssavaluetypes[val.id+1] = a.typ
                 end
             end
             e.args[i] = val
diff --git a/base/serialize.jl b/base/serialize.jl
index b406c6c194aac..f2051f98f15fb 100644
--- a/base/serialize.jl
+++ b/base/serialize.jl
@@ -333,7 +333,7 @@ function serialize(s::SerializationState, linfo::LambdaInfo)
     serialize(s, linfo.slotnames)
     serialize(s, linfo.slottypes)
     serialize(s, linfo.slotflags)
-    serialize(s, linfo.gensymtypes)
+    serialize(s, linfo.ssavaluetypes)
     serialize(s, linfo.sparam_syms)
     serialize(s, linfo.sparam_vals)
     serialize(s, linfo.rettype)
@@ -620,7 +620,7 @@ function deserialize(s::SerializationState, ::Type{LambdaInfo})
     linfo.slotnames = deserialize(s)::Array{Any, 1}
     linfo.slottypes = deserialize(s)
     linfo.slotflags = deserialize(s)
-    linfo.gensymtypes = deserialize(s)
+    linfo.ssavaluetypes = deserialize(s)
     linfo.sparam_syms = deserialize(s)::SimpleVector
     linfo.sparam_vals = deserialize(s)::SimpleVector
     linfo.rettype = deserialize(s)
diff --git a/doc/devdocs/ast.rst b/doc/devdocs/ast.rst
index 858a9b625400e..f3801320a6eb3 100644
--- a/doc/devdocs/ast.rst
+++ b/doc/devdocs/ast.rst
@@ -62,7 +62,7 @@ The following data types exist in lowered form:
     forces a name to be resolved as a global in Base. This is now mostly
     redundant with ``GlobalRef(Base, :x)``.
 
-``GenSym``
+``SSAValue``
     refers to a consecutively-numbered (starting at 0) static single assignment
     (SSA) variable inserted by the compiler.
 
@@ -203,7 +203,7 @@ LambdaInfo
     - 16 - statically assigned once
     - 32 - might be used before assigned. This flag is only valid after type inference.
 
-``gensymtypes`` - Either an array or an Int giving the number of compiler-inserted
+``ssavaluetypes`` - Either an array or an Int giving the number of compiler-inserted
     temporary locations in the function. If an array, specifies a type for each location.
 
 ``nargs`` - The number of argument slots. The first ``nargs`` entries of the slots
diff --git a/src/alloc.c b/src/alloc.c
index 8d22209acede0..b514aab695f71 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -329,15 +329,16 @@ void jl_lambda_info_set_ast(jl_lambda_info_t *li, jl_value_t *ast)
         li->pure = 1;
     jl_array_t *vis = jl_lam_vinfo((jl_expr_t*)ast);
     size_t nslots = jl_array_len(vis);
-    jl_value_t *gensym_types = jl_lam_gensyms((jl_expr_t*)ast);
-    size_t ngensym = (jl_is_array(gensym_types) ? jl_array_len(gensym_types) : jl_unbox_long(gensym_types));
+    jl_value_t *ssavalue_types = jl_lam_ssavalues((jl_expr_t*)ast);
+    assert(jl_is_long(ssavalue_types));
+    size_t nssavalue = jl_unbox_long(ssavalue_types);
     li->slotnames = jl_alloc_cell_1d(nslots);
     jl_gc_wb(li, li->slotnames);
     li->slottypes = jl_nothing;
     li->slotflags = jl_alloc_array_1d(jl_array_uint8_type, nslots);
     jl_gc_wb(li, li->slotflags);
-    li->gensymtypes = jl_box_long(ngensym);
-    jl_gc_wb(li, li->gensymtypes);
+    li->ssavaluetypes = jl_box_long(nssavalue);
+    jl_gc_wb(li, li->ssavaluetypes);
     int i;
     for(i=0; i < nslots; i++) {
         jl_value_t *vi = jl_cellref(vis, i);
@@ -370,7 +371,7 @@ JL_DLLEXPORT jl_lambda_info_t *jl_new_lambda_info_uninit(jl_svec_t *sparam_syms)
                                   NWORDS(sizeof(jl_lambda_info_t)));
     li->code = NULL;
     li->slotnames = li->slotflags = NULL;
-    li->slottypes = li->gensymtypes = NULL;
+    li->slottypes = li->ssavaluetypes = NULL;
     li->rettype = (jl_value_t*)jl_any_type;
     li->sparam_syms = sparam_syms;
     li->sparam_vals = jl_emptysvec;
@@ -470,7 +471,7 @@ static jl_lambda_info_t *jl_copy_lambda(jl_lambda_info_t *linfo)
     new_linfo->slotnames = linfo->slotnames;
     new_linfo->slottypes = linfo->slottypes;
     new_linfo->slotflags = linfo->slotflags;
-    new_linfo->gensymtypes = linfo->gensymtypes;
+    new_linfo->ssavaluetypes = linfo->ssavaluetypes;
     new_linfo->sparam_vals = linfo->sparam_vals;
     new_linfo->pure = linfo->pure;
     new_linfo->nargs = linfo->nargs;
@@ -1068,7 +1069,6 @@ UNBOX_FUNC(bool,   int8_t)
 UNBOX_FUNC(float32, float)
 UNBOX_FUNC(float64, double)
 UNBOX_FUNC(voidpointer, void*)
-UNBOX_FUNC(gensym, ssize_t)
 
 #define BOX_FUNC(typ,c_type,pfx,nw)                         \
     JL_DLLEXPORT jl_value_t *pfx##_##typ(c_type x)          \
@@ -1116,7 +1116,7 @@ SIBOX_FUNC(int32,  int32_t, 1)
 UIBOX_FUNC(uint16, uint16_t, 1)
 UIBOX_FUNC(uint32, uint32_t, 1)
 UIBOX_FUNC(char,   uint32_t, 1)
-UIBOX_FUNC(gensym, size_t, 1)
+UIBOX_FUNC(ssavalue, size_t, 1)
 UIBOX_FUNC(slotnumber, size_t, 1)
 #ifdef _P64
 SIBOX_FUNC(int64,  int64_t, 1)
@@ -1144,10 +1144,10 @@ void jl_init_int32_int64_cache(void)
         boxed_int32_cache[i]  = jl_box32(jl_int32_type, i-NBOX_C/2);
         boxed_int64_cache[i]  = jl_box64(jl_int64_type, i-NBOX_C/2);
 #ifdef _P64
-        boxed_gensym_cache[i] = jl_box64(jl_gensym_type, i);
+        boxed_ssavalue_cache[i] = jl_box64(jl_ssavalue_type, i);
         boxed_slotnumber_cache[i] = jl_box64(jl_slotnumber_type, i);
 #else
-        boxed_gensym_cache[i] = jl_box32(jl_gensym_type, i);
+        boxed_ssavalue_cache[i] = jl_box32(jl_ssavalue_type, i);
         boxed_slotnumber_cache[i] = jl_box32(jl_slotnumber_type, i);
 #endif
     }
@@ -1186,7 +1186,7 @@ void jl_mark_box_caches(void)
         jl_gc_setmark(boxed_uint32_cache[i]);
         jl_gc_setmark(boxed_char_cache[i]);
         jl_gc_setmark(boxed_uint64_cache[i]);
-        jl_gc_setmark(boxed_gensym_cache[i]);
+        jl_gc_setmark(boxed_ssavalue_cache[i]);
         jl_gc_setmark(boxed_slotnumber_cache[i]);
     }
 }
diff --git a/src/ast.c b/src/ast.c
index eba4769be0734..9c7735a2adba1 100644
--- a/src/ast.c
+++ b/src/ast.c
@@ -60,9 +60,8 @@ typedef struct _jl_ast_context_t {
     value_t false_sym;
     value_t error_sym;
     value_t null_sym;
-    value_t jlgensym_sym;
+    value_t ssavalue_sym;
     value_t slot_sym;
-    arraylist_t gensym_to_flisp;
     jl_ast_context_list_t list;
     int ref;
     jl_task_t *task;
@@ -211,7 +210,7 @@ static void jl_init_ast_ctx(jl_ast_context_t *ast_ctx)
     jl_ast_ctx(fl_ctx)->false_sym = symbol(fl_ctx, "false");
     jl_ast_ctx(fl_ctx)->error_sym = symbol(fl_ctx, "error");
     jl_ast_ctx(fl_ctx)->null_sym = symbol(fl_ctx, "null");
-    jl_ast_ctx(fl_ctx)->jlgensym_sym = symbol(fl_ctx, "jlgensym");
+    jl_ast_ctx(fl_ctx)->ssavalue_sym = symbol(fl_ctx, "ssavalue");
     jl_ast_ctx(fl_ctx)->slot_sym = symbol(fl_ctx, "slot");
 
     // Enable / disable syntax deprecation warnings
@@ -441,8 +440,8 @@ static jl_value_t *scm_to_julia_(fl_context_t *fl_ctx, value_t e, int eo)
         }
         else {
             hd = car_(e);
-            if (hd == jl_ast_ctx(fl_ctx)->jlgensym_sym)
-                return jl_box_gensym(numval(car_(cdr_(e))));
+            if (hd == jl_ast_ctx(fl_ctx)->ssavalue_sym)
+                return jl_box_ssavalue(numval(car_(cdr_(e))));
             else if (hd == jl_ast_ctx(fl_ctx)->slot_sym)
                 return jl_box_slotnumber(numval(car_(cdr_(e))));
             else if (hd == jl_ast_ctx(fl_ctx)->null_sym && llength(e) == 1)
@@ -579,11 +578,6 @@ static value_t julia_to_scm_(fl_context_t *fl_ctx, jl_value_t *v);
 static value_t julia_to_scm(fl_context_t *fl_ctx, jl_value_t *v)
 {
     value_t temp;
-    arraylist_t *jlgensym_to_flisp = &jl_ast_ctx(fl_ctx)->gensym_to_flisp;
-    if (jlgensym_to_flisp->len)
-        jlgensym_to_flisp->len = 0; // in case we didn't free it last time we got here (for example, if we threw an error)
-    else
-        arraylist_new(jlgensym_to_flisp, 0);
     // need try/catch to reset GC handle stack in case of error
     FL_TRY_EXTERN(fl_ctx) {
         temp = julia_to_scm_(fl_ctx, v);
@@ -591,7 +585,6 @@ static value_t julia_to_scm(fl_context_t *fl_ctx, jl_value_t *v)
     FL_CATCH_EXTERN(fl_ctx) {
         temp = fl_list2(fl_ctx, jl_ast_ctx(fl_ctx)->error_sym, cvalue_static_cstring(fl_ctx, "expression too large"));
     }
-    arraylist_free(jlgensym_to_flisp);
     return temp;
 }
 
@@ -622,20 +615,6 @@ static value_t julia_to_scm_(fl_context_t *fl_ctx, jl_value_t *v)
 {
     if (jl_is_symbol(v))
         return symbol(fl_ctx, jl_symbol_name((jl_sym_t*)v));
-    if (jl_is_gensym(v)) {
-        size_t idx = ((jl_gensym_t*)v)->id;
-        size_t i;
-        arraylist_t *jlgensym_to_flisp = &jl_ast_ctx(fl_ctx)->gensym_to_flisp;
-        for (i = 0; i < jlgensym_to_flisp->len; i+=2) {
-            if ((ssize_t)jlgensym_to_flisp->items[i] == idx)
-                return fl_list2(fl_ctx, jl_ast_ctx(fl_ctx)->jlgensym_sym, fixnum((size_t)jlgensym_to_flisp->items[i+1]));
-        }
-        arraylist_push(jlgensym_to_flisp, (void*)idx);
-        value_t flv = fl_applyn(fl_ctx, 0, symbol_value(symbol(fl_ctx, "make-jlgensym")));
-        assert(iscons(flv) && car_(flv) == jl_ast_ctx(fl_ctx)->jlgensym_sym);
-        arraylist_push(jlgensym_to_flisp, (void*)(size_t)numval(car_(cdr_(flv))));
-        return flv;
-    }
     if (v == jl_true)
         return fl_ctx->T;
     if (v == jl_false)
@@ -672,8 +651,6 @@ static value_t julia_to_scm_(fl_context_t *fl_ctx, jl_value_t *v)
     // GC Note: jl_fieldref(v, 0) allocate for LabelNode, GotoNode
     //          but we don't need a GC root here because julia_to_list2
     //          shouldn't allocate in this case.
-    if (jl_is_slot(v))
-        return julia_to_list2(fl_ctx, (jl_value_t*)slot_sym, jl_fieldref(v,0));
     if (jl_typeis(v, jl_labelnode_type))
         return julia_to_list2(fl_ctx, (jl_value_t*)label_sym, jl_fieldref(v,0));
     if (jl_typeis(v, jl_gotonode_type))
@@ -686,6 +663,10 @@ static value_t julia_to_scm_(fl_context_t *fl_ctx, jl_value_t *v)
         return julia_to_list2(fl_ctx, (jl_value_t*)top_sym, jl_fieldref(v,0));
     if (jl_is_long(v) && fits_fixnum(jl_unbox_long(v)))
         return fixnum(jl_unbox_long(v));
+    if (jl_is_ssavalue(v))
+        jl_error("SSAValue objects should not occur in an AST");
+    if (jl_is_slot(v))
+        jl_error("Slot objects should not occur in an AST");
     value_t opaque = cvalue(fl_ctx, jl_ast_ctx(fl_ctx)->jvtype, sizeof(void*));
     *(jl_value_t**)cv_data((cvalue_t*)ptr(opaque)) = v;
     return opaque;
@@ -865,24 +846,6 @@ JL_DLLEXPORT jl_value_t *jl_macroexpand(jl_value_t *expr)
     return jl_call_scm_on_ast("jl-macroexpand", expr);
 }
 
-ssize_t jl_max_jlgensym_in(jl_value_t *v)
-{
-    ssize_t genid = -1;
-    if (jl_is_gensym(v)) {
-        genid = ((jl_gensym_t*)v)->id;
-    }
-    else if (jl_is_expr(v)) {
-        jl_expr_t *e = (jl_expr_t*)v;
-        size_t i, l = jl_array_len(e->args);
-        for (i = 0; i < l; i++) {
-            ssize_t maxid = jl_max_jlgensym_in(jl_exprarg(e, i));
-            if (maxid > genid)
-                genid = maxid;
-        }
-    }
-    return genid;
-}
-
 // wrap expr in a thunk AST
 jl_lambda_info_t *jl_wrap_expr(jl_value_t *expr)
 {
@@ -896,7 +859,8 @@ jl_lambda_info_t *jl_wrap_expr(jl_value_t *expr)
     vi = (jl_value_t*)jl_alloc_cell_1d(3);
     jl_cellset(vi, 0, mt);
     jl_cellset(vi, 1, mt);
-    jl_cellset(vi, 2, jl_box_long(jl_max_jlgensym_in(expr)+1));
+    // front end always wraps toplevel exprs with ssavalues in (thunk (lambda () ...))
+    jl_cellset(vi, 2, jl_box_long(0));
     jl_cellset(le->args, 1, vi);
     if (!jl_is_expr(expr) || ((jl_expr_t*)expr)->head != body_sym) {
         bo = jl_exprn(body_sym, 1);
@@ -934,8 +898,8 @@ jl_array_t *jl_lam_vinfo(jl_expr_t *l)
     return (jl_array_t*)ll;
 }
 
-// get array of types for GenSym vars, or its length (if not type-inferred)
-jl_value_t *jl_lam_gensyms(jl_expr_t *l)
+// get array of types for SSAValues, or its length (if not type-inferred)
+jl_value_t *jl_lam_ssavalues(jl_expr_t *l)
 {
     assert(jl_is_expr(l));
     jl_value_t *le = jl_exprarg(l, 1);
diff --git a/src/ast.scm b/src/ast.scm
index c31f30ea741d9..775e30887d446 100644
--- a/src/ast.scm
+++ b/src/ast.scm
@@ -56,7 +56,7 @@
                              "")))
                 ((comparison) (apply string (map deparse (cdr e))))
                 ((in) (string (deparse (cadr e)) " in " (deparse (caddr e))))
-                ((jlgensym) (string "GenSym(" (cdr e) ")"))
+                ((ssavalue) (string "SSAValue(" (cdr e) ")"))
                 ((line) (if (length= e 2)
                             (string "# line " (cadr e))
                             (string "# " (caddr e) ", line " (cadr e))))
@@ -93,11 +93,11 @@
 (define (reset-gensyms)
   (set! *current-gensyms* *gensyms*))
 
-(define make-jlgensym
-  (let ((jlgensym-counter 0))
+(define make-ssavalue
+  (let ((ssavalue-counter 0))
     (lambda ()
-      (begin0 `(jlgensym ,jlgensym-counter)
-              (set! jlgensym-counter (+ 1 jlgensym-counter))))))
+      (begin0 `(ssavalue ,ssavalue-counter)
+              (set! ssavalue-counter (+ 1 ssavalue-counter))))))
 
 ;; predicates and accessors
 
@@ -162,11 +162,11 @@
 
 (define (make-decl n t) `(|::| ,n ,t))
 
-(define (jlgensym? e)
-  (and (pair? e) (eq? (car e) 'jlgensym)))
+(define (ssavalue? e)
+  (and (pair? e) (eq? (car e) 'ssavalue)))
 
 (define (symbol-like? e)
-  (or (symbol? e) (jlgensym? e)))
+  (or (symbol? e) (ssavalue? e)))
 
 (define (simple-atom? x)
   (or (number? x) (string? x) (char? x) (eq? x 'true) (eq? x 'false)))
@@ -207,7 +207,7 @@
 (define (return? e) (and (pair? e) (eq? (car e) 'return)))
 
 (define (eq-sym? a b)
-  (or (eq? a b) (and (jlgensym? a) (jlgensym? b) (eqv? (cdr a) (cdr b)))))
+  (or (eq? a b) (and (ssavalue? a) (ssavalue? b) (eqv? (cdr a) (cdr b)))))
 
 (define (make-var-info name) (list name 'Any 0))
 (define vinfo:name car)
diff --git a/src/builtins.c b/src/builtins.c
index c38cfd40165b2..85f3f38310aa9 100644
--- a/src/builtins.c
+++ b/src/builtins.c
@@ -1141,7 +1141,7 @@ void jl_init_primitives(void)
     add_builtin("TypeMapEntry", (jl_value_t*)jl_typemap_entry_type);
     add_builtin("TypeMapLevel", (jl_value_t*)jl_typemap_level_type);
     add_builtin("Symbol", (jl_value_t*)jl_sym_type);
-    add_builtin("GenSym", (jl_value_t*)jl_gensym_type);
+    add_builtin("SSAValue", (jl_value_t*)jl_ssavalue_type);
     add_builtin("Slot", (jl_value_t*)jl_abstractslot_type);
     add_builtin("SlotNumber", (jl_value_t*)jl_slotnumber_type);
     add_builtin("TypedSlot", (jl_value_t*)jl_typedslot_type);
@@ -1343,9 +1343,9 @@ static size_t jl_static_show_x_(JL_STREAM *out, jl_value_t *v, jl_datatype_t *vt
     else if (vt == jl_sym_type) {
         n += jl_printf(out, ":%s", jl_symbol_name((jl_sym_t*)v));
     }
-    else if (vt == jl_gensym_type) {
-        n += jl_printf(out, "GenSym(%" PRIuPTR ")",
-                       (uintptr_t)((jl_gensym_t*)v)->id);
+    else if (vt == jl_ssavalue_type) {
+        n += jl_printf(out, "SSAValue(%" PRIuPTR ")",
+                       (uintptr_t)((jl_ssavalue_t*)v)->id);
     }
     else if (vt == jl_globalref_type) {
         n += jl_static_show_x(out, (jl_value_t*)jl_globalref_mod(v), depth);
diff --git a/src/ccall.cpp b/src/ccall.cpp
index b8681b66826a8..f75426033a37f 100644
--- a/src/ccall.cpp
+++ b/src/ccall.cpp
@@ -414,7 +414,7 @@ static jl_value_t* try_eval(jl_value_t *ex, jl_codectx_t *ctx, const char *failu
 {
     jl_value_t *constant = NULL;
     constant = static_eval(ex, ctx, true, true);
-    if (constant || jl_is_gensym(ex))
+    if (constant || jl_is_ssavalue(ex))
         return constant;
     JL_TRY {
         constant = jl_interpret_toplevel_expr_in(ctx->module, ex, ctx->linfo);
diff --git a/src/cgutils.cpp b/src/cgutils.cpp
index da63ea9078dce..12e21221dbcbe 100644
--- a/src/cgutils.cpp
+++ b/src/cgutils.cpp
@@ -256,10 +256,6 @@ static Value *literal_pointer_val(jl_value_t *p)
         // Symbols are prefixed with jl_sym#
         return julia_gv("jl_sym#", addr, NULL, p);
     }
-    if (jl_is_gensym(p)) {
-        // GenSyms are prefixed with jl_gensym#
-        return julia_gv("jl_gensym#", p);
-    }
     // something else gets just a generic name
     return julia_gv("jl_global#", p);
 }
@@ -882,13 +878,13 @@ static inline jl_module_t *topmod(jl_codectx_t *ctx)
 
 static jl_value_t *expr_type(jl_value_t *e, jl_codectx_t *ctx)
 {
-    if (jl_is_gensym(e)) {
-        if (jl_is_long(ctx->linfo->gensymtypes))
+    if (jl_is_ssavalue(e)) {
+        if (jl_is_long(ctx->linfo->ssavaluetypes))
             return (jl_value_t*)jl_any_type;
-        int idx = ((jl_gensym_t*)e)->id;
-        assert(jl_is_array(ctx->linfo->gensymtypes));
-        jl_array_t *gensym_types = (jl_array_t*)ctx->linfo->gensymtypes;
-        return jl_cellref(gensym_types, idx);
+        int idx = ((jl_ssavalue_t*)e)->id;
+        assert(jl_is_array(ctx->linfo->ssavaluetypes));
+        jl_array_t *ssavalue_types = (jl_array_t*)ctx->linfo->ssavaluetypes;
+        return jl_cellref(ssavalue_types, idx);
     }
     if (jl_typeis(e, jl_slotnumber_type)) {
         jl_array_t *slot_types = (jl_array_t*)ctx->linfo->slottypes;
@@ -1132,7 +1128,7 @@ static jl_arrayvar_t *arrayvar_for(jl_value_t *ex, jl_codectx_t *ctx)
     int sl = jl_slot_number(ex)-1;
     if (ctx->arrayvars->find(sl) != ctx->arrayvars->end())
         return &(*ctx->arrayvars)[sl];
-    //TODO: gensym case
+    //TODO: ssavalue case
     return NULL;
 }
 
@@ -1457,11 +1453,11 @@ static Value *boxed(const jl_cgval_t &vinfo, jl_codectx_t *ctx, bool gcrooted)
         box = call_with_unsigned(box_uint64_func, v);
     else if (jb == jl_char_type)
         box = call_with_unsigned(box_char_func, v);
-    else if (jb == jl_gensym_type) {
+    else if (jb == jl_ssavalue_type) {
         unsigned zero = 0;
-        assert(v->getType() == jl_gensym_type->struct_decl);
+        assert(v->getType() == jl_ssavalue_type->struct_decl);
         v = builder.CreateExtractValue(v, makeArrayRef(&zero, 1));
-        box = call_with_unsigned(box_gensym_func, v);
+        box = call_with_unsigned(box_ssavalue_func, v);
     }
     else if (!jl_isbits(jt) || !jl_is_leaf_type(jt)) {
         assert("Don't know how to box this type" && false);
@@ -1601,7 +1597,7 @@ static void emit_setfield(jl_datatype_t *sty, const jl_cgval_t &strct, size_t id
 
 static bool might_need_root(jl_value_t *ex)
 {
-    return (!jl_is_symbol(ex) && !jl_is_slot(ex) && !jl_is_gensym(ex) &&
+    return (!jl_is_symbol(ex) && !jl_is_slot(ex) && !jl_is_ssavalue(ex) &&
             !jl_is_bool(ex) && !jl_is_quotenode(ex) && !jl_is_byte_string(ex) &&
             !jl_is_globalref(ex));
 }
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 3bcb04e4ed634..a036922c9a68f 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -391,7 +391,7 @@ static Function *box_int64_func;
 static Function *box_uint64_func;
 static Function *box_float32_func;
 static Function *box_float64_func;
-static Function *box_gensym_func;
+static Function *box_ssavalue_func;
 static Function *box8_func;
 static Function *box16_func;
 static Function *box32_func;
@@ -555,8 +555,8 @@ typedef struct {
     Function *f;
     // local var info. globals are not in here.
     std::vector<jl_varinfo_t> slots;
-    std::vector<jl_cgval_t> gensym_SAvalues;
-    std::vector<bool> gensym_assigned;
+    std::vector<jl_cgval_t> SAvalues;
+    std::vector<bool> ssavalue_assigned;
     std::map<int, jl_arrayvar_t> *arrayvars;
     std::map<int, BasicBlock*> *labels;
     std::map<int, Value*> *handlers;
@@ -1540,11 +1540,11 @@ jl_value_t *jl_static_eval(jl_value_t *ex, void *ctx_, jl_module_t *mod,
     }
     if (jl_is_slot(ex))
         return NULL;
-    if (jl_is_gensym(ex)) {
-        ssize_t idx = ((jl_gensym_t*)ex)->id;
+    if (jl_is_ssavalue(ex)) {
+        ssize_t idx = ((jl_ssavalue_t*)ex)->id;
         assert(idx >= 0);
-        if (ctx != NULL && ctx->gensym_assigned.at(idx)) {
-            return ctx->gensym_SAvalues.at(idx).constant;
+        if (ctx != NULL && ctx->ssavalue_assigned.at(idx)) {
+            return ctx->SAvalues.at(idx).constant;
         }
         return NULL;
     }
@@ -2939,10 +2939,10 @@ static jl_cgval_t emit_local(jl_value_t *slotload, jl_codectx_t *ctx)
 
 static void emit_assignment(jl_value_t *l, jl_value_t *r, jl_codectx_t *ctx)
 {
-    if (jl_is_gensym(l)) {
-        ssize_t idx = ((jl_gensym_t*)l)->id;
+    if (jl_is_ssavalue(l)) {
+        ssize_t idx = ((jl_ssavalue_t*)l)->id;
         assert(idx >= 0);
-        assert(!ctx->gensym_assigned.at(idx));
+        assert(!ctx->ssavalue_assigned.at(idx));
         jl_cgval_t slot = emit_expr(r, ctx); // slot could be a jl_value_t (unboxed) or jl_value_t* (ispointer)
         if (!slot.isboxed && !slot.isimmutable) { // emit a copy of values stored in mutable slots
             Type *vtype = julia_type_to_llvm(slot.typ);
@@ -2952,17 +2952,17 @@ static void emit_assignment(jl_value_t *l, jl_value_t *r, jl_codectx_t *ctx)
                     false, slot.typ, ctx);
         }
         if (slot.isboxed && slot.isimmutable) {
-            // see if inference had a better type for the gensym than the expression (after inlining getfield on a Tuple)
-            jl_value_t *gensym_types = (jl_value_t*)ctx->linfo->gensymtypes;
-            if (jl_is_array(gensym_types)) {
-                jl_value_t *declType = jl_cellref(gensym_types, idx);
+            // see if inference had a better type for the ssavalue than the expression (after inlining getfield on a Tuple)
+            jl_value_t *ssavalue_types = (jl_value_t*)ctx->linfo->ssavaluetypes;
+            if (jl_is_array(ssavalue_types)) {
+                jl_value_t *declType = jl_cellref(ssavalue_types, idx);
                 if (declType != slot.typ) {
                     slot = remark_julia_type(slot, declType);
                 }
             }
         }
-        ctx->gensym_SAvalues.at(idx) = slot; // now gensym_SAvalues[idx] contains the SAvalue
-        ctx->gensym_assigned.at(idx) = true;
+        ctx->SAvalues.at(idx) = slot; // now SAvalues[idx] contains the SAvalue
+        ctx->ssavalue_assigned.at(idx) = true;
         return;
     }
 
@@ -3052,7 +3052,7 @@ static Value *emit_condition(jl_value_t *cond, const std::string &msg, jl_codect
 
 static void emit_stmtpos(jl_value_t *expr, jl_codectx_t *ctx)
 {
-    if (jl_is_gensym(expr))
+    if (jl_is_ssavalue(expr))
         return; // value not used, no point in attempting codegen for it
     if (jl_is_linenode(expr))
         return;
@@ -3094,15 +3094,15 @@ static jl_cgval_t emit_expr(jl_value_t *expr, jl_codectx_t *ctx)
     if (jl_is_slot(expr)) {
         return emit_local(expr, ctx);
     }
-    if (jl_is_gensym(expr)) {
-        ssize_t idx = ((jl_gensym_t*)expr)->id;
+    if (jl_is_ssavalue(expr)) {
+        ssize_t idx = ((jl_ssavalue_t*)expr)->id;
         assert(idx >= 0);
-        if (!ctx->gensym_assigned.at(idx)) {
-            ctx->gensym_assigned.at(idx) = true; // (assignment, not comparison test)
+        if (!ctx->ssavalue_assigned.at(idx)) {
+            ctx->ssavalue_assigned.at(idx) = true; // (assignment, not comparison test)
             return jl_cgval_t(); // dead code branch
         }
         else {
-            return ctx->gensym_SAvalues.at(idx); // at this point, gensym_SAvalues[idx] actually contains the SAvalue
+            return ctx->SAvalues.at(idx); // at this point, SAvalues[idx] actually contains the SAvalue
         }
     }
     if (jl_is_labelnode(expr)) {
@@ -3990,7 +3990,7 @@ static std::unique_ptr<Module> emit_function(jl_lambda_info_t *lam, jl_llvm_func
     ctx.spvals_ptr = NULL;
 
     // step 2. process var-info lists to see what vars need boxing
-    int n_gensyms = jl_is_long(lam->gensymtypes) ? jl_unbox_long(lam->gensymtypes) : jl_array_len(lam->gensymtypes);
+    int n_ssavalues = jl_is_long(lam->ssavaluetypes) ? jl_unbox_long(lam->ssavaluetypes) : jl_array_len(lam->ssavaluetypes);
     size_t largslen = lam->nargs;
     size_t vinfoslen = jl_array_dim0(lam->slotnames);
     ctx.slots.resize(vinfoslen);
@@ -4011,9 +4011,9 @@ static std::unique_ptr<Module> emit_function(jl_lambda_info_t *lam, jl_llvm_func
     }
     ctx.nReqArgs = nreq;
 
-    // create SAvalue locations for GenSym objects
-    ctx.gensym_assigned.assign(n_gensyms, false);
-    ctx.gensym_SAvalues.assign(n_gensyms, jl_cgval_t());
+    // create SAvalue locations for SSAValue objects
+    ctx.ssavalue_assigned.assign(n_ssavalues, false);
+    ctx.SAvalues.assign(n_ssavalues, jl_cgval_t());
 
     // step 3. some variable analysis
     size_t i;
@@ -5835,7 +5835,7 @@ extern "C" void jl_init_codegen(void)
     BOX_F(int64,int64); UBOX_F(uint64,uint64);
     BOX_F(float32,float32); BOX_F(float64,float64);
     BOX_F(char,char);
-    UBOX_F(gensym,size);
+    UBOX_F(ssavalue,size);
 
     box8_func  = boxfunc_llvm(ft2arg(T_pjlvalue, T_pjlvalue, T_int8),
                               "jl_box8", &jl_box8, m);
diff --git a/src/dump.c b/src/dump.c
index 814a0598c696b..7bb29b6624b52 100644
--- a/src/dump.c
+++ b/src/dump.c
@@ -625,7 +625,7 @@ static void jl_serialize_module(ios_t *s, jl_module_t *m)
 
 static int is_ast_node(jl_value_t *v)
 {
-    return jl_is_symbol(v) || jl_is_slot(v) || jl_is_gensym(v) ||
+    return jl_is_symbol(v) || jl_is_slot(v) || jl_is_ssavalue(v) ||
         jl_is_expr(v) || jl_is_newvarnode(v) || jl_is_svec(v) ||
         jl_typeis(v, jl_array_any_type) || jl_is_tuple(v) ||
         jl_is_uniontype(v) || jl_is_int32(v) || jl_is_int64(v) ||
@@ -757,9 +757,9 @@ static void jl_serialize_value_(ios_t *s, jl_value_t *v)
             jl_serialize_value(s, jl_globalref_name(v));
         }
     }
-    else if (jl_is_gensym(v) && ((jl_gensym_t*)v)->id < 65536) {
-        writetag(s, (jl_value_t*)jl_gensym_type);
-        write_uint16(s, ((jl_gensym_t*)v)->id);
+    else if (jl_is_ssavalue(v) && ((jl_ssavalue_t*)v)->id < 65536) {
+        writetag(s, (jl_value_t*)jl_ssavalue_type);
+        write_uint16(s, ((jl_ssavalue_t*)v)->id);
     }
     else if (jl_typeis(v,jl_slotnumber_type) && jl_slot_number(v) < 65536) {
         writetag(s, (jl_value_t*)jl_slotnumber_type);
@@ -855,7 +855,7 @@ static void jl_serialize_value_(ios_t *s, jl_value_t *v)
         jl_serialize_value(s, li->slotnames);
         jl_serialize_value(s, li->slottypes);
         jl_serialize_value(s, li->slotflags);
-        jl_serialize_value(s, li->gensymtypes);
+        jl_serialize_value(s, li->ssavaluetypes);
         jl_serialize_value(s, li->rettype);
         jl_serialize_value(s, (jl_value_t*)li->sparam_syms);
         jl_serialize_value(s, (jl_value_t*)li->sparam_vals);
@@ -1341,8 +1341,8 @@ static jl_value_t *jl_deserialize_value_(ios_t *s, jl_value_t *vtag, jl_value_t
             arraylist_push(&backref_list, sym);
         return sym;
     }
-    else if (vtag == (jl_value_t*)jl_gensym_type) {
-        jl_value_t *v = jl_box_gensym(read_uint16(s));
+    else if (vtag == (jl_value_t*)jl_ssavalue_type) {
+        jl_value_t *v = jl_box_ssavalue(read_uint16(s));
         if (usetable) arraylist_push(&backref_list, v);
         return v;
     }
@@ -1467,7 +1467,7 @@ static jl_value_t *jl_deserialize_value_(ios_t *s, jl_value_t *vtag, jl_value_t
         li->slotnames = (jl_array_t*)jl_deserialize_value(s, (jl_value_t**)&li->slotnames); jl_gc_wb(li, li->slotnames);
         li->slottypes = jl_deserialize_value(s, &li->slottypes); jl_gc_wb(li, li->slottypes);
         li->slotflags = (jl_array_t*)jl_deserialize_value(s, (jl_value_t**)&li->slotflags); jl_gc_wb(li, li->slotflags);
-        li->gensymtypes = jl_deserialize_value(s, &li->gensymtypes); jl_gc_wb(li, li->gensymtypes);
+        li->ssavaluetypes = jl_deserialize_value(s, &li->ssavaluetypes); jl_gc_wb(li, li->ssavaluetypes);
         li->rettype = jl_deserialize_value(s, &li->rettype);
         jl_gc_wb(li, li->rettype);
         li->sparam_syms = (jl_svec_t*)jl_deserialize_value(s, (jl_value_t**)&li->sparam_syms);
@@ -2387,7 +2387,7 @@ void jl_init_serializer(void)
     htable_new(&fptr_to_id, sizeof(id_to_fptrs)/sizeof(*id_to_fptrs));
     htable_new(&backref_table, 0);
 
-    void *tags[] = { jl_symbol_type, jl_gensym_type, jl_datatype_type, jl_slotnumber_type,
+    void *tags[] = { jl_symbol_type, jl_ssavalue_type, jl_datatype_type, jl_slotnumber_type,
                      jl_simplevector_type, jl_array_type, jl_typedslot_type,
                      jl_expr_type, (void*)LongSymbol_tag, (void*)LongSvec_tag,
                      (void*)LongExpr_tag, (void*)LiteralVal_tag,
@@ -2450,7 +2450,7 @@ void jl_init_serializer(void)
                      jl_voidpointer_type, jl_newvarnode_type,
                      jl_array_symbol_type, jl_anytuple_type, jl_tparam0(jl_anytuple_type),
                      jl_typeof(jl_emptytuple), jl_array_uint8_type,
-                     jl_symbol_type->name, jl_gensym_type->name, jl_tuple_typename,
+                     jl_symbol_type->name, jl_ssavalue_type->name, jl_tuple_typename,
                      jl_ref_type->name, jl_pointer_type->name, jl_simplevector_type->name,
                      jl_datatype_type->name, jl_uniontype_type->name, jl_array_type->name,
                      jl_expr_type->name, jl_typename_type->name, jl_type_type->name,
diff --git a/src/interpreter.c b/src/interpreter.c
index 2ce282d8d280b..d1754101378f6 100644
--- a/src/interpreter.c
+++ b/src/interpreter.c
@@ -117,9 +117,9 @@ static int jl_linfo_nslots(jl_lambda_info_t *li)
     return jl_array_len(li->slotflags);
 }
 
-static int jl_linfo_ngensyms(jl_lambda_info_t *li)
+static int jl_linfo_nssavalues(jl_lambda_info_t *li)
 {
-    return jl_is_long(li->gensymtypes) ? jl_unbox_long(li->gensymtypes) : jl_array_len(li->gensymtypes);
+    return jl_is_long(li->ssavaluetypes) ? jl_unbox_long(li->ssavaluetypes) : jl_array_len(li->ssavaluetypes);
 }
 
 static jl_value_t *eval(jl_value_t *e, jl_value_t **locals, jl_lambda_info_t *lam)
@@ -130,12 +130,12 @@ static jl_value_t *eval(jl_value_t *e, jl_value_t **locals, jl_lambda_info_t *la
             jl_undefined_var_error((jl_sym_t*)e);
         return v;
     }
-    if (jl_is_gensym(e)) {
-        ssize_t genid = ((jl_gensym_t*)e)->id;
-        if (genid >= jl_linfo_ngensyms(lam) || genid < 0 || locals == NULL)
-            jl_error("access to invalid GenSym location");
+    if (jl_is_ssavalue(e)) {
+        ssize_t id = ((jl_ssavalue_t*)e)->id;
+        if (id >= jl_linfo_nssavalues(lam) || id < 0 || locals == NULL)
+            jl_error("access to invalid SSAValue");
         else
-            return locals[jl_linfo_nslots(lam) + genid];
+            return locals[jl_linfo_nslots(lam) + id];
     }
     if (jl_is_quotenode(e)) {
         return jl_fieldref(e,0);
@@ -183,11 +183,11 @@ static jl_value_t *eval(jl_value_t *e, jl_value_t **locals, jl_lambda_info_t *la
     else if (ex->head == assign_sym) {
         jl_value_t *sym = args[0];
         jl_value_t *rhs = eval(args[1], locals, lam);
-        if (jl_is_gensym(sym)) {
-            ssize_t genid = ((jl_gensym_t*)sym)->id;
-            if (genid >= jl_linfo_ngensyms(lam) || genid < 0)
-                jl_error("assignment to invalid GenSym location");
-            locals[jl_linfo_nslots(lam) + genid] = rhs;
+        if (jl_is_ssavalue(sym)) {
+            ssize_t id = ((jl_ssavalue_t*)sym)->id;
+            if (id >= jl_linfo_nssavalues(lam) || id < 0)
+                jl_error("assignment to invalid SSAValue");
+            locals[jl_linfo_nslots(lam) + id] = rhs;
         }
         else if (jl_is_slot(sym)) {
             ssize_t n = jl_slot_number(sym);
@@ -445,17 +445,7 @@ static jl_value_t *eval(jl_value_t *e, jl_value_t **locals, jl_lambda_info_t *la
 
 jl_value_t *jl_toplevel_eval_body(jl_array_t *stmts)
 {
-    ssize_t ngensym = 0;
-    size_t i, l = jl_array_len(stmts);
-    for (i = 0; i < l; i++) {
-        ssize_t maxid = jl_max_jlgensym_in(jl_cellref(stmts, i))+1;
-        if (maxid > ngensym)
-            ngensym = maxid;
-    }
-    jl_value_t **locals = NULL;
-    assert(ngensym == 0);
-    jl_value_t *ret = eval_body(stmts, locals, NULL, 0, 1);
-    return ret;
+    return eval_body(stmts, NULL, NULL, 0, 1);
 }
 
 static jl_value_t *eval_body(jl_array_t *stmts, jl_value_t **locals, jl_lambda_info_t *lam,
@@ -532,7 +522,7 @@ jl_value_t *jl_interpret_toplevel_thunk(jl_lambda_info_t *lam)
 {
     jl_array_t *stmts = lam->code;
     jl_value_t **locals;
-    JL_GC_PUSHARGS(locals, jl_linfo_nslots(lam) + jl_linfo_ngensyms(lam));
+    JL_GC_PUSHARGS(locals, jl_linfo_nslots(lam) + jl_linfo_nssavalues(lam));
     jl_value_t *r = eval_body(stmts, locals, lam, 0, 1);
     JL_GC_POP();
     return r;
diff --git a/src/intrinsics.cpp b/src/intrinsics.cpp
index f0088a8e0f70f..8de0bbfad6873 100644
--- a/src/intrinsics.cpp
+++ b/src/intrinsics.cpp
@@ -147,7 +147,7 @@ static Constant *julia_const_to_llvm(jl_value_t *e, bool nested=false)
     jl_value_t *jt = jl_typeof(e);
     jl_datatype_t *bt = (jl_datatype_t*)jt;
 
-    if (!jl_is_datatype(bt) || bt == jl_gensym_type)
+    if (!jl_is_datatype(bt) || bt == jl_ssavalue_type)
         return NULL;
 
     if (e == jl_true)
diff --git a/src/jlfrontend.scm b/src/jlfrontend.scm
index d04afda7b6570..3dca3254efbf5 100644
--- a/src/jlfrontend.scm
+++ b/src/jlfrontend.scm
@@ -32,7 +32,7 @@
   (cond ((atom? e)   tab)
         ((quoted? e) tab)
         (else (case (car e)
-                ((=)            (if (not (jlgensym? (cadr e)))
+                ((=)            (if (not (ssavalue? (cadr e)))
                                     (put! tab (decl-var (cadr e)) #t))
                                 (find-possible-globals- (caddr e) tab))
                 ((method)       (let ((n (method-expr-name e)))
diff --git a/src/jltypes.c b/src/jltypes.c
index 5a5cf9de8bc36..62ee99e91cc65 100644
--- a/src/jltypes.c
+++ b/src/jltypes.c
@@ -25,7 +25,7 @@ jl_datatype_t *jl_type_type;
 jl_datatype_t *jl_typename_type;
 jl_datatype_t *jl_sym_type;
 jl_datatype_t *jl_symbol_type;
-jl_datatype_t *jl_gensym_type;
+jl_datatype_t *jl_ssavalue_type;
 jl_datatype_t *jl_abstractslot_type;
 jl_datatype_t *jl_slotnumber_type;
 jl_datatype_t *jl_typedslot_type;
@@ -3356,9 +3356,9 @@ void jl_init_types(void)
     jl_uint8_type = jl_new_bitstype((jl_value_t*)jl_symbol("UInt8"),
                                     jl_any_type, jl_emptysvec, 8);
 
-    jl_gensym_type = jl_new_datatype(jl_symbol("GenSym"), jl_any_type, jl_emptysvec,
-                                     jl_svec1(jl_symbol("id")),
-                                     jl_svec1(jl_long_type), 0, 0, 1);
+    jl_ssavalue_type = jl_new_datatype(jl_symbol("SSAValue"), jl_any_type, jl_emptysvec,
+                                       jl_svec1(jl_symbol("id")),
+                                       jl_svec1(jl_long_type), 0, 0, 1);
 
     jl_abstractslot_type = jl_new_abstracttype((jl_value_t*)jl_symbol("Slot"), jl_any_type,
                                                jl_emptysvec);
@@ -3542,7 +3542,7 @@ void jl_init_types(void)
                                 jl_symbol("slotnames"),
                                 jl_symbol("slottypes"),
                                 jl_symbol("slotflags"),
-                                jl_symbol("gensymtypes"),
+                                jl_symbol("ssavaluetypes"),
                                 jl_symbol("rettype"),
                                 jl_symbol("sparam_syms"),
                                 jl_symbol("sparam_vals"),
diff --git a/src/julia-syntax.scm b/src/julia-syntax.scm
index 031600b1a9b46..5468814fcf343 100644
--- a/src/julia-syntax.scm
+++ b/src/julia-syntax.scm
@@ -22,7 +22,7 @@
 
 ;; identify some expressions that are safe to repeat
 (define (effect-free? e)
-  (or (not (pair? e)) (jlgensym? e) (sym-dot? e) (quoted? e) (equal? e '(null))))
+  (or (not (pair? e)) (ssavalue? e) (sym-dot? e) (quoted? e) (equal? e '(null))))
 
 ;; expanding comparison chains: (comparison a op b op c ...)
 
@@ -49,7 +49,7 @@
   (let* ((arg   (caddr e))
          (arg2  (if (and (pair? arg)
                          (pair? (cdddr e)))
-                    (make-jlgensym) arg)))
+                    (make-ssavalue) arg)))
     (if (and (not (dotop? (cadr e)))
              (length> e 5)
              (pair? (cadddr (cdr e)))
@@ -57,7 +57,7 @@
         ;; look ahead: if the 2nd argument of the next comparison is also
         ;; an argument to an eager (dot) op, make sure we don't skip the
         ;; initialization of its variable by short-circuiting
-        (let ((s (make-jlgensym)))
+        (let ((s (make-ssavalue)))
           (cons `(block
                   ,@(if (eq? arg arg2) '() `((= ,arg2 ,arg)))
                   (= ,s ,(cadddr (cdr e)))
@@ -143,7 +143,7 @@
                         (cons (cadr idx) tuples)
                         (cons `(... ,(replace-end (cadr idx) a n tuples last))
                               ret))
-                  (let ((g (make-jlgensym)))
+                  (let ((g (make-ssavalue)))
                     (loop (cdr lst) (+ n 1)
                           (cons `(= ,g ,(replace-end (cadr idx) a n tuples last))
                                 stmts)
@@ -288,9 +288,9 @@
              (name  (if iscall #f name))
              (types (llist-types argl))
              (body  (method-lambda-expr argl body))
-             ;; HACK: the typevars need to be bound to jlgensyms, since this code
+             ;; HACK: the typevars need to be bound to ssavalues, since this code
              ;; might be moved to a different scope by closure-convert.
-             (temps (map (lambda (x) (make-jlgensym)) names))
+             (temps (map (lambda (x) (make-ssavalue)) names))
              (renames (map cons names temps))
              (mdef
               (if (null? sparams)
@@ -640,7 +640,7 @@
                `(new ,Texpr ,@(map (lambda (fty val)
                                      `(call (top convert) ,fty ,val))
                                    (list-head field-types (length args)) args))
-               (let ((tn (make-jlgensym)))
+               (let ((tn (make-ssavalue)))
                  `(block
                    (= ,tn ,Texpr)
                    (new ,tn ,@(map (lambda (fld val)
@@ -850,7 +850,7 @@
                (ty    (if isseq (cadar F) (car F))))
           (if (eq? ty 'Any)
               (loop (if isseq F (cdr F)) (cdr A) stmts (list* 0 a C))
-              (let* ((g (make-jlgensym))
+              (let* ((g (make-ssavalue))
                      (isamp (and (pair? a) (eq? (car a) '&)))
                      (a (if isamp (cadr a) a))
                      (stmts (cons `(= ,g (call (top ,(if isamp 'ptr_arg_cconvert 'cconvert)) ,ty ,a)) stmts))
@@ -946,7 +946,7 @@
                   (loop (cdr binds)
                         (if (contains (lambda (x) (eq? x vname))
                                       (caddar binds))
-                            (let ((tmp (make-jlgensym)))
+                            (let ((tmp (make-ssavalue)))
                               `(scope-block
                                 (block (= ,tmp ,(caddar binds))
                                        (scope-block
@@ -1093,7 +1093,7 @@
                 (retval (if hasret (gensy) #f))
                 (bb  (gensy))
                 (finally-exception (gensy))
-                (val (gensy))) ;; this is jlgensym, but llvm has trouble determining that it dominates all uses
+                (val (gensy))) ;; this is an ssavalue, but llvm has trouble determining that it dominates all uses
             (let ((tryb   (replace-return tryb bb ret retval))
                   (catchb (replace-return catchb bb ret retval)))
               (expand-forms
@@ -1256,7 +1256,7 @@
                     (cons (make-assignment L R) stmts)
                     after
                     (cons R elts))
-              (let ((temp (make-jlgensym)))
+              (let ((temp (make-ssavalue)))
                 (loop (cdr lhss)
                       (cons L assigned)
                       (cdr rhss)
@@ -1266,7 +1266,7 @@
 
 ;; convert (lhss...) = x to tuple indexing
 (define (lower-tuple-assignment lhss x)
-  (let ((t (make-jlgensym)))
+  (let ((t (make-ssavalue)))
     `(block
       (= ,t ,x)
       ,@(let loop ((lhs lhss)
@@ -1296,7 +1296,7 @@
                      (set! a (cons x a))
                      (cadr x))
                     ((not (effect-free? x))
-                     (let ((g (make-jlgensym)))
+                     (let ((g (make-ssavalue)))
                        (if (or (eq? (car x) '...) (eq? (car x) '&))
                            (if (and (pair? (cadr x))
                                     (not (quoted? (cadr x))))
@@ -1328,12 +1328,12 @@
                               keys))))
      (if (null? restkeys)
          `(call (call (top kwfunc) ,f) (cell1d ,@keyargs) ,f ,@pa)
-         (let ((container (make-jlgensym)))
+         (let ((container (make-ssavalue)))
            `(block
              (= ,container (cell1d ,@keyargs))
              ,@(map (lambda (rk)
-                      (let* ((k (make-jlgensym))
-                             (v (make-jlgensym))
+                      (let* ((k (make-ssavalue))
+                             (v (make-ssavalue))
                              (push-expr `(ccall 'jl_cell_1d_push2 Void
                                                 (tuple Any Any Any)
                                                 ,container
@@ -1399,7 +1399,7 @@
                                        (and (pair? x)
                                             (eq? (car x) ':))))
                                  idxs)))
-           (arr   (if reuse (make-jlgensym) a))
+           (arr   (if reuse (make-ssavalue) a))
            (stmts (if reuse `((= ,arr ,a)) '())))
       (receive
        (new-idxs stuff) (process-indexes arr idxs)
@@ -1454,13 +1454,13 @@
               (if (symbol-like? (car tail))
                   `(if ,(car tail) ,(car tail)
                        ,(loop (cdr tail)))
-                  (let ((g (make-jlgensym)))
+                  (let ((g (make-ssavalue)))
                     `(block (= ,g ,(car tail))
                             (if ,g ,g
                                 ,(loop (cdr tail)))))))))))
 
 (define (expand-forms e)
-  (if (or (atom? e) (memq (car e) '(quote inert top line module toplevel jlgensym null meta)))
+  (if (or (atom? e) (memq (car e) '(quote inert top line module toplevel ssavalue null meta)))
       e
       (let ((ex (get expand-table (car e) #f)))
         (if ex
@@ -1470,7 +1470,7 @@
 
 (define (expand-for while lhs X body)
   ;; (for (= lhs X) body)
-  (let ((coll  (make-jlgensym))
+  (let ((coll  (make-ssavalue))
         (state (gensy)))
     `(scope-block
       (block (= ,coll ,(expand-forms X))
@@ -1552,7 +1552,7 @@
                   (rhs  (caddr e)))
          (if (assignment? rhs)
              (loop (cons (cadr rhs) lhss) (caddr rhs))
-             (let ((rr (if (symbol-like? rhs) rhs (make-jlgensym))))
+             (let ((rr (if (symbol-like? rhs) rhs (make-ssavalue))))
                (expand-forms
                 `(block ,.(if (eq? rr rhs) '() `((= ,rr ,rhs)))
                         ,@(map (lambda (l) `(= ,l ,rr))
@@ -1569,10 +1569,10 @@
           (let ((a   (cadr (cadr e)))
                 (b   (caddr (cadr e)))
                 (rhs (caddr e)))
-            (let ((aa (if (symbol-like? a) a (make-jlgensym)))
+            (let ((aa (if (symbol-like? a) a (make-ssavalue)))
                   (bb (if (or (atom? b) (symbol-like? b) (and (pair? b) (quoted? b)))
-                          b (make-jlgensym)))
-                  (rr (if (or (symbol-like? rhs) (atom? rhs)) rhs (make-jlgensym))))
+                          b (make-ssavalue)))
+                  (rr (if (or (symbol-like? rhs) (atom? rhs)) rhs (make-ssavalue))))
               `(block
                 ,.(if (eq? aa a)   '() `((= ,aa ,(expand-forms a))))
                 ,.(if (eq? bb b)   '() `((= ,bb ,(expand-forms b))))
@@ -1593,7 +1593,7 @@
                  (tuple-to-assignments lhss x))
                 ;; (a, b, ...) = other
                 (let* ((xx  (if (and (symbol? x) (not (memq x lhss)))
-                                x (make-jlgensym)))
+                                x (make-ssavalue)))
                        (ini (if (eq? x xx) '() `((= ,xx ,(expand-forms x)))))
                        (st  (gensy)))
                   `(block
@@ -1623,10 +1623,10 @@
                                                (and (pair? x)
                                                     (eq? (car x) ':))))
                                          idxs)))
-                   (arr   (if reuse (make-jlgensym) a))
+                   (arr   (if reuse (make-ssavalue) a))
                    (stmts (if reuse `((= ,arr ,(expand-forms a))) '()))
-                   (rrhs (and (pair? rhs) (not (jlgensym? rhs)) (not (quoted? rhs))))
-                   (r    (if rrhs (make-jlgensym) rhs))
+                   (rrhs (and (pair? rhs) (not (ssavalue? rhs)) (not (quoted? rhs))))
+                   (r    (if rrhs (make-ssavalue) rhs))
                    (rini (if rrhs `((= ,r ,(expand-forms rhs))) '())))
               (receive
                (new-idxs stuff) (process-indexes arr idxs)
@@ -1774,7 +1774,7 @@
               (expand-forms
                `(call (top cell_1d) ,@args)))
              (else
-              (let ((name (make-jlgensym)))
+              (let ((name (make-ssavalue)))
                 `(block (= ,name (call (top Array) (top Any)
                                        ,(length args)))
                         ,.(map (lambda (i elt)
@@ -1792,7 +1792,7 @@
        (if (any vararg? args)
            (expand-forms
             `(call (top cell_2d) ,nr ,nc ,@args))
-           (let ((name (make-jlgensym)))
+           (let ((name (make-ssavalue)))
              `(block (= ,name (call (top Array) (top Any)
                                     ,nr ,nc))
                      ,.(map (lambda (i elt)
@@ -1991,7 +1991,7 @@
      (expand-forms (lower-typed-dict-comprehension (cadr e) (caddr e) (cdddr e))))))
 
 (define (lower-nd-comprehension atype expr ranges)
-  (let ((result      (make-jlgensym))
+  (let ((result      (make-ssavalue))
         (ri          (gensy))
         (oneresult   (gensy)))
     ;; evaluate one expression to figure out type and size
@@ -2024,7 +2024,7 @@
               `(block (call (top setindex!) ,result (ref ,expr ,@(reverse iters)) ,ri)
                       (= ,ri (call (top +) ,ri 1))) )
           (if (eq? (car ranges) `:)
-              (let ((i (make-jlgensym)))
+              (let ((i (make-ssavalue)))
                 `(for (= ,i (: 1 (call (top size) ,oneresult ,oneresult-dim)))
                       ,(construct-loops (cdr ranges) (cons i iters) (+ oneresult-dim 1)) ))
               `(for ,(car ranges)
@@ -2044,14 +2044,14 @@
 (define (lower-comprehension atype expr ranges)
   (if (any (lambda (x) (eq? x ':)) ranges)
       (lower-nd-comprehension atype expr ranges)
-  (let ((result    (make-jlgensym))
+  (let ((result    (make-ssavalue))
         (ri        (gensy))
-        (initlabl  (if atype #f (make-jlgensym)))
-        (oneresult (make-jlgensym))
-        (lengths   (map (lambda (x) (make-jlgensym)) ranges))
+        (initlabl  (if atype #f (make-ssavalue)))
+        (oneresult (make-ssavalue))
+        (lengths   (map (lambda (x) (make-ssavalue)) ranges))
         (states    (map (lambda (x) (gensy)) ranges))
         (is        (map (lambda (x) (gensy)) ranges))
-        (rv        (map (lambda (x) (make-jlgensym)) ranges)))
+        (rv        (map (lambda (x) (make-ssavalue)) ranges)))
 
     ;; construct loops to cycle over all dimensions of an n-d comprehension
     (define (construct-loops ranges rv is states lengths)
@@ -2092,11 +2092,11 @@
         ,result))))))
 
 (define (lower-dict-comprehension expr ranges)
-  (let ((result   (make-jlgensym))
-        (initlabl (make-jlgensym))
-        (onekey   (make-jlgensym))
-        (oneval   (make-jlgensym))
-        (rv         (map (lambda (x) (make-jlgensym)) ranges)))
+  (let ((result   (make-ssavalue))
+        (initlabl (make-ssavalue))
+        (onekey   (make-ssavalue))
+        (oneval   (make-ssavalue))
+        (rv         (map (lambda (x) (make-ssavalue)) ranges)))
 
     ;; construct loops to cycle over all dimensions of an n-d comprehension
     (define (construct-loops ranges)
@@ -2132,8 +2132,8 @@
   (if (not (and (length= atypes 3)
                 (eq? (car atypes) '=>)))
       (error "invalid \"typed_dict_comprehension\" syntax")
-      (let ( (result (make-jlgensym))
-             (rs (map (lambda (x) (make-jlgensym)) ranges)) )
+      (let ( (result (make-ssavalue))
+             (rs (map (lambda (x) (make-ssavalue)) ranges)) )
 
         ;; construct loops to cycle over all dimensions of an n-d comprehension
         (define (construct-loops ranges rs)
@@ -2188,7 +2188,7 @@
         ((=)
          (let ((v (decl-var (cadr e)))
                (rest (find-assigned-vars (caddr e) env)))
-           (if (or (jlgensym? v) (memq v env))
+           (if (or (ssavalue? v) (memq v env))
                rest
                (cons v rest))))
         (else
@@ -2370,7 +2370,7 @@
 ;; type declarations.
 ;; this info is recorded by setting the second argument of `lambda` expressions
 ;; in-place to
-;;   (var-info-lst captured-var-infos gensyms static_params)
+;;   (var-info-lst captured-var-infos ssavalues static_params)
 ;; where var-info-lst is a list of var-info records
 (define (analyze-vars e env captvars sp)
   (if (or (atom? e) (quoted? e))
@@ -2507,10 +2507,10 @@ f(x) = yt(x)
          (capt   (and vi (vinfo:asgn vi) (vinfo:capt vi))))
     (if (and (not closed) (not capt) (eq? vt 'Any))
         `(= ,var ,rhs0)
-        (let* ((rhs1 (if (or (jlgensym? rhs0) (simple-atom? rhs0)
+        (let* ((rhs1 (if (or (ssavalue? rhs0) (simple-atom? rhs0)
                              (equal? rhs0 '(the_exception)))
                          rhs0
-                         (make-jlgensym)))
+                         (make-ssavalue)))
                (rhs  (if (eq? vt 'Any)
                          rhs1
                          (convert-for-type-decl rhs1 (cl-convert vt fname lam #f #f interp))))
@@ -2674,7 +2674,7 @@ f(x) = yt(x)
           ((=)
            (let ((var (cadr e))
                  (rhs (cl-convert (caddr e) fname lam namemap toplevel interp)))
-             (if (jlgensym? var)
+             (if (ssavalue? var)
                  `(= ,var ,rhs)
                  (convert-assignment var rhs fname lam interp))))
           ((newvar)
@@ -2777,7 +2777,7 @@ f(x) = yt(x)
                                             alldefs))))
                         (capt-sp (intersect cvs sps))
                         (capt-vars (diff cvs capt-sp))
-                        (method-sp (map (lambda (s) (make-jlgensym)) capt-sp))
+                        (method-sp (map (lambda (s) (make-ssavalue)) capt-sp))
                         (typedef  ;; expression to define the type
                          (let* ((fieldtypes (map (lambda (v)
                                                    (if (is-var-boxed? v lam)
@@ -2906,8 +2906,8 @@ f(x) = yt(x)
             l)))
     (define (emit-return x)
       (if (> handler-level 0)
-          (let ((tmp (if (or (simple-atom? x) (jlgensym? x) (equal? x '(null)))
-                         #f (make-jlgensym))))
+          (let ((tmp (if (or (simple-atom? x) (ssavalue? x) (equal? x '(null)))
+                         #f (make-ssavalue))))
             (if tmp (emit `(= ,tmp ,x)))
             (emit `(leave ,handler-level))
             (emit `(return ,(or tmp x))))
@@ -2923,7 +2923,7 @@ f(x) = yt(x)
                             (expr-contains-p (lambda (x) (and (assignment? x)
                                                               (symbol? (cadr x))))
                                              (cons 'block (cdr lst)))))
-                (simple? (every (lambda (x) (or (simple-atom? x) (symbol? x) (jlgensym? x)
+                (simple? (every (lambda (x) (or (simple-atom? x) (symbol? x) (ssavalue? x)
                                                 (and (pair? x)
                                                      (memq (car x) '(quote inert top copyast)))))
                                 lst)))
@@ -2935,14 +2935,14 @@ f(x) = yt(x)
                          (aval (compile arg break-labels #t #f)))
                     (loop (cdr lst)
                           (cons (if (and temps? (not simple?)
-                                         (not (simple-atom? arg))  (not (jlgensym? arg))
-                                         (not (simple-atom? aval)) (not (jlgensym? aval))
+                                         (not (simple-atom? arg))  (not (ssavalue? arg))
+                                         (not (simple-atom? aval)) (not (ssavalue? aval))
                                          (not (and (pair? arg)
                                                    (memq (car arg) '(& quote inert top copyast))))
                                          (not (and (symbol? arg)
                                                    (or (null? (cdr lst))
                                                        (null? vals)))))
-                                    (let ((tmp (make-jlgensym)))
+                                    (let ((tmp (make-ssavalue)))
                                       (emit `(= ,tmp ,aval))
                                       tmp)
                                     aval)
@@ -2950,8 +2950,8 @@ f(x) = yt(x)
     (define (compile-cond ex break-labels)
       (let ((cnd (compile ex break-labels #t #f)))
         (if (and *very-linear-mode*
-                 (not (or (simple-atom? cnd) (jlgensym? cnd) (symbol? cnd))))
-            (let ((tmp (make-jlgensym)))
+                 (not (or (simple-atom? cnd) (ssavalue? cnd) (symbol? cnd))))
+            (let ((tmp (make-ssavalue)))
               (emit `(= ,tmp ,cnd))
               tmp)
             cnd)))
@@ -2962,7 +2962,7 @@ f(x) = yt(x)
     ;; `tail` means we are in tail position, where a value needs to be `return`ed
     ;; from the current function.
     (define (compile e break-labels value tail)
-      (if (or (not (pair? e)) (memq (car e) '(null jlgensym quote inert top copyast the_exception $
+      (if (or (not (pair? e)) (memq (car e) '(null ssavalue quote inert top copyast the_exception $
                                                    cdecl stdcall fastcall thiscall)))
           (cond (tail  (emit-return e))
                 (value e)
@@ -2984,8 +2984,8 @@ f(x) = yt(x)
             ((=)
              (let ((rhs (compile (caddr e) break-labels #t #f)))
                (if value
-                   (let ((rr (if (or (atom? rhs) (jlgensym? rhs) (eq? (car rhs) 'null))
-                                 rhs (make-jlgensym))))
+                   (let ((rr (if (or (atom? rhs) (ssavalue? rhs) (eq? (car rhs) 'null))
+                                 rhs (make-ssavalue))))
                      (if (not (eq? rr rhs))
                          (emit `(= ,rr ,rhs)))
                      (emit `(= ,(cadr e) ,rr))
@@ -3236,8 +3236,8 @@ f(x) = yt(x)
 
 (define (renumber-lambda lam)
   (renumber-labels! lam (label-to-idx-map (lam:body lam)))
-  (define ngensyms 0)
-  (define gensym-table (table))
+  (define nssavalues 0)
+  (define ssavalue-table (table))
   (define nslots (length (car (lam:vinfo lam))))
   (define slot-table (symbol-to-idx-map (map car (car (lam:vinfo lam)))))
   (define sp-table (symbol-to-idx-map (lam:sp lam)))
@@ -3249,12 +3249,12 @@ f(x) = yt(x)
                    (or (and idx `(static_parameter ,idx))
                        e)))))
           ((or (atom? e) (quoted? e)) e)
-          ((jlgensym? e)
-           (let ((idx (or (get gensym-table (cadr e) #f)
-                          (begin0 ngensyms
-                                  (put! gensym-table (cadr e) ngensyms)
-                                  (set! ngensyms (+ ngensyms 1))))))
-             `(jlgensym ,idx)))
+          ((ssavalue? e)
+           (let ((idx (or (get ssavalue-table (cadr e) #f)
+                          (begin0 nssavalues
+                                  (put! ssavalue-table (cadr e) nssavalues)
+                                  (set! nssavalues (+ nssavalues 1))))))
+             `(ssavalue ,idx)))
           ((eq? (car e) 'lambda)
            (renumber-lambda e))
           (else (cons (car e)
@@ -3262,7 +3262,7 @@ f(x) = yt(x)
   (let ((body (renumber-slots (lam:body lam)))
         (vi   (lam:vinfo lam)))
     `(lambda ,(cadr lam)
-       (,(car vi) ,(cadr vi) ,ngensyms ,(last vi))
+       (,(car vi) ,(cadr vi) ,nssavalues ,(last vi))
        ,body)))
 
 (define (renumber-slots-and-labels ex)
diff --git a/src/julia.h b/src/julia.h
index 0bb49c07f33d7..24477e370c8d7 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -100,12 +100,12 @@ typedef struct _jl_sym_t {
     // JL_ATTRIBUTE_ALIGN_PTRSIZE(char name[]);
 } jl_sym_t;
 
-// An SSA symbol, for optimized code analysis and generation
+// A numbered SSA value, for optimized code analysis and generation
 // the `id` is a unique, small number
-typedef struct _jl_gensym_t {
+typedef struct _jl_ssavalue_t {
     JL_DATA_TYPE
     ssize_t id;
-} jl_gensym_t;
+} jl_ssavalue_t;
 
 // A SimpleVector is an immutable pointer array
 // Data is stored at the end of this variable-length struct.
@@ -231,7 +231,7 @@ typedef struct _jl_lambda_info_t {
     jl_array_t *slotnames; // names of local variables
     jl_value_t *slottypes;
     jl_array_t *slotflags;  // local var bit flags
-    jl_value_t *gensymtypes;
+    jl_value_t *ssavaluetypes;  // types of ssa values
     jl_value_t *rettype;
     jl_svec_t *sparam_syms; // sparams is a vector of values indexed by symbols
     jl_svec_t *sparam_vals;
@@ -440,7 +440,7 @@ extern JL_DLLEXPORT jl_datatype_t *jl_typename_type;
 extern JL_DLLEXPORT jl_datatype_t *jl_typector_type;
 extern JL_DLLEXPORT jl_datatype_t *jl_sym_type;
 extern JL_DLLEXPORT jl_datatype_t *jl_symbol_type;
-extern JL_DLLEXPORT jl_datatype_t *jl_gensym_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_ssavalue_type;
 extern JL_DLLEXPORT jl_datatype_t *jl_abstractslot_type;
 extern JL_DLLEXPORT jl_datatype_t *jl_slotnumber_type;
 extern JL_DLLEXPORT jl_datatype_t *jl_typedslot_type;
@@ -849,7 +849,7 @@ static inline uint32_t jl_fielddesc_size(int8_t fielddesc_type)
 #define jl_is_float64(v)     jl_typeis(v,jl_float64_type)
 #define jl_is_bool(v)        jl_typeis(v,jl_bool_type)
 #define jl_is_symbol(v)      jl_typeis(v,jl_sym_type)
-#define jl_is_gensym(v)      jl_typeis(v,jl_gensym_type)
+#define jl_is_ssavalue(v)    jl_typeis(v,jl_ssavalue_type)
 #define jl_is_slot(v)        (jl_typeis(v,jl_slotnumber_type) || jl_typeis(v,jl_typedslot_type))
 #define jl_is_expr(v)        jl_typeis(v,jl_expr_type)
 #define jl_is_globalref(v)   jl_typeis(v,jl_globalref_type)
@@ -1051,7 +1051,7 @@ JL_DLLEXPORT jl_value_t *jl_box_uint64(uint64_t x);
 JL_DLLEXPORT jl_value_t *jl_box_float32(float x);
 JL_DLLEXPORT jl_value_t *jl_box_float64(double x);
 JL_DLLEXPORT jl_value_t *jl_box_voidpointer(void *x);
-JL_DLLEXPORT jl_value_t *jl_box_gensym(size_t x);
+JL_DLLEXPORT jl_value_t *jl_box_ssavalue(size_t x);
 JL_DLLEXPORT jl_value_t *jl_box_slotnumber(size_t x);
 JL_DLLEXPORT jl_value_t *jl_box8 (jl_datatype_t *t, int8_t  x);
 JL_DLLEXPORT jl_value_t *jl_box16(jl_datatype_t *t, int16_t x);
@@ -1069,7 +1069,6 @@ JL_DLLEXPORT uint64_t jl_unbox_uint64(jl_value_t *v);
 JL_DLLEXPORT float jl_unbox_float32(jl_value_t *v);
 JL_DLLEXPORT double jl_unbox_float64(jl_value_t *v);
 JL_DLLEXPORT void *jl_unbox_voidpointer(jl_value_t *v);
-JL_DLLEXPORT ssize_t jl_unbox_gensym(jl_value_t *v);
 
 JL_DLLEXPORT int jl_get_size(jl_value_t *val, size_t *pnt);
 
diff --git a/src/julia_internal.h b/src/julia_internal.h
index 8f3a7281bb160..b64f30627189b 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -156,8 +156,6 @@ void *jl_install_thread_signal_handler(void);
 
 jl_fptr_t jl_get_builtin_fptr(jl_value_t *b);
 
-ssize_t jl_max_jlgensym_in(jl_value_t *v);
-
 extern uv_loop_t *jl_io_loop;
 
 JL_DLLEXPORT void jl_uv_associate_julia_struct(uv_handle_t *handle,
@@ -221,7 +219,7 @@ jl_value_t *jl_gf_invoke(jl_tupletype_t *types, jl_value_t **args, size_t nargs)
 jl_array_t *jl_lam_args(jl_expr_t *l);
 jl_array_t *jl_lam_vinfo(jl_expr_t *l);
 jl_array_t *jl_lam_capt(jl_expr_t *l);
-jl_value_t *jl_lam_gensyms(jl_expr_t *l);
+jl_value_t *jl_lam_ssavalues(jl_expr_t *l);
 jl_array_t *jl_lam_staticparams(jl_expr_t *l);
 int jl_lam_vars_captured(jl_expr_t *ast);
 jl_expr_t *jl_lam_body(jl_expr_t *l);
diff --git a/src/macroexpand.scm b/src/macroexpand.scm
index 8fe352869976d..0963b46a1f695 100644
--- a/src/macroexpand.scm
+++ b/src/macroexpand.scm
@@ -23,7 +23,7 @@
 
 (define (julia-bq-expand x d)
   (cond ((or (eq? x 'true) (eq? x 'false))  x)
-        ((or (symbol? x) (jlgensym? x))     (list 'inert x))
+        ((or (symbol? x) (ssavalue? x))     (list 'inert x))
         ((atom? x)  x)
         ((eq? (car x) 'quote)
          `(call (top _expr) (inert quote) ,(julia-bq-expand (cadr x) (+ d 1))))
@@ -216,7 +216,7 @@
          e)
         (else
          (case (car e)
-           ((jlgensym) e)
+           ((ssavalue) e)
            ((escape) (cadr e))
            ((global) (let ((arg (cadr e)))
                        (cond ((symbol? arg) e)
diff --git a/src/toplevel.c b/src/toplevel.c
index 3a5acecb9eb78..2016d681aa423 100644
--- a/src/toplevel.c
+++ b/src/toplevel.c
@@ -251,7 +251,7 @@ int jl_has_intrinsics(jl_lambda_info_t *li, jl_value_t *v, jl_module_t *m)
         if (sv && jl_typeis(sv, jl_intrinsic_type))
             return 1;
     }
-    if (0 && e->head == assign_sym && jl_is_gensym(e0)) { // code branch needed for *very-linear-mode*, but not desirable otherwise
+    if (0 && e->head == assign_sym && jl_is_ssavalue(e0)) { // code branch needed for *very-linear-mode*, but not desirable otherwise
         jl_value_t *e1 = jl_exprarg(e, 1);
         jl_value_t *sv = jl_static_eval(e1, NULL, m, li, li != NULL, 0);
         if (sv && jl_typeis(sv, jl_intrinsic_type))