<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[82130] trunk/Source/JavaScriptCore</title>
</head>
<body>
<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; }
#msg dl a { font-weight: bold}
#msg dl a:link { color:#fc3; }
#msg dl a:active { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/82130">82130</a></dd>
<dt>Author</dt> <dd>oliver@apple.com</dd>
<dt>Date</dt> <dd>2011-03-28 10:14:57 -0700 (Mon, 28 Mar 2011)</dd>
</dl>
<h3>Log Message</h3>
<pre>2011-03-27 Oliver Hunt <oliver@apple.com>
Reviewed by Maciej Stachowiak.
Add additional immediate types to allow us to distinguish the source of a JIT immediate
https://bugs.webkit.org/show_bug.cgi?id=57190
Allow us to distinguish whether a JIT immediate is a value that we
control (TrustedImm32 and TrustedImmPtr) vs. ones that can be controlled
or influenced by code we are compiling. Currently we do nothing with this
information -- this change is large and mechanical but would obscure any
logic changes that we would have made.
* assembler/AbstractMacroAssembler.h:
(JSC::AbstractMacroAssembler::TrustedImmPtr::TrustedImmPtr):
(JSC::AbstractMacroAssembler::ImmPtr::ImmPtr):
(JSC::AbstractMacroAssembler::TrustedImm32::TrustedImm32):
(JSC::AbstractMacroAssembler::Imm32::Imm32):
* assembler/MacroAssembler.h:
(JSC::MacroAssembler::pop):
(JSC::MacroAssembler::poke):
(JSC::MacroAssembler::branchPtr):
(JSC::MacroAssembler::branch32):
(JSC::MacroAssembler::addPtr):
(JSC::MacroAssembler::andPtr):
(JSC::MacroAssembler::orPtr):
(JSC::MacroAssembler::subPtr):
(JSC::MacroAssembler::xorPtr):
(JSC::MacroAssembler::setPtr):
(JSC::MacroAssembler::storePtr):
(JSC::MacroAssembler::branchTestPtr):
(JSC::MacroAssembler::branchSubPtr):
(JSC::MacroAssembler::branchTest8):
* assembler/MacroAssemblerARM.h:
(JSC::MacroAssemblerARM::add32):
(JSC::MacroAssemblerARM::and32):
(JSC::MacroAssemblerARM::lshift32):
(JSC::MacroAssemblerARM::mul32):
(JSC::MacroAssemblerARM::or32):
(JSC::MacroAssemblerARM::rshift32):
(JSC::MacroAssemblerARM::urshift32):
(JSC::MacroAssemblerARM::sub32):
(JSC::MacroAssemblerARM::xor32):
(JSC::MacroAssemblerARM::store32):
(JSC::MacroAssemblerARM::push):
(JSC::MacroAssemblerARM::move):
(JSC::MacroAssemblerARM::branch8):
(JSC::MacroAssemblerARM::branch32):
(JSC::MacroAssemblerARM::branch32WithUnalignedHalfWords):
(JSC::MacroAssemblerARM::branch16):
(JSC::MacroAssemblerARM::branchTest8):
(JSC::MacroAssemblerARM::branchTest32):
(JSC::MacroAssemblerARM::branchAdd32):
(JSC::MacroAssemblerARM::branchMul32):
(JSC::MacroAssemblerARM::branchSub32):
(JSC::MacroAssemblerARM::set32Compare32):
(JSC::MacroAssemblerARM::set8Compare32):
(JSC::MacroAssemblerARM::set32Test32):
(JSC::MacroAssemblerARM::set32Test8):
(JSC::MacroAssemblerARM::moveWithPatch):
(JSC::MacroAssemblerARM::branchPtrWithPatch):
(JSC::MacroAssemblerARM::storePtrWithPatch):
* assembler/MacroAssemblerARMv7.h:
(JSC::MacroAssemblerARMv7::add32):
(JSC::MacroAssemblerARMv7::and32):
(JSC::MacroAssemblerARMv7::lshift32):
(JSC::MacroAssemblerARMv7::mul32):
(JSC::MacroAssemblerARMv7::or32):
(JSC::MacroAssemblerARMv7::rshift32):
(JSC::MacroAssemblerARMv7::urshift32):
(JSC::MacroAssemblerARMv7::sub32):
(JSC::MacroAssemblerARMv7::xor32):
(JSC::MacroAssemblerARMv7::load32):
(JSC::MacroAssemblerARMv7::load32WithAddressOffsetPatch):
(JSC::MacroAssemblerARMv7::load16):
(JSC::MacroAssemblerARMv7::store32WithAddressOffsetPatch):
(JSC::MacroAssemblerARMv7::store32):
(JSC::MacroAssemblerARMv7::loadDouble):
(JSC::MacroAssemblerARMv7::storeDouble):
(JSC::MacroAssemblerARMv7::push):
(JSC::MacroAssemblerARMv7::move):
(JSC::MacroAssemblerARMv7::compare32):
(JSC::MacroAssemblerARMv7::test32):
(JSC::MacroAssemblerARMv7::branch32):
(JSC::MacroAssemblerARMv7::branch32WithUnalignedHalfWords):
(JSC::MacroAssemblerARMv7::branch16):
(JSC::MacroAssemblerARMv7::branch8):
(JSC::MacroAssemblerARMv7::branchTest32):
(JSC::MacroAssemblerARMv7::branchTest8):
(JSC::MacroAssemblerARMv7::branchAdd32):
(JSC::MacroAssemblerARMv7::branchMul32):
(JSC::MacroAssemblerARMv7::branchSub32):
(JSC::MacroAssemblerARMv7::nearCall):
(JSC::MacroAssemblerARMv7::call):
(JSC::MacroAssemblerARMv7::set32Compare32):
(JSC::MacroAssemblerARMv7::set8Compare32):
(JSC::MacroAssemblerARMv7::set32Test32):
(JSC::MacroAssemblerARMv7::set32Test8):
(JSC::MacroAssemblerARMv7::moveWithPatch):
(JSC::MacroAssemblerARMv7::branchPtrWithPatch):
(JSC::MacroAssemblerARMv7::storePtrWithPatch):
(JSC::MacroAssemblerARMv7::tailRecursiveCall):
(JSC::MacroAssemblerARMv7::makeJump):
(JSC::MacroAssemblerARMv7::makeBranch):
(JSC::MacroAssemblerARMv7::setupArmAddress):
(JSC::MacroAssemblerARMv7::makeBaseIndexBase):
(JSC::MacroAssemblerARMv7::moveFixedWidthEncoding):
* assembler/MacroAssemblerMIPS.h:
(JSC::MacroAssemblerMIPS::add32):
(JSC::MacroAssemblerMIPS::and32):
(JSC::MacroAssemblerMIPS::lshift32):
(JSC::MacroAssemblerMIPS::mul32):
(JSC::MacroAssemblerMIPS::or32):
(JSC::MacroAssemblerMIPS::rshift32):
(JSC::MacroAssemblerMIPS::urshift32):
(JSC::MacroAssemblerMIPS::sub32):
(JSC::MacroAssemblerMIPS::xor32):
(JSC::MacroAssemblerMIPS::load32):
(JSC::MacroAssemblerMIPS::load32WithAddressOffsetPatch):
(JSC::MacroAssemblerMIPS::store32WithAddressOffsetPatch):
(JSC::MacroAssemblerMIPS::store32):
(JSC::MacroAssemblerMIPS::push):
(JSC::MacroAssemblerMIPS::move):
(JSC::MacroAssemblerMIPS::branch8):
(JSC::MacroAssemblerMIPS::branch32):
(JSC::MacroAssemblerMIPS::branch32WithUnalignedHalfWords):
(JSC::MacroAssemblerMIPS::branch16):
(JSC::MacroAssemblerMIPS::branchTest32):
(JSC::MacroAssemblerMIPS::branchTest8):
(JSC::MacroAssemblerMIPS::branchAdd32):
(JSC::MacroAssemblerMIPS::branchMul32):
(JSC::MacroAssemblerMIPS::branchSub32):
(JSC::MacroAssemblerMIPS::set8Compare32):
(JSC::MacroAssemblerMIPS::set32Compare32):
(JSC::MacroAssemblerMIPS::set32Test8):
(JSC::MacroAssemblerMIPS::set32Test32):
(JSC::MacroAssemblerMIPS::moveWithPatch):
(JSC::MacroAssemblerMIPS::branchPtrWithPatch):
(JSC::MacroAssemblerMIPS::storePtrWithPatch):
(JSC::MacroAssemblerMIPS::tailRecursiveCall):
(JSC::MacroAssemblerMIPS::loadDouble):
(JSC::MacroAssemblerMIPS::storeDouble):
(JSC::MacroAssemblerMIPS::branchTruncateDoubleToInt32):
* assembler/MacroAssemblerX86.h:
(JSC::MacroAssemblerX86::add32):
(JSC::MacroAssemblerX86::addWithCarry32):
(JSC::MacroAssemblerX86::and32):
(JSC::MacroAssemblerX86::or32):
(JSC::MacroAssemblerX86::sub32):
(JSC::MacroAssemblerX86::store32):
(JSC::MacroAssemblerX86::branch32):
(JSC::MacroAssemblerX86::moveWithPatch):
(JSC::MacroAssemblerX86::branchPtrWithPatch):
(JSC::MacroAssemblerX86::storePtrWithPatch):
* assembler/MacroAssemblerX86Common.h:
(JSC::MacroAssemblerX86Common::add32):
(JSC::MacroAssemblerX86Common::and32):
(JSC::MacroAssemblerX86Common::lshift32):
(JSC::MacroAssemblerX86Common::mul32):
(JSC::MacroAssemblerX86Common::or32):
(JSC::MacroAssemblerX86Common::rshift32):
(JSC::MacroAssemblerX86Common::urshift32):
(JSC::MacroAssemblerX86Common::sub32):
(JSC::MacroAssemblerX86Common::xor32):
(JSC::MacroAssemblerX86Common::store32):
(JSC::MacroAssemblerX86Common::branchTruncateDoubleToInt32):
(JSC::MacroAssemblerX86Common::push):
(JSC::MacroAssemblerX86Common::move):
(JSC::MacroAssemblerX86Common::branch8):
(JSC::MacroAssemblerX86Common::branch32):
(JSC::MacroAssemblerX86Common::branch32WithUnalignedHalfWords):
(JSC::MacroAssemblerX86Common::branch16):
(JSC::MacroAssemblerX86Common::branchTest32):
(JSC::MacroAssemblerX86Common::branchTest8):
(JSC::MacroAssemblerX86Common::branchAdd32):
(JSC::MacroAssemblerX86Common::branchMul32):
(JSC::MacroAssemblerX86Common::branchSub32):
(JSC::MacroAssemblerX86Common::set8Compare32):
(JSC::MacroAssemblerX86Common::set32Compare32):
(JSC::MacroAssemblerX86Common::set32Test8):
(JSC::MacroAssemblerX86Common::set32Test32):
* assembler/MacroAssemblerX86_64.h:
(JSC::MacroAssemblerX86_64::add32):
(JSC::MacroAssemblerX86_64::and32):
(JSC::MacroAssemblerX86_64::or32):
(JSC::MacroAssemblerX86_64::sub32):
(JSC::MacroAssemblerX86_64::loadDouble):
(JSC::MacroAssemblerX86_64::addDouble):
(JSC::MacroAssemblerX86_64::convertInt32ToDouble):
(JSC::MacroAssemblerX86_64::store32):
(JSC::MacroAssemblerX86_64::call):
(JSC::MacroAssemblerX86_64::tailRecursiveCall):
(JSC::MacroAssemblerX86_64::makeTailRecursiveCall):
(JSC::MacroAssemblerX86_64::addPtr):
(JSC::MacroAssemblerX86_64::andPtr):
(JSC::MacroAssemblerX86_64::orPtr):
(JSC::MacroAssemblerX86_64::subPtr):
(JSC::MacroAssemblerX86_64::xorPtr):
(JSC::MacroAssemblerX86_64::storePtr):
(JSC::MacroAssemblerX86_64::setPtr):
(JSC::MacroAssemblerX86_64::branchPtr):
(JSC::MacroAssemblerX86_64::branchTestPtr):
(JSC::MacroAssemblerX86_64::branchSubPtr):
(JSC::MacroAssemblerX86_64::moveWithPatch):
(JSC::MacroAssemblerX86_64::branchPtrWithPatch):
(JSC::MacroAssemblerX86_64::storePtrWithPatch):
(JSC::MacroAssemblerX86_64::branchTest8):
* dfg/DFGJITCodeGenerator.h:
(JSC::DFG::JITCodeGenerator::callOperation):
* dfg/DFGJITCompiler.cpp:
(JSC::DFG::JITCompiler::jitAssertIsInt32):
(JSC::DFG::JITCompiler::emitCount):
* dfg/DFGJITCompiler.h:
(JSC::DFG::JITCompiler::emitPutImmediateToCallFrameHeader):
* dfg/DFGNonSpeculativeJIT.cpp:
(JSC::DFG::NonSpeculativeJIT::compile):
* dfg/DFGSpeculativeJIT.cpp:
(JSC::DFG::SpeculativeJIT::fillSpeculateCell):
(JSC::DFG::SpeculativeJIT::compile):
* jit/JIT.cpp:
(JSC::JIT::emitTimeoutCheck):
(JSC::JIT::privateCompile):
* jit/JIT.h:
* jit/JITArithmetic.cpp:
(JSC::JIT::emit_op_urshift):
(JSC::JIT::emitSlow_op_urshift):
(JSC::JIT::emit_op_post_inc):
(JSC::JIT::emit_op_post_dec):
(JSC::JIT::emit_op_pre_inc):
(JSC::JIT::emit_op_pre_dec):
(JSC::JIT::emit_op_mod):
* jit/JITArithmetic32_64.cpp:
(JSC::JIT::emit_op_negate):
(JSC::JIT::emit_op_jnless):
(JSC::JIT::emit_op_jless):
(JSC::JIT::emit_op_jlesseq):
(JSC::JIT::emit_op_lshift):
(JSC::JIT::emitRightShift):
(JSC::JIT::emitRightShiftSlowCase):
(JSC::JIT::emit_op_bitand):
(JSC::JIT::emit_op_bitor):
(JSC::JIT::emit_op_bitxor):
(JSC::JIT::emit_op_bitnot):
(JSC::JIT::emit_op_post_inc):
(JSC::JIT::emit_op_post_dec):
(JSC::JIT::emitSlow_op_post_dec):
(JSC::JIT::emit_op_pre_inc):
(JSC::JIT::emit_op_pre_dec):
(JSC::JIT::emit_op_add):
(JSC::JIT::emitAdd32Constant):
(JSC::JIT::emit_op_sub):
(JSC::JIT::emitSub32Constant):
(JSC::JIT::emitBinaryDoubleOp):
(JSC::JIT::emit_op_mul):
(JSC::JIT::emitSlow_op_mul):
(JSC::JIT::emit_op_div):
(JSC::JIT::emit_op_mod):
* jit/JITCall.cpp:
(JSC::JIT::compileOpCallVarargs):
(JSC::JIT::compileOpCall):
(JSC::JIT::compileOpCallSlowCase):
* jit/JITCall32_64.cpp:
(JSC::JIT::compileOpCallVarargs):
(JSC::JIT::emit_op_ret_object_or_this):
(JSC::JIT::compileOpCall):
(JSC::JIT::compileOpCallSlowCase):
* jit/JITInlineMethods.h:
(JSC::JIT::emitPutCellToCallFrameHeader):
(JSC::JIT::emitPutIntToCallFrameHeader):
(JSC::JIT::emitPutImmediateToCallFrameHeader):
(JSC::JIT::emitLoadCharacterString):
(JSC::JIT::restoreArgumentReferenceForTrampoline):
(JSC::JIT::checkStructure):
(JSC::JIT::setSamplingFlag):
(JSC::JIT::clearSamplingFlag):
(JSC::JIT::emitCount):
(JSC::JIT::sampleInstruction):
(JSC::JIT::sampleCodeBlock):
(JSC::JIT::emitStoreInt32):
(JSC::JIT::emitStoreCell):
(JSC::JIT::emitStoreBool):
(JSC::JIT::emitJumpSlowCaseIfNotJSCell):
(JSC::JIT::emitInitRegister):
(JSC::JIT::emitJumpIfJSCell):
(JSC::JIT::emitJumpIfNotJSCell):
(JSC::JIT::emitJumpIfImmediateInteger):
(JSC::JIT::emitJumpIfNotImmediateInteger):
(JSC::JIT::emitFastArithDeTagImmediate):
(JSC::JIT::emitFastArithDeTagImmediateJumpIfZero):
(JSC::JIT::emitFastArithReTagImmediate):
(JSC::JIT::emitTagAsBoolImmediate):
* jit/JITOpcodes.cpp:
(JSC::JIT::privateCompileCTIMachineTrampolines):
(JSC::JIT::privateCompileCTINativeCall):
(JSC::JIT::emit_op_check_has_instance):
(JSC::JIT::emit_op_instanceof):
(JSC::JIT::emit_op_ret_object_or_this):
(JSC::JIT::emit_op_resolve):
(JSC::JIT::emit_op_to_primitive):
(JSC::JIT::emit_op_resolve_base):
(JSC::JIT::emit_op_ensure_property_exists):
(JSC::JIT::emit_op_resolve_skip):
(JSC::JIT::emit_op_resolve_global):
(JSC::JIT::emitSlow_op_resolve_global):
(JSC::JIT::emit_op_not):
(JSC::JIT::emit_op_jfalse):
(JSC::JIT::emit_op_jeq_null):
(JSC::JIT::emit_op_jneq_null):
(JSC::JIT::emit_op_jneq_ptr):
(JSC::JIT::emit_op_jsr):
(JSC::JIT::emit_op_resolve_with_base):
(JSC::JIT::emit_op_new_func_exp):
(JSC::JIT::emit_op_jtrue):
(JSC::JIT::emit_op_get_pnames):
(JSC::JIT::emit_op_next_pname):
(JSC::JIT::emit_op_to_jsnumber):
(JSC::JIT::emit_op_push_new_scope):
(JSC::JIT::emit_op_catch):
(JSC::JIT::emit_op_eq_null):
(JSC::JIT::emit_op_neq_null):
(JSC::JIT::emit_op_init_lazy_reg):
(JSC::JIT::emit_op_convert_this):
(JSC::JIT::emit_op_convert_this_strict):
(JSC::JIT::emitSlow_op_not):
(JSC::JIT::emitSlow_op_neq):
(JSC::JIT::emit_op_get_arguments_length):
(JSC::JIT::emitSlow_op_get_arguments_length):
(JSC::JIT::emit_op_get_argument_by_val):
(JSC::JIT::emitSlow_op_resolve_global_dynamic):
(JSC::JIT::emit_op_new_regexp):
(JSC::JIT::emit_op_load_varargs):
(JSC::JIT::emitSlow_op_load_varargs):
(JSC::JIT::emit_op_new_func):
* jit/JITOpcodes32_64.cpp:
(JSC::JIT::privateCompileCTIMachineTrampolines):
(JSC::JIT::privateCompileCTINativeCall):
(JSC::JIT::emit_op_loop_if_lesseq):
(JSC::JIT::emit_op_check_has_instance):
(JSC::JIT::emit_op_instanceof):
(JSC::JIT::emit_op_get_scoped_var):
(JSC::JIT::emit_op_put_scoped_var):
(JSC::JIT::emit_op_tear_off_activation):
(JSC::JIT::emit_op_tear_off_arguments):
(JSC::JIT::emit_op_resolve):
(JSC::JIT::emit_op_to_primitive):
(JSC::JIT::emit_op_resolve_base):
(JSC::JIT::emit_op_ensure_property_exists):
(JSC::JIT::emit_op_resolve_skip):
(JSC::JIT::emit_op_resolve_global):
(JSC::JIT::emitSlow_op_resolve_global):
(JSC::JIT::emit_op_not):
(JSC::JIT::emit_op_jfalse):
(JSC::JIT::emit_op_jtrue):
(JSC::JIT::emit_op_jeq_null):
(JSC::JIT::emit_op_jneq_null):
(JSC::JIT::emit_op_jneq_ptr):
(JSC::JIT::emit_op_jsr):
(JSC::JIT::emit_op_eq):
(JSC::JIT::emitSlow_op_eq):
(JSC::JIT::emit_op_neq):
(JSC::JIT::emitSlow_op_neq):
(JSC::JIT::compileOpStrictEq):
(JSC::JIT::emit_op_eq_null):
(JSC::JIT::emit_op_neq_null):
(JSC::JIT::emit_op_resolve_with_base):
(JSC::JIT::emit_op_new_func_exp):
(JSC::JIT::emit_op_get_pnames):
(JSC::JIT::emit_op_next_pname):
(JSC::JIT::emit_op_to_jsnumber):
(JSC::JIT::emit_op_push_new_scope):
(JSC::JIT::emit_op_catch):
(JSC::JIT::emit_op_create_activation):
(JSC::JIT::emit_op_create_arguments):
(JSC::JIT::emit_op_convert_this):
(JSC::JIT::emit_op_convert_this_strict):
(JSC::JIT::emit_op_get_arguments_length):
(JSC::JIT::emitSlow_op_get_arguments_length):
(JSC::JIT::emit_op_get_argument_by_val):
(JSC::JIT::softModulo):
* jit/JITPropertyAccess.cpp:
(JSC::JIT::stringGetByValStubGenerator):
(JSC::JIT::emit_op_get_by_val):
(JSC::JIT::emitSlow_op_get_by_val):
(JSC::JIT::emit_op_get_by_pname):
(JSC::JIT::emit_op_put_by_val):
(JSC::JIT::emit_op_put_by_index):
(JSC::JIT::emit_op_put_getter):
(JSC::JIT::emit_op_put_setter):
(JSC::JIT::emit_op_del_by_id):
(JSC::JIT::emit_op_get_by_id):
(JSC::JIT::emit_op_put_by_id):
(JSC::JIT::emit_op_method_check):
(JSC::JIT::compileGetByIdHotPath):
(JSC::JIT::compileGetByIdSlowCase):
(JSC::JIT::emitSlow_op_put_by_id):
(JSC::JIT::testPrototype):
(JSC::JIT::privateCompilePutByIdTransition):
(JSC::JIT::privateCompilePatchGetArrayLength):
(JSC::JIT::privateCompileGetByIdProto):
(JSC::JIT::privateCompileGetByIdSelfList):
(JSC::JIT::privateCompileGetByIdProtoList):
(JSC::JIT::privateCompileGetByIdChainList):
(JSC::JIT::privateCompileGetByIdChain):
* jit/JITPropertyAccess32_64.cpp:
(JSC::JIT::emit_op_put_getter):
(JSC::JIT::emit_op_put_setter):
(JSC::JIT::emit_op_del_by_id):
(JSC::JIT::emit_op_get_by_id):
(JSC::JIT::emit_op_put_by_id):
(JSC::JIT::emit_op_method_check):
(JSC::JIT::stringGetByValStubGenerator):
(JSC::JIT::emit_op_get_by_val):
(JSC::JIT::emitSlow_op_get_by_val):
(JSC::JIT::emit_op_put_by_val):
(JSC::JIT::compileGetByIdHotPath):
(JSC::JIT::compileGetByIdSlowCase):
(JSC::JIT::emitSlow_op_put_by_id):
(JSC::JIT::testPrototype):
(JSC::JIT::privateCompilePutByIdTransition):
(JSC::JIT::privateCompilePatchGetArrayLength):
(JSC::JIT::privateCompileGetByIdProto):
(JSC::JIT::privateCompileGetByIdSelfList):
(JSC::JIT::privateCompileGetByIdProtoList):
(JSC::JIT::privateCompileGetByIdChainList):
(JSC::JIT::privateCompileGetByIdChain):
(JSC::JIT::emit_op_get_by_pname):
* jit/JITStubCall.h:
(JSC::JITStubCall::addArgument):
* jit/JITStubs.cpp:
(JSC::getPolymorphicAccessStructureListSlot):
(JSC::DEFINE_STUB_FUNCTION):
* jit/JSInterfaceJIT.h:
(JSC::JSInterfaceJIT::emitJumpIfNotJSCell):
(JSC::JSInterfaceJIT::emitLoadInt32):
(JSC::JSInterfaceJIT::emitLoadDouble):
* jit/SpecializedThunkJIT.h:
(JSC::SpecializedThunkJIT::SpecializedThunkJIT):
(JSC::SpecializedThunkJIT::loadJSStringArgument):
(JSC::SpecializedThunkJIT::tagReturnAsInt32):
(JSC::SpecializedThunkJIT::tagReturnAsJSCell):
* jit/ThunkGenerators.cpp:
(JSC::charToString):
(JSC::powThunkGenerator):
* yarr/YarrJIT.cpp:
(JSC::Yarr::YarrGenerator::matchCharacterClass):
(JSC::Yarr::YarrGenerator::storeToFrame):
(JSC::Yarr::YarrGenerator::storeToFrameWithPatch):
(JSC::Yarr::YarrGenerator::ParenthesesTail::generateCode):
(JSC::Yarr::YarrGenerator::generatePatternCharacterSingle):
(JSC::Yarr::YarrGenerator::generatePatternCharacterFixed):
(JSC::Yarr::YarrGenerator::generatePatternCharacterGreedy):
(JSC::Yarr::YarrGenerator::generatePatternCharacterNonGreedy):
(JSC::Yarr::YarrGenerator::generateCharacterClassFixed):
(JSC::Yarr::YarrGenerator::generateCharacterClassGreedy):
(JSC::Yarr::YarrGenerator::generateCharacterClassNonGreedy):
(JSC::Yarr::YarrGenerator::generateParenthesesSingle):
(JSC::Yarr::YarrGenerator::generateDisjunction):</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkSourceJavaScriptCoreChangeLog">trunk/Source/JavaScriptCore/ChangeLog</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerAbstractMacroAssemblerh">trunk/Source/JavaScriptCore/assembler/AbstractMacroAssembler.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerMacroAssemblerh">trunk/Source/JavaScriptCore/assembler/MacroAssembler.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerMacroAssemblerARMh">trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerMacroAssemblerARMv7h">trunk/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerMacroAssemblerMIPSh">trunk/Source/JavaScriptCore/assembler/MacroAssemblerMIPS.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerMacroAssemblerX86h">trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerMacroAssemblerX86Commonh">trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerMacroAssemblerX86_64h">trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86_64.h</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGJITCodeGeneratorh">trunk/Source/JavaScriptCore/dfg/DFGJITCodeGenerator.h</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGJITCompilercpp">trunk/Source/JavaScriptCore/dfg/DFGJITCompiler.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGJITCompilerh">trunk/Source/JavaScriptCore/dfg/DFGJITCompiler.h</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGNonSpeculativeJITcpp">trunk/Source/JavaScriptCore/dfg/DFGNonSpeculativeJIT.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGSpeculativeJITcpp">trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCorejitJITcpp">trunk/Source/JavaScriptCore/jit/JIT.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCorejitJITh">trunk/Source/JavaScriptCore/jit/JIT.h</a></li>
<li><a href="#trunkSourceJavaScriptCorejitJITArithmeticcpp">trunk/Source/JavaScriptCore/jit/JITArithmetic.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCorejitJITArithmetic32_64cpp">trunk/Source/JavaScriptCore/jit/JITArithmetic32_64.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCorejitJITCallcpp">trunk/Source/JavaScriptCore/jit/JITCall.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCorejitJITCall32_64cpp">trunk/Source/JavaScriptCore/jit/JITCall32_64.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCorejitJITInlineMethodsh">trunk/Source/JavaScriptCore/jit/JITInlineMethods.h</a></li>
<li><a href="#trunkSourceJavaScriptCorejitJITOpcodescpp">trunk/Source/JavaScriptCore/jit/JITOpcodes.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCorejitJITOpcodes32_64cpp">trunk/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCorejitJITPropertyAccesscpp">trunk/Source/JavaScriptCore/jit/JITPropertyAccess.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCorejitJITPropertyAccess32_64cpp">trunk/Source/JavaScriptCore/jit/JITPropertyAccess32_64.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCorejitJITStubCallh">trunk/Source/JavaScriptCore/jit/JITStubCall.h</a></li>
<li><a href="#trunkSourceJavaScriptCorejitJSInterfaceJITh">trunk/Source/JavaScriptCore/jit/JSInterfaceJIT.h</a></li>
<li><a href="#trunkSourceJavaScriptCorejitSpecializedThunkJITh">trunk/Source/JavaScriptCore/jit/SpecializedThunkJIT.h</a></li>
<li><a href="#trunkSourceJavaScriptCorejitThunkGeneratorscpp">trunk/Source/JavaScriptCore/jit/ThunkGenerators.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreyarrYarrJITcpp">trunk/Source/JavaScriptCore/yarr/YarrJIT.cpp</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkSourceJavaScriptCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ChangeLog (82129 => 82130)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ChangeLog 2011-03-28 17:10:30 UTC (rev 82129)
+++ trunk/Source/JavaScriptCore/ChangeLog 2011-03-28 17:14:57 UTC (rev 82130)
</span><span class="lines">@@ -1,3 +1,461 @@
</span><ins>+2011-03-27 Oliver Hunt <oliver@apple.com>
+
+ Reviewed by Maciej Stachowiak.
+
+ Add additional immediate types to allow us to distinguish the source of a JIT immediate
+ https://bugs.webkit.org/show_bug.cgi?id=57190
+
+ Allow us to distinguish whether a JIT immediate is a value that we
+ control (TrustedImm32 and TrustedImmPtr) vs. ones that can be controlled
+ or influenced by code we are compiling. Currently we do nothing with this
+ information -- this change is large and mechanical but would obscure any
+ logic changes that we would have made.
+
+ * assembler/AbstractMacroAssembler.h:
+ (JSC::AbstractMacroAssembler::TrustedImmPtr::TrustedImmPtr):
+ (JSC::AbstractMacroAssembler::ImmPtr::ImmPtr):
+ (JSC::AbstractMacroAssembler::TrustedImm32::TrustedImm32):
+ (JSC::AbstractMacroAssembler::Imm32::Imm32):
+ * assembler/MacroAssembler.h:
+ (JSC::MacroAssembler::pop):
+ (JSC::MacroAssembler::poke):
+ (JSC::MacroAssembler::branchPtr):
+ (JSC::MacroAssembler::branch32):
+ (JSC::MacroAssembler::addPtr):
+ (JSC::MacroAssembler::andPtr):
+ (JSC::MacroAssembler::orPtr):
+ (JSC::MacroAssembler::subPtr):
+ (JSC::MacroAssembler::xorPtr):
+ (JSC::MacroAssembler::setPtr):
+ (JSC::MacroAssembler::storePtr):
+ (JSC::MacroAssembler::branchTestPtr):
+ (JSC::MacroAssembler::branchSubPtr):
+ (JSC::MacroAssembler::branchTest8):
+ * assembler/MacroAssemblerARM.h:
+ (JSC::MacroAssemblerARM::add32):
+ (JSC::MacroAssemblerARM::and32):
+ (JSC::MacroAssemblerARM::lshift32):
+ (JSC::MacroAssemblerARM::mul32):
+ (JSC::MacroAssemblerARM::or32):
+ (JSC::MacroAssemblerARM::rshift32):
+ (JSC::MacroAssemblerARM::urshift32):
+ (JSC::MacroAssemblerARM::sub32):
+ (JSC::MacroAssemblerARM::xor32):
+ (JSC::MacroAssemblerARM::store32):
+ (JSC::MacroAssemblerARM::push):
+ (JSC::MacroAssemblerARM::move):
+ (JSC::MacroAssemblerARM::branch8):
+ (JSC::MacroAssemblerARM::branch32):
+ (JSC::MacroAssemblerARM::branch32WithUnalignedHalfWords):
+ (JSC::MacroAssemblerARM::branch16):
+ (JSC::MacroAssemblerARM::branchTest8):
+ (JSC::MacroAssemblerARM::branchTest32):
+ (JSC::MacroAssemblerARM::branchAdd32):
+ (JSC::MacroAssemblerARM::branchMul32):
+ (JSC::MacroAssemblerARM::branchSub32):
+ (JSC::MacroAssemblerARM::set32Compare32):
+ (JSC::MacroAssemblerARM::set8Compare32):
+ (JSC::MacroAssemblerARM::set32Test32):
+ (JSC::MacroAssemblerARM::set32Test8):
+ (JSC::MacroAssemblerARM::moveWithPatch):
+ (JSC::MacroAssemblerARM::branchPtrWithPatch):
+ (JSC::MacroAssemblerARM::storePtrWithPatch):
+ * assembler/MacroAssemblerARMv7.h:
+ (JSC::MacroAssemblerARMv7::add32):
+ (JSC::MacroAssemblerARMv7::and32):
+ (JSC::MacroAssemblerARMv7::lshift32):
+ (JSC::MacroAssemblerARMv7::mul32):
+ (JSC::MacroAssemblerARMv7::or32):
+ (JSC::MacroAssemblerARMv7::rshift32):
+ (JSC::MacroAssemblerARMv7::urshift32):
+ (JSC::MacroAssemblerARMv7::sub32):
+ (JSC::MacroAssemblerARMv7::xor32):
+ (JSC::MacroAssemblerARMv7::load32):
+ (JSC::MacroAssemblerARMv7::load32WithAddressOffsetPatch):
+ (JSC::MacroAssemblerARMv7::load16):
+ (JSC::MacroAssemblerARMv7::store32WithAddressOffsetPatch):
+ (JSC::MacroAssemblerARMv7::store32):
+ (JSC::MacroAssemblerARMv7::loadDouble):
+ (JSC::MacroAssemblerARMv7::storeDouble):
+ (JSC::MacroAssemblerARMv7::push):
+ (JSC::MacroAssemblerARMv7::move):
+ (JSC::MacroAssemblerARMv7::compare32):
+ (JSC::MacroAssemblerARMv7::test32):
+ (JSC::MacroAssemblerARMv7::branch32):
+ (JSC::MacroAssemblerARMv7::branch32WithUnalignedHalfWords):
+ (JSC::MacroAssemblerARMv7::branch16):
+ (JSC::MacroAssemblerARMv7::branch8):
+ (JSC::MacroAssemblerARMv7::branchTest32):
+ (JSC::MacroAssemblerARMv7::branchTest8):
+ (JSC::MacroAssemblerARMv7::branchAdd32):
+ (JSC::MacroAssemblerARMv7::branchMul32):
+ (JSC::MacroAssemblerARMv7::branchSub32):
+ (JSC::MacroAssemblerARMv7::nearCall):
+ (JSC::MacroAssemblerARMv7::call):
+ (JSC::MacroAssemblerARMv7::set32Compare32):
+ (JSC::MacroAssemblerARMv7::set8Compare32):
+ (JSC::MacroAssemblerARMv7::set32Test32):
+ (JSC::MacroAssemblerARMv7::set32Test8):
+ (JSC::MacroAssemblerARMv7::moveWithPatch):
+ (JSC::MacroAssemblerARMv7::branchPtrWithPatch):
+ (JSC::MacroAssemblerARMv7::storePtrWithPatch):
+ (JSC::MacroAssemblerARMv7::tailRecursiveCall):
+ (JSC::MacroAssemblerARMv7::makeJump):
+ (JSC::MacroAssemblerARMv7::makeBranch):
+ (JSC::MacroAssemblerARMv7::setupArmAddress):
+ (JSC::MacroAssemblerARMv7::makeBaseIndexBase):
+ (JSC::MacroAssemblerARMv7::moveFixedWidthEncoding):
+ * assembler/MacroAssemblerMIPS.h:
+ (JSC::MacroAssemblerMIPS::add32):
+ (JSC::MacroAssemblerMIPS::and32):
+ (JSC::MacroAssemblerMIPS::lshift32):
+ (JSC::MacroAssemblerMIPS::mul32):
+ (JSC::MacroAssemblerMIPS::or32):
+ (JSC::MacroAssemblerMIPS::rshift32):
+ (JSC::MacroAssemblerMIPS::urshift32):
+ (JSC::MacroAssemblerMIPS::sub32):
+ (JSC::MacroAssemblerMIPS::xor32):
+ (JSC::MacroAssemblerMIPS::load32):
+ (JSC::MacroAssemblerMIPS::load32WithAddressOffsetPatch):
+ (JSC::MacroAssemblerMIPS::store32WithAddressOffsetPatch):
+ (JSC::MacroAssemblerMIPS::store32):
+ (JSC::MacroAssemblerMIPS::push):
+ (JSC::MacroAssemblerMIPS::move):
+ (JSC::MacroAssemblerMIPS::branch8):
+ (JSC::MacroAssemblerMIPS::branch32):
+ (JSC::MacroAssemblerMIPS::branch32WithUnalignedHalfWords):
+ (JSC::MacroAssemblerMIPS::branch16):
+ (JSC::MacroAssemblerMIPS::branchTest32):
+ (JSC::MacroAssemblerMIPS::branchTest8):
+ (JSC::MacroAssemblerMIPS::branchAdd32):
+ (JSC::MacroAssemblerMIPS::branchMul32):
+ (JSC::MacroAssemblerMIPS::branchSub32):
+ (JSC::MacroAssemblerMIPS::set8Compare32):
+ (JSC::MacroAssemblerMIPS::set32Compare32):
+ (JSC::MacroAssemblerMIPS::set32Test8):
+ (JSC::MacroAssemblerMIPS::set32Test32):
+ (JSC::MacroAssemblerMIPS::moveWithPatch):
+ (JSC::MacroAssemblerMIPS::branchPtrWithPatch):
+ (JSC::MacroAssemblerMIPS::storePtrWithPatch):
+ (JSC::MacroAssemblerMIPS::tailRecursiveCall):
+ (JSC::MacroAssemblerMIPS::loadDouble):
+ (JSC::MacroAssemblerMIPS::storeDouble):
+ (JSC::MacroAssemblerMIPS::branchTruncateDoubleToInt32):
+ * assembler/MacroAssemblerX86.h:
+ (JSC::MacroAssemblerX86::add32):
+ (JSC::MacroAssemblerX86::addWithCarry32):
+ (JSC::MacroAssemblerX86::and32):
+ (JSC::MacroAssemblerX86::or32):
+ (JSC::MacroAssemblerX86::sub32):
+ (JSC::MacroAssemblerX86::store32):
+ (JSC::MacroAssemblerX86::branch32):
+ (JSC::MacroAssemblerX86::moveWithPatch):
+ (JSC::MacroAssemblerX86::branchPtrWithPatch):
+ (JSC::MacroAssemblerX86::storePtrWithPatch):
+ * assembler/MacroAssemblerX86Common.h:
+ (JSC::MacroAssemblerX86Common::add32):
+ (JSC::MacroAssemblerX86Common::and32):
+ (JSC::MacroAssemblerX86Common::lshift32):
+ (JSC::MacroAssemblerX86Common::mul32):
+ (JSC::MacroAssemblerX86Common::or32):
+ (JSC::MacroAssemblerX86Common::rshift32):
+ (JSC::MacroAssemblerX86Common::urshift32):
+ (JSC::MacroAssemblerX86Common::sub32):
+ (JSC::MacroAssemblerX86Common::xor32):
+ (JSC::MacroAssemblerX86Common::store32):
+ (JSC::MacroAssemblerX86Common::branchTruncateDoubleToInt32):
+ (JSC::MacroAssemblerX86Common::push):
+ (JSC::MacroAssemblerX86Common::move):
+ (JSC::MacroAssemblerX86Common::branch8):
+ (JSC::MacroAssemblerX86Common::branch32):
+ (JSC::MacroAssemblerX86Common::branch32WithUnalignedHalfWords):
+ (JSC::MacroAssemblerX86Common::branch16):
+ (JSC::MacroAssemblerX86Common::branchTest32):
+ (JSC::MacroAssemblerX86Common::branchTest8):
+ (JSC::MacroAssemblerX86Common::branchAdd32):
+ (JSC::MacroAssemblerX86Common::branchMul32):
+ (JSC::MacroAssemblerX86Common::branchSub32):
+ (JSC::MacroAssemblerX86Common::set8Compare32):
+ (JSC::MacroAssemblerX86Common::set32Compare32):
+ (JSC::MacroAssemblerX86Common::set32Test8):
+ (JSC::MacroAssemblerX86Common::set32Test32):
+ * assembler/MacroAssemblerX86_64.h:
+ (JSC::MacroAssemblerX86_64::add32):
+ (JSC::MacroAssemblerX86_64::and32):
+ (JSC::MacroAssemblerX86_64::or32):
+ (JSC::MacroAssemblerX86_64::sub32):
+ (JSC::MacroAssemblerX86_64::loadDouble):
+ (JSC::MacroAssemblerX86_64::addDouble):
+ (JSC::MacroAssemblerX86_64::convertInt32ToDouble):
+ (JSC::MacroAssemblerX86_64::store32):
+ (JSC::MacroAssemblerX86_64::call):
+ (JSC::MacroAssemblerX86_64::tailRecursiveCall):
+ (JSC::MacroAssemblerX86_64::makeTailRecursiveCall):
+ (JSC::MacroAssemblerX86_64::addPtr):
+ (JSC::MacroAssemblerX86_64::andPtr):
+ (JSC::MacroAssemblerX86_64::orPtr):
+ (JSC::MacroAssemblerX86_64::subPtr):
+ (JSC::MacroAssemblerX86_64::xorPtr):
+ (JSC::MacroAssemblerX86_64::storePtr):
+ (JSC::MacroAssemblerX86_64::setPtr):
+ (JSC::MacroAssemblerX86_64::branchPtr):
+ (JSC::MacroAssemblerX86_64::branchTestPtr):
+ (JSC::MacroAssemblerX86_64::branchSubPtr):
+ (JSC::MacroAssemblerX86_64::moveWithPatch):
+ (JSC::MacroAssemblerX86_64::branchPtrWithPatch):
+ (JSC::MacroAssemblerX86_64::storePtrWithPatch):
+ (JSC::MacroAssemblerX86_64::branchTest8):
+ * dfg/DFGJITCodeGenerator.h:
+ (JSC::DFG::JITCodeGenerator::callOperation):
+ * dfg/DFGJITCompiler.cpp:
+ (JSC::DFG::JITCompiler::jitAssertIsInt32):
+ (JSC::DFG::JITCompiler::emitCount):
+ * dfg/DFGJITCompiler.h:
+ (JSC::DFG::JITCompiler::emitPutImmediateToCallFrameHeader):
+ * dfg/DFGNonSpeculativeJIT.cpp:
+ (JSC::DFG::NonSpeculativeJIT::compile):
+ * dfg/DFGSpeculativeJIT.cpp:
+ (JSC::DFG::SpeculativeJIT::fillSpeculateCell):
+ (JSC::DFG::SpeculativeJIT::compile):
+ * jit/JIT.cpp:
+ (JSC::JIT::emitTimeoutCheck):
+ (JSC::JIT::privateCompile):
+ * jit/JIT.h:
+ * jit/JITArithmetic.cpp:
+ (JSC::JIT::emit_op_urshift):
+ (JSC::JIT::emitSlow_op_urshift):
+ (JSC::JIT::emit_op_post_inc):
+ (JSC::JIT::emit_op_post_dec):
+ (JSC::JIT::emit_op_pre_inc):
+ (JSC::JIT::emit_op_pre_dec):
+ (JSC::JIT::emit_op_mod):
+ * jit/JITArithmetic32_64.cpp:
+ (JSC::JIT::emit_op_negate):
+ (JSC::JIT::emit_op_jnless):
+ (JSC::JIT::emit_op_jless):
+ (JSC::JIT::emit_op_jlesseq):
+ (JSC::JIT::emit_op_lshift):
+ (JSC::JIT::emitRightShift):
+ (JSC::JIT::emitRightShiftSlowCase):
+ (JSC::JIT::emit_op_bitand):
+ (JSC::JIT::emit_op_bitor):
+ (JSC::JIT::emit_op_bitxor):
+ (JSC::JIT::emit_op_bitnot):
+ (JSC::JIT::emit_op_post_inc):
+ (JSC::JIT::emit_op_post_dec):
+ (JSC::JIT::emitSlow_op_post_dec):
+ (JSC::JIT::emit_op_pre_inc):
+ (JSC::JIT::emit_op_pre_dec):
+ (JSC::JIT::emit_op_add):
+ (JSC::JIT::emitAdd32Constant):
+ (JSC::JIT::emit_op_sub):
+ (JSC::JIT::emitSub32Constant):
+ (JSC::JIT::emitBinaryDoubleOp):
+ (JSC::JIT::emit_op_mul):
+ (JSC::JIT::emitSlow_op_mul):
+ (JSC::JIT::emit_op_div):
+ (JSC::JIT::emit_op_mod):
+ * jit/JITCall.cpp:
+ (JSC::JIT::compileOpCallVarargs):
+ (JSC::JIT::compileOpCall):
+ (JSC::JIT::compileOpCallSlowCase):
+ * jit/JITCall32_64.cpp:
+ (JSC::JIT::compileOpCallVarargs):
+ (JSC::JIT::emit_op_ret_object_or_this):
+ (JSC::JIT::compileOpCall):
+ (JSC::JIT::compileOpCallSlowCase):
+ * jit/JITInlineMethods.h:
+ (JSC::JIT::emitPutCellToCallFrameHeader):
+ (JSC::JIT::emitPutIntToCallFrameHeader):
+ (JSC::JIT::emitPutImmediateToCallFrameHeader):
+ (JSC::JIT::emitLoadCharacterString):
+ (JSC::JIT::restoreArgumentReferenceForTrampoline):
+ (JSC::JIT::checkStructure):
+ (JSC::JIT::setSamplingFlag):
+ (JSC::JIT::clearSamplingFlag):
+ (JSC::JIT::emitCount):
+ (JSC::JIT::sampleInstruction):
+ (JSC::JIT::sampleCodeBlock):
+ (JSC::JIT::emitStoreInt32):
+ (JSC::JIT::emitStoreCell):
+ (JSC::JIT::emitStoreBool):
+ (JSC::JIT::emitJumpSlowCaseIfNotJSCell):
+ (JSC::JIT::emitInitRegister):
+ (JSC::JIT::emitJumpIfJSCell):
+ (JSC::JIT::emitJumpIfNotJSCell):
+ (JSC::JIT::emitJumpIfImmediateInteger):
+ (JSC::JIT::emitJumpIfNotImmediateInteger):
+ (JSC::JIT::emitFastArithDeTagImmediate):
+ (JSC::JIT::emitFastArithDeTagImmediateJumpIfZero):
+ (JSC::JIT::emitFastArithReTagImmediate):
+ (JSC::JIT::emitTagAsBoolImmediate):
+ * jit/JITOpcodes.cpp:
+ (JSC::JIT::privateCompileCTIMachineTrampolines):
+ (JSC::JIT::privateCompileCTINativeCall):
+ (JSC::JIT::emit_op_check_has_instance):
+ (JSC::JIT::emit_op_instanceof):
+ (JSC::JIT::emit_op_ret_object_or_this):
+ (JSC::JIT::emit_op_resolve):
+ (JSC::JIT::emit_op_to_primitive):
+ (JSC::JIT::emit_op_resolve_base):
+ (JSC::JIT::emit_op_ensure_property_exists):
+ (JSC::JIT::emit_op_resolve_skip):
+ (JSC::JIT::emit_op_resolve_global):
+ (JSC::JIT::emitSlow_op_resolve_global):
+ (JSC::JIT::emit_op_not):
+ (JSC::JIT::emit_op_jfalse):
+ (JSC::JIT::emit_op_jeq_null):
+ (JSC::JIT::emit_op_jneq_null):
+ (JSC::JIT::emit_op_jneq_ptr):
+ (JSC::JIT::emit_op_jsr):
+ (JSC::JIT::emit_op_resolve_with_base):
+ (JSC::JIT::emit_op_new_func_exp):
+ (JSC::JIT::emit_op_jtrue):
+ (JSC::JIT::emit_op_get_pnames):
+ (JSC::JIT::emit_op_next_pname):
+ (JSC::JIT::emit_op_to_jsnumber):
+ (JSC::JIT::emit_op_push_new_scope):
+ (JSC::JIT::emit_op_catch):
+ (JSC::JIT::emit_op_eq_null):
+ (JSC::JIT::emit_op_neq_null):
+ (JSC::JIT::emit_op_init_lazy_reg):
+ (JSC::JIT::emit_op_convert_this):
+ (JSC::JIT::emit_op_convert_this_strict):
+ (JSC::JIT::emitSlow_op_not):
+ (JSC::JIT::emitSlow_op_neq):
+ (JSC::JIT::emit_op_get_arguments_length):
+ (JSC::JIT::emitSlow_op_get_arguments_length):
+ (JSC::JIT::emit_op_get_argument_by_val):
+ (JSC::JIT::emitSlow_op_resolve_global_dynamic):
+ (JSC::JIT::emit_op_new_regexp):
+ (JSC::JIT::emit_op_load_varargs):
+ (JSC::JIT::emitSlow_op_load_varargs):
+ (JSC::JIT::emit_op_new_func):
+ * jit/JITOpcodes32_64.cpp:
+ (JSC::JIT::privateCompileCTIMachineTrampolines):
+ (JSC::JIT::privateCompileCTINativeCall):
+ (JSC::JIT::emit_op_loop_if_lesseq):
+ (JSC::JIT::emit_op_check_has_instance):
+ (JSC::JIT::emit_op_instanceof):
+ (JSC::JIT::emit_op_get_scoped_var):
+ (JSC::JIT::emit_op_put_scoped_var):
+ (JSC::JIT::emit_op_tear_off_activation):
+ (JSC::JIT::emit_op_tear_off_arguments):
+ (JSC::JIT::emit_op_resolve):
+ (JSC::JIT::emit_op_to_primitive):
+ (JSC::JIT::emit_op_resolve_base):
+ (JSC::JIT::emit_op_ensure_property_exists):
+ (JSC::JIT::emit_op_resolve_skip):
+ (JSC::JIT::emit_op_resolve_global):
+ (JSC::JIT::emitSlow_op_resolve_global):
+ (JSC::JIT::emit_op_not):
+ (JSC::JIT::emit_op_jfalse):
+ (JSC::JIT::emit_op_jtrue):
+ (JSC::JIT::emit_op_jeq_null):
+ (JSC::JIT::emit_op_jneq_null):
+ (JSC::JIT::emit_op_jneq_ptr):
+ (JSC::JIT::emit_op_jsr):
+ (JSC::JIT::emit_op_eq):
+ (JSC::JIT::emitSlow_op_eq):
+ (JSC::JIT::emit_op_neq):
+ (JSC::JIT::emitSlow_op_neq):
+ (JSC::JIT::compileOpStrictEq):
+ (JSC::JIT::emit_op_eq_null):
+ (JSC::JIT::emit_op_neq_null):
+ (JSC::JIT::emit_op_resolve_with_base):
+ (JSC::JIT::emit_op_new_func_exp):
+ (JSC::JIT::emit_op_get_pnames):
+ (JSC::JIT::emit_op_next_pname):
+ (JSC::JIT::emit_op_to_jsnumber):
+ (JSC::JIT::emit_op_push_new_scope):
+ (JSC::JIT::emit_op_catch):
+ (JSC::JIT::emit_op_create_activation):
+ (JSC::JIT::emit_op_create_arguments):
+ (JSC::JIT::emit_op_convert_this):
+ (JSC::JIT::emit_op_convert_this_strict):
+ (JSC::JIT::emit_op_get_arguments_length):
+ (JSC::JIT::emitSlow_op_get_arguments_length):
+ (JSC::JIT::emit_op_get_argument_by_val):
+ (JSC::JIT::softModulo):
+ * jit/JITPropertyAccess.cpp:
+ (JSC::JIT::stringGetByValStubGenerator):
+ (JSC::JIT::emit_op_get_by_val):
+ (JSC::JIT::emitSlow_op_get_by_val):
+ (JSC::JIT::emit_op_get_by_pname):
+ (JSC::JIT::emit_op_put_by_val):
+ (JSC::JIT::emit_op_put_by_index):
+ (JSC::JIT::emit_op_put_getter):
+ (JSC::JIT::emit_op_put_setter):
+ (JSC::JIT::emit_op_del_by_id):
+ (JSC::JIT::emit_op_get_by_id):
+ (JSC::JIT::emit_op_put_by_id):
+ (JSC::JIT::emit_op_method_check):
+ (JSC::JIT::compileGetByIdHotPath):
+ (JSC::JIT::compileGetByIdSlowCase):
+ (JSC::JIT::emitSlow_op_put_by_id):
+ (JSC::JIT::testPrototype):
+ (JSC::JIT::privateCompilePutByIdTransition):
+ (JSC::JIT::privateCompilePatchGetArrayLength):
+ (JSC::JIT::privateCompileGetByIdProto):
+ (JSC::JIT::privateCompileGetByIdSelfList):
+ (JSC::JIT::privateCompileGetByIdProtoList):
+ (JSC::JIT::privateCompileGetByIdChainList):
+ (JSC::JIT::privateCompileGetByIdChain):
+ * jit/JITPropertyAccess32_64.cpp:
+ (JSC::JIT::emit_op_put_getter):
+ (JSC::JIT::emit_op_put_setter):
+ (JSC::JIT::emit_op_del_by_id):
+ (JSC::JIT::emit_op_get_by_id):
+ (JSC::JIT::emit_op_put_by_id):
+ (JSC::JIT::emit_op_method_check):
+ (JSC::JIT::stringGetByValStubGenerator):
+ (JSC::JIT::emit_op_get_by_val):
+ (JSC::JIT::emitSlow_op_get_by_val):
+ (JSC::JIT::emit_op_put_by_val):
+ (JSC::JIT::compileGetByIdHotPath):
+ (JSC::JIT::compileGetByIdSlowCase):
+ (JSC::JIT::emitSlow_op_put_by_id):
+ (JSC::JIT::testPrototype):
+ (JSC::JIT::privateCompilePutByIdTransition):
+ (JSC::JIT::privateCompilePatchGetArrayLength):
+ (JSC::JIT::privateCompileGetByIdProto):
+ (JSC::JIT::privateCompileGetByIdSelfList):
+ (JSC::JIT::privateCompileGetByIdProtoList):
+ (JSC::JIT::privateCompileGetByIdChainList):
+ (JSC::JIT::privateCompileGetByIdChain):
+ (JSC::JIT::emit_op_get_by_pname):
+ * jit/JITStubCall.h:
+ (JSC::JITStubCall::addArgument):
+ * jit/JITStubs.cpp:
+ (JSC::getPolymorphicAccessStructureListSlot):
+ (JSC::DEFINE_STUB_FUNCTION):
+ * jit/JSInterfaceJIT.h:
+ (JSC::JSInterfaceJIT::emitJumpIfNotJSCell):
+ (JSC::JSInterfaceJIT::emitLoadInt32):
+ (JSC::JSInterfaceJIT::emitLoadDouble):
+ * jit/SpecializedThunkJIT.h:
+ (JSC::SpecializedThunkJIT::SpecializedThunkJIT):
+ (JSC::SpecializedThunkJIT::loadJSStringArgument):
+ (JSC::SpecializedThunkJIT::tagReturnAsInt32):
+ (JSC::SpecializedThunkJIT::tagReturnAsJSCell):
+ * jit/ThunkGenerators.cpp:
+ (JSC::charToString):
+ (JSC::powThunkGenerator):
+ * yarr/YarrJIT.cpp:
+ (JSC::Yarr::YarrGenerator::matchCharacterClass):
+ (JSC::Yarr::YarrGenerator::storeToFrame):
+ (JSC::Yarr::YarrGenerator::storeToFrameWithPatch):
+ (JSC::Yarr::YarrGenerator::ParenthesesTail::generateCode):
+ (JSC::Yarr::YarrGenerator::generatePatternCharacterSingle):
+ (JSC::Yarr::YarrGenerator::generatePatternCharacterFixed):
+ (JSC::Yarr::YarrGenerator::generatePatternCharacterGreedy):
+ (JSC::Yarr::YarrGenerator::generatePatternCharacterNonGreedy):
+ (JSC::Yarr::YarrGenerator::generateCharacterClassFixed):
+ (JSC::Yarr::YarrGenerator::generateCharacterClassGreedy):
+ (JSC::Yarr::YarrGenerator::generateCharacterClassNonGreedy):
+ (JSC::Yarr::YarrGenerator::generateParenthesesSingle):
+ (JSC::Yarr::YarrGenerator::generateDisjunction):
+
</ins><span class="cx"> 2011-03-28 Andras Becsi <abecsi@webkit.org>
</span><span class="cx">
</span><span class="cx"> Reviewed by Csaba Osztrogonác.
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerAbstractMacroAssemblerh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/AbstractMacroAssembler.h (82129 => 82130)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/AbstractMacroAssembler.h 2011-03-28 17:10:30 UTC (rev 82129)
+++ trunk/Source/JavaScriptCore/assembler/AbstractMacroAssembler.h 2011-03-28 17:14:57 UTC (rev 82130)
</span><span class="lines">@@ -153,13 +153,13 @@
</span><span class="cx"> const void* m_ptr;
</span><span class="cx"> };
</span><span class="cx">
</span><del>- // ImmPtr:
</del><ins>+ // TrustedImmPtr:
</ins><span class="cx"> //
</span><span class="cx"> // A pointer sized immediate operand to an instruction - this is wrapped
</span><span class="cx"> // in a class requiring explicit construction in order to differentiate
</span><span class="cx"> // from pointers used as absolute addresses to memory operations
</span><del>- struct ImmPtr {
- explicit ImmPtr(const void* value)
</del><ins>+ struct TrustedImmPtr {
+ explicit TrustedImmPtr(const void* value)
</ins><span class="cx"> : m_value(value)
</span><span class="cx"> {
</span><span class="cx"> }
</span><span class="lines">@@ -172,14 +172,21 @@
</span><span class="cx"> const void* m_value;
</span><span class="cx"> };
</span><span class="cx">
</span><del>- // Imm32:
</del><ins>+ struct ImmPtr : public TrustedImmPtr {
+ explicit ImmPtr(const void* value)
+ : TrustedImmPtr(value)
+ {
+ }
+ };
+
+ // TrustedImm32:
</ins><span class="cx"> //
</span><span class="cx"> // A 32bit immediate operand to an instruction - this is wrapped in a
</span><span class="cx"> // class requiring explicit construction in order to prevent RegisterIDs
</span><span class="cx"> // (which are implemented as an enum) from accidentally being passed as
</span><span class="cx"> // immediate values.
</span><del>- struct Imm32 {
- explicit Imm32(int32_t value)
</del><ins>+ struct TrustedImm32 {
+ explicit TrustedImm32(int32_t value)
</ins><span class="cx"> : m_value(value)
</span><span class="cx"> #if CPU(ARM) || CPU(MIPS)
</span><span class="cx"> , m_isPointer(false)
</span><span class="lines">@@ -188,7 +195,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> #if !CPU(X86_64)
</span><del>- explicit Imm32(ImmPtr ptr)
</del><ins>+ explicit TrustedImm32(TrustedImmPtr ptr)
</ins><span class="cx"> : m_value(ptr.asIntptr())
</span><span class="cx"> #if CPU(ARM) || CPU(MIPS)
</span><span class="cx"> , m_isPointer(true)
</span><span class="lines">@@ -211,6 +218,19 @@
</span><span class="cx"> };
</span><span class="cx">
</span><span class="cx">
</span><ins>+ struct Imm32 : public TrustedImm32 {
+ explicit Imm32(int32_t value)
+ : TrustedImm32(value)
+ {
+ }
+#if !CPU(X86_64)
+ explicit Imm32(TrustedImmPtr ptr)
+ : TrustedImm32(ptr)
+ {
+ }
+#endif
+ };
+
</ins><span class="cx"> // Section 2: MacroAssembler code buffer handles
</span><span class="cx"> //
</span><span class="cx"> // The following types are used to reference items in the code buffer
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerMacroAssemblerh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/MacroAssembler.h (82129 => 82130)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssembler.h 2011-03-28 17:10:30 UTC (rev 82129)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssembler.h 2011-03-28 17:14:57 UTC (rev 82130)
</span><span class="lines">@@ -74,7 +74,7 @@
</span><span class="cx"> // described in terms of other macro assembly methods.
</span><span class="cx"> void pop()
</span><span class="cx"> {
</span><del>- addPtr(Imm32(sizeof(void*)), stackPointerRegister);
</del><ins>+ addPtr(TrustedImm32(sizeof(void*)), stackPointerRegister);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void peek(RegisterID dest, int index = 0)
</span><span class="lines">@@ -87,19 +87,19 @@
</span><span class="cx"> storePtr(src, Address(stackPointerRegister, (index * sizeof(void*))));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void poke(Imm32 value, int index = 0)
</del><ins>+ void poke(TrustedImm32 value, int index = 0)
</ins><span class="cx"> {
</span><span class="cx"> store32(value, Address(stackPointerRegister, (index * sizeof(void*))));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void poke(ImmPtr imm, int index = 0)
</del><ins>+ void poke(TrustedImmPtr imm, int index = 0)
</ins><span class="cx"> {
</span><span class="cx"> storePtr(imm, Address(stackPointerRegister, (index * sizeof(void*))));
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx">
</span><span class="cx"> // Backwards banches, these are currently all implemented using existing forwards branch mechanisms.
</span><del>- void branchPtr(Condition cond, RegisterID op1, ImmPtr imm, Label target)
</del><ins>+ void branchPtr(Condition cond, RegisterID op1, TrustedImmPtr imm, Label target)
</ins><span class="cx"> {
</span><span class="cx"> branchPtr(cond, op1, imm).linkTo(target, this);
</span><span class="cx"> }
</span><span class="lines">@@ -109,7 +109,7 @@
</span><span class="cx"> branch32(cond, op1, op2).linkTo(target, this);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void branch32(Condition cond, RegisterID op1, Imm32 imm, Label target)
</del><ins>+ void branch32(Condition cond, RegisterID op1, TrustedImm32 imm, Label target)
</ins><span class="cx"> {
</span><span class="cx"> branch32(cond, op1, imm).linkTo(target, this);
</span><span class="cx"> }
</span><span class="lines">@@ -144,17 +144,17 @@
</span><span class="cx"> add32(src, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void addPtr(Imm32 imm, RegisterID srcDest)
</del><ins>+ void addPtr(TrustedImm32 imm, RegisterID srcDest)
</ins><span class="cx"> {
</span><span class="cx"> add32(imm, srcDest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void addPtr(ImmPtr imm, RegisterID dest)
</del><ins>+ void addPtr(TrustedImmPtr imm, RegisterID dest)
</ins><span class="cx"> {
</span><del>- add32(Imm32(imm), dest);
</del><ins>+ add32(TrustedImm32(imm), dest);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>- void addPtr(Imm32 imm, RegisterID src, RegisterID dest)
</del><ins>+ void addPtr(TrustedImm32 imm, RegisterID src, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> add32(imm, src, dest);
</span><span class="cx"> }
</span><span class="lines">@@ -164,7 +164,7 @@
</span><span class="cx"> and32(src, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void andPtr(Imm32 imm, RegisterID srcDest)
</del><ins>+ void andPtr(TrustedImm32 imm, RegisterID srcDest)
</ins><span class="cx"> {
</span><span class="cx"> and32(imm, srcDest);
</span><span class="cx"> }
</span><span class="lines">@@ -174,12 +174,12 @@
</span><span class="cx"> or32(src, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void orPtr(ImmPtr imm, RegisterID dest)
</del><ins>+ void orPtr(TrustedImmPtr imm, RegisterID dest)
</ins><span class="cx"> {
</span><del>- or32(Imm32(imm), dest);
</del><ins>+ or32(TrustedImm32(imm), dest);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>- void orPtr(Imm32 imm, RegisterID dest)
</del><ins>+ void orPtr(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> or32(imm, dest);
</span><span class="cx"> }
</span><span class="lines">@@ -189,14 +189,14 @@
</span><span class="cx"> sub32(src, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void subPtr(Imm32 imm, RegisterID dest)
</del><ins>+ void subPtr(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> sub32(imm, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void subPtr(ImmPtr imm, RegisterID dest)
</del><ins>+ void subPtr(TrustedImmPtr imm, RegisterID dest)
</ins><span class="cx"> {
</span><del>- sub32(Imm32(imm), dest);
</del><ins>+ sub32(TrustedImm32(imm), dest);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void xorPtr(RegisterID src, RegisterID dest)
</span><span class="lines">@@ -204,7 +204,7 @@
</span><span class="cx"> xor32(src, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void xorPtr(Imm32 imm, RegisterID srcDest)
</del><ins>+ void xorPtr(TrustedImm32 imm, RegisterID srcDest)
</ins><span class="cx"> {
</span><span class="cx"> xor32(imm, srcDest);
</span><span class="cx"> }
</span><span class="lines">@@ -230,7 +230,7 @@
</span><span class="cx"> return load32WithAddressOffsetPatch(address, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void setPtr(Condition cond, RegisterID left, Imm32 right, RegisterID dest)
</del><ins>+ void setPtr(Condition cond, RegisterID left, TrustedImm32 right, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> set32Compare32(cond, left, right, dest);
</span><span class="cx"> }
</span><span class="lines">@@ -250,14 +250,14 @@
</span><span class="cx"> store32(src, address);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void storePtr(ImmPtr imm, ImplicitAddress address)
</del><ins>+ void storePtr(TrustedImmPtr imm, ImplicitAddress address)
</ins><span class="cx"> {
</span><del>- store32(Imm32(imm), address);
</del><ins>+ store32(TrustedImm32(imm), address);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>- void storePtr(ImmPtr imm, void* address)
</del><ins>+ void storePtr(TrustedImmPtr imm, void* address)
</ins><span class="cx"> {
</span><del>- store32(Imm32(imm), address);
</del><ins>+ store32(TrustedImm32(imm), address);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> DataLabel32 storePtrWithAddressOffsetPatch(RegisterID src, Address address)
</span><span class="lines">@@ -271,9 +271,9 @@
</span><span class="cx"> return branch32(cond, left, right);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchPtr(Condition cond, RegisterID left, ImmPtr right)
</del><ins>+ Jump branchPtr(Condition cond, RegisterID left, TrustedImmPtr right)
</ins><span class="cx"> {
</span><del>- return branch32(cond, left, Imm32(right));
</del><ins>+ return branch32(cond, left, TrustedImm32(right));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> Jump branchPtr(Condition cond, RegisterID left, Address right)
</span><span class="lines">@@ -291,14 +291,14 @@
</span><span class="cx"> return branch32(cond, left, right);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchPtr(Condition cond, Address left, ImmPtr right)
</del><ins>+ Jump branchPtr(Condition cond, Address left, TrustedImmPtr right)
</ins><span class="cx"> {
</span><del>- return branch32(cond, left, Imm32(right));
</del><ins>+ return branch32(cond, left, TrustedImm32(right));
</ins><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchPtr(Condition cond, AbsoluteAddress left, ImmPtr right)
</del><ins>+ Jump branchPtr(Condition cond, AbsoluteAddress left, TrustedImmPtr right)
</ins><span class="cx"> {
</span><del>- return branch32(cond, left, Imm32(right));
</del><ins>+ return branch32(cond, left, TrustedImm32(right));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> Jump branchTestPtr(Condition cond, RegisterID reg, RegisterID mask)
</span><span class="lines">@@ -306,17 +306,17 @@
</span><span class="cx"> return branchTest32(cond, reg, mask);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchTestPtr(Condition cond, RegisterID reg, Imm32 mask = Imm32(-1))
</del><ins>+ Jump branchTestPtr(Condition cond, RegisterID reg, TrustedImm32 mask = TrustedImm32(-1))
</ins><span class="cx"> {
</span><span class="cx"> return branchTest32(cond, reg, mask);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchTestPtr(Condition cond, Address address, Imm32 mask = Imm32(-1))
</del><ins>+ Jump branchTestPtr(Condition cond, Address address, TrustedImm32 mask = TrustedImm32(-1))
</ins><span class="cx"> {
</span><span class="cx"> return branchTest32(cond, address, mask);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchTestPtr(Condition cond, BaseIndex address, Imm32 mask = Imm32(-1))
</del><ins>+ Jump branchTestPtr(Condition cond, BaseIndex address, TrustedImm32 mask = TrustedImm32(-1))
</ins><span class="cx"> {
</span><span class="cx"> return branchTest32(cond, address, mask);
</span><span class="cx"> }
</span><span class="lines">@@ -327,12 +327,12 @@
</span><span class="cx"> return branchAdd32(cond, src, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchSubPtr(Condition cond, Imm32 imm, RegisterID dest)
</del><ins>+ Jump branchSubPtr(Condition cond, TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> return branchSub32(cond, imm, dest);
</span><span class="cx"> }
</span><span class="cx"> using MacroAssemblerBase::branchTest8;
</span><del>- Jump branchTest8(Condition cond, ExtendedAddress address, Imm32 mask = Imm32(-1))
</del><ins>+ Jump branchTest8(Condition cond, ExtendedAddress address, TrustedImm32 mask = TrustedImm32(-1))
</ins><span class="cx"> {
</span><span class="cx"> return MacroAssemblerBase::branchTest8(cond, Address(address.base, address.offset), mask);
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerMacroAssemblerARMh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM.h (82129 => 82130)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM.h 2011-03-28 17:10:30 UTC (rev 82129)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM.h 2011-03-28 17:14:57 UTC (rev 82130)
</span><span class="lines">@@ -86,14 +86,14 @@
</span><span class="cx"> m_assembler.adds_r(dest, dest, src);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void add32(Imm32 imm, Address address)
</del><ins>+ void add32(TrustedImm32 imm, Address address)
</ins><span class="cx"> {
</span><span class="cx"> load32(address, ARMRegisters::S1);
</span><span class="cx"> add32(imm, ARMRegisters::S1);
</span><span class="cx"> store32(ARMRegisters::S1, address);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void add32(Imm32 imm, RegisterID dest)
</del><ins>+ void add32(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.adds_r(dest, dest, m_assembler.getImm(imm.m_value, ARMRegisters::S0));
</span><span class="cx"> }
</span><span class="lines">@@ -109,7 +109,7 @@
</span><span class="cx"> m_assembler.ands_r(dest, dest, src);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void and32(Imm32 imm, RegisterID dest)
</del><ins>+ void and32(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> ARMWord w = m_assembler.getImm(imm.m_value, ARMRegisters::S0, true);
</span><span class="cx"> if (w & ARMAssembler::OP2_INV_IMM)
</span><span class="lines">@@ -127,7 +127,7 @@
</span><span class="cx"> m_assembler.movs_r(dest, m_assembler.lsl_r(dest, ARMRegisters::S0));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void lshift32(Imm32 imm, RegisterID dest)
</del><ins>+ void lshift32(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.movs_r(dest, m_assembler.lsl(dest, imm.m_value & 0x1f));
</span><span class="cx"> }
</span><span class="lines">@@ -141,7 +141,7 @@
</span><span class="cx"> m_assembler.muls_r(dest, dest, src);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void mul32(Imm32 imm, RegisterID src, RegisterID dest)
</del><ins>+ void mul32(TrustedImm32 imm, RegisterID src, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> move(imm, ARMRegisters::S0);
</span><span class="cx"> m_assembler.muls_r(dest, src, ARMRegisters::S0);
</span><span class="lines">@@ -162,7 +162,7 @@
</span><span class="cx"> m_assembler.orrs_r(dest, dest, src);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void or32(Imm32 imm, RegisterID dest)
</del><ins>+ void or32(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.orrs_r(dest, dest, m_assembler.getImm(imm.m_value, ARMRegisters::S0));
</span><span class="cx"> }
</span><span class="lines">@@ -176,7 +176,7 @@
</span><span class="cx"> m_assembler.movs_r(dest, m_assembler.asr_r(dest, ARMRegisters::S0));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void rshift32(Imm32 imm, RegisterID dest)
</del><ins>+ void rshift32(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.movs_r(dest, m_assembler.asr(dest, imm.m_value & 0x1f));
</span><span class="cx"> }
</span><span class="lines">@@ -190,7 +190,7 @@
</span><span class="cx"> m_assembler.movs_r(dest, m_assembler.lsr_r(dest, ARMRegisters::S0));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void urshift32(Imm32 imm, RegisterID dest)
</del><ins>+ void urshift32(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.movs_r(dest, m_assembler.lsr(dest, imm.m_value & 0x1f));
</span><span class="cx"> }
</span><span class="lines">@@ -200,12 +200,12 @@
</span><span class="cx"> m_assembler.subs_r(dest, dest, src);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void sub32(Imm32 imm, RegisterID dest)
</del><ins>+ void sub32(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.subs_r(dest, dest, m_assembler.getImm(imm.m_value, ARMRegisters::S0));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void sub32(Imm32 imm, Address address)
</del><ins>+ void sub32(TrustedImm32 imm, Address address)
</ins><span class="cx"> {
</span><span class="cx"> load32(address, ARMRegisters::S1);
</span><span class="cx"> sub32(imm, ARMRegisters::S1);
</span><span class="lines">@@ -223,7 +223,7 @@
</span><span class="cx"> m_assembler.eors_r(dest, dest, src);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void xor32(Imm32 imm, RegisterID dest)
</del><ins>+ void xor32(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.eors_r(dest, dest, m_assembler.getImm(imm.m_value, ARMRegisters::S0));
</span><span class="cx"> }
</span><span class="lines">@@ -303,7 +303,7 @@
</span><span class="cx"> m_assembler.baseIndexTransfer32(false, src, address.base, address.index, static_cast<int>(address.scale), address.offset);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void store32(Imm32 imm, ImplicitAddress address)
</del><ins>+ void store32(TrustedImm32 imm, ImplicitAddress address)
</ins><span class="cx"> {
</span><span class="cx"> if (imm.m_isPointer)
</span><span class="cx"> m_assembler.ldr_un_imm(ARMRegisters::S1, imm.m_value);
</span><span class="lines">@@ -318,7 +318,7 @@
</span><span class="cx"> m_assembler.dtr_u(false, src, ARMRegisters::S0, 0);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void store32(Imm32 imm, void* address)
</del><ins>+ void store32(TrustedImm32 imm, void* address)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.ldr_un_imm(ARMRegisters::S0, reinterpret_cast<ARMWord>(address));
</span><span class="cx"> if (imm.m_isPointer)
</span><span class="lines">@@ -344,13 +344,13 @@
</span><span class="cx"> push(ARMRegisters::S1);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void push(Imm32 imm)
</del><ins>+ void push(TrustedImm32 imm)
</ins><span class="cx"> {
</span><span class="cx"> move(imm, ARMRegisters::S0);
</span><span class="cx"> push(ARMRegisters::S0);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void move(Imm32 imm, RegisterID dest)
</del><ins>+ void move(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> if (imm.m_isPointer)
</span><span class="cx"> m_assembler.ldr_un_imm(dest, imm.m_value);
</span><span class="lines">@@ -363,9 +363,9 @@
</span><span class="cx"> m_assembler.mov_r(dest, src);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void move(ImmPtr imm, RegisterID dest)
</del><ins>+ void move(TrustedImmPtr imm, RegisterID dest)
</ins><span class="cx"> {
</span><del>- move(Imm32(imm), dest);
</del><ins>+ move(TrustedImm32(imm), dest);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void swap(RegisterID reg1, RegisterID reg2)
</span><span class="lines">@@ -387,7 +387,7 @@
</span><span class="cx"> move(src, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branch8(Condition cond, Address left, Imm32 right)
</del><ins>+ Jump branch8(Condition cond, Address left, TrustedImm32 right)
</ins><span class="cx"> {
</span><span class="cx"> load8(left, ARMRegisters::S1);
</span><span class="cx"> return branch32(cond, ARMRegisters::S1, right);
</span><span class="lines">@@ -399,7 +399,7 @@
</span><span class="cx"> return Jump(m_assembler.jmp(ARMCondition(cond), useConstantPool));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branch32(Condition cond, RegisterID left, Imm32 right, int useConstantPool = 0)
</del><ins>+ Jump branch32(Condition cond, RegisterID left, TrustedImm32 right, int useConstantPool = 0)
</ins><span class="cx"> {
</span><span class="cx"> if (right.m_isPointer) {
</span><span class="cx"> m_assembler.ldr_un_imm(ARMRegisters::S0, right.m_value);
</span><span class="lines">@@ -426,19 +426,19 @@
</span><span class="cx"> return branch32(cond, ARMRegisters::S1, right);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branch32(Condition cond, Address left, Imm32 right)
</del><ins>+ Jump branch32(Condition cond, Address left, TrustedImm32 right)
</ins><span class="cx"> {
</span><span class="cx"> load32(left, ARMRegisters::S1);
</span><span class="cx"> return branch32(cond, ARMRegisters::S1, right);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branch32(Condition cond, BaseIndex left, Imm32 right)
</del><ins>+ Jump branch32(Condition cond, BaseIndex left, TrustedImm32 right)
</ins><span class="cx"> {
</span><span class="cx"> load32(left, ARMRegisters::S1);
</span><span class="cx"> return branch32(cond, ARMRegisters::S1, right);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branch32WithUnalignedHalfWords(Condition cond, BaseIndex left, Imm32 right)
</del><ins>+ Jump branch32WithUnalignedHalfWords(Condition cond, BaseIndex left, TrustedImm32 right)
</ins><span class="cx"> {
</span><span class="cx"> load32WithUnalignedHalfWords(left, ARMRegisters::S1);
</span><span class="cx"> return branch32(cond, ARMRegisters::S1, right);
</span><span class="lines">@@ -453,7 +453,7 @@
</span><span class="cx"> return jump();
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branch16(Condition cond, BaseIndex left, Imm32 right)
</del><ins>+ Jump branch16(Condition cond, BaseIndex left, TrustedImm32 right)
</ins><span class="cx"> {
</span><span class="cx"> load16(left, ARMRegisters::S0);
</span><span class="cx"> move(right, ARMRegisters::S1);
</span><span class="lines">@@ -461,7 +461,7 @@
</span><span class="cx"> return m_assembler.jmp(ARMCondition(cond));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchTest8(Condition cond, Address address, Imm32 mask = Imm32(-1))
</del><ins>+ Jump branchTest8(Condition cond, Address address, TrustedImm32 mask = TrustedImm32(-1))
</ins><span class="cx"> {
</span><span class="cx"> load8(address, ARMRegisters::S1);
</span><span class="cx"> return branchTest32(cond, ARMRegisters::S1, mask);
</span><span class="lines">@@ -474,7 +474,7 @@
</span><span class="cx"> return Jump(m_assembler.jmp(ARMCondition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchTest32(Condition cond, RegisterID reg, Imm32 mask = Imm32(-1))
</del><ins>+ Jump branchTest32(Condition cond, RegisterID reg, TrustedImm32 mask = TrustedImm32(-1))
</ins><span class="cx"> {
</span><span class="cx"> ASSERT((cond == Zero) || (cond == NonZero));
</span><span class="cx"> ARMWord w = m_assembler.getImm(mask.m_value, ARMRegisters::S0, true);
</span><span class="lines">@@ -485,13 +485,13 @@
</span><span class="cx"> return Jump(m_assembler.jmp(ARMCondition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchTest32(Condition cond, Address address, Imm32 mask = Imm32(-1))
</del><ins>+ Jump branchTest32(Condition cond, Address address, TrustedImm32 mask = TrustedImm32(-1))
</ins><span class="cx"> {
</span><span class="cx"> load32(address, ARMRegisters::S1);
</span><span class="cx"> return branchTest32(cond, ARMRegisters::S1, mask);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchTest32(Condition cond, BaseIndex address, Imm32 mask = Imm32(-1))
</del><ins>+ Jump branchTest32(Condition cond, BaseIndex address, TrustedImm32 mask = TrustedImm32(-1))
</ins><span class="cx"> {
</span><span class="cx"> load32(address, ARMRegisters::S1);
</span><span class="cx"> return branchTest32(cond, ARMRegisters::S1, mask);
</span><span class="lines">@@ -519,7 +519,7 @@
</span><span class="cx"> return Jump(m_assembler.jmp(ARMCondition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchAdd32(Condition cond, Imm32 imm, RegisterID dest)
</del><ins>+ Jump branchAdd32(Condition cond, TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> ASSERT((cond == Overflow) || (cond == Signed) || (cond == Zero) || (cond == NonZero));
</span><span class="cx"> add32(imm, dest);
</span><span class="lines">@@ -548,7 +548,7 @@
</span><span class="cx"> return Jump(m_assembler.jmp(ARMCondition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchMul32(Condition cond, Imm32 imm, RegisterID src, RegisterID dest)
</del><ins>+ Jump branchMul32(Condition cond, TrustedImm32 imm, RegisterID src, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> ASSERT((cond == Overflow) || (cond == Signed) || (cond == Zero) || (cond == NonZero));
</span><span class="cx"> if (cond == Overflow) {
</span><span class="lines">@@ -568,7 +568,7 @@
</span><span class="cx"> return Jump(m_assembler.jmp(ARMCondition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchSub32(Condition cond, Imm32 imm, RegisterID dest)
</del><ins>+ Jump branchSub32(Condition cond, TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> ASSERT((cond == Overflow) || (cond == Signed) || (cond == Zero) || (cond == NonZero));
</span><span class="cx"> sub32(imm, dest);
</span><span class="lines">@@ -628,7 +628,7 @@
</span><span class="cx"> m_assembler.mov_r(dest, ARMAssembler::getOp2(1), ARMCondition(cond));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void set32Compare32(Condition cond, RegisterID left, Imm32 right, RegisterID dest)
</del><ins>+ void set32Compare32(Condition cond, RegisterID left, TrustedImm32 right, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.cmp_r(left, m_assembler.getImm(right.m_value, ARMRegisters::S0));
</span><span class="cx"> m_assembler.mov_r(dest, ARMAssembler::getOp2(0));
</span><span class="lines">@@ -648,13 +648,13 @@
</span><span class="cx"> set32Compare32(cond, ARMRegisters::S1, right, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void set8Compare32(Condition cond, RegisterID left, Imm32 right, RegisterID dest)
</del><ins>+ void set8Compare32(Condition cond, RegisterID left, TrustedImm32 right, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> // ARM doesn't have byte registers
</span><span class="cx"> set32Compare32(cond, left, right, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void set32Test32(Condition cond, RegisterID reg, Imm32 mask, RegisterID dest)
</del><ins>+ void set32Test32(Condition cond, RegisterID reg, TrustedImm32 mask, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> if (mask.m_value == -1)
</span><span class="cx"> m_assembler.cmp_r(0, reg);
</span><span class="lines">@@ -664,24 +664,24 @@
</span><span class="cx"> m_assembler.mov_r(dest, ARMAssembler::getOp2(1), ARMCondition(cond));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void set32Test32(Condition cond, Address address, Imm32 mask, RegisterID dest)
</del><ins>+ void set32Test32(Condition cond, Address address, TrustedImm32 mask, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> load32(address, ARMRegisters::S1);
</span><span class="cx"> set32Test32(cond, ARMRegisters::S1, mask, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void set32Test8(Condition cond, Address address, Imm32 mask, RegisterID dest)
</del><ins>+ void set32Test8(Condition cond, Address address, TrustedImm32 mask, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> load8(address, ARMRegisters::S1);
</span><span class="cx"> set32Test32(cond, ARMRegisters::S1, mask, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void add32(Imm32 imm, RegisterID src, RegisterID dest)
</del><ins>+ void add32(TrustedImm32 imm, RegisterID src, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.add_r(dest, src, m_assembler.getImm(imm.m_value, ARMRegisters::S0));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void add32(Imm32 imm, AbsoluteAddress address)
</del><ins>+ void add32(TrustedImm32 imm, AbsoluteAddress address)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.ldr_un_imm(ARMRegisters::S1, reinterpret_cast<ARMWord>(address.m_ptr));
</span><span class="cx"> m_assembler.dtr_u(true, ARMRegisters::S1, ARMRegisters::S1, 0);
</span><span class="lines">@@ -690,7 +690,7 @@
</span><span class="cx"> m_assembler.dtr_u(false, ARMRegisters::S1, ARMRegisters::S0, 0);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void sub32(Imm32 imm, AbsoluteAddress address)
</del><ins>+ void sub32(TrustedImm32 imm, AbsoluteAddress address)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.ldr_un_imm(ARMRegisters::S1, reinterpret_cast<ARMWord>(address.m_ptr));
</span><span class="cx"> m_assembler.dtr_u(true, ARMRegisters::S1, ARMRegisters::S1, 0);
</span><span class="lines">@@ -711,7 +711,7 @@
</span><span class="cx"> return branch32(cond, ARMRegisters::S1, right);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branch32(Condition cond, AbsoluteAddress left, Imm32 right)
</del><ins>+ Jump branch32(Condition cond, AbsoluteAddress left, TrustedImm32 right)
</ins><span class="cx"> {
</span><span class="cx"> load32(left.m_ptr, ARMRegisters::S1);
</span><span class="cx"> return branch32(cond, ARMRegisters::S1, right);
</span><span class="lines">@@ -748,21 +748,21 @@
</span><span class="cx"> return Call::fromTailJump(oldJump);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- DataLabelPtr moveWithPatch(ImmPtr initialValue, RegisterID dest)
</del><ins>+ DataLabelPtr moveWithPatch(TrustedImmPtr initialValue, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> DataLabelPtr dataLabel(this);
</span><span class="cx"> m_assembler.ldr_un_imm(dest, reinterpret_cast<ARMWord>(initialValue.m_value));
</span><span class="cx"> return dataLabel;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchPtrWithPatch(Condition cond, RegisterID left, DataLabelPtr& dataLabel, ImmPtr initialRightValue = ImmPtr(0))
</del><ins>+ Jump branchPtrWithPatch(Condition cond, RegisterID left, DataLabelPtr& dataLabel, TrustedImmPtr initialRightValue = TrustedImmPtr(0))
</ins><span class="cx"> {
</span><span class="cx"> dataLabel = moveWithPatch(initialRightValue, ARMRegisters::S1);
</span><span class="cx"> Jump jump = branch32(cond, left, ARMRegisters::S1, true);
</span><span class="cx"> return jump;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchPtrWithPatch(Condition cond, Address left, DataLabelPtr& dataLabel, ImmPtr initialRightValue = ImmPtr(0))
</del><ins>+ Jump branchPtrWithPatch(Condition cond, Address left, DataLabelPtr& dataLabel, TrustedImmPtr initialRightValue = TrustedImmPtr(0))
</ins><span class="cx"> {
</span><span class="cx"> load32(left, ARMRegisters::S1);
</span><span class="cx"> dataLabel = moveWithPatch(initialRightValue, ARMRegisters::S0);
</span><span class="lines">@@ -770,7 +770,7 @@
</span><span class="cx"> return jump;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- DataLabelPtr storePtrWithPatch(ImmPtr initialValue, ImplicitAddress address)
</del><ins>+ DataLabelPtr storePtrWithPatch(TrustedImmPtr initialValue, ImplicitAddress address)
</ins><span class="cx"> {
</span><span class="cx"> DataLabelPtr dataLabel = moveWithPatch(initialValue, ARMRegisters::S1);
</span><span class="cx"> store32(ARMRegisters::S1, address);
</span><span class="lines">@@ -779,7 +779,7 @@
</span><span class="cx">
</span><span class="cx"> DataLabelPtr storePtrWithPatch(ImplicitAddress address)
</span><span class="cx"> {
</span><del>- return storePtrWithPatch(ImmPtr(0), address);
</del><ins>+ return storePtrWithPatch(TrustedImmPtr(0), address);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // Floating point operators
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerMacroAssemblerARMv7h"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.h (82129 => 82130)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.h 2011-03-28 17:10:30 UTC (rev 82129)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.h 2011-03-28 17:14:57 UTC (rev 82130)
</span><span class="lines">@@ -139,7 +139,7 @@
</span><span class="cx"> // Integer arithmetic operations:
</span><span class="cx"> //
</span><span class="cx"> // Operations are typically two operand - operation(source, srcDst)
</span><del>- // For many operations the source may be an Imm32, the srcDst operand
</del><ins>+ // For many operations the source may be an TrustedImm32, the srcDst operand
</ins><span class="cx"> // may often be a memory location (explictly described using an Address
</span><span class="cx"> // object).
</span><span class="cx">
</span><span class="lines">@@ -148,12 +148,12 @@
</span><span class="cx"> m_assembler.add(dest, dest, src);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void add32(Imm32 imm, RegisterID dest)
</del><ins>+ void add32(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> add32(imm, dest, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void add32(Imm32 imm, RegisterID src, RegisterID dest)
</del><ins>+ void add32(TrustedImm32 imm, RegisterID src, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> ARMThumbImmediate armImm = ARMThumbImmediate::makeUInt12OrEncodedImm(imm.m_value);
</span><span class="cx"> if (armImm.isValid())
</span><span class="lines">@@ -164,7 +164,7 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void add32(Imm32 imm, Address address)
</del><ins>+ void add32(TrustedImm32 imm, Address address)
</ins><span class="cx"> {
</span><span class="cx"> load32(address, dataTempRegister);
</span><span class="cx">
</span><span class="lines">@@ -187,7 +187,7 @@
</span><span class="cx"> add32(dataTempRegister, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void add32(Imm32 imm, AbsoluteAddress address)
</del><ins>+ void add32(TrustedImm32 imm, AbsoluteAddress address)
</ins><span class="cx"> {
</span><span class="cx"> load32(address.m_ptr, dataTempRegister);
</span><span class="cx">
</span><span class="lines">@@ -209,7 +209,7 @@
</span><span class="cx"> m_assembler.ARM_and(dest, dest, src);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void and32(Imm32 imm, RegisterID dest)
</del><ins>+ void and32(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> ARMThumbImmediate armImm = ARMThumbImmediate::makeEncodedImm(imm.m_value);
</span><span class="cx"> if (armImm.isValid())
</span><span class="lines">@@ -235,7 +235,7 @@
</span><span class="cx"> m_assembler.lsl(dest, dest, dataTempRegister);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void lshift32(Imm32 imm, RegisterID dest)
</del><ins>+ void lshift32(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.lsl(dest, dest, imm.m_value & 0x1f);
</span><span class="cx"> }
</span><span class="lines">@@ -245,7 +245,7 @@
</span><span class="cx"> m_assembler.smull(dest, dataTempRegister, dest, src);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void mul32(Imm32 imm, RegisterID src, RegisterID dest)
</del><ins>+ void mul32(TrustedImm32 imm, RegisterID src, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> move(imm, dataTempRegister);
</span><span class="cx"> m_assembler.smull(dest, dataTempRegister, src, dataTempRegister);
</span><span class="lines">@@ -266,7 +266,7 @@
</span><span class="cx"> m_assembler.orr(dest, dest, src);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void or32(Imm32 imm, RegisterID dest)
</del><ins>+ void or32(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> ARMThumbImmediate armImm = ARMThumbImmediate::makeEncodedImm(imm.m_value);
</span><span class="cx"> if (armImm.isValid())
</span><span class="lines">@@ -287,7 +287,7 @@
</span><span class="cx"> m_assembler.asr(dest, dest, dataTempRegister);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void rshift32(Imm32 imm, RegisterID dest)
</del><ins>+ void rshift32(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.asr(dest, dest, imm.m_value & 0x1f);
</span><span class="cx"> }
</span><span class="lines">@@ -302,7 +302,7 @@
</span><span class="cx"> m_assembler.lsr(dest, dest, dataTempRegister);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void urshift32(Imm32 imm, RegisterID dest)
</del><ins>+ void urshift32(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.lsr(dest, dest, imm.m_value & 0x1f);
</span><span class="cx"> }
</span><span class="lines">@@ -312,7 +312,7 @@
</span><span class="cx"> m_assembler.sub(dest, dest, src);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void sub32(Imm32 imm, RegisterID dest)
</del><ins>+ void sub32(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> ARMThumbImmediate armImm = ARMThumbImmediate::makeUInt12OrEncodedImm(imm.m_value);
</span><span class="cx"> if (armImm.isValid())
</span><span class="lines">@@ -323,7 +323,7 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void sub32(Imm32 imm, Address address)
</del><ins>+ void sub32(TrustedImm32 imm, Address address)
</ins><span class="cx"> {
</span><span class="cx"> load32(address, dataTempRegister);
</span><span class="cx">
</span><span class="lines">@@ -346,7 +346,7 @@
</span><span class="cx"> sub32(dataTempRegister, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void sub32(Imm32 imm, AbsoluteAddress address)
</del><ins>+ void sub32(TrustedImm32 imm, AbsoluteAddress address)
</ins><span class="cx"> {
</span><span class="cx"> load32(address.m_ptr, dataTempRegister);
</span><span class="cx">
</span><span class="lines">@@ -368,7 +368,7 @@
</span><span class="cx"> m_assembler.eor(dest, dest, src);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void xor32(Imm32 imm, RegisterID dest)
</del><ins>+ void xor32(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> ARMThumbImmediate armImm = ARMThumbImmediate::makeEncodedImm(imm.m_value);
</span><span class="cx"> if (armImm.isValid())
</span><span class="lines">@@ -383,7 +383,7 @@
</span><span class="cx"> // Memory access operations:
</span><span class="cx"> //
</span><span class="cx"> // Loads are of the form load(address, destination) and stores of the form
</span><del>- // store(source, address). The source for a store may be an Imm32. Address
</del><ins>+ // store(source, address). The source for a store may be an TrustedImm32. Address
</ins><span class="cx"> // operand objects to loads and store will be implicitly constructed if a
</span><span class="cx"> // register is passed.
</span><span class="cx">
</span><span class="lines">@@ -462,7 +462,7 @@
</span><span class="cx">
</span><span class="cx"> void load32(const void* address, RegisterID dest)
</span><span class="cx"> {
</span><del>- move(ImmPtr(address), addressTempRegister);
</del><ins>+ move(TrustedImmPtr(address), addressTempRegister);
</ins><span class="cx"> m_assembler.ldr(dest, addressTempRegister, ARMThumbImmediate::makeUInt16(0));
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -473,7 +473,7 @@
</span><span class="cx">
</span><span class="cx"> DataLabel32 load32WithAddressOffsetPatch(Address address, RegisterID dest)
</span><span class="cx"> {
</span><del>- DataLabel32 label = moveWithPatch(Imm32(address.offset), dataTempRegister);
</del><ins>+ DataLabel32 label = moveWithPatch(TrustedImm32(address.offset), dataTempRegister);
</ins><span class="cx"> load32(ArmAddress(address.base, dataTempRegister), dest);
</span><span class="cx"> return label;
</span><span class="cx"> }
</span><span class="lines">@@ -489,14 +489,14 @@
</span><span class="cx"> if (armImm.isValid())
</span><span class="cx"> m_assembler.ldrh(dest, address.base, armImm);
</span><span class="cx"> else {
</span><del>- move(Imm32(address.offset), dataTempRegister);
</del><ins>+ move(TrustedImm32(address.offset), dataTempRegister);
</ins><span class="cx"> m_assembler.ldrh(dest, address.base, dataTempRegister);
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> DataLabel32 store32WithAddressOffsetPatch(RegisterID src, Address address)
</span><span class="cx"> {
</span><del>- DataLabel32 label = moveWithPatch(Imm32(address.offset), dataTempRegister);
</del><ins>+ DataLabel32 label = moveWithPatch(TrustedImm32(address.offset), dataTempRegister);
</ins><span class="cx"> store32(src, ArmAddress(address.base, dataTempRegister));
</span><span class="cx"> return label;
</span><span class="cx"> }
</span><span class="lines">@@ -511,7 +511,7 @@
</span><span class="cx"> store32(src, setupArmAddress(address));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void store32(Imm32 imm, ImplicitAddress address)
</del><ins>+ void store32(TrustedImm32 imm, ImplicitAddress address)
</ins><span class="cx"> {
</span><span class="cx"> move(imm, dataTempRegister);
</span><span class="cx"> store32(dataTempRegister, setupArmAddress(address));
</span><span class="lines">@@ -519,11 +519,11 @@
</span><span class="cx">
</span><span class="cx"> void store32(RegisterID src, const void* address)
</span><span class="cx"> {
</span><del>- move(ImmPtr(address), addressTempRegister);
</del><ins>+ move(TrustedImmPtr(address), addressTempRegister);
</ins><span class="cx"> m_assembler.str(src, addressTempRegister, ARMThumbImmediate::makeUInt16(0));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void store32(Imm32 imm, const void* address)
</del><ins>+ void store32(TrustedImm32 imm, const void* address)
</ins><span class="cx"> {
</span><span class="cx"> move(imm, dataTempRegister);
</span><span class="cx"> store32(dataTempRegister, address);
</span><span class="lines">@@ -558,7 +558,7 @@
</span><span class="cx">
</span><span class="cx"> // Arm vfp addresses can be offset by a 9-bit ones-comp immediate, left shifted by 2.
</span><span class="cx"> if ((offset & 3) || (offset > (255 * 4)) || (offset < -(255 * 4))) {
</span><del>- add32(Imm32(offset), base, addressTempRegister);
</del><ins>+ add32(TrustedImm32(offset), base, addressTempRegister);
</ins><span class="cx"> base = addressTempRegister;
</span><span class="cx"> offset = 0;
</span><span class="cx"> }
</span><span class="lines">@@ -568,7 +568,7 @@
</span><span class="cx">
</span><span class="cx"> void loadDouble(const void* address, FPRegisterID dest)
</span><span class="cx"> {
</span><del>- move(ImmPtr(address), addressTempRegister);
</del><ins>+ move(TrustedImmPtr(address), addressTempRegister);
</ins><span class="cx"> m_assembler.vldr(dest, addressTempRegister, 0);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -579,7 +579,7 @@
</span><span class="cx">
</span><span class="cx"> // Arm vfp addresses can be offset by a 9-bit ones-comp immediate, left shifted by 2.
</span><span class="cx"> if ((offset & 3) || (offset > (255 * 4)) || (offset < -(255 * 4))) {
</span><del>- add32(Imm32(offset), base, addressTempRegister);
</del><ins>+ add32(TrustedImm32(offset), base, addressTempRegister);
</ins><span class="cx"> base = addressTempRegister;
</span><span class="cx"> offset = 0;
</span><span class="cx"> }
</span><span class="lines">@@ -748,7 +748,7 @@
</span><span class="cx"> push(dataTempRegister);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void push(Imm32 imm)
</del><ins>+ void push(TrustedImm32 imm)
</ins><span class="cx"> {
</span><span class="cx"> move(imm, dataTempRegister);
</span><span class="cx"> push(dataTempRegister);
</span><span class="lines">@@ -758,7 +758,7 @@
</span><span class="cx"> //
</span><span class="cx"> // Move values in registers.
</span><span class="cx">
</span><del>- void move(Imm32 imm, RegisterID dest)
</del><ins>+ void move(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> uint32_t value = imm.m_value;
</span><span class="cx">
</span><span class="lines">@@ -784,9 +784,9 @@
</span><span class="cx"> m_assembler.mov(dest, src);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void move(ImmPtr imm, RegisterID dest)
</del><ins>+ void move(TrustedImmPtr imm, RegisterID dest)
</ins><span class="cx"> {
</span><del>- move(Imm32(imm), dest);
</del><ins>+ move(TrustedImm32(imm), dest);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void swap(RegisterID reg1, RegisterID reg2)
</span><span class="lines">@@ -821,7 +821,7 @@
</span><span class="cx"> // used (representing the names 'below' and 'above').
</span><span class="cx"> //
</span><span class="cx"> // Operands to the comparision are provided in the expected order, e.g.
</span><del>- // jle32(reg1, Imm32(5)) will branch if the value held in reg1, when
</del><ins>+ // jle32(reg1, TrustedImm32(5)) will branch if the value held in reg1, when
</ins><span class="cx"> // treated as a signed 32bit value, is less than or equal to 5.
</span><span class="cx"> //
</span><span class="cx"> // jz and jnz test whether the first operand is equal to zero, and take
</span><span class="lines">@@ -829,7 +829,7 @@
</span><span class="cx"> private:
</span><span class="cx">
</span><span class="cx"> // Should we be using TEQ for equal/not-equal?
</span><del>- void compare32(RegisterID left, Imm32 right)
</del><ins>+ void compare32(RegisterID left, TrustedImm32 right)
</ins><span class="cx"> {
</span><span class="cx"> int32_t imm = right.m_value;
</span><span class="cx"> if (!imm)
</span><span class="lines">@@ -841,13 +841,13 @@
</span><span class="cx"> else if ((armImm = ARMThumbImmediate::makeEncodedImm(-imm)).isValid())
</span><span class="cx"> m_assembler.cmn(left, armImm);
</span><span class="cx"> else {
</span><del>- move(Imm32(imm), dataTempRegister);
</del><ins>+ move(TrustedImm32(imm), dataTempRegister);
</ins><span class="cx"> m_assembler.cmp(left, dataTempRegister);
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void test32(RegisterID reg, Imm32 mask)
</del><ins>+ void test32(RegisterID reg, TrustedImm32 mask)
</ins><span class="cx"> {
</span><span class="cx"> int32_t imm = mask.m_value;
</span><span class="cx">
</span><span class="lines">@@ -871,7 +871,7 @@
</span><span class="cx"> return Jump(makeBranch(cond));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branch32(Condition cond, RegisterID left, Imm32 right)
</del><ins>+ Jump branch32(Condition cond, RegisterID left, TrustedImm32 right)
</ins><span class="cx"> {
</span><span class="cx"> compare32(left, right);
</span><span class="cx"> return Jump(makeBranch(cond));
</span><span class="lines">@@ -889,21 +889,21 @@
</span><span class="cx"> return branch32(cond, dataTempRegister, right);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branch32(Condition cond, Address left, Imm32 right)
</del><ins>+ Jump branch32(Condition cond, Address left, TrustedImm32 right)
</ins><span class="cx"> {
</span><span class="cx"> // use addressTempRegister incase the branch32 we call uses dataTempRegister. :-/
</span><span class="cx"> load32(left, addressTempRegister);
</span><span class="cx"> return branch32(cond, addressTempRegister, right);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branch32(Condition cond, BaseIndex left, Imm32 right)
</del><ins>+ Jump branch32(Condition cond, BaseIndex left, TrustedImm32 right)
</ins><span class="cx"> {
</span><span class="cx"> // use addressTempRegister incase the branch32 we call uses dataTempRegister. :-/
</span><span class="cx"> load32(left, addressTempRegister);
</span><span class="cx"> return branch32(cond, addressTempRegister, right);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branch32WithUnalignedHalfWords(Condition cond, BaseIndex left, Imm32 right)
</del><ins>+ Jump branch32WithUnalignedHalfWords(Condition cond, BaseIndex left, TrustedImm32 right)
</ins><span class="cx"> {
</span><span class="cx"> // use addressTempRegister incase the branch32 we call uses dataTempRegister. :-/
</span><span class="cx"> load32WithUnalignedHalfWords(left, addressTempRegister);
</span><span class="lines">@@ -916,7 +916,7 @@
</span><span class="cx"> return branch32(cond, dataTempRegister, right);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branch32(Condition cond, AbsoluteAddress left, Imm32 right)
</del><ins>+ Jump branch32(Condition cond, AbsoluteAddress left, TrustedImm32 right)
</ins><span class="cx"> {
</span><span class="cx"> // use addressTempRegister incase the branch32 we call uses dataTempRegister. :-/
</span><span class="cx"> load32(left.m_ptr, addressTempRegister);
</span><span class="lines">@@ -931,21 +931,21 @@
</span><span class="cx"> return branch32(cond, dataTempRegister, addressTempRegister);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branch16(Condition cond, BaseIndex left, Imm32 right)
</del><ins>+ Jump branch16(Condition cond, BaseIndex left, TrustedImm32 right)
</ins><span class="cx"> {
</span><span class="cx"> // use addressTempRegister incase the branch32 we call uses dataTempRegister. :-/
</span><span class="cx"> load16(left, addressTempRegister);
</span><span class="cx"> m_assembler.lsl(addressTempRegister, addressTempRegister, 16);
</span><del>- return branch32(cond, addressTempRegister, Imm32(right.m_value << 16));
</del><ins>+ return branch32(cond, addressTempRegister, TrustedImm32(right.m_value << 16));
</ins><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branch8(Condition cond, RegisterID left, Imm32 right)
</del><ins>+ Jump branch8(Condition cond, RegisterID left, TrustedImm32 right)
</ins><span class="cx"> {
</span><span class="cx"> compare32(left, right);
</span><span class="cx"> return Jump(makeBranch(cond));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branch8(Condition cond, Address left, Imm32 right)
</del><ins>+ Jump branch8(Condition cond, Address left, TrustedImm32 right)
</ins><span class="cx"> {
</span><span class="cx"> // use addressTempRegister incase the branch8 we call uses dataTempRegister. :-/
</span><span class="cx"> load8(left, addressTempRegister);
</span><span class="lines">@@ -959,14 +959,14 @@
</span><span class="cx"> return Jump(makeBranch(cond));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchTest32(Condition cond, RegisterID reg, Imm32 mask = Imm32(-1))
</del><ins>+ Jump branchTest32(Condition cond, RegisterID reg, TrustedImm32 mask = TrustedImm32(-1))
</ins><span class="cx"> {
</span><span class="cx"> ASSERT((cond == Zero) || (cond == NonZero));
</span><span class="cx"> test32(reg, mask);
</span><span class="cx"> return Jump(makeBranch(cond));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchTest32(Condition cond, Address address, Imm32 mask = Imm32(-1))
</del><ins>+ Jump branchTest32(Condition cond, Address address, TrustedImm32 mask = TrustedImm32(-1))
</ins><span class="cx"> {
</span><span class="cx"> ASSERT((cond == Zero) || (cond == NonZero));
</span><span class="cx"> // use addressTempRegister incase the branchTest32 we call uses dataTempRegister. :-/
</span><span class="lines">@@ -974,7 +974,7 @@
</span><span class="cx"> return branchTest32(cond, addressTempRegister, mask);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchTest32(Condition cond, BaseIndex address, Imm32 mask = Imm32(-1))
</del><ins>+ Jump branchTest32(Condition cond, BaseIndex address, TrustedImm32 mask = TrustedImm32(-1))
</ins><span class="cx"> {
</span><span class="cx"> ASSERT((cond == Zero) || (cond == NonZero));
</span><span class="cx"> // use addressTempRegister incase the branchTest32 we call uses dataTempRegister. :-/
</span><span class="lines">@@ -982,14 +982,14 @@
</span><span class="cx"> return branchTest32(cond, addressTempRegister, mask);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchTest8(Condition cond, RegisterID reg, Imm32 mask = Imm32(-1))
</del><ins>+ Jump branchTest8(Condition cond, RegisterID reg, TrustedImm32 mask = TrustedImm32(-1))
</ins><span class="cx"> {
</span><span class="cx"> ASSERT((cond == Zero) || (cond == NonZero));
</span><span class="cx"> test32(reg, mask);
</span><span class="cx"> return Jump(makeBranch(cond));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchTest8(Condition cond, Address address, Imm32 mask = Imm32(-1))
</del><ins>+ Jump branchTest8(Condition cond, Address address, TrustedImm32 mask = TrustedImm32(-1))
</ins><span class="cx"> {
</span><span class="cx"> ASSERT((cond == Zero) || (cond == NonZero));
</span><span class="cx"> // use addressTempRegister incase the branchTest8 we call uses dataTempRegister. :-/
</span><span class="lines">@@ -1032,7 +1032,7 @@
</span><span class="cx"> return Jump(makeBranch(cond));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchAdd32(Condition cond, Imm32 imm, RegisterID dest)
</del><ins>+ Jump branchAdd32(Condition cond, TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> ASSERT((cond == Overflow) || (cond == Signed) || (cond == Zero) || (cond == NonZero));
</span><span class="cx"> ARMThumbImmediate armImm = ARMThumbImmediate::makeEncodedImm(imm.m_value);
</span><span class="lines">@@ -1053,7 +1053,7 @@
</span><span class="cx"> return branch32(NotEqual, addressTempRegister, dataTempRegister);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchMul32(Condition cond, Imm32 imm, RegisterID src, RegisterID dest)
</del><ins>+ Jump branchMul32(Condition cond, TrustedImm32 imm, RegisterID src, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> ASSERT_UNUSED(cond, cond == Overflow);
</span><span class="cx"> move(imm, dataTempRegister);
</span><span class="lines">@@ -1076,7 +1076,7 @@
</span><span class="cx"> return Jump(makeBranch(cond));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchSub32(Condition cond, Imm32 imm, RegisterID dest)
</del><ins>+ Jump branchSub32(Condition cond, TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> ASSERT((cond == Overflow) || (cond == Signed) || (cond == Zero) || (cond == NonZero));
</span><span class="cx"> ARMThumbImmediate armImm = ARMThumbImmediate::makeEncodedImm(imm.m_value);
</span><span class="lines">@@ -1111,13 +1111,13 @@
</span><span class="cx">
</span><span class="cx"> Call nearCall()
</span><span class="cx"> {
</span><del>- moveFixedWidthEncoding(Imm32(0), dataTempRegister);
</del><ins>+ moveFixedWidthEncoding(TrustedImm32(0), dataTempRegister);
</ins><span class="cx"> return Call(m_assembler.blx(dataTempRegister, ARMv7Assembler::JumpFixed), Call::LinkableNear);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> Call call()
</span><span class="cx"> {
</span><del>- moveFixedWidthEncoding(Imm32(0), dataTempRegister);
</del><ins>+ moveFixedWidthEncoding(TrustedImm32(0), dataTempRegister);
</ins><span class="cx"> return Call(m_assembler.blx(dataTempRegister, ARMv7Assembler::JumpFixed), Call::Linkable);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1151,7 +1151,7 @@
</span><span class="cx"> set32Compare32(cond, dataTempRegister, right, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void set32Compare32(Condition cond, RegisterID left, Imm32 right, RegisterID dest)
</del><ins>+ void set32Compare32(Condition cond, RegisterID left, TrustedImm32 right, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> compare32(left, right);
</span><span class="cx"> m_assembler.it(armV7Condition(cond), false);
</span><span class="lines">@@ -1169,7 +1169,7 @@
</span><span class="cx"> set32Compare32(cond, left, right, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void set8Compare32(Condition cond, RegisterID left, Imm32 right, RegisterID dest)
</del><ins>+ void set8Compare32(Condition cond, RegisterID left, TrustedImm32 right, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> set32Compare32(cond, left, right, dest);
</span><span class="cx"> }
</span><span class="lines">@@ -1178,7 +1178,7 @@
</span><span class="cx"> // The mask should be optional... paerhaps the argument order should be
</span><span class="cx"> // dest-src, operations always have a dest? ... possibly not true, considering
</span><span class="cx"> // asm ops like test, or pseudo ops like pop().
</span><del>- void set32Test32(Condition cond, Address address, Imm32 mask, RegisterID dest)
</del><ins>+ void set32Test32(Condition cond, Address address, TrustedImm32 mask, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> load32(address, dataTempRegister);
</span><span class="cx"> test32(dataTempRegister, mask);
</span><span class="lines">@@ -1187,7 +1187,7 @@
</span><span class="cx"> m_assembler.mov(dest, ARMThumbImmediate::makeUInt16(0));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void set32Test8(Condition cond, Address address, Imm32 mask, RegisterID dest)
</del><ins>+ void set32Test8(Condition cond, Address address, TrustedImm32 mask, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> load8(address, dataTempRegister);
</span><span class="cx"> test32(dataTempRegister, mask);
</span><span class="lines">@@ -1196,44 +1196,44 @@
</span><span class="cx"> m_assembler.mov(dest, ARMThumbImmediate::makeUInt16(0));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- DataLabel32 moveWithPatch(Imm32 imm, RegisterID dst)
</del><ins>+ DataLabel32 moveWithPatch(TrustedImm32 imm, RegisterID dst)
</ins><span class="cx"> {
</span><span class="cx"> moveFixedWidthEncoding(imm, dst);
</span><span class="cx"> return DataLabel32(this);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- DataLabelPtr moveWithPatch(ImmPtr imm, RegisterID dst)
</del><ins>+ DataLabelPtr moveWithPatch(TrustedImmPtr imm, RegisterID dst)
</ins><span class="cx"> {
</span><del>- moveFixedWidthEncoding(Imm32(imm), dst);
</del><ins>+ moveFixedWidthEncoding(TrustedImm32(imm), dst);
</ins><span class="cx"> return DataLabelPtr(this);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchPtrWithPatch(Condition cond, RegisterID left, DataLabelPtr& dataLabel, ImmPtr initialRightValue = ImmPtr(0))
</del><ins>+ Jump branchPtrWithPatch(Condition cond, RegisterID left, DataLabelPtr& dataLabel, TrustedImmPtr initialRightValue = TrustedImmPtr(0))
</ins><span class="cx"> {
</span><span class="cx"> dataLabel = moveWithPatch(initialRightValue, dataTempRegister);
</span><span class="cx"> return branch32(cond, left, dataTempRegister);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchPtrWithPatch(Condition cond, Address left, DataLabelPtr& dataLabel, ImmPtr initialRightValue = ImmPtr(0))
</del><ins>+ Jump branchPtrWithPatch(Condition cond, Address left, DataLabelPtr& dataLabel, TrustedImmPtr initialRightValue = TrustedImmPtr(0))
</ins><span class="cx"> {
</span><span class="cx"> load32(left, addressTempRegister);
</span><span class="cx"> dataLabel = moveWithPatch(initialRightValue, dataTempRegister);
</span><span class="cx"> return branch32(cond, addressTempRegister, dataTempRegister);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- DataLabelPtr storePtrWithPatch(ImmPtr initialValue, ImplicitAddress address)
</del><ins>+ DataLabelPtr storePtrWithPatch(TrustedImmPtr initialValue, ImplicitAddress address)
</ins><span class="cx"> {
</span><span class="cx"> DataLabelPtr label = moveWithPatch(initialValue, dataTempRegister);
</span><span class="cx"> store32(dataTempRegister, address);
</span><span class="cx"> return label;
</span><span class="cx"> }
</span><del>- DataLabelPtr storePtrWithPatch(ImplicitAddress address) { return storePtrWithPatch(ImmPtr(0), address); }
</del><ins>+ DataLabelPtr storePtrWithPatch(ImplicitAddress address) { return storePtrWithPatch(TrustedImmPtr(0), address); }
</ins><span class="cx">
</span><span class="cx">
</span><span class="cx"> Call tailRecursiveCall()
</span><span class="cx"> {
</span><span class="cx"> // Like a normal call, but don't link.
</span><del>- moveFixedWidthEncoding(Imm32(0), dataTempRegister);
</del><ins>+ moveFixedWidthEncoding(TrustedImm32(0), dataTempRegister);
</ins><span class="cx"> return Call(m_assembler.bx(dataTempRegister, ARMv7Assembler::JumpFixed), Call::Linkable);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1257,14 +1257,14 @@
</span><span class="cx">
</span><span class="cx"> ARMv7Assembler::JmpSrc makeJump()
</span><span class="cx"> {
</span><del>- moveFixedWidthEncoding(Imm32(0), dataTempRegister);
</del><ins>+ moveFixedWidthEncoding(TrustedImm32(0), dataTempRegister);
</ins><span class="cx"> return m_assembler.bx(dataTempRegister, inUninterruptedSequence() ? ARMv7Assembler::JumpNoConditionFixedSize : ARMv7Assembler::JumpNoCondition);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> ARMv7Assembler::JmpSrc makeBranch(ARMv7Assembler::Condition cond)
</span><span class="cx"> {
</span><span class="cx"> m_assembler.it(cond, true, true);
</span><del>- moveFixedWidthEncoding(Imm32(0), dataTempRegister);
</del><ins>+ moveFixedWidthEncoding(TrustedImm32(0), dataTempRegister);
</ins><span class="cx"> return m_assembler.bx(dataTempRegister, inUninterruptedSequence() ? ARMv7Assembler::JumpConditionFixedSize : ARMv7Assembler::JumpCondition, cond);
</span><span class="cx"> }
</span><span class="cx"> ARMv7Assembler::JmpSrc makeBranch(Condition cond) { return makeBranch(armV7Condition(cond)); }
</span><span class="lines">@@ -1277,7 +1277,7 @@
</span><span class="cx"> if (imm.isValid())
</span><span class="cx"> m_assembler.add(addressTempRegister, address.base, imm);
</span><span class="cx"> else {
</span><del>- move(Imm32(address.offset), addressTempRegister);
</del><ins>+ move(TrustedImm32(address.offset), addressTempRegister);
</ins><span class="cx"> m_assembler.add(addressTempRegister, addressTempRegister, address.base);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1291,7 +1291,7 @@
</span><span class="cx"> if ((address.offset >= -0xff) && (address.offset <= 0xfff))
</span><span class="cx"> return ArmAddress(address.base, address.offset);
</span><span class="cx">
</span><del>- move(Imm32(address.offset), addressTempRegister);
</del><ins>+ move(TrustedImm32(address.offset), addressTempRegister);
</ins><span class="cx"> return ArmAddress(address.base, addressTempRegister);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1300,7 +1300,7 @@
</span><span class="cx"> if ((address.offset >= -0xff) && (address.offset <= 0xfff))
</span><span class="cx"> return ArmAddress(address.base, address.offset);
</span><span class="cx">
</span><del>- move(Imm32(address.offset), addressTempRegister);
</del><ins>+ move(TrustedImm32(address.offset), addressTempRegister);
</ins><span class="cx"> return ArmAddress(address.base, addressTempRegister);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1313,14 +1313,14 @@
</span><span class="cx"> if (imm.isValid())
</span><span class="cx"> m_assembler.add(addressTempRegister, address.base, imm);
</span><span class="cx"> else {
</span><del>- move(Imm32(address.offset), addressTempRegister);
</del><ins>+ move(TrustedImm32(address.offset), addressTempRegister);
</ins><span class="cx"> m_assembler.add(addressTempRegister, addressTempRegister, address.base);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> return addressTempRegister;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void moveFixedWidthEncoding(Imm32 imm, RegisterID dst)
</del><ins>+ void moveFixedWidthEncoding(TrustedImm32 imm, RegisterID dst)
</ins><span class="cx"> {
</span><span class="cx"> uint32_t value = imm.m_value;
</span><span class="cx"> m_assembler.movT3(dst, ARMThumbImmediate::makeUInt16(value & 0xffff));
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerMacroAssemblerMIPSh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/MacroAssemblerMIPS.h (82129 => 82130)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssemblerMIPS.h 2011-03-28 17:10:30 UTC (rev 82129)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssemblerMIPS.h 2011-03-28 17:14:57 UTC (rev 82130)
</span><span class="lines">@@ -95,7 +95,7 @@
</span><span class="cx"> // Integer arithmetic operations:
</span><span class="cx"> //
</span><span class="cx"> // Operations are typically two operand - operation(source, srcDst)
</span><del>- // For many operations the source may be an Imm32, the srcDst operand
</del><ins>+ // For many operations the source may be an TrustedImm32, the srcDst operand
</ins><span class="cx"> // may often be a memory location (explictly described using an Address
</span><span class="cx"> // object).
</span><span class="cx">
</span><span class="lines">@@ -104,12 +104,12 @@
</span><span class="cx"> m_assembler.addu(dest, dest, src);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void add32(Imm32 imm, RegisterID dest)
</del><ins>+ void add32(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> add32(imm, dest, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void add32(Imm32 imm, RegisterID src, RegisterID dest)
</del><ins>+ void add32(TrustedImm32 imm, RegisterID src, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> if (!imm.m_isPointer && imm.m_value >= -32768 && imm.m_value <= 32767
</span><span class="cx"> && !m_fixedWidth) {
</span><span class="lines">@@ -127,7 +127,7 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void add32(Imm32 imm, Address address)
</del><ins>+ void add32(TrustedImm32 imm, Address address)
</ins><span class="cx"> {
</span><span class="cx"> if (address.offset >= -32768 && address.offset <= 32767
</span><span class="cx"> && !m_fixedWidth) {
</span><span class="lines">@@ -207,7 +207,7 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void add32(Imm32 imm, AbsoluteAddress address)
</del><ins>+ void add32(TrustedImm32 imm, AbsoluteAddress address)
</ins><span class="cx"> {
</span><span class="cx"> /*
</span><span class="cx"> li addrTemp, address
</span><span class="lines">@@ -216,7 +216,7 @@
</span><span class="cx"> addu dataTemp, dataTemp, immTemp
</span><span class="cx"> sw dataTemp, 0(addrTemp)
</span><span class="cx"> */
</span><del>- move(ImmPtr(address.m_ptr), addrTempRegister);
</del><ins>+ move(TrustedImmPtr(address.m_ptr), addrTempRegister);
</ins><span class="cx"> m_assembler.lw(dataTempRegister, addrTempRegister, 0);
</span><span class="cx"> if (!imm.m_isPointer && imm.m_value >= -32768 && imm.m_value <= 32767
</span><span class="cx"> && !m_fixedWidth)
</span><span class="lines">@@ -233,7 +233,7 @@
</span><span class="cx"> m_assembler.andInsn(dest, dest, src);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void and32(Imm32 imm, RegisterID dest)
</del><ins>+ void and32(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> if (!imm.m_isPointer && !imm.m_value && !m_fixedWidth)
</span><span class="cx"> move(MIPSRegisters::zero, dest);
</span><span class="lines">@@ -250,7 +250,7 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void lshift32(Imm32 imm, RegisterID dest)
</del><ins>+ void lshift32(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.sll(dest, dest, imm.m_value);
</span><span class="cx"> }
</span><span class="lines">@@ -265,7 +265,7 @@
</span><span class="cx"> m_assembler.mul(dest, dest, src);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void mul32(Imm32 imm, RegisterID src, RegisterID dest)
</del><ins>+ void mul32(TrustedImm32 imm, RegisterID src, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> if (!imm.m_isPointer && !imm.m_value && !m_fixedWidth)
</span><span class="cx"> move(MIPSRegisters::zero, dest);
</span><span class="lines">@@ -296,7 +296,7 @@
</span><span class="cx"> m_assembler.orInsn(dest, dest, src);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void or32(Imm32 imm, RegisterID dest)
</del><ins>+ void or32(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> if (!imm.m_isPointer && !imm.m_value && !m_fixedWidth)
</span><span class="cx"> return;
</span><span class="lines">@@ -320,7 +320,7 @@
</span><span class="cx"> m_assembler.srav(dest, dest, shiftAmount);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void rshift32(Imm32 imm, RegisterID dest)
</del><ins>+ void rshift32(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.sra(dest, dest, imm.m_value);
</span><span class="cx"> }
</span><span class="lines">@@ -330,7 +330,7 @@
</span><span class="cx"> m_assembler.srlv(dest, dest, shiftAmount);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void urshift32(Imm32 imm, RegisterID dest)
</del><ins>+ void urshift32(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.srl(dest, dest, imm.m_value);
</span><span class="cx"> }
</span><span class="lines">@@ -340,7 +340,7 @@
</span><span class="cx"> m_assembler.subu(dest, dest, src);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void sub32(Imm32 imm, RegisterID dest)
</del><ins>+ void sub32(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> if (!imm.m_isPointer && imm.m_value >= -32767 && imm.m_value <= 32768
</span><span class="cx"> && !m_fixedWidth) {
</span><span class="lines">@@ -358,7 +358,7 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void sub32(Imm32 imm, Address address)
</del><ins>+ void sub32(TrustedImm32 imm, Address address)
</ins><span class="cx"> {
</span><span class="cx"> if (address.offset >= -32768 && address.offset <= 32767
</span><span class="cx"> && !m_fixedWidth) {
</span><span class="lines">@@ -413,7 +413,7 @@
</span><span class="cx"> sub32(dataTempRegister, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void sub32(Imm32 imm, AbsoluteAddress address)
</del><ins>+ void sub32(TrustedImm32 imm, AbsoluteAddress address)
</ins><span class="cx"> {
</span><span class="cx"> /*
</span><span class="cx"> li addrTemp, address
</span><span class="lines">@@ -422,7 +422,7 @@
</span><span class="cx"> subu dataTemp, dataTemp, immTemp
</span><span class="cx"> sw dataTemp, 0(addrTemp)
</span><span class="cx"> */
</span><del>- move(ImmPtr(address.m_ptr), addrTempRegister);
</del><ins>+ move(TrustedImmPtr(address.m_ptr), addrTempRegister);
</ins><span class="cx"> m_assembler.lw(dataTempRegister, addrTempRegister, 0);
</span><span class="cx">
</span><span class="cx"> if (!imm.m_isPointer && imm.m_value >= -32767 && imm.m_value <= 32768
</span><span class="lines">@@ -441,7 +441,7 @@
</span><span class="cx"> m_assembler.xorInsn(dest, dest, src);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void xor32(Imm32 imm, RegisterID dest)
</del><ins>+ void xor32(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> /*
</span><span class="cx"> li immTemp, imm
</span><span class="lines">@@ -459,7 +459,7 @@
</span><span class="cx"> // Memory access operations:
</span><span class="cx"> //
</span><span class="cx"> // Loads are of the form load(address, destination) and stores of the form
</span><del>- // store(source, address). The source for a store may be an Imm32. Address
</del><ins>+ // store(source, address). The source for a store may be an TrustedImm32. Address
</ins><span class="cx"> // operand objects to loads and store will be implicitly constructed if a
</span><span class="cx"> // register is passed.
</span><span class="cx">
</span><span class="lines">@@ -587,7 +587,7 @@
</span><span class="cx"> li addrTemp, address
</span><span class="cx"> lw dest, 0(addrTemp)
</span><span class="cx"> */
</span><del>- move(ImmPtr(address), addrTempRegister);
</del><ins>+ move(TrustedImmPtr(address), addrTempRegister);
</ins><span class="cx"> m_assembler.lw(dest, addrTempRegister, 0);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -601,7 +601,7 @@
</span><span class="cx"> lw dest, 0(addrTemp)
</span><span class="cx"> */
</span><span class="cx"> DataLabel32 dataLabel(this);
</span><del>- move(Imm32(address.offset), addrTempRegister);
</del><ins>+ move(TrustedImm32(address.offset), addrTempRegister);
</ins><span class="cx"> m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
</span><span class="cx"> m_assembler.lw(dest, addrTempRegister, 0);
</span><span class="cx"> m_fixedWidth = false;
</span><span class="lines">@@ -666,7 +666,7 @@
</span><span class="cx"> sw src, 0(addrTemp)
</span><span class="cx"> */
</span><span class="cx"> DataLabel32 dataLabel(this);
</span><del>- move(Imm32(address.offset), addrTempRegister);
</del><ins>+ move(TrustedImm32(address.offset), addrTempRegister);
</ins><span class="cx"> m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
</span><span class="cx"> m_assembler.sw(src, addrTempRegister, 0);
</span><span class="cx"> m_fixedWidth = false;
</span><span class="lines">@@ -719,7 +719,7 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void store32(Imm32 imm, ImplicitAddress address)
</del><ins>+ void store32(TrustedImm32 imm, ImplicitAddress address)
</ins><span class="cx"> {
</span><span class="cx"> if (address.offset >= -32768 && address.offset <= 32767
</span><span class="cx"> && !m_fixedWidth) {
</span><span class="lines">@@ -755,11 +755,11 @@
</span><span class="cx"> li addrTemp, address
</span><span class="cx"> sw src, 0(addrTemp)
</span><span class="cx"> */
</span><del>- move(ImmPtr(address), addrTempRegister);
</del><ins>+ move(TrustedImmPtr(address), addrTempRegister);
</ins><span class="cx"> m_assembler.sw(src, addrTempRegister, 0);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void store32(Imm32 imm, const void* address)
</del><ins>+ void store32(TrustedImm32 imm, const void* address)
</ins><span class="cx"> {
</span><span class="cx"> /*
</span><span class="cx"> li immTemp, imm
</span><span class="lines">@@ -767,11 +767,11 @@
</span><span class="cx"> sw src, 0(addrTemp)
</span><span class="cx"> */
</span><span class="cx"> if (!imm.m_isPointer && !imm.m_value && !m_fixedWidth) {
</span><del>- move(ImmPtr(address), addrTempRegister);
</del><ins>+ move(TrustedImmPtr(address), addrTempRegister);
</ins><span class="cx"> m_assembler.sw(MIPSRegisters::zero, addrTempRegister, 0);
</span><span class="cx"> } else {
</span><span class="cx"> move(imm, immTempRegister);
</span><del>- move(ImmPtr(address), addrTempRegister);
</del><ins>+ move(TrustedImmPtr(address), addrTempRegister);
</ins><span class="cx"> m_assembler.sw(immTempRegister, addrTempRegister, 0);
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="lines">@@ -831,7 +831,7 @@
</span><span class="cx"> push(dataTempRegister);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void push(Imm32 imm)
</del><ins>+ void push(TrustedImm32 imm)
</ins><span class="cx"> {
</span><span class="cx"> move(imm, immTempRegister);
</span><span class="cx"> push(immTempRegister);
</span><span class="lines">@@ -841,7 +841,7 @@
</span><span class="cx"> //
</span><span class="cx"> // Move values in registers.
</span><span class="cx">
</span><del>- void move(Imm32 imm, RegisterID dest)
</del><ins>+ void move(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> if (!imm.m_isPointer && !imm.m_value && !m_fixedWidth)
</span><span class="cx"> move(MIPSRegisters::zero, dest);
</span><span class="lines">@@ -858,9 +858,9 @@
</span><span class="cx"> m_assembler.move(dest, src);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void move(ImmPtr imm, RegisterID dest)
</del><ins>+ void move(TrustedImmPtr imm, RegisterID dest)
</ins><span class="cx"> {
</span><del>- move(Imm32(imm), dest);
</del><ins>+ move(TrustedImm32(imm), dest);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void swap(RegisterID reg1, RegisterID reg2)
</span><span class="lines">@@ -894,13 +894,13 @@
</span><span class="cx"> // used (representing the names 'below' and 'above').
</span><span class="cx"> //
</span><span class="cx"> // Operands to the comparision are provided in the expected order, e.g.
</span><del>- // jle32(reg1, Imm32(5)) will branch if the value held in reg1, when
</del><ins>+ // jle32(reg1, TrustedImm32(5)) will branch if the value held in reg1, when
</ins><span class="cx"> // treated as a signed 32bit value, is less than or equal to 5.
</span><span class="cx"> //
</span><span class="cx"> // jz and jnz test whether the first operand is equal to zero, and take
</span><span class="cx"> // an optional second operand of a mask under which to perform the test.
</span><span class="cx">
</span><del>- Jump branch8(Condition cond, Address left, Imm32 right)
</del><ins>+ Jump branch8(Condition cond, Address left, TrustedImm32 right)
</ins><span class="cx"> {
</span><span class="cx"> // Make sure the immediate value is unsigned 8 bits.
</span><span class="cx"> ASSERT(!(right.m_value & 0xFFFFFF00));
</span><span class="lines">@@ -985,7 +985,7 @@
</span><span class="cx"> return Jump();
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branch32(Condition cond, RegisterID left, Imm32 right)
</del><ins>+ Jump branch32(Condition cond, RegisterID left, TrustedImm32 right)
</ins><span class="cx"> {
</span><span class="cx"> move(right, immTempRegister);
</span><span class="cx"> return branch32(cond, left, immTempRegister);
</span><span class="lines">@@ -1003,14 +1003,14 @@
</span><span class="cx"> return branch32(cond, dataTempRegister, right);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branch32(Condition cond, Address left, Imm32 right)
</del><ins>+ Jump branch32(Condition cond, Address left, TrustedImm32 right)
</ins><span class="cx"> {
</span><span class="cx"> load32(left, dataTempRegister);
</span><span class="cx"> move(right, immTempRegister);
</span><span class="cx"> return branch32(cond, dataTempRegister, immTempRegister);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branch32(Condition cond, BaseIndex left, Imm32 right)
</del><ins>+ Jump branch32(Condition cond, BaseIndex left, TrustedImm32 right)
</ins><span class="cx"> {
</span><span class="cx"> load32(left, dataTempRegister);
</span><span class="cx"> // Be careful that the previous load32() uses immTempRegister.
</span><span class="lines">@@ -1019,7 +1019,7 @@
</span><span class="cx"> return branch32(cond, dataTempRegister, immTempRegister);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branch32WithUnalignedHalfWords(Condition cond, BaseIndex left, Imm32 right)
</del><ins>+ Jump branch32WithUnalignedHalfWords(Condition cond, BaseIndex left, TrustedImm32 right)
</ins><span class="cx"> {
</span><span class="cx"> load32WithUnalignedHalfWords(left, dataTempRegister);
</span><span class="cx"> // Be careful that the previous load32WithUnalignedHalfWords()
</span><span class="lines">@@ -1035,7 +1035,7 @@
</span><span class="cx"> return branch32(cond, dataTempRegister, right);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branch32(Condition cond, AbsoluteAddress left, Imm32 right)
</del><ins>+ Jump branch32(Condition cond, AbsoluteAddress left, TrustedImm32 right)
</ins><span class="cx"> {
</span><span class="cx"> load32(left.m_ptr, dataTempRegister);
</span><span class="cx"> move(right, immTempRegister);
</span><span class="lines">@@ -1048,7 +1048,7 @@
</span><span class="cx"> return branch32(cond, dataTempRegister, right);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branch16(Condition cond, BaseIndex left, Imm32 right)
</del><ins>+ Jump branch16(Condition cond, BaseIndex left, TrustedImm32 right)
</ins><span class="cx"> {
</span><span class="cx"> ASSERT(!(right.m_value & 0xFFFF0000));
</span><span class="cx"> load16(left, dataTempRegister);
</span><span class="lines">@@ -1067,7 +1067,7 @@
</span><span class="cx"> return branchNotEqual(cmpTempRegister, MIPSRegisters::zero);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchTest32(Condition cond, RegisterID reg, Imm32 mask = Imm32(-1))
</del><ins>+ Jump branchTest32(Condition cond, RegisterID reg, TrustedImm32 mask = TrustedImm32(-1))
</ins><span class="cx"> {
</span><span class="cx"> ASSERT((cond == Zero) || (cond == NonZero));
</span><span class="cx"> if (mask.m_value == -1 && !m_fixedWidth) {
</span><span class="lines">@@ -1079,19 +1079,19 @@
</span><span class="cx"> return branchTest32(cond, reg, immTempRegister);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchTest32(Condition cond, Address address, Imm32 mask = Imm32(-1))
</del><ins>+ Jump branchTest32(Condition cond, Address address, TrustedImm32 mask = TrustedImm32(-1))
</ins><span class="cx"> {
</span><span class="cx"> load32(address, dataTempRegister);
</span><span class="cx"> return branchTest32(cond, dataTempRegister, mask);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchTest32(Condition cond, BaseIndex address, Imm32 mask = Imm32(-1))
</del><ins>+ Jump branchTest32(Condition cond, BaseIndex address, TrustedImm32 mask = TrustedImm32(-1))
</ins><span class="cx"> {
</span><span class="cx"> load32(address, dataTempRegister);
</span><span class="cx"> return branchTest32(cond, dataTempRegister, mask);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchTest8(Condition cond, Address address, Imm32 mask = Imm32(-1))
</del><ins>+ Jump branchTest8(Condition cond, Address address, TrustedImm32 mask = TrustedImm32(-1))
</ins><span class="cx"> {
</span><span class="cx"> load8(address, dataTempRegister);
</span><span class="cx"> return branchTest32(cond, dataTempRegister, mask);
</span><span class="lines">@@ -1174,7 +1174,7 @@
</span><span class="cx"> return Jump();
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchAdd32(Condition cond, Imm32 imm, RegisterID dest)
</del><ins>+ Jump branchAdd32(Condition cond, TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> move(imm, immTempRegister);
</span><span class="cx"> return branchAdd32(cond, immTempRegister, dest);
</span><span class="lines">@@ -1225,7 +1225,7 @@
</span><span class="cx"> return Jump();
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchMul32(Condition cond, Imm32 imm, RegisterID src, RegisterID dest)
</del><ins>+ Jump branchMul32(Condition cond, TrustedImm32 imm, RegisterID src, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> move(imm, immTempRegister);
</span><span class="cx"> move(src, dest);
</span><span class="lines">@@ -1279,7 +1279,7 @@
</span><span class="cx"> return Jump();
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchSub32(Condition cond, Imm32 imm, RegisterID dest)
</del><ins>+ Jump branchSub32(Condition cond, TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> move(imm, immTempRegister);
</span><span class="cx"> return branchSub32(cond, immTempRegister, dest);
</span><span class="lines">@@ -1360,7 +1360,7 @@
</span><span class="cx"> set32Compare32(cond, left, right, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void set8Compare32(Condition cond, RegisterID left, Imm32 right, RegisterID dest)
</del><ins>+ void set8Compare32(Condition cond, RegisterID left, TrustedImm32 right, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> move(right, immTempRegister);
</span><span class="cx"> set32Compare32(cond, left, immTempRegister, dest);
</span><span class="lines">@@ -1417,13 +1417,13 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void set32Compare32(Condition cond, RegisterID left, Imm32 right, RegisterID dest)
</del><ins>+ void set32Compare32(Condition cond, RegisterID left, TrustedImm32 right, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> move(right, immTempRegister);
</span><span class="cx"> set32Compare32(cond, left, immTempRegister, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void set32Test8(Condition cond, Address address, Imm32 mask, RegisterID dest)
</del><ins>+ void set32Test8(Condition cond, Address address, TrustedImm32 mask, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> ASSERT((cond == Zero) || (cond == NonZero));
</span><span class="cx"> load8(address, dataTempRegister);
</span><span class="lines">@@ -1443,7 +1443,7 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void set32Test32(Condition cond, Address address, Imm32 mask, RegisterID dest)
</del><ins>+ void set32Test32(Condition cond, Address address, TrustedImm32 mask, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> ASSERT((cond == Zero) || (cond == NonZero));
</span><span class="cx"> load32(address, dataTempRegister);
</span><span class="lines">@@ -1463,7 +1463,7 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>- DataLabel32 moveWithPatch(Imm32 imm, RegisterID dest)
</del><ins>+ DataLabel32 moveWithPatch(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> m_fixedWidth = true;
</span><span class="cx"> DataLabel32 label(this);
</span><span class="lines">@@ -1472,7 +1472,7 @@
</span><span class="cx"> return label;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- DataLabelPtr moveWithPatch(ImmPtr initialValue, RegisterID dest)
</del><ins>+ DataLabelPtr moveWithPatch(TrustedImmPtr initialValue, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> m_fixedWidth = true;
</span><span class="cx"> DataLabelPtr label(this);
</span><span class="lines">@@ -1481,7 +1481,7 @@
</span><span class="cx"> return label;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchPtrWithPatch(Condition cond, RegisterID left, DataLabelPtr& dataLabel, ImmPtr initialRightValue = ImmPtr(0))
</del><ins>+ Jump branchPtrWithPatch(Condition cond, RegisterID left, DataLabelPtr& dataLabel, TrustedImmPtr initialRightValue = TrustedImmPtr(0))
</ins><span class="cx"> {
</span><span class="cx"> m_fixedWidth = true;
</span><span class="cx"> dataLabel = moveWithPatch(initialRightValue, immTempRegister);
</span><span class="lines">@@ -1490,7 +1490,7 @@
</span><span class="cx"> return temp;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchPtrWithPatch(Condition cond, Address left, DataLabelPtr& dataLabel, ImmPtr initialRightValue = ImmPtr(0))
</del><ins>+ Jump branchPtrWithPatch(Condition cond, Address left, DataLabelPtr& dataLabel, TrustedImmPtr initialRightValue = TrustedImmPtr(0))
</ins><span class="cx"> {
</span><span class="cx"> m_fixedWidth = true;
</span><span class="cx"> load32(left, dataTempRegister);
</span><span class="lines">@@ -1500,7 +1500,7 @@
</span><span class="cx"> return temp;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- DataLabelPtr storePtrWithPatch(ImmPtr initialValue, ImplicitAddress address)
</del><ins>+ DataLabelPtr storePtrWithPatch(TrustedImmPtr initialValue, ImplicitAddress address)
</ins><span class="cx"> {
</span><span class="cx"> m_fixedWidth = true;
</span><span class="cx"> DataLabelPtr dataLabel = moveWithPatch(initialValue, dataTempRegister);
</span><span class="lines">@@ -1511,14 +1511,14 @@
</span><span class="cx">
</span><span class="cx"> DataLabelPtr storePtrWithPatch(ImplicitAddress address)
</span><span class="cx"> {
</span><del>- return storePtrWithPatch(ImmPtr(0), address);
</del><ins>+ return storePtrWithPatch(TrustedImmPtr(0), address);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> Call tailRecursiveCall()
</span><span class="cx"> {
</span><span class="cx"> // Like a normal call, but don't update the returned address register
</span><span class="cx"> m_fixedWidth = true;
</span><del>- move(Imm32(0), MIPSRegisters::t9);
</del><ins>+ move(TrustedImm32(0), MIPSRegisters::t9);
</ins><span class="cx"> m_assembler.jr(MIPSRegisters::t9);
</span><span class="cx"> m_assembler.nop();
</span><span class="cx"> m_fixedWidth = false;
</span><span class="lines">@@ -1540,7 +1540,7 @@
</span><span class="cx"> lwc1 dest, 0(addrTemp)
</span><span class="cx"> lwc1 dest+1, 4(addrTemp)
</span><span class="cx"> */
</span><del>- move(Imm32(address.offset), addrTempRegister);
</del><ins>+ move(TrustedImm32(address.offset), addrTempRegister);
</ins><span class="cx"> m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
</span><span class="cx"> m_assembler.lwc1(dest, addrTempRegister, 0);
</span><span class="cx"> m_assembler.lwc1(FPRegisterID(dest + 1), addrTempRegister, 4);
</span><span class="lines">@@ -1569,7 +1569,7 @@
</span><span class="cx"> lwc1 dest, 0(addrTemp)
</span><span class="cx"> lwc1 dest+1, 4(addrTemp)
</span><span class="cx"> */
</span><del>- move(ImmPtr(address), addrTempRegister);
</del><ins>+ move(TrustedImmPtr(address), addrTempRegister);
</ins><span class="cx"> m_assembler.lwc1(dest, addrTempRegister, 0);
</span><span class="cx"> m_assembler.lwc1(FPRegisterID(dest + 1), addrTempRegister, 4);
</span><span class="cx"> #else
</span><span class="lines">@@ -1577,7 +1577,7 @@
</span><span class="cx"> li addrTemp, address
</span><span class="cx"> ldc1 dest, 0(addrTemp)
</span><span class="cx"> */
</span><del>- move(ImmPtr(address), addrTempRegister);
</del><ins>+ move(TrustedImmPtr(address), addrTempRegister);
</ins><span class="cx"> m_assembler.ldc1(dest, addrTempRegister, 0);
</span><span class="cx"> #endif
</span><span class="cx"> }
</span><span class="lines">@@ -1592,7 +1592,7 @@
</span><span class="cx"> swc1 dest, 0(addrTemp)
</span><span class="cx"> swc1 dest+1, 4(addrTemp)
</span><span class="cx"> */
</span><del>- move(Imm32(address.offset), addrTempRegister);
</del><ins>+ move(TrustedImm32(address.offset), addrTempRegister);
</ins><span class="cx"> m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
</span><span class="cx"> m_assembler.swc1(src, addrTempRegister, 0);
</span><span class="cx"> m_assembler.swc1(FPRegisterID(src + 1), addrTempRegister, 4);
</span><span class="lines">@@ -1779,7 +1779,7 @@
</span><span class="cx"> {
</span><span class="cx"> m_assembler.truncwd(fpTempRegister, src);
</span><span class="cx"> m_assembler.mfc1(dest, fpTempRegister);
</span><del>- return branch32(Equal, dest, Imm32(0x7fffffff));
</del><ins>+ return branch32(Equal, dest, TrustedImm32(0x7fffffff));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // Convert 'src' to an integer, and places the resulting 'dest'.
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerMacroAssemblerX86h"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86.h (82129 => 82130)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86.h 2011-03-28 17:10:30 UTC (rev 82129)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86.h 2011-03-28 17:14:57 UTC (rev 82130)
</span><span class="lines">@@ -52,32 +52,32 @@
</span><span class="cx"> using MacroAssemblerX86Common::loadDouble;
</span><span class="cx"> using MacroAssemblerX86Common::convertInt32ToDouble;
</span><span class="cx">
</span><del>- void add32(Imm32 imm, RegisterID src, RegisterID dest)
</del><ins>+ void add32(TrustedImm32 imm, RegisterID src, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.leal_mr(imm.m_value, src, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void add32(Imm32 imm, AbsoluteAddress address)
</del><ins>+ void add32(TrustedImm32 imm, AbsoluteAddress address)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.addl_im(imm.m_value, address.m_ptr);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void addWithCarry32(Imm32 imm, AbsoluteAddress address)
</del><ins>+ void addWithCarry32(TrustedImm32 imm, AbsoluteAddress address)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.adcl_im(imm.m_value, address.m_ptr);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void and32(Imm32 imm, AbsoluteAddress address)
</del><ins>+ void and32(TrustedImm32 imm, AbsoluteAddress address)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.andl_im(imm.m_value, address.m_ptr);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void or32(Imm32 imm, AbsoluteAddress address)
</del><ins>+ void or32(TrustedImm32 imm, AbsoluteAddress address)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.orl_im(imm.m_value, address.m_ptr);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void sub32(Imm32 imm, AbsoluteAddress address)
</del><ins>+ void sub32(TrustedImm32 imm, AbsoluteAddress address)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.subl_im(imm.m_value, address.m_ptr);
</span><span class="cx"> }
</span><span class="lines">@@ -98,7 +98,7 @@
</span><span class="cx"> m_assembler.cvtsi2sd_mr(src.m_ptr, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void store32(Imm32 imm, void* address)
</del><ins>+ void store32(TrustedImm32 imm, void* address)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.movl_i32m(imm.m_value, address);
</span><span class="cx"> }
</span><span class="lines">@@ -114,7 +114,7 @@
</span><span class="cx"> return Jump(m_assembler.jCC(x86Condition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branch32(Condition cond, AbsoluteAddress left, Imm32 right)
</del><ins>+ Jump branch32(Condition cond, AbsoluteAddress left, TrustedImm32 right)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.cmpl_im(right.m_value, left.m_ptr);
</span><span class="cx"> return Jump(m_assembler.jCC(x86Condition(cond)));
</span><span class="lines">@@ -136,27 +136,27 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx">
</span><del>- DataLabelPtr moveWithPatch(ImmPtr initialValue, RegisterID dest)
</del><ins>+ DataLabelPtr moveWithPatch(TrustedImmPtr initialValue, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.movl_i32r(initialValue.asIntptr(), dest);
</span><span class="cx"> return DataLabelPtr(this);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchPtrWithPatch(Condition cond, RegisterID left, DataLabelPtr& dataLabel, ImmPtr initialRightValue = ImmPtr(0))
</del><ins>+ Jump branchPtrWithPatch(Condition cond, RegisterID left, DataLabelPtr& dataLabel, TrustedImmPtr initialRightValue = TrustedImmPtr(0))
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.cmpl_ir_force32(initialRightValue.asIntptr(), left);
</span><span class="cx"> dataLabel = DataLabelPtr(this);
</span><span class="cx"> return Jump(m_assembler.jCC(x86Condition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchPtrWithPatch(Condition cond, Address left, DataLabelPtr& dataLabel, ImmPtr initialRightValue = ImmPtr(0))
</del><ins>+ Jump branchPtrWithPatch(Condition cond, Address left, DataLabelPtr& dataLabel, TrustedImmPtr initialRightValue = TrustedImmPtr(0))
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.cmpl_im_force32(initialRightValue.asIntptr(), left.offset, left.base);
</span><span class="cx"> dataLabel = DataLabelPtr(this);
</span><span class="cx"> return Jump(m_assembler.jCC(x86Condition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- DataLabelPtr storePtrWithPatch(ImmPtr initialValue, ImplicitAddress address)
</del><ins>+ DataLabelPtr storePtrWithPatch(TrustedImmPtr initialValue, ImplicitAddress address)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.movl_i32m(initialValue.asIntptr(), address.offset, address.base);
</span><span class="cx"> return DataLabelPtr(this);
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerMacroAssemblerX86Commonh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h (82129 => 82130)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h 2011-03-28 17:10:30 UTC (rev 82129)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h 2011-03-28 17:14:57 UTC (rev 82130)
</span><span class="lines">@@ -83,7 +83,7 @@
</span><span class="cx"> // Integer arithmetic operations:
</span><span class="cx"> //
</span><span class="cx"> // Operations are typically two operand - operation(source, srcDst)
</span><del>- // For many operations the source may be an Imm32, the srcDst operand
</del><ins>+ // For many operations the source may be an TrustedImm32, the srcDst operand
</ins><span class="cx"> // may often be a memory location (explictly described using an Address
</span><span class="cx"> // object).
</span><span class="cx">
</span><span class="lines">@@ -92,12 +92,12 @@
</span><span class="cx"> m_assembler.addl_rr(src, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void add32(Imm32 imm, Address address)
</del><ins>+ void add32(TrustedImm32 imm, Address address)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.addl_im(imm.m_value, address.offset, address.base);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void add32(Imm32 imm, RegisterID dest)
</del><ins>+ void add32(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.addl_ir(imm.m_value, dest);
</span><span class="cx"> }
</span><span class="lines">@@ -117,7 +117,7 @@
</span><span class="cx"> m_assembler.andl_rr(src, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void and32(Imm32 imm, RegisterID dest)
</del><ins>+ void and32(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.andl_ir(imm.m_value, dest);
</span><span class="cx"> }
</span><span class="lines">@@ -132,7 +132,7 @@
</span><span class="cx"> m_assembler.andl_mr(src.offset, src.base, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void and32(Imm32 imm, Address address)
</del><ins>+ void and32(TrustedImm32 imm, Address address)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.andl_im(imm.m_value, address.offset, address.base);
</span><span class="cx"> }
</span><span class="lines">@@ -149,7 +149,7 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void and32(Imm32 imm, RegisterID src, RegisterID dest)
</del><ins>+ void and32(TrustedImm32 imm, RegisterID src, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> move(src, dest);
</span><span class="cx"> and32(imm, dest);
</span><span class="lines">@@ -180,12 +180,12 @@
</span><span class="cx"> lshift32(shift_amount, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void lshift32(Imm32 imm, RegisterID dest)
</del><ins>+ void lshift32(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.shll_i8r(imm.m_value, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void lshift32(RegisterID src, Imm32 imm, RegisterID dest)
</del><ins>+ void lshift32(RegisterID src, TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> if (src != dest)
</span><span class="cx"> move(src, dest);
</span><span class="lines">@@ -202,7 +202,7 @@
</span><span class="cx"> m_assembler.imull_mr(src.offset, src.base, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void mul32(Imm32 imm, RegisterID src, RegisterID dest)
</del><ins>+ void mul32(TrustedImm32 imm, RegisterID src, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.imull_i32r(src, imm.m_value, dest);
</span><span class="cx"> }
</span><span class="lines">@@ -232,7 +232,7 @@
</span><span class="cx"> m_assembler.orl_rr(src, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void or32(Imm32 imm, RegisterID dest)
</del><ins>+ void or32(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.orl_ir(imm.m_value, dest);
</span><span class="cx"> }
</span><span class="lines">@@ -247,7 +247,7 @@
</span><span class="cx"> m_assembler.orl_mr(src.offset, src.base, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void or32(Imm32 imm, Address address)
</del><ins>+ void or32(TrustedImm32 imm, Address address)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.orl_im(imm.m_value, address.offset, address.base);
</span><span class="cx"> }
</span><span class="lines">@@ -264,7 +264,7 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void or32(Imm32 imm, RegisterID src, RegisterID dest)
</del><ins>+ void or32(TrustedImm32 imm, RegisterID src, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> move(src, dest);
</span><span class="cx"> or32(imm, dest);
</span><span class="lines">@@ -295,12 +295,12 @@
</span><span class="cx"> rshift32(shift_amount, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void rshift32(Imm32 imm, RegisterID dest)
</del><ins>+ void rshift32(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.sarl_i8r(imm.m_value, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void rshift32(RegisterID src, Imm32 imm, RegisterID dest)
</del><ins>+ void rshift32(RegisterID src, TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> if (src != dest)
</span><span class="cx"> move(src, dest);
</span><span class="lines">@@ -332,12 +332,12 @@
</span><span class="cx"> urshift32(shift_amount, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void urshift32(Imm32 imm, RegisterID dest)
</del><ins>+ void urshift32(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.shrl_i8r(imm.m_value, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void urshift32(RegisterID src, Imm32 imm, RegisterID dest)
</del><ins>+ void urshift32(RegisterID src, TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> if (src != dest)
</span><span class="cx"> move(src, dest);
</span><span class="lines">@@ -349,12 +349,12 @@
</span><span class="cx"> m_assembler.subl_rr(src, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void sub32(Imm32 imm, RegisterID dest)
</del><ins>+ void sub32(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.subl_ir(imm.m_value, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void sub32(Imm32 imm, Address address)
</del><ins>+ void sub32(TrustedImm32 imm, Address address)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.subl_im(imm.m_value, address.offset, address.base);
</span><span class="cx"> }
</span><span class="lines">@@ -375,12 +375,12 @@
</span><span class="cx"> m_assembler.xorl_rr(src, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void xor32(Imm32 imm, Address dest)
</del><ins>+ void xor32(TrustedImm32 imm, Address dest)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.xorl_im(imm.m_value, dest.offset, dest.base);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void xor32(Imm32 imm, RegisterID dest)
</del><ins>+ void xor32(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.xorl_ir(imm.m_value, dest);
</span><span class="cx"> }
</span><span class="lines">@@ -398,7 +398,7 @@
</span><span class="cx"> void xor32(RegisterID op1, RegisterID op2, RegisterID dest)
</span><span class="cx"> {
</span><span class="cx"> if (op1 == op2)
</span><del>- move(Imm32(0), dest);
</del><ins>+ move(TrustedImm32(0), dest);
</ins><span class="cx"> else if (op1 == dest)
</span><span class="cx"> xor32(op2, dest);
</span><span class="cx"> else {
</span><span class="lines">@@ -407,7 +407,7 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void xor32(Imm32 imm, RegisterID src, RegisterID dest)
</del><ins>+ void xor32(TrustedImm32 imm, RegisterID src, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> move(src, dest);
</span><span class="cx"> xor32(imm, dest);
</span><span class="lines">@@ -421,7 +421,7 @@
</span><span class="cx"> // Memory access operations:
</span><span class="cx"> //
</span><span class="cx"> // Loads are of the form load(address, destination) and stores of the form
</span><del>- // store(source, address). The source for a store may be an Imm32. Address
</del><ins>+ // store(source, address). The source for a store may be an TrustedImm32. Address
</ins><span class="cx"> // operand objects to loads and store will be implicitly constructed if a
</span><span class="cx"> // register is passed.
</span><span class="cx">
</span><span class="lines">@@ -472,7 +472,7 @@
</span><span class="cx"> m_assembler.movl_rm(src, address.offset, address.base, address.index, address.scale);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void store32(Imm32 imm, ImplicitAddress address)
</del><ins>+ void store32(TrustedImm32 imm, ImplicitAddress address)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.movl_i32m(imm.m_value, address.offset, address.base);
</span><span class="cx"> }
</span><span class="lines">@@ -637,7 +637,7 @@
</span><span class="cx"> {
</span><span class="cx"> ASSERT(isSSE2Present());
</span><span class="cx"> m_assembler.cvttsd2si_rr(src, dest);
</span><del>- return branch32(branchType ? NotEqual : Equal, dest, Imm32(0x80000000));
</del><ins>+ return branch32(branchType ? NotEqual : Equal, dest, TrustedImm32(0x80000000));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // Convert 'src' to an integer, and places the resulting 'dest'.
</span><span class="lines">@@ -696,7 +696,7 @@
</span><span class="cx"> m_assembler.push_m(address.offset, address.base);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void push(Imm32 imm)
</del><ins>+ void push(TrustedImm32 imm)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.push_i32(imm.m_value);
</span><span class="cx"> }
</span><span class="lines">@@ -706,9 +706,9 @@
</span><span class="cx"> //
</span><span class="cx"> // Move values in registers.
</span><span class="cx">
</span><del>- void move(Imm32 imm, RegisterID dest)
</del><ins>+ void move(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><del>- // Note: on 64-bit the Imm32 value is zero extended into the register, it
</del><ins>+ // Note: on 64-bit the TrustedImm32 value is zero extended into the register, it
</ins><span class="cx"> // may be useful to have a separate version that sign extends the value?
</span><span class="cx"> if (!imm.m_value)
</span><span class="cx"> m_assembler.xorl_rr(dest, dest);
</span><span class="lines">@@ -725,7 +725,7 @@
</span><span class="cx"> m_assembler.movq_rr(src, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void move(ImmPtr imm, RegisterID dest)
</del><ins>+ void move(TrustedImmPtr imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.movq_i64r(imm.asIntptr(), dest);
</span><span class="cx"> }
</span><span class="lines">@@ -752,7 +752,7 @@
</span><span class="cx"> m_assembler.movl_rr(src, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void move(ImmPtr imm, RegisterID dest)
</del><ins>+ void move(TrustedImmPtr imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.movl_i32r(imm.asIntptr(), dest);
</span><span class="cx"> }
</span><span class="lines">@@ -787,14 +787,14 @@
</span><span class="cx"> // used (representing the names 'below' and 'above').
</span><span class="cx"> //
</span><span class="cx"> // Operands to the comparision are provided in the expected order, e.g.
</span><del>- // jle32(reg1, Imm32(5)) will branch if the value held in reg1, when
</del><ins>+ // jle32(reg1, TrustedImm32(5)) will branch if the value held in reg1, when
</ins><span class="cx"> // treated as a signed 32bit value, is less than or equal to 5.
</span><span class="cx"> //
</span><span class="cx"> // jz and jnz test whether the first operand is equal to zero, and take
</span><span class="cx"> // an optional second operand of a mask under which to perform the test.
</span><span class="cx">
</span><span class="cx"> public:
</span><del>- Jump branch8(Condition cond, Address left, Imm32 right)
</del><ins>+ Jump branch8(Condition cond, Address left, TrustedImm32 right)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.cmpb_im(right.m_value, left.offset, left.base);
</span><span class="cx"> return Jump(m_assembler.jCC(x86Condition(cond)));
</span><span class="lines">@@ -806,7 +806,7 @@
</span><span class="cx"> return Jump(m_assembler.jCC(x86Condition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branch32(Condition cond, RegisterID left, Imm32 right)
</del><ins>+ Jump branch32(Condition cond, RegisterID left, TrustedImm32 right)
</ins><span class="cx"> {
</span><span class="cx"> if (((cond == Equal) || (cond == NotEqual)) && !right.m_value)
</span><span class="cx"> m_assembler.testl_rr(left, left);
</span><span class="lines">@@ -827,19 +827,19 @@
</span><span class="cx"> return Jump(m_assembler.jCC(x86Condition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branch32(Condition cond, Address left, Imm32 right)
</del><ins>+ Jump branch32(Condition cond, Address left, TrustedImm32 right)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.cmpl_im(right.m_value, left.offset, left.base);
</span><span class="cx"> return Jump(m_assembler.jCC(x86Condition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branch32(Condition cond, BaseIndex left, Imm32 right)
</del><ins>+ Jump branch32(Condition cond, BaseIndex left, TrustedImm32 right)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.cmpl_im(right.m_value, left.offset, left.base, left.index, left.scale);
</span><span class="cx"> return Jump(m_assembler.jCC(x86Condition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branch32WithUnalignedHalfWords(Condition cond, BaseIndex left, Imm32 right)
</del><ins>+ Jump branch32WithUnalignedHalfWords(Condition cond, BaseIndex left, TrustedImm32 right)
</ins><span class="cx"> {
</span><span class="cx"> return branch32(cond, left, right);
</span><span class="cx"> }
</span><span class="lines">@@ -850,7 +850,7 @@
</span><span class="cx"> return Jump(m_assembler.jCC(x86Condition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branch16(Condition cond, BaseIndex left, Imm32 right)
</del><ins>+ Jump branch16(Condition cond, BaseIndex left, TrustedImm32 right)
</ins><span class="cx"> {
</span><span class="cx"> ASSERT(!(right.m_value & 0xFFFF0000));
</span><span class="cx">
</span><span class="lines">@@ -865,7 +865,7 @@
</span><span class="cx"> return Jump(m_assembler.jCC(x86Condition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchTest32(Condition cond, RegisterID reg, Imm32 mask = Imm32(-1))
</del><ins>+ Jump branchTest32(Condition cond, RegisterID reg, TrustedImm32 mask = TrustedImm32(-1))
</ins><span class="cx"> {
</span><span class="cx"> ASSERT((cond == Zero) || (cond == NonZero) || (cond == Signed));
</span><span class="cx"> // if we are only interested in the low seven bits, this can be tested with a testb
</span><span class="lines">@@ -878,7 +878,7 @@
</span><span class="cx"> return Jump(m_assembler.jCC(x86Condition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchTest32(Condition cond, Address address, Imm32 mask = Imm32(-1))
</del><ins>+ Jump branchTest32(Condition cond, Address address, TrustedImm32 mask = TrustedImm32(-1))
</ins><span class="cx"> {
</span><span class="cx"> ASSERT((cond == Zero) || (cond == NonZero) || (cond == Signed));
</span><span class="cx"> if (mask.m_value == -1)
</span><span class="lines">@@ -888,7 +888,7 @@
</span><span class="cx"> return Jump(m_assembler.jCC(x86Condition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchTest32(Condition cond, BaseIndex address, Imm32 mask = Imm32(-1))
</del><ins>+ Jump branchTest32(Condition cond, BaseIndex address, TrustedImm32 mask = TrustedImm32(-1))
</ins><span class="cx"> {
</span><span class="cx"> ASSERT((cond == Zero) || (cond == NonZero) || (cond == Signed));
</span><span class="cx"> if (mask.m_value == -1)
</span><span class="lines">@@ -898,9 +898,9 @@
</span><span class="cx"> return Jump(m_assembler.jCC(x86Condition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchTest8(Condition cond, RegisterID reg, Imm32 mask = Imm32(-1))
</del><ins>+ Jump branchTest8(Condition cond, RegisterID reg, TrustedImm32 mask = TrustedImm32(-1))
</ins><span class="cx"> {
</span><del>- // Byte in Imm32 is not well defined, so be a little permisive here, but don't accept nonsense values.
</del><ins>+ // Byte in TrustedImm32 is not well defined, so be a little permisive here, but don't accept nonsense values.
</ins><span class="cx"> ASSERT(mask.m_value >= -128 && mask.m_value <= 255);
</span><span class="cx"> ASSERT((cond == Zero) || (cond == NonZero) || (cond == Signed));
</span><span class="cx"> if (mask.m_value == -1)
</span><span class="lines">@@ -910,9 +910,9 @@
</span><span class="cx"> return Jump(m_assembler.jCC(x86Condition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchTest8(Condition cond, Address address, Imm32 mask = Imm32(-1))
</del><ins>+ Jump branchTest8(Condition cond, Address address, TrustedImm32 mask = TrustedImm32(-1))
</ins><span class="cx"> {
</span><del>- // Byte in Imm32 is not well defined, so be a little permisive here, but don't accept nonsense values.
</del><ins>+ // Byte in TrustedImm32 is not well defined, so be a little permisive here, but don't accept nonsense values.
</ins><span class="cx"> ASSERT(mask.m_value >= -128 && mask.m_value <= 255);
</span><span class="cx"> ASSERT((cond == Zero) || (cond == NonZero) || (cond == Signed));
</span><span class="cx"> if (mask.m_value == -1)
</span><span class="lines">@@ -922,9 +922,9 @@
</span><span class="cx"> return Jump(m_assembler.jCC(x86Condition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchTest8(Condition cond, BaseIndex address, Imm32 mask = Imm32(-1))
</del><ins>+ Jump branchTest8(Condition cond, BaseIndex address, TrustedImm32 mask = TrustedImm32(-1))
</ins><span class="cx"> {
</span><del>- // Byte in Imm32 is not well defined, so be a little permisive here, but don't accept nonsense values.
</del><ins>+ // Byte in TrustedImm32 is not well defined, so be a little permisive here, but don't accept nonsense values.
</ins><span class="cx"> ASSERT(mask.m_value >= -128 && mask.m_value <= 255);
</span><span class="cx"> ASSERT((cond == Zero) || (cond == NonZero) || (cond == Signed));
</span><span class="cx"> if (mask.m_value == -1)
</span><span class="lines">@@ -968,14 +968,14 @@
</span><span class="cx"> return Jump(m_assembler.jCC(x86Condition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchAdd32(Condition cond, Imm32 imm, RegisterID dest)
</del><ins>+ Jump branchAdd32(Condition cond, TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> ASSERT((cond == Overflow) || (cond == Signed) || (cond == Zero) || (cond == NonZero));
</span><span class="cx"> add32(imm, dest);
</span><span class="cx"> return Jump(m_assembler.jCC(x86Condition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchAdd32(Condition cond, Imm32 src, Address dest)
</del><ins>+ Jump branchAdd32(Condition cond, TrustedImm32 src, Address dest)
</ins><span class="cx"> {
</span><span class="cx"> ASSERT((cond == Overflow) || (cond == Zero) || (cond == NonZero));
</span><span class="cx"> add32(src, dest);
</span><span class="lines">@@ -1004,7 +1004,7 @@
</span><span class="cx"> return branchAdd32(cond, src1, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchAdd32(Condition cond, Imm32 imm, RegisterID src, RegisterID dest)
</del><ins>+ Jump branchAdd32(Condition cond, TrustedImm32 imm, RegisterID src, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> move(src, dest);
</span><span class="cx"> return branchAdd32(cond, imm, dest);
</span><span class="lines">@@ -1024,7 +1024,7 @@
</span><span class="cx"> return Jump(m_assembler.jCC(x86Condition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchMul32(Condition cond, Imm32 imm, RegisterID src, RegisterID dest)
</del><ins>+ Jump branchMul32(Condition cond, TrustedImm32 imm, RegisterID src, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> ASSERT(cond == Overflow);
</span><span class="cx"> mul32(imm, src, dest);
</span><span class="lines">@@ -1046,14 +1046,14 @@
</span><span class="cx"> return Jump(m_assembler.jCC(x86Condition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchSub32(Condition cond, Imm32 imm, RegisterID dest)
</del><ins>+ Jump branchSub32(Condition cond, TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> ASSERT((cond == Overflow) || (cond == Signed) || (cond == Zero) || (cond == NonZero));
</span><span class="cx"> sub32(imm, dest);
</span><span class="cx"> return Jump(m_assembler.jCC(x86Condition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchSub32(Condition cond, Imm32 imm, Address dest)
</del><ins>+ Jump branchSub32(Condition cond, TrustedImm32 imm, Address dest)
</ins><span class="cx"> {
</span><span class="cx"> ASSERT((cond == Overflow) || (cond == Zero) || (cond == NonZero));
</span><span class="cx"> sub32(imm, dest);
</span><span class="lines">@@ -1137,7 +1137,7 @@
</span><span class="cx"> m_assembler.setCC_r(x86Condition(cond), dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void set8Compare32(Condition cond, RegisterID left, Imm32 right, RegisterID dest)
</del><ins>+ void set8Compare32(Condition cond, RegisterID left, TrustedImm32 right, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> if (((cond == Equal) || (cond == NotEqual)) && !right.m_value)
</span><span class="cx"> m_assembler.testl_rr(left, left);
</span><span class="lines">@@ -1153,7 +1153,7 @@
</span><span class="cx"> m_assembler.movzbl_rr(dest, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void set32Compare32(Condition cond, RegisterID left, Imm32 right, RegisterID dest)
</del><ins>+ void set32Compare32(Condition cond, RegisterID left, TrustedImm32 right, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> if (((cond == Equal) || (cond == NotEqual)) && !right.m_value)
</span><span class="cx"> m_assembler.testl_rr(left, left);
</span><span class="lines">@@ -1168,7 +1168,7 @@
</span><span class="cx"> // dest-src, operations always have a dest? ... possibly not true, considering
</span><span class="cx"> // asm ops like test, or pseudo ops like pop().
</span><span class="cx">
</span><del>- void set32Test8(Condition cond, Address address, Imm32 mask, RegisterID dest)
</del><ins>+ void set32Test8(Condition cond, Address address, TrustedImm32 mask, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> if (mask.m_value == -1)
</span><span class="cx"> m_assembler.cmpb_im(0, address.offset, address.base);
</span><span class="lines">@@ -1178,7 +1178,7 @@
</span><span class="cx"> m_assembler.movzbl_rr(dest, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void set32Test32(Condition cond, Address address, Imm32 mask, RegisterID dest)
</del><ins>+ void set32Test32(Condition cond, Address address, TrustedImm32 mask, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> if (mask.m_value == -1)
</span><span class="cx"> m_assembler.cmpl_im(0, address.offset, address.base);
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerMacroAssemblerX86_64h"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86_64.h (82129 => 82130)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86_64.h 2011-03-28 17:10:30 UTC (rev 82129)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86_64.h 2011-03-28 17:14:57 UTC (rev 82130)
</span><span class="lines">@@ -52,27 +52,27 @@
</span><span class="cx"> using MacroAssemblerX86Common::loadDouble;
</span><span class="cx"> using MacroAssemblerX86Common::convertInt32ToDouble;
</span><span class="cx">
</span><del>- void add32(Imm32 imm, AbsoluteAddress address)
</del><ins>+ void add32(TrustedImm32 imm, AbsoluteAddress address)
</ins><span class="cx"> {
</span><del>- move(ImmPtr(address.m_ptr), scratchRegister);
</del><ins>+ move(TrustedImmPtr(address.m_ptr), scratchRegister);
</ins><span class="cx"> add32(imm, Address(scratchRegister));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void and32(Imm32 imm, AbsoluteAddress address)
</del><ins>+ void and32(TrustedImm32 imm, AbsoluteAddress address)
</ins><span class="cx"> {
</span><del>- move(ImmPtr(address.m_ptr), scratchRegister);
</del><ins>+ move(TrustedImmPtr(address.m_ptr), scratchRegister);
</ins><span class="cx"> and32(imm, Address(scratchRegister));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void or32(Imm32 imm, AbsoluteAddress address)
</del><ins>+ void or32(TrustedImm32 imm, AbsoluteAddress address)
</ins><span class="cx"> {
</span><del>- move(ImmPtr(address.m_ptr), scratchRegister);
</del><ins>+ move(TrustedImmPtr(address.m_ptr), scratchRegister);
</ins><span class="cx"> or32(imm, Address(scratchRegister));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void sub32(Imm32 imm, AbsoluteAddress address)
</del><ins>+ void sub32(TrustedImm32 imm, AbsoluteAddress address)
</ins><span class="cx"> {
</span><del>- move(ImmPtr(address.m_ptr), scratchRegister);
</del><ins>+ move(TrustedImmPtr(address.m_ptr), scratchRegister);
</ins><span class="cx"> sub32(imm, Address(scratchRegister));
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -89,23 +89,23 @@
</span><span class="cx">
</span><span class="cx"> void loadDouble(const void* address, FPRegisterID dest)
</span><span class="cx"> {
</span><del>- move(ImmPtr(address), scratchRegister);
</del><ins>+ move(TrustedImmPtr(address), scratchRegister);
</ins><span class="cx"> loadDouble(scratchRegister, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void addDouble(AbsoluteAddress address, FPRegisterID dest)
</span><span class="cx"> {
</span><del>- move(ImmPtr(address.m_ptr), scratchRegister);
</del><ins>+ move(TrustedImmPtr(address.m_ptr), scratchRegister);
</ins><span class="cx"> m_assembler.addsd_mr(0, scratchRegister, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void convertInt32ToDouble(Imm32 imm, FPRegisterID dest)
</del><ins>+ void convertInt32ToDouble(TrustedImm32 imm, FPRegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> move(imm, scratchRegister);
</span><span class="cx"> m_assembler.cvtsi2sd_rr(scratchRegister, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void store32(Imm32 imm, void* address)
</del><ins>+ void store32(TrustedImm32 imm, void* address)
</ins><span class="cx"> {
</span><span class="cx"> move(X86Registers::eax, scratchRegister);
</span><span class="cx"> move(imm, X86Registers::eax);
</span><span class="lines">@@ -115,7 +115,7 @@
</span><span class="cx">
</span><span class="cx"> Call call()
</span><span class="cx"> {
</span><del>- DataLabelPtr label = moveWithPatch(ImmPtr(0), scratchRegister);
</del><ins>+ DataLabelPtr label = moveWithPatch(TrustedImmPtr(0), scratchRegister);
</ins><span class="cx"> Call result = Call(m_assembler.call(scratchRegister), Call::Linkable);
</span><span class="cx"> ASSERT(differenceBetween(label, result) == REPTACH_OFFSET_CALL_R11);
</span><span class="cx"> return result;
</span><span class="lines">@@ -123,7 +123,7 @@
</span><span class="cx">
</span><span class="cx"> Call tailRecursiveCall()
</span><span class="cx"> {
</span><del>- DataLabelPtr label = moveWithPatch(ImmPtr(0), scratchRegister);
</del><ins>+ DataLabelPtr label = moveWithPatch(TrustedImmPtr(0), scratchRegister);
</ins><span class="cx"> Jump newJump = Jump(m_assembler.jmp_r(scratchRegister));
</span><span class="cx"> ASSERT(differenceBetween(label, newJump) == REPTACH_OFFSET_CALL_R11);
</span><span class="cx"> return Call::fromTailJump(newJump);
</span><span class="lines">@@ -132,7 +132,7 @@
</span><span class="cx"> Call makeTailRecursiveCall(Jump oldJump)
</span><span class="cx"> {
</span><span class="cx"> oldJump.link(this);
</span><del>- DataLabelPtr label = moveWithPatch(ImmPtr(0), scratchRegister);
</del><ins>+ DataLabelPtr label = moveWithPatch(TrustedImmPtr(0), scratchRegister);
</ins><span class="cx"> Jump newJump = Jump(m_assembler.jmp_r(scratchRegister));
</span><span class="cx"> ASSERT(differenceBetween(label, newJump) == REPTACH_OFFSET_CALL_R11);
</span><span class="cx"> return Call::fromTailJump(newJump);
</span><span class="lines">@@ -144,30 +144,30 @@
</span><span class="cx"> m_assembler.addq_rr(src, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void addPtr(Imm32 imm, RegisterID srcDest)
</del><ins>+ void addPtr(TrustedImm32 imm, RegisterID srcDest)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.addq_ir(imm.m_value, srcDest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void addPtr(ImmPtr imm, RegisterID dest)
</del><ins>+ void addPtr(TrustedImmPtr imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> move(imm, scratchRegister);
</span><span class="cx"> m_assembler.addq_rr(scratchRegister, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void addPtr(Imm32 imm, RegisterID src, RegisterID dest)
</del><ins>+ void addPtr(TrustedImm32 imm, RegisterID src, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.leaq_mr(imm.m_value, src, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void addPtr(Imm32 imm, Address address)
</del><ins>+ void addPtr(TrustedImm32 imm, Address address)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.addq_im(imm.m_value, address.offset, address.base);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void addPtr(Imm32 imm, AbsoluteAddress address)
</del><ins>+ void addPtr(TrustedImm32 imm, AbsoluteAddress address)
</ins><span class="cx"> {
</span><del>- move(ImmPtr(address.m_ptr), scratchRegister);
</del><ins>+ move(TrustedImmPtr(address.m_ptr), scratchRegister);
</ins><span class="cx"> addPtr(imm, Address(scratchRegister));
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -176,7 +176,7 @@
</span><span class="cx"> m_assembler.andq_rr(src, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void andPtr(Imm32 imm, RegisterID srcDest)
</del><ins>+ void andPtr(TrustedImm32 imm, RegisterID srcDest)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.andq_ir(imm.m_value, srcDest);
</span><span class="cx"> }
</span><span class="lines">@@ -186,13 +186,13 @@
</span><span class="cx"> m_assembler.orq_rr(src, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void orPtr(ImmPtr imm, RegisterID dest)
</del><ins>+ void orPtr(TrustedImmPtr imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> move(imm, scratchRegister);
</span><span class="cx"> m_assembler.orq_rr(scratchRegister, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void orPtr(Imm32 imm, RegisterID dest)
</del><ins>+ void orPtr(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.orq_ir(imm.m_value, dest);
</span><span class="cx"> }
</span><span class="lines">@@ -202,12 +202,12 @@
</span><span class="cx"> m_assembler.subq_rr(src, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void subPtr(Imm32 imm, RegisterID dest)
</del><ins>+ void subPtr(TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.subq_ir(imm.m_value, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void subPtr(ImmPtr imm, RegisterID dest)
</del><ins>+ void subPtr(TrustedImmPtr imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> move(imm, scratchRegister);
</span><span class="cx"> m_assembler.subq_rr(scratchRegister, dest);
</span><span class="lines">@@ -218,7 +218,7 @@
</span><span class="cx"> m_assembler.xorq_rr(src, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void xorPtr(Imm32 imm, RegisterID srcDest)
</del><ins>+ void xorPtr(TrustedImm32 imm, RegisterID srcDest)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.xorq_ir(imm.m_value, srcDest);
</span><span class="cx"> }
</span><span class="lines">@@ -272,7 +272,7 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void storePtr(ImmPtr imm, ImplicitAddress address)
</del><ins>+ void storePtr(TrustedImmPtr imm, ImplicitAddress address)
</ins><span class="cx"> {
</span><span class="cx"> move(imm, scratchRegister);
</span><span class="cx"> storePtr(scratchRegister, address);
</span><span class="lines">@@ -294,7 +294,7 @@
</span><span class="cx"> m_assembler.movq_rr(src, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void setPtr(Condition cond, RegisterID left, Imm32 right, RegisterID dest)
</del><ins>+ void setPtr(Condition cond, RegisterID left, TrustedImm32 right, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> if (((cond == Equal) || (cond == NotEqual)) && !right.m_value)
</span><span class="cx"> m_assembler.testq_rr(left, left);
</span><span class="lines">@@ -310,7 +310,7 @@
</span><span class="cx"> return Jump(m_assembler.jCC(x86Condition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchPtr(Condition cond, RegisterID left, ImmPtr right)
</del><ins>+ Jump branchPtr(Condition cond, RegisterID left, TrustedImmPtr right)
</ins><span class="cx"> {
</span><span class="cx"> move(right, scratchRegister);
</span><span class="cx"> return branchPtr(cond, left, scratchRegister);
</span><span class="lines">@@ -324,7 +324,7 @@
</span><span class="cx">
</span><span class="cx"> Jump branchPtr(Condition cond, AbsoluteAddress left, RegisterID right)
</span><span class="cx"> {
</span><del>- move(ImmPtr(left.m_ptr), scratchRegister);
</del><ins>+ move(TrustedImmPtr(left.m_ptr), scratchRegister);
</ins><span class="cx"> return branchPtr(cond, Address(scratchRegister), right);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -334,7 +334,7 @@
</span><span class="cx"> return Jump(m_assembler.jCC(x86Condition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchPtr(Condition cond, Address left, ImmPtr right)
</del><ins>+ Jump branchPtr(Condition cond, Address left, TrustedImmPtr right)
</ins><span class="cx"> {
</span><span class="cx"> move(right, scratchRegister);
</span><span class="cx"> return branchPtr(cond, left, scratchRegister);
</span><span class="lines">@@ -346,7 +346,7 @@
</span><span class="cx"> return Jump(m_assembler.jCC(x86Condition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchTestPtr(Condition cond, RegisterID reg, Imm32 mask = Imm32(-1))
</del><ins>+ Jump branchTestPtr(Condition cond, RegisterID reg, TrustedImm32 mask = TrustedImm32(-1))
</ins><span class="cx"> {
</span><span class="cx"> // if we are only interested in the low seven bits, this can be tested with a testb
</span><span class="cx"> if (mask.m_value == -1)
</span><span class="lines">@@ -358,13 +358,13 @@
</span><span class="cx"> return Jump(m_assembler.jCC(x86Condition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchTestPtr(Condition cond, AbsoluteAddress address, Imm32 mask = Imm32(-1))
</del><ins>+ Jump branchTestPtr(Condition cond, AbsoluteAddress address, TrustedImm32 mask = TrustedImm32(-1))
</ins><span class="cx"> {
</span><span class="cx"> loadPtr(address.m_ptr, scratchRegister);
</span><span class="cx"> return branchTestPtr(cond, scratchRegister, mask);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchTestPtr(Condition cond, Address address, Imm32 mask = Imm32(-1))
</del><ins>+ Jump branchTestPtr(Condition cond, Address address, TrustedImm32 mask = TrustedImm32(-1))
</ins><span class="cx"> {
</span><span class="cx"> if (mask.m_value == -1)
</span><span class="cx"> m_assembler.cmpq_im(0, address.offset, address.base);
</span><span class="lines">@@ -373,7 +373,7 @@
</span><span class="cx"> return Jump(m_assembler.jCC(x86Condition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchTestPtr(Condition cond, BaseIndex address, Imm32 mask = Imm32(-1))
</del><ins>+ Jump branchTestPtr(Condition cond, BaseIndex address, TrustedImm32 mask = TrustedImm32(-1))
</ins><span class="cx"> {
</span><span class="cx"> if (mask.m_value == -1)
</span><span class="cx"> m_assembler.cmpq_im(0, address.offset, address.base, address.index, address.scale);
</span><span class="lines">@@ -390,32 +390,32 @@
</span><span class="cx"> return Jump(m_assembler.jCC(x86Condition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchSubPtr(Condition cond, Imm32 imm, RegisterID dest)
</del><ins>+ Jump branchSubPtr(Condition cond, TrustedImm32 imm, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> ASSERT((cond == Overflow) || (cond == Zero) || (cond == NonZero));
</span><span class="cx"> subPtr(imm, dest);
</span><span class="cx"> return Jump(m_assembler.jCC(x86Condition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- DataLabelPtr moveWithPatch(ImmPtr initialValue, RegisterID dest)
</del><ins>+ DataLabelPtr moveWithPatch(TrustedImmPtr initialValue, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> m_assembler.movq_i64r(initialValue.asIntptr(), dest);
</span><span class="cx"> return DataLabelPtr(this);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchPtrWithPatch(Condition cond, RegisterID left, DataLabelPtr& dataLabel, ImmPtr initialRightValue = ImmPtr(0))
</del><ins>+ Jump branchPtrWithPatch(Condition cond, RegisterID left, DataLabelPtr& dataLabel, TrustedImmPtr initialRightValue = TrustedImmPtr(0))
</ins><span class="cx"> {
</span><span class="cx"> dataLabel = moveWithPatch(initialRightValue, scratchRegister);
</span><span class="cx"> return branchPtr(cond, left, scratchRegister);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- Jump branchPtrWithPatch(Condition cond, Address left, DataLabelPtr& dataLabel, ImmPtr initialRightValue = ImmPtr(0))
</del><ins>+ Jump branchPtrWithPatch(Condition cond, Address left, DataLabelPtr& dataLabel, TrustedImmPtr initialRightValue = TrustedImmPtr(0))
</ins><span class="cx"> {
</span><span class="cx"> dataLabel = moveWithPatch(initialRightValue, scratchRegister);
</span><span class="cx"> return branchPtr(cond, left, scratchRegister);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- DataLabelPtr storePtrWithPatch(ImmPtr initialValue, ImplicitAddress address)
</del><ins>+ DataLabelPtr storePtrWithPatch(TrustedImmPtr initialValue, ImplicitAddress address)
</ins><span class="cx"> {
</span><span class="cx"> DataLabelPtr label = moveWithPatch(initialValue, scratchRegister);
</span><span class="cx"> storePtr(scratchRegister, address);
</span><span class="lines">@@ -423,9 +423,9 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> using MacroAssemblerX86Common::branchTest8;
</span><del>- Jump branchTest8(Condition cond, ExtendedAddress address, Imm32 mask = Imm32(-1))
</del><ins>+ Jump branchTest8(Condition cond, ExtendedAddress address, TrustedImm32 mask = TrustedImm32(-1))
</ins><span class="cx"> {
</span><del>- ImmPtr addr(reinterpret_cast<void*>(address.offset));
</del><ins>+ TrustedImmPtr addr(reinterpret_cast<void*>(address.offset));
</ins><span class="cx"> MacroAssemblerX86Common::move(addr, scratchRegister);
</span><span class="cx"> return MacroAssemblerX86Common::branchTest8(cond, BaseIndex(scratchRegister, address.base, TimesOne), mask);
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGJITCodeGeneratorh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGJITCodeGenerator.h (82129 => 82130)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGJITCodeGenerator.h 2011-03-28 17:10:30 UTC (rev 82129)
+++ trunk/Source/JavaScriptCore/dfg/DFGJITCodeGenerator.h 2011-03-28 17:14:57 UTC (rev 82130)
</span><span class="lines">@@ -50,6 +50,7 @@
</span><span class="cx"> // functions, etc.
</span><span class="cx"> class JITCodeGenerator {
</span><span class="cx"> protected:
</span><ins>+ typedef MacroAssembler::TrustedImm32 TrustedImm32;
</ins><span class="cx"> typedef MacroAssembler::Imm32 Imm32;
</span><span class="cx">
</span><span class="cx"> // These constants are used to set priorities for spill order for
</span><span class="lines">@@ -586,7 +587,7 @@
</span><span class="cx"> ASSERT(isFlushed());
</span><span class="cx">
</span><span class="cx"> m_jit.move(JITCompiler::gprToRegisterID(arg1), JITCompiler::argumentRegister1);
</span><del>- m_jit.move(JITCompiler::ImmPtr(pointer), JITCompiler::argumentRegister2);
</del><ins>+ m_jit.move(JITCompiler::TrustedImmPtr(pointer), JITCompiler::argumentRegister2);
</ins><span class="cx"> m_jit.move(JITCompiler::callFrameRegister, JITCompiler::argumentRegister0);
</span><span class="cx">
</span><span class="cx"> appendCallWithExceptionCheck(operation);
</span><span class="lines">@@ -621,7 +622,7 @@
</span><span class="cx"> ASSERT(isFlushed());
</span><span class="cx">
</span><span class="cx"> setupStubArguments(arg1, arg2);
</span><del>- m_jit.move(JITCompiler::ImmPtr(pointer), JITCompiler::argumentRegister3);
</del><ins>+ m_jit.move(JITCompiler::TrustedImmPtr(pointer), JITCompiler::argumentRegister3);
</ins><span class="cx"> m_jit.move(JITCompiler::callFrameRegister, JITCompiler::argumentRegister0);
</span><span class="cx">
</span><span class="cx"> appendCallWithExceptionCheck(operation);
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGJITCompilercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGJITCompiler.cpp (82129 => 82130)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGJITCompiler.cpp 2011-03-28 17:10:30 UTC (rev 82129)
+++ trunk/Source/JavaScriptCore/dfg/DFGJITCompiler.cpp 2011-03-28 17:14:57 UTC (rev 82130)
</span><span class="lines">@@ -376,7 +376,7 @@
</span><span class="cx"> void JITCompiler::jitAssertIsInt32(GPRReg gpr)
</span><span class="cx"> {
</span><span class="cx"> #if CPU(X86_64)
</span><del>- Jump checkInt32 = branchPtr(BelowOrEqual, gprToRegisterID(gpr), ImmPtr(reinterpret_cast<void*>(static_cast<uintptr_t>(0xFFFFFFFFu))));
</del><ins>+ Jump checkInt32 = branchPtr(BelowOrEqual, gprToRegisterID(gpr), TrustedImmPtr(reinterpret_cast<void*>(static_cast<uintptr_t>(0xFFFFFFFFu))));
</ins><span class="cx"> breakpoint();
</span><span class="cx"> checkInt32.link(this);
</span><span class="cx"> #else
</span><span class="lines">@@ -411,7 +411,7 @@
</span><span class="cx"> #if ENABLE(SAMPLING_COUNTERS) && CPU(X86_64) // Or any other 64-bit platform!
</span><span class="cx"> void JITCompiler::emitCount(AbstractSamplingCounter& counter, uint32_t increment)
</span><span class="cx"> {
</span><del>- addPtr(Imm32(increment), AbsoluteAddress(counter.addressOfCounter()));
</del><ins>+ addPtr(TrustedImm32(increment), AbsoluteAddress(counter.addressOfCounter()));
</ins><span class="cx"> }
</span><span class="cx"> #endif
</span><span class="cx">
</span><span class="lines">@@ -419,8 +419,8 @@
</span><span class="cx"> void JITCompiler::emitCount(AbstractSamplingCounter& counter, uint32_t increment)
</span><span class="cx"> {
</span><span class="cx"> intptr_t hiWord = reinterpret_cast<intptr_t>(counter.addressOfCounter()) + sizeof(int32_t);
</span><del>- add32(Imm32(increment), AbsoluteAddress(counter.addressOfCounter()));
- addWithCarry32(Imm32(0), AbsoluteAddress(reinterpret_cast<void*>(hiWord)));
</del><ins>+ add32(TrustedImm32(increment), AbsoluteAddress(counter.addressOfCounter()));
+ addWithCarry32(TrustedImm32(0), AbsoluteAddress(reinterpret_cast<void*>(hiWord)));
</ins><span class="cx"> }
</span><span class="cx"> #endif
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGJITCompilerh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGJITCompiler.h (82129 => 82130)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGJITCompiler.h 2011-03-28 17:10:30 UTC (rev 82129)
+++ trunk/Source/JavaScriptCore/dfg/DFGJITCompiler.h 2011-03-28 17:14:57 UTC (rev 82130)
</span><span class="lines">@@ -198,7 +198,7 @@
</span><span class="cx">
</span><span class="cx"> void emitPutImmediateToCallFrameHeader(void* value, RegisterFile::CallFrameHeaderEntry entry)
</span><span class="cx"> {
</span><del>- storePtr(ImmPtr(value), Address(callFrameRegister, entry * sizeof(Register)));
</del><ins>+ storePtr(TrustedImmPtr(value), Address(callFrameRegister, entry * sizeof(Register)));
</ins><span class="cx"> }
</span><span class="cx"> #endif
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGNonSpeculativeJITcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGNonSpeculativeJIT.cpp (82129 => 82130)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGNonSpeculativeJIT.cpp 2011-03-28 17:10:30 UTC (rev 82129)
+++ trunk/Source/JavaScriptCore/dfg/DFGNonSpeculativeJIT.cpp 2011-03-28 17:14:57 UTC (rev 82130)
</span><span class="lines">@@ -231,7 +231,7 @@
</span><span class="cx"> FPRTemporary result(this);
</span><span class="cx"> m_jit.convertInt32ToDouble(op1.registerID(), result.registerID());
</span><span class="cx">
</span><del>- MacroAssembler::Jump positive = m_jit.branch32(MacroAssembler::GreaterThanOrEqual, op1.registerID(), Imm32(0));
</del><ins>+ MacroAssembler::Jump positive = m_jit.branch32(MacroAssembler::GreaterThanOrEqual, op1.registerID(), TrustedImm32(0));
</ins><span class="cx"> m_jit.addDouble(JITCompiler::AbsoluteAddress(&twoToThe32), result.registerID());
</span><span class="cx"> positive.link(&m_jit);
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGSpeculativeJITcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp (82129 => 82130)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp 2011-03-28 17:10:30 UTC (rev 82129)
+++ trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp 2011-03-28 17:14:57 UTC (rev 82130)
</span><span class="lines">@@ -196,7 +196,7 @@
</span><span class="cx"> m_gprs.retain(gpr, virtualRegister, SpillOrderConstant);
</span><span class="cx"> JSValue jsValue = constantAsJSValue(nodeIndex);
</span><span class="cx"> if (jsValue.isCell()) {
</span><del>- m_jit.move(MacroAssembler::ImmPtr(jsValue.asCell()), reg);
</del><ins>+ m_jit.move(MacroAssembler::TrustedImmPtr(jsValue.asCell()), reg);
</ins><span class="cx"> info.fillJSValue(gpr, DataFormatJSCell);
</span><span class="cx"> return gpr;
</span><span class="cx"> }
</span><span class="lines">@@ -325,7 +325,7 @@
</span><span class="cx"> GPRTemporary result(this, op1);
</span><span class="cx">
</span><span class="cx"> // Test the operand is positive.
</span><del>- speculationCheck(m_jit.branch32(MacroAssembler::LessThan, op1.registerID(), Imm32(0)));
</del><ins>+ speculationCheck(m_jit.branch32(MacroAssembler::LessThan, op1.registerID(), TrustedImm32(0)));
</ins><span class="cx">
</span><span class="cx"> m_jit.move(op1.registerID(), result.registerID());
</span><span class="cx"> integerResult(result.gpr(), m_compileIndex, op1.format());
</span><span class="lines">@@ -458,7 +458,7 @@
</span><span class="cx"> m_jit.loadPtr(MacroAssembler::Address(baseReg, JSArray::storageOffset()), storageReg);
</span><span class="cx">
</span><span class="cx"> // Check that base is an array, and that property is contained within m_vector (< m_vectorLength).
</span><del>- speculationCheck(m_jit.branchPtr(MacroAssembler::NotEqual, MacroAssembler::Address(baseReg), MacroAssembler::ImmPtr(m_jit.globalData()->jsArrayVPtr)));
</del><ins>+ speculationCheck(m_jit.branchPtr(MacroAssembler::NotEqual, MacroAssembler::Address(baseReg), MacroAssembler::TrustedImmPtr(m_jit.globalData()->jsArrayVPtr)));
</ins><span class="cx"> speculationCheck(m_jit.branch32(MacroAssembler::AboveOrEqual, propertyReg, MacroAssembler::Address(baseReg, JSArray::vectorLengthOffset())));
</span><span class="cx">
</span><span class="cx"> // FIXME: In cases where there are subsequent by_val accesses to the same base it might help to cache
</span><span class="lines">@@ -503,7 +503,7 @@
</span><span class="cx"> MacroAssembler::RegisterID baseReg = base.registerID();
</span><span class="cx">
</span><span class="cx"> // Check that base is an array, and that property is contained within m_vector (< m_vectorLength).
</span><del>- speculationCheck(m_jit.branchPtr(MacroAssembler::NotEqual, MacroAssembler::Address(baseReg), MacroAssembler::ImmPtr(m_jit.globalData()->jsArrayVPtr)));
</del><ins>+ speculationCheck(m_jit.branchPtr(MacroAssembler::NotEqual, MacroAssembler::Address(baseReg), MacroAssembler::TrustedImmPtr(m_jit.globalData()->jsArrayVPtr)));
</ins><span class="cx"> speculationCheck(m_jit.branch32(MacroAssembler::AboveOrEqual, propertyReg, MacroAssembler::Address(baseReg, JSArray::vectorLengthOffset())));
</span><span class="cx">
</span><span class="cx"> // Get the array storage.
</span><span class="lines">@@ -511,13 +511,13 @@
</span><span class="cx">
</span><span class="cx"> // Check if we're writing to a hole; if so increment m_numValuesInVector.
</span><span class="cx"> MacroAssembler::Jump notHoleValue = m_jit.branchTestPtr(MacroAssembler::NonZero, MacroAssembler::BaseIndex(storageReg, propertyReg, MacroAssembler::ScalePtr, OBJECT_OFFSETOF(ArrayStorage, m_vector[0])));
</span><del>- m_jit.add32(Imm32(1), MacroAssembler::Address(storageReg, OBJECT_OFFSETOF(ArrayStorage, m_numValuesInVector)));
</del><ins>+ m_jit.add32(TrustedImm32(1), MacroAssembler::Address(storageReg, OBJECT_OFFSETOF(ArrayStorage, m_numValuesInVector)));
</ins><span class="cx">
</span><span class="cx"> // If we're writing to a hole we might be growing the array;
</span><span class="cx"> MacroAssembler::Jump lengthDoesNotNeedUpdate = m_jit.branch32(MacroAssembler::Below, propertyReg, MacroAssembler::Address(storageReg, OBJECT_OFFSETOF(ArrayStorage, m_length)));
</span><del>- m_jit.add32(Imm32(1), propertyReg);
</del><ins>+ m_jit.add32(TrustedImm32(1), propertyReg);
</ins><span class="cx"> m_jit.store32(propertyReg, MacroAssembler::Address(storageReg, OBJECT_OFFSETOF(ArrayStorage, m_length)));
</span><del>- m_jit.sub32(Imm32(1), propertyReg);
</del><ins>+ m_jit.sub32(TrustedImm32(1), propertyReg);
</ins><span class="cx">
</span><span class="cx"> lengthDoesNotNeedUpdate.link(&m_jit);
</span><span class="cx"> notHoleValue.link(&m_jit);
</span><span class="lines">@@ -560,7 +560,7 @@
</span><span class="cx"> GPRTemporary temp(this);
</span><span class="cx">
</span><span class="cx"> m_jit.loadPtr(JITCompiler::Address(thisValue.registerID(), JSCell::structureOffset()), temp.registerID());
</span><del>- speculationCheck(m_jit.branchTest8(JITCompiler::NonZero, JITCompiler::Address(temp.registerID(), Structure::typeInfoFlagsOffset()), JITCompiler::Imm32(NeedsThisConversion)));
</del><ins>+ speculationCheck(m_jit.branchTest8(JITCompiler::NonZero, JITCompiler::Address(temp.registerID(), Structure::typeInfoFlagsOffset()), JITCompiler::TrustedImm32(NeedsThisConversion)));
</ins><span class="cx">
</span><span class="cx"> cellResult(thisValue.gpr(), m_compileIndex);
</span><span class="cx"> break;
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorejitJITcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/jit/JIT.cpp (82129 => 82130)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/jit/JIT.cpp 2011-03-28 17:10:30 UTC (rev 82129)
+++ trunk/Source/JavaScriptCore/jit/JIT.cpp 2011-03-28 17:14:57 UTC (rev 82130)
</span><span class="lines">@@ -92,7 +92,7 @@
</span><span class="cx"> #if USE(JSVALUE32_64)
</span><span class="cx"> void JIT::emitTimeoutCheck()
</span><span class="cx"> {
</span><del>- Jump skipTimeout = branchSub32(NonZero, Imm32(1), timeoutCheckRegister);
</del><ins>+ Jump skipTimeout = branchSub32(NonZero, TrustedImm32(1), timeoutCheckRegister);
</ins><span class="cx"> JITStubCall stubCall(this, cti_timeout_check);
</span><span class="cx"> stubCall.addArgument(regT1, regT0); // save last result registers.
</span><span class="cx"> stubCall.call(timeoutCheckRegister);
</span><span class="lines">@@ -102,7 +102,7 @@
</span><span class="cx"> #else
</span><span class="cx"> void JIT::emitTimeoutCheck()
</span><span class="cx"> {
</span><del>- Jump skipTimeout = branchSub32(NonZero, Imm32(1), timeoutCheckRegister);
</del><ins>+ Jump skipTimeout = branchSub32(NonZero, TrustedImm32(1), timeoutCheckRegister);
</ins><span class="cx"> JITStubCall(this, cti_timeout_check).call(timeoutCheckRegister);
</span><span class="cx"> skipTimeout.link(this);
</span><span class="cx">
</span><span class="lines">@@ -497,7 +497,7 @@
</span><span class="cx"> arityCheck = label();
</span><span class="cx"> preserveReturnAddressAfterCall(regT2);
</span><span class="cx"> emitPutToCallFrameHeader(regT2, RegisterFile::ReturnPC);
</span><del>- branch32(Equal, regT1, Imm32(m_codeBlock->m_numParameters)).linkTo(beginLabel, this);
</del><ins>+ branch32(Equal, regT1, TrustedImm32(m_codeBlock->m_numParameters)).linkTo(beginLabel, this);
</ins><span class="cx"> restoreArgumentReference();
</span><span class="cx">
</span><span class="cx"> JITStubCall(this, m_codeBlock->m_isConstructor ? cti_op_construct_arityCheck : cti_op_call_arityCheck).call(callFrameRegister);
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorejitJITh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/jit/JIT.h (82129 => 82130)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/jit/JIT.h 2011-03-28 17:10:30 UTC (rev 82129)
+++ trunk/Source/JavaScriptCore/jit/JIT.h 2011-03-28 17:14:57 UTC (rev 82130)
</span><span class="lines">@@ -309,7 +309,7 @@
</span><span class="cx"> void emitStore(unsigned index, RegisterID tag, RegisterID payload, RegisterID base = callFrameRegister);
</span><span class="cx"> void emitStore(unsigned index, const JSValue constant, RegisterID base = callFrameRegister);
</span><span class="cx"> void emitStoreInt32(unsigned index, RegisterID payload, bool indexIsInt32 = false);
</span><del>- void emitStoreInt32(unsigned index, Imm32 payload, bool indexIsInt32 = false);
</del><ins>+ void emitStoreInt32(unsigned index, TrustedImm32 payload, bool indexIsInt32 = false);
</ins><span class="cx"> void emitStoreCell(unsigned index, RegisterID payload, bool indexIsCell = false);
</span><span class="cx"> void emitStoreBool(unsigned index, RegisterID tag, bool indexIsBool = false);
</span><span class="cx"> void emitStoreDouble(unsigned index, FPRegisterID value);
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorejitJITArithmeticcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/jit/JITArithmetic.cpp (82129 => 82130)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/jit/JITArithmetic.cpp 2011-03-28 17:10:30 UTC (rev 82129)
+++ trunk/Source/JavaScriptCore/jit/JITArithmetic.cpp 2011-03-28 17:14:57 UTC (rev 82130)
</span><span class="lines">@@ -167,7 +167,7 @@
</span><span class="cx"> // a toUint conversion, which can result in a value we can represent
</span><span class="cx"> // as an immediate int.
</span><span class="cx"> if (shift < 0 || !(shift & 31))
</span><del>- addSlowCase(branch32(LessThan, regT0, Imm32(0)));
</del><ins>+ addSlowCase(branch32(LessThan, regT0, TrustedImm32(0)));
</ins><span class="cx"> emitFastArithReTagImmediate(regT0, regT0);
</span><span class="cx"> emitPutVirtualRegister(dst, regT0);
</span><span class="cx"> return;
</span><span class="lines">@@ -179,7 +179,7 @@
</span><span class="cx"> emitFastArithImmToInt(regT0);
</span><span class="cx"> emitFastArithImmToInt(regT1);
</span><span class="cx"> urshift32(regT1, regT0);
</span><del>- addSlowCase(branch32(LessThan, regT0, Imm32(0)));
</del><ins>+ addSlowCase(branch32(LessThan, regT0, TrustedImm32(0)));
</ins><span class="cx"> emitFastArithReTagImmediate(regT0, regT0);
</span><span class="cx"> emitPutVirtualRegister(dst, regT0);
</span><span class="cx"> }
</span><span class="lines">@@ -202,7 +202,7 @@
</span><span class="cx"> if (shift)
</span><span class="cx"> urshift32(Imm32(shift & 0x1f), regT0);
</span><span class="cx"> if (shift < 0 || !(shift & 31))
</span><del>- failures.append(branch32(LessThan, regT0, Imm32(0)));
</del><ins>+ failures.append(branch32(LessThan, regT0, TrustedImm32(0)));
</ins><span class="cx"> emitFastArithReTagImmediate(regT0, regT0);
</span><span class="cx"> emitPutVirtualRegister(dst, regT0);
</span><span class="cx"> emitJumpSlowToHot(jump(), OPCODE_LENGTH(op_rshift));
</span><span class="lines">@@ -224,7 +224,7 @@
</span><span class="cx"> failures.append(emitJumpIfNotImmediateInteger(regT1)); // op2 is not an int
</span><span class="cx"> emitFastArithImmToInt(regT1);
</span><span class="cx"> urshift32(regT1, regT0);
</span><del>- failures.append(branch32(LessThan, regT0, Imm32(0)));
</del><ins>+ failures.append(branch32(LessThan, regT0, TrustedImm32(0)));
</ins><span class="cx"> emitFastArithReTagImmediate(regT0, regT0);
</span><span class="cx"> emitPutVirtualRegister(dst, regT0);
</span><span class="cx"> emitJumpSlowToHot(jump(), OPCODE_LENGTH(op_rshift));
</span><span class="lines">@@ -773,7 +773,7 @@
</span><span class="cx"> emitGetVirtualRegister(srcDst, regT0);
</span><span class="cx"> move(regT0, regT1);
</span><span class="cx"> emitJumpSlowCaseIfNotImmediateInteger(regT0);
</span><del>- addSlowCase(branchAdd32(Overflow, Imm32(1), regT1));
</del><ins>+ addSlowCase(branchAdd32(Overflow, TrustedImm32(1), regT1));
</ins><span class="cx"> emitFastArithIntToImmNoCheck(regT1, regT1);
</span><span class="cx"> emitPutVirtualRegister(srcDst, regT1);
</span><span class="cx"> emitPutVirtualRegister(result);
</span><span class="lines">@@ -800,7 +800,7 @@
</span><span class="cx"> emitGetVirtualRegister(srcDst, regT0);
</span><span class="cx"> move(regT0, regT1);
</span><span class="cx"> emitJumpSlowCaseIfNotImmediateInteger(regT0);
</span><del>- addSlowCase(branchSub32(Zero, Imm32(1), regT1));
</del><ins>+ addSlowCase(branchSub32(Zero, TrustedImm32(1), regT1));
</ins><span class="cx"> emitFastArithIntToImmNoCheck(regT1, regT1);
</span><span class="cx"> emitPutVirtualRegister(srcDst, regT1);
</span><span class="cx"> emitPutVirtualRegister(result);
</span><span class="lines">@@ -825,7 +825,7 @@
</span><span class="cx">
</span><span class="cx"> emitGetVirtualRegister(srcDst, regT0);
</span><span class="cx"> emitJumpSlowCaseIfNotImmediateInteger(regT0);
</span><del>- addSlowCase(branchAdd32(Overflow, Imm32(1), regT0));
</del><ins>+ addSlowCase(branchAdd32(Overflow, TrustedImm32(1), regT0));
</ins><span class="cx"> emitFastArithIntToImmNoCheck(regT0, regT0);
</span><span class="cx"> emitPutVirtualRegister(srcDst);
</span><span class="cx"> }
</span><span class="lines">@@ -849,7 +849,7 @@
</span><span class="cx">
</span><span class="cx"> emitGetVirtualRegister(srcDst, regT0);
</span><span class="cx"> emitJumpSlowCaseIfNotImmediateInteger(regT0);
</span><del>- addSlowCase(branchSub32(Zero, Imm32(1), regT0));
</del><ins>+ addSlowCase(branchSub32(Zero, TrustedImm32(1), regT0));
</ins><span class="cx"> emitFastArithIntToImmNoCheck(regT0, regT0);
</span><span class="cx"> emitPutVirtualRegister(srcDst);
</span><span class="cx"> }
</span><span class="lines">@@ -888,7 +888,7 @@
</span><span class="cx"> emitJumpSlowCaseIfNotImmediateInteger(regT0);
</span><span class="cx"> emitJumpSlowCaseIfNotImmediateInteger(regT2);
</span><span class="cx">
</span><del>- addSlowCase(branchPtr(Equal, regT2, ImmPtr(JSValue::encode(jsNumber(0)))));
</del><ins>+ addSlowCase(branchPtr(Equal, regT2, TrustedImmPtr(JSValue::encode(jsNumber(0)))));
</ins><span class="cx"> m_assembler.cdq();
</span><span class="cx"> m_assembler.idivl_r(regT2);
</span><span class="cx"> emitFastArithReTagImmediate(regT1, regT0);
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorejitJITArithmetic32_64cpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/jit/JITArithmetic32_64.cpp (82129 => 82130)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/jit/JITArithmetic32_64.cpp 2011-03-28 17:10:30 UTC (rev 82129)
+++ trunk/Source/JavaScriptCore/jit/JITArithmetic32_64.cpp 2011-03-28 17:14:57 UTC (rev 82130)
</span><span class="lines">@@ -54,17 +54,17 @@
</span><span class="cx">
</span><span class="cx"> emitLoad(src, regT1, regT0);
</span><span class="cx">
</span><del>- Jump srcNotInt = branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag));
- addSlowCase(branchTest32(Zero, regT0, Imm32(0x7fffffff)));
</del><ins>+ Jump srcNotInt = branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag));
+ addSlowCase(branchTest32(Zero, regT0, TrustedImm32(0x7fffffff)));
</ins><span class="cx"> neg32(regT0);
</span><span class="cx"> emitStoreInt32(dst, regT0, (dst == src));
</span><span class="cx">
</span><span class="cx"> Jump end = jump();
</span><span class="cx">
</span><span class="cx"> srcNotInt.link(this);
</span><del>- addSlowCase(branch32(Above, regT1, Imm32(JSValue::LowestTag)));
</del><ins>+ addSlowCase(branch32(Above, regT1, TrustedImm32(JSValue::LowestTag)));
</ins><span class="cx">
</span><del>- xor32(Imm32(1 << 31), regT1);
</del><ins>+ xor32(TrustedImm32(1 << 31), regT1);
</ins><span class="cx"> store32(regT1, tagFor(dst));
</span><span class="cx"> if (dst != src)
</span><span class="cx"> store32(regT0, payloadFor(dst));
</span><span class="lines">@@ -96,7 +96,7 @@
</span><span class="cx"> // Character less.
</span><span class="cx"> if (isOperandConstantImmediateChar(op1)) {
</span><span class="cx"> emitLoad(op2, regT1, regT0);
</span><del>- addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::CellTag)));
</del><ins>+ addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::CellTag)));
</ins><span class="cx"> JumpList failures;
</span><span class="cx"> emitLoadCharacterString(regT0, regT0, failures);
</span><span class="cx"> addSlowCase(failures);
</span><span class="lines">@@ -105,7 +105,7 @@
</span><span class="cx"> }
</span><span class="cx"> if (isOperandConstantImmediateChar(op2)) {
</span><span class="cx"> emitLoad(op1, regT1, regT0);
</span><del>- addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::CellTag)));
</del><ins>+ addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::CellTag)));
</ins><span class="cx"> JumpList failures;
</span><span class="cx"> emitLoadCharacterString(regT0, regT0, failures);
</span><span class="cx"> addSlowCase(failures);
</span><span class="lines">@@ -115,16 +115,16 @@
</span><span class="cx"> if (isOperandConstantImmediateInt(op1)) {
</span><span class="cx"> // Int32 less.
</span><span class="cx"> emitLoad(op2, regT3, regT2);
</span><del>- notInt32Op2.append(branch32(NotEqual, regT3, Imm32(JSValue::Int32Tag)));
</del><ins>+ notInt32Op2.append(branch32(NotEqual, regT3, TrustedImm32(JSValue::Int32Tag)));
</ins><span class="cx"> addJump(branch32(LessThanOrEqual, regT2, Imm32(getConstantOperand(op1).asInt32())), target);
</span><span class="cx"> } else if (isOperandConstantImmediateInt(op2)) {
</span><span class="cx"> emitLoad(op1, regT1, regT0);
</span><del>- notInt32Op1.append(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));
</del><ins>+ notInt32Op1.append(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
</ins><span class="cx"> addJump(branch32(GreaterThanOrEqual, regT0, Imm32(getConstantOperand(op2).asInt32())), target);
</span><span class="cx"> } else {
</span><span class="cx"> emitLoad2(op1, regT1, regT0, op2, regT3, regT2);
</span><del>- notInt32Op1.append(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));
- notInt32Op2.append(branch32(NotEqual, regT3, Imm32(JSValue::Int32Tag)));
</del><ins>+ notInt32Op1.append(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
+ notInt32Op2.append(branch32(NotEqual, regT3, TrustedImm32(JSValue::Int32Tag)));
</ins><span class="cx"> addJump(branch32(GreaterThanOrEqual, regT0, regT2), target);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -185,7 +185,7 @@
</span><span class="cx"> // Character less.
</span><span class="cx"> if (isOperandConstantImmediateChar(op1)) {
</span><span class="cx"> emitLoad(op2, regT1, regT0);
</span><del>- addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::CellTag)));
</del><ins>+ addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::CellTag)));
</ins><span class="cx"> JumpList failures;
</span><span class="cx"> emitLoadCharacterString(regT0, regT0, failures);
</span><span class="cx"> addSlowCase(failures);
</span><span class="lines">@@ -194,7 +194,7 @@
</span><span class="cx"> }
</span><span class="cx"> if (isOperandConstantImmediateChar(op2)) {
</span><span class="cx"> emitLoad(op1, regT1, regT0);
</span><del>- addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::CellTag)));
</del><ins>+ addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::CellTag)));
</ins><span class="cx"> JumpList failures;
</span><span class="cx"> emitLoadCharacterString(regT0, regT0, failures);
</span><span class="cx"> addSlowCase(failures);
</span><span class="lines">@@ -203,16 +203,16 @@
</span><span class="cx"> }
</span><span class="cx"> if (isOperandConstantImmediateInt(op1)) {
</span><span class="cx"> emitLoad(op2, regT3, regT2);
</span><del>- notInt32Op2.append(branch32(NotEqual, regT3, Imm32(JSValue::Int32Tag)));
</del><ins>+ notInt32Op2.append(branch32(NotEqual, regT3, TrustedImm32(JSValue::Int32Tag)));
</ins><span class="cx"> addJump(branch32(GreaterThan, regT2, Imm32(getConstantOperand(op1).asInt32())), target);
</span><span class="cx"> } else if (isOperandConstantImmediateInt(op2)) {
</span><span class="cx"> emitLoad(op1, regT1, regT0);
</span><del>- notInt32Op1.append(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));
</del><ins>+ notInt32Op1.append(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
</ins><span class="cx"> addJump(branch32(LessThan, regT0, Imm32(getConstantOperand(op2).asInt32())), target);
</span><span class="cx"> } else {
</span><span class="cx"> emitLoad2(op1, regT1, regT0, op2, regT3, regT2);
</span><del>- notInt32Op1.append(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));
- notInt32Op2.append(branch32(NotEqual, regT3, Imm32(JSValue::Int32Tag)));
</del><ins>+ notInt32Op1.append(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
+ notInt32Op2.append(branch32(NotEqual, regT3, TrustedImm32(JSValue::Int32Tag)));
</ins><span class="cx"> addJump(branch32(LessThan, regT0, regT2), target);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -272,7 +272,7 @@
</span><span class="cx"> // Character less.
</span><span class="cx"> if (isOperandConstantImmediateChar(op1)) {
</span><span class="cx"> emitLoad(op2, regT1, regT0);
</span><del>- addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::CellTag)));
</del><ins>+ addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::CellTag)));
</ins><span class="cx"> JumpList failures;
</span><span class="cx"> emitLoadCharacterString(regT0, regT0, failures);
</span><span class="cx"> addSlowCase(failures);
</span><span class="lines">@@ -281,7 +281,7 @@
</span><span class="cx"> }
</span><span class="cx"> if (isOperandConstantImmediateChar(op2)) {
</span><span class="cx"> emitLoad(op1, regT1, regT0);
</span><del>- addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::CellTag)));
</del><ins>+ addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::CellTag)));
</ins><span class="cx"> JumpList failures;
</span><span class="cx"> emitLoadCharacterString(regT0, regT0, failures);
</span><span class="cx"> addSlowCase(failures);
</span><span class="lines">@@ -290,16 +290,16 @@
</span><span class="cx"> }
</span><span class="cx"> if (isOperandConstantImmediateInt(op1)) {
</span><span class="cx"> emitLoad(op2, regT3, regT2);
</span><del>- notInt32Op2.append(branch32(NotEqual, regT3, Imm32(JSValue::Int32Tag)));
</del><ins>+ notInt32Op2.append(branch32(NotEqual, regT3, TrustedImm32(JSValue::Int32Tag)));
</ins><span class="cx"> addJump(branch32(invert ? LessThan : GreaterThanOrEqual, regT2, Imm32(getConstantOperand(op1).asInt32())), target);
</span><span class="cx"> } else if (isOperandConstantImmediateInt(op2)) {
</span><span class="cx"> emitLoad(op1, regT1, regT0);
</span><del>- notInt32Op1.append(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));
</del><ins>+ notInt32Op1.append(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
</ins><span class="cx"> addJump(branch32(invert ? GreaterThan : LessThanOrEqual, regT0, Imm32(getConstantOperand(op2).asInt32())), target);
</span><span class="cx"> } else {
</span><span class="cx"> emitLoad2(op1, regT1, regT0, op2, regT3, regT2);
</span><del>- notInt32Op1.append(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));
- notInt32Op2.append(branch32(NotEqual, regT3, Imm32(JSValue::Int32Tag)));
</del><ins>+ notInt32Op1.append(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
+ notInt32Op2.append(branch32(NotEqual, regT3, TrustedImm32(JSValue::Int32Tag)));
</ins><span class="cx"> addJump(branch32(invert ? GreaterThan : LessThanOrEqual, regT0, regT2), target);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -368,7 +368,7 @@
</span><span class="cx">
</span><span class="cx"> if (isOperandConstantImmediateInt(op2)) {
</span><span class="cx"> emitLoad(op1, regT1, regT0);
</span><del>- addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));
</del><ins>+ addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
</ins><span class="cx"> lshift32(Imm32(getConstantOperand(op2).asInt32()), regT0);
</span><span class="cx"> emitStoreInt32(dst, regT0, dst == op1);
</span><span class="cx"> return;
</span><span class="lines">@@ -376,8 +376,8 @@
</span><span class="cx">
</span><span class="cx"> emitLoad2(op1, regT1, regT0, op2, regT3, regT2);
</span><span class="cx"> if (!isOperandConstantImmediateInt(op1))
</span><del>- addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));
- addSlowCase(branch32(NotEqual, regT3, Imm32(JSValue::Int32Tag)));
</del><ins>+ addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
+ addSlowCase(branch32(NotEqual, regT3, TrustedImm32(JSValue::Int32Tag)));
</ins><span class="cx"> lshift32(regT2, regT0);
</span><span class="cx"> emitStoreInt32(dst, regT0, dst == op1 || dst == op2);
</span><span class="cx"> }
</span><span class="lines">@@ -410,7 +410,7 @@
</span><span class="cx"> // shift arguments, so any changes must be updated there as well.
</span><span class="cx"> if (isOperandConstantImmediateInt(op2)) {
</span><span class="cx"> emitLoad(op1, regT1, regT0);
</span><del>- addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));
</del><ins>+ addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
</ins><span class="cx"> int shift = getConstantOperand(op2).asInt32();
</span><span class="cx"> if (isUnsigned) {
</span><span class="cx"> if (shift)
</span><span class="lines">@@ -419,7 +419,7 @@
</span><span class="cx"> // a toUint conversion, which can result in a value we can represent
</span><span class="cx"> // as an immediate int.
</span><span class="cx"> if (shift < 0 || !(shift & 31))
</span><del>- addSlowCase(branch32(LessThan, regT0, Imm32(0)));
</del><ins>+ addSlowCase(branch32(LessThan, regT0, TrustedImm32(0)));
</ins><span class="cx"> } else if (shift) { // signed right shift by zero is simply toInt conversion
</span><span class="cx"> rshift32(Imm32(shift & 0x1f), regT0);
</span><span class="cx"> }
</span><span class="lines">@@ -429,11 +429,11 @@
</span><span class="cx">
</span><span class="cx"> emitLoad2(op1, regT1, regT0, op2, regT3, regT2);
</span><span class="cx"> if (!isOperandConstantImmediateInt(op1))
</span><del>- addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));
- addSlowCase(branch32(NotEqual, regT3, Imm32(JSValue::Int32Tag)));
</del><ins>+ addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
+ addSlowCase(branch32(NotEqual, regT3, TrustedImm32(JSValue::Int32Tag)));
</ins><span class="cx"> if (isUnsigned) {
</span><span class="cx"> urshift32(regT2, regT0);
</span><del>- addSlowCase(branch32(LessThan, regT0, Imm32(0)));
</del><ins>+ addSlowCase(branch32(LessThan, regT0, TrustedImm32(0)));
</ins><span class="cx"> } else
</span><span class="cx"> rshift32(regT2, regT0);
</span><span class="cx"> emitStoreInt32(dst, regT0, dst == op1 || dst == op2);
</span><span class="lines">@@ -450,14 +450,14 @@
</span><span class="cx"> linkSlowCase(iter); // int32 check
</span><span class="cx"> if (supportsFloatingPointTruncate()) {
</span><span class="cx"> JumpList failures;
</span><del>- failures.append(branch32(AboveOrEqual, regT1, Imm32(JSValue::LowestTag)));
</del><ins>+ failures.append(branch32(AboveOrEqual, regT1, TrustedImm32(JSValue::LowestTag)));
</ins><span class="cx"> emitLoadDouble(op1, fpRegT0);
</span><span class="cx"> failures.append(branchTruncateDoubleToInt32(fpRegT0, regT0));
</span><span class="cx"> if (isUnsigned) {
</span><span class="cx"> if (shift)
</span><span class="cx"> urshift32(Imm32(shift & 0x1f), regT0);
</span><span class="cx"> if (shift < 0 || !(shift & 31))
</span><del>- failures.append(branch32(LessThan, regT0, Imm32(0)));
</del><ins>+ failures.append(branch32(LessThan, regT0, TrustedImm32(0)));
</ins><span class="cx"> } else if (shift)
</span><span class="cx"> rshift32(Imm32(shift & 0x1f), regT0);
</span><span class="cx"> emitStoreInt32(dst, regT0, false);
</span><span class="lines">@@ -472,9 +472,9 @@
</span><span class="cx"> if (!isOperandConstantImmediateInt(op1)) {
</span><span class="cx"> linkSlowCase(iter); // int32 check -- op1 is not an int
</span><span class="cx"> if (supportsFloatingPointTruncate()) {
</span><del>- Jump notDouble = branch32(Above, regT1, Imm32(JSValue::LowestTag)); // op1 is not a double
</del><ins>+ Jump notDouble = branch32(Above, regT1, TrustedImm32(JSValue::LowestTag)); // op1 is not a double
</ins><span class="cx"> emitLoadDouble(op1, fpRegT0);
</span><del>- Jump notInt = branch32(NotEqual, regT3, Imm32(JSValue::Int32Tag)); // op2 is not an int
</del><ins>+ Jump notInt = branch32(NotEqual, regT3, TrustedImm32(JSValue::Int32Tag)); // op2 is not an int
</ins><span class="cx"> Jump cantTruncate = branchTruncateDoubleToInt32(fpRegT0, regT0);
</span><span class="cx"> if (isUnsigned)
</span><span class="cx"> urshift32(regT2, regT0);
</span><span class="lines">@@ -535,15 +535,15 @@
</span><span class="cx"> int32_t constant;
</span><span class="cx"> if (getOperandConstantImmediateInt(op1, op2, op, constant)) {
</span><span class="cx"> emitLoad(op, regT1, regT0);
</span><del>- addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));
</del><ins>+ addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
</ins><span class="cx"> and32(Imm32(constant), regT0);
</span><span class="cx"> emitStoreInt32(dst, regT0, (op == dst));
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> emitLoad2(op1, regT1, regT0, op2, regT3, regT2);
</span><del>- addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));
- addSlowCase(branch32(NotEqual, regT3, Imm32(JSValue::Int32Tag)));
</del><ins>+ addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
+ addSlowCase(branch32(NotEqual, regT3, TrustedImm32(JSValue::Int32Tag)));
</ins><span class="cx"> and32(regT2, regT0);
</span><span class="cx"> emitStoreInt32(dst, regT0, (op1 == dst || op2 == dst));
</span><span class="cx"> }
</span><span class="lines">@@ -576,15 +576,15 @@
</span><span class="cx"> int32_t constant;
</span><span class="cx"> if (getOperandConstantImmediateInt(op1, op2, op, constant)) {
</span><span class="cx"> emitLoad(op, regT1, regT0);
</span><del>- addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));
</del><ins>+ addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
</ins><span class="cx"> or32(Imm32(constant), regT0);
</span><span class="cx"> emitStoreInt32(dst, regT0, (op == dst));
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> emitLoad2(op1, regT1, regT0, op2, regT3, regT2);
</span><del>- addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));
- addSlowCase(branch32(NotEqual, regT3, Imm32(JSValue::Int32Tag)));
</del><ins>+ addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
+ addSlowCase(branch32(NotEqual, regT3, TrustedImm32(JSValue::Int32Tag)));
</ins><span class="cx"> or32(regT2, regT0);
</span><span class="cx"> emitStoreInt32(dst, regT0, (op1 == dst || op2 == dst));
</span><span class="cx"> }
</span><span class="lines">@@ -617,15 +617,15 @@
</span><span class="cx"> int32_t constant;
</span><span class="cx"> if (getOperandConstantImmediateInt(op1, op2, op, constant)) {
</span><span class="cx"> emitLoad(op, regT1, regT0);
</span><del>- addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));
</del><ins>+ addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
</ins><span class="cx"> xor32(Imm32(constant), regT0);
</span><span class="cx"> emitStoreInt32(dst, regT0, (op == dst));
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> emitLoad2(op1, regT1, regT0, op2, regT3, regT2);
</span><del>- addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));
- addSlowCase(branch32(NotEqual, regT3, Imm32(JSValue::Int32Tag)));
</del><ins>+ addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
+ addSlowCase(branch32(NotEqual, regT3, TrustedImm32(JSValue::Int32Tag)));
</ins><span class="cx"> xor32(regT2, regT0);
</span><span class="cx"> emitStoreInt32(dst, regT0, (op1 == dst || op2 == dst));
</span><span class="cx"> }
</span><span class="lines">@@ -654,7 +654,7 @@
</span><span class="cx"> unsigned src = currentInstruction[2].u.operand;
</span><span class="cx">
</span><span class="cx"> emitLoad(src, regT1, regT0);
</span><del>- addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));
</del><ins>+ addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
</ins><span class="cx">
</span><span class="cx"> not32(regT0);
</span><span class="cx"> emitStoreInt32(dst, regT0, (dst == src));
</span><span class="lines">@@ -679,14 +679,14 @@
</span><span class="cx"> unsigned srcDst = currentInstruction[2].u.operand;
</span><span class="cx">
</span><span class="cx"> emitLoad(srcDst, regT1, regT0);
</span><del>- addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));
</del><ins>+ addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
</ins><span class="cx">
</span><span class="cx"> if (dst == srcDst) // x = x++ is a noop for ints.
</span><span class="cx"> return;
</span><span class="cx">
</span><span class="cx"> emitStoreInt32(dst, regT0);
</span><span class="cx">
</span><del>- addSlowCase(branchAdd32(Overflow, Imm32(1), regT0));
</del><ins>+ addSlowCase(branchAdd32(Overflow, TrustedImm32(1), regT0));
</ins><span class="cx"> emitStoreInt32(srcDst, regT0, true);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -713,14 +713,14 @@
</span><span class="cx"> unsigned srcDst = currentInstruction[2].u.operand;
</span><span class="cx">
</span><span class="cx"> emitLoad(srcDst, regT1, regT0);
</span><del>- addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));
</del><ins>+ addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
</ins><span class="cx">
</span><span class="cx"> if (dst == srcDst) // x = x-- is a noop for ints.
</span><span class="cx"> return;
</span><span class="cx">
</span><span class="cx"> emitStoreInt32(dst, regT0);
</span><span class="cx">
</span><del>- addSlowCase(branchSub32(Overflow, Imm32(1), regT0));
</del><ins>+ addSlowCase(branchSub32(Overflow, TrustedImm32(1), regT0));
</ins><span class="cx"> emitStoreInt32(srcDst, regT0, true);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -735,7 +735,7 @@
</span><span class="cx">
</span><span class="cx"> JITStubCall stubCall(this, cti_op_post_dec);
</span><span class="cx"> stubCall.addArgument(srcDst);
</span><del>- stubCall.addArgument(Imm32(srcDst));
</del><ins>+ stubCall.addArgument(TrustedImm32(srcDst));
</ins><span class="cx"> stubCall.call(dst);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -747,8 +747,8 @@
</span><span class="cx">
</span><span class="cx"> emitLoad(srcDst, regT1, regT0);
</span><span class="cx">
</span><del>- addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));
- addSlowCase(branchAdd32(Overflow, Imm32(1), regT0));
</del><ins>+ addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
+ addSlowCase(branchAdd32(Overflow, TrustedImm32(1), regT0));
</ins><span class="cx"> emitStoreInt32(srcDst, regT0, true);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -772,8 +772,8 @@
</span><span class="cx">
</span><span class="cx"> emitLoad(srcDst, regT1, regT0);
</span><span class="cx">
</span><del>- addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));
- addSlowCase(branchSub32(Overflow, Imm32(1), regT0));
</del><ins>+ addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
+ addSlowCase(branchSub32(Overflow, TrustedImm32(1), regT0));
</ins><span class="cx"> emitStoreInt32(srcDst, regT0, true);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -817,8 +817,8 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> emitLoad2(op1, regT1, regT0, op2, regT3, regT2);
</span><del>- notInt32Op1.append(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));
- notInt32Op2.append(branch32(NotEqual, regT3, Imm32(JSValue::Int32Tag)));
</del><ins>+ notInt32Op1.append(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
+ notInt32Op2.append(branch32(NotEqual, regT3, TrustedImm32(JSValue::Int32Tag)));
</ins><span class="cx">
</span><span class="cx"> // Int32 case.
</span><span class="cx"> addSlowCase(branchAdd32(Overflow, regT2, regT0));
</span><span class="lines">@@ -840,7 +840,7 @@
</span><span class="cx"> {
</span><span class="cx"> // Int32 case.
</span><span class="cx"> emitLoad(op, regT1, regT0);
</span><del>- Jump notInt32 = branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag));
</del><ins>+ Jump notInt32 = branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag));
</ins><span class="cx"> addSlowCase(branchAdd32(Overflow, Imm32(constant), regT0));
</span><span class="cx"> emitStoreInt32(dst, regT0, (op == dst));
</span><span class="cx">
</span><span class="lines">@@ -853,7 +853,7 @@
</span><span class="cx">
</span><span class="cx"> notInt32.link(this);
</span><span class="cx"> if (!opType.definitelyIsNumber())
</span><del>- addSlowCase(branch32(Above, regT1, Imm32(JSValue::LowestTag)));
</del><ins>+ addSlowCase(branch32(Above, regT1, TrustedImm32(JSValue::LowestTag)));
</ins><span class="cx"> move(Imm32(constant), regT2);
</span><span class="cx"> convertInt32ToDouble(regT2, fpRegT0);
</span><span class="cx"> emitLoadDouble(op, fpRegT1);
</span><span class="lines">@@ -926,8 +926,8 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> emitLoad2(op1, regT1, regT0, op2, regT3, regT2);
</span><del>- notInt32Op1.append(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));
- notInt32Op2.append(branch32(NotEqual, regT3, Imm32(JSValue::Int32Tag)));
</del><ins>+ notInt32Op1.append(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
+ notInt32Op2.append(branch32(NotEqual, regT3, TrustedImm32(JSValue::Int32Tag)));
</ins><span class="cx">
</span><span class="cx"> // Int32 case.
</span><span class="cx"> addSlowCase(branchSub32(Overflow, regT2, regT0));
</span><span class="lines">@@ -949,7 +949,7 @@
</span><span class="cx"> {
</span><span class="cx"> // Int32 case.
</span><span class="cx"> emitLoad(op, regT1, regT0);
</span><del>- Jump notInt32 = branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag));
</del><ins>+ Jump notInt32 = branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag));
</ins><span class="cx"> addSlowCase(branchSub32(Overflow, Imm32(constant), regT0));
</span><span class="cx"> emitStoreInt32(dst, regT0, (op == dst));
</span><span class="cx">
</span><span class="lines">@@ -962,7 +962,7 @@
</span><span class="cx">
</span><span class="cx"> notInt32.link(this);
</span><span class="cx"> if (!opType.definitelyIsNumber())
</span><del>- addSlowCase(branch32(Above, regT1, Imm32(JSValue::LowestTag)));
</del><ins>+ addSlowCase(branch32(Above, regT1, TrustedImm32(JSValue::LowestTag)));
</ins><span class="cx"> move(Imm32(constant), regT2);
</span><span class="cx"> convertInt32ToDouble(regT2, fpRegT0);
</span><span class="cx"> emitLoadDouble(op, fpRegT1);
</span><span class="lines">@@ -1019,15 +1019,15 @@
</span><span class="cx">
</span><span class="cx"> // Verify Op1 is double.
</span><span class="cx"> if (!types.first().definitelyIsNumber())
</span><del>- addSlowCase(branch32(Above, regT1, Imm32(JSValue::LowestTag)));
</del><ins>+ addSlowCase(branch32(Above, regT1, TrustedImm32(JSValue::LowestTag)));
</ins><span class="cx">
</span><span class="cx"> if (!op2IsInRegisters)
</span><span class="cx"> emitLoad(op2, regT3, regT2);
</span><span class="cx">
</span><del>- Jump doubleOp2 = branch32(Below, regT3, Imm32(JSValue::LowestTag));
</del><ins>+ Jump doubleOp2 = branch32(Below, regT3, TrustedImm32(JSValue::LowestTag));
</ins><span class="cx">
</span><span class="cx"> if (!types.second().definitelyIsNumber())
</span><del>- addSlowCase(branch32(NotEqual, regT3, Imm32(JSValue::Int32Tag)));
</del><ins>+ addSlowCase(branch32(NotEqual, regT3, TrustedImm32(JSValue::Int32Tag)));
</ins><span class="cx">
</span><span class="cx"> convertInt32ToDouble(regT2, fpRegT0);
</span><span class="cx"> Jump doTheMath = jump();
</span><span class="lines">@@ -1096,7 +1096,7 @@
</span><span class="cx">
</span><span class="cx"> // Verify op2 is double.
</span><span class="cx"> if (!types.second().definitelyIsNumber())
</span><del>- addSlowCase(branch32(Above, regT3, Imm32(JSValue::LowestTag)));
</del><ins>+ addSlowCase(branch32(Above, regT3, TrustedImm32(JSValue::LowestTag)));
</ins><span class="cx">
</span><span class="cx"> // Do the math.
</span><span class="cx"> switch (opcodeID) {
</span><span class="lines">@@ -1157,8 +1157,8 @@
</span><span class="cx"> JumpList notInt32Op2;
</span><span class="cx">
</span><span class="cx"> emitLoad2(op1, regT1, regT0, op2, regT3, regT2);
</span><del>- notInt32Op1.append(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));
- notInt32Op2.append(branch32(NotEqual, regT3, Imm32(JSValue::Int32Tag)));
</del><ins>+ notInt32Op1.append(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
+ notInt32Op2.append(branch32(NotEqual, regT3, TrustedImm32(JSValue::Int32Tag)));
</ins><span class="cx">
</span><span class="cx"> // Int32 case.
</span><span class="cx"> move(regT0, regT3);
</span><span class="lines">@@ -1189,7 +1189,7 @@
</span><span class="cx"> linkSlowCase(iter); // zero result check
</span><span class="cx">
</span><span class="cx"> Jump negZero = branchOr32(Signed, regT2, regT3);
</span><del>- emitStoreInt32(dst, Imm32(0), (op1 == dst || op2 == dst));
</del><ins>+ emitStoreInt32(dst, TrustedImm32(0), (op1 == dst || op2 == dst));
</ins><span class="cx">
</span><span class="cx"> emitJumpSlowToHot(jump(), OPCODE_LENGTH(op_mul));
</span><span class="cx">
</span><span class="lines">@@ -1240,8 +1240,8 @@
</span><span class="cx">
</span><span class="cx"> emitLoad2(op1, regT1, regT0, op2, regT3, regT2);
</span><span class="cx">
</span><del>- notInt32Op1.append(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));
- notInt32Op2.append(branch32(NotEqual, regT3, Imm32(JSValue::Int32Tag)));
</del><ins>+ notInt32Op1.append(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
+ notInt32Op2.append(branch32(NotEqual, regT3, TrustedImm32(JSValue::Int32Tag)));
</ins><span class="cx">
</span><span class="cx"> convertInt32ToDouble(regT0, fpRegT0);
</span><span class="cx"> convertInt32ToDouble(regT2, fpRegT1);
</span><span class="lines">@@ -1312,16 +1312,16 @@
</span><span class="cx"> if (isOperandConstantImmediateInt(op2) && getConstantOperand(op2).asInt32() != 0) {
</span><span class="cx"> emitLoad(op1, regT1, regT0);
</span><span class="cx"> move(Imm32(getConstantOperand(op2).asInt32()), regT2);
</span><del>- addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));
</del><ins>+ addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
</ins><span class="cx"> if (getConstantOperand(op2).asInt32() == -1)
</span><del>- addSlowCase(branch32(Equal, regT0, Imm32(0x80000000))); // -2147483648 / -1 => EXC_ARITHMETIC
</del><ins>+ addSlowCase(branch32(Equal, regT0, TrustedImm32(0x80000000))); // -2147483648 / -1 => EXC_ARITHMETIC
</ins><span class="cx"> } else {
</span><span class="cx"> emitLoad2(op1, regT1, regT0, op2, regT3, regT2);
</span><del>- addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));
- addSlowCase(branch32(NotEqual, regT3, Imm32(JSValue::Int32Tag)));
</del><ins>+ addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
+ addSlowCase(branch32(NotEqual, regT3, TrustedImm32(JSValue::Int32Tag)));
</ins><span class="cx">
</span><del>- addSlowCase(branch32(Equal, regT0, Imm32(0x80000000))); // -2147483648 / -1 => EXC_ARITHMETIC
- addSlowCase(branch32(Equal, regT2, Imm32(0))); // divide by 0
</del><ins>+ addSlowCase(branch32(Equal, regT0, TrustedImm32(0x80000000))); // -2147483648 / -1 => EXC_ARITHMETIC
+ addSlowCase(branch32(Equal, regT2, TrustedImm32(0))); // divide by 0
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> move(regT0, regT3); // Save dividend payload, in case of 0.
</span><span class="lines">@@ -1335,7 +1335,7 @@
</span><span class="cx">
</span><span class="cx"> // If the remainder is zero and the dividend is negative, the result is -0.
</span><span class="cx"> Jump storeResult1 = branchTest32(NonZero, regT1);
</span><del>- Jump storeResult2 = branchTest32(Zero, regT3, Imm32(0x80000000)); // not negative
</del><ins>+ Jump storeResult2 = branchTest32(Zero, regT3, TrustedImm32(0x80000000)); // not negative
</ins><span class="cx"> emitStore(dst, jsNumber(-0.0));
</span><span class="cx"> Jump end = jump();
</span><span class="cx">
</span><span class="lines">@@ -1378,10 +1378,10 @@
</span><span class="cx">
</span><span class="cx"> #if ENABLE(JIT_USE_SOFT_MODULO)
</span><span class="cx"> emitLoad2(op1, regT1, regT0, op2, regT3, regT2);
</span><del>- addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));
- addSlowCase(branch32(NotEqual, regT3, Imm32(JSValue::Int32Tag)));
</del><ins>+ addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
+ addSlowCase(branch32(NotEqual, regT3, TrustedImm32(JSValue::Int32Tag)));
</ins><span class="cx">
</span><del>- addSlowCase(branch32(Equal, regT2, Imm32(0)));
</del><ins>+ addSlowCase(branch32(Equal, regT2, TrustedImm32(0)));
</ins><span class="cx">
</span><span class="cx"> emitNakedCall(m_globalData->jitStubs->ctiSoftModulo());
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorejitJITCallcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/jit/JITCall.cpp (82129 => 82130)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/jit/JITCall.cpp 2011-03-28 17:10:30 UTC (rev 82129)
+++ trunk/Source/JavaScriptCore/jit/JITCall.cpp 2011-03-28 17:14:57 UTC (rev 82130)
</span><span class="lines">@@ -74,10 +74,10 @@
</span><span class="cx">
</span><span class="cx"> // Check for JSFunctions.
</span><span class="cx"> emitJumpSlowCaseIfNotJSCell(regT0);
</span><del>- addSlowCase(branchPtr(NotEqual, Address(regT0), ImmPtr(m_globalData->jsFunctionVPtr)));
</del><ins>+ addSlowCase(branchPtr(NotEqual, Address(regT0), TrustedImmPtr(m_globalData->jsFunctionVPtr)));
</ins><span class="cx">
</span><span class="cx"> // Speculatively roll the callframe, assuming argCount will match the arity.
</span><del>- mul32(Imm32(sizeof(Register)), regT2, regT2);
</del><ins>+ mul32(TrustedImm32(sizeof(Register)), regT2, regT2);
</ins><span class="cx"> intptr_t offset = (intptr_t)sizeof(Register) * (intptr_t)RegisterFile::CallerFrame;
</span><span class="cx"> addPtr(Imm32((int32_t)offset), regT2, regT3);
</span><span class="cx"> addPtr(callFrameRegister, regT3);
</span><span class="lines">@@ -120,14 +120,14 @@
</span><span class="cx"> stubCall.addArgument(JIT::Imm32(registerOffset));
</span><span class="cx"> stubCall.addArgument(JIT::Imm32(argCount));
</span><span class="cx"> stubCall.call();
</span><del>- wasEval = branchPtr(NotEqual, regT0, ImmPtr(JSValue::encode(JSValue())));
</del><ins>+ wasEval = branchPtr(NotEqual, regT0, TrustedImmPtr(JSValue::encode(JSValue())));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> emitGetVirtualRegister(callee, regT0);
</span><span class="cx">
</span><span class="cx"> // Check for JSFunctions.
</span><span class="cx"> emitJumpSlowCaseIfNotJSCell(regT0);
</span><del>- addSlowCase(branchPtr(NotEqual, Address(regT0), ImmPtr(m_globalData->jsFunctionVPtr)));
</del><ins>+ addSlowCase(branchPtr(NotEqual, Address(regT0), TrustedImmPtr(m_globalData->jsFunctionVPtr)));
</ins><span class="cx">
</span><span class="cx"> // Speculatively roll the callframe, assuming argCount will match the arity.
</span><span class="cx"> storePtr(callFrameRegister, Address(callFrameRegister, (RegisterFile::CallerFrame + registerOffset) * static_cast<int>(sizeof(Register))));
</span><span class="lines">@@ -177,7 +177,7 @@
</span><span class="cx"> stubCall.addArgument(JIT::Imm32(registerOffset));
</span><span class="cx"> stubCall.addArgument(JIT::Imm32(argCount));
</span><span class="cx"> stubCall.call();
</span><del>- wasEval = branchPtr(NotEqual, regT0, ImmPtr(JSValue::encode(JSValue())));
</del><ins>+ wasEval = branchPtr(NotEqual, regT0, TrustedImmPtr(JSValue::encode(JSValue())));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // This plants a check for a cached JSFunction value, so we can plant a fast link to the callee.
</span><span class="lines">@@ -187,7 +187,7 @@
</span><span class="cx">
</span><span class="cx"> BEGIN_UNINTERRUPTED_SEQUENCE(sequenceOpCall);
</span><span class="cx">
</span><del>- Jump jumpToSlow = branchPtrWithPatch(NotEqual, regT0, addressOfLinkedFunctionCheck, ImmPtr(JSValue::encode(JSValue())));
</del><ins>+ Jump jumpToSlow = branchPtrWithPatch(NotEqual, regT0, addressOfLinkedFunctionCheck, TrustedImmPtr(JSValue::encode(JSValue())));
</ins><span class="cx">
</span><span class="cx"> END_UNINTERRUPTED_SEQUENCE(sequenceOpCall);
</span><span class="cx">
</span><span class="lines">@@ -202,7 +202,7 @@
</span><span class="cx">
</span><span class="cx"> loadPtr(Address(regT0, OBJECT_OFFSETOF(JSFunction, m_scopeChain)), regT1); // newScopeChain
</span><span class="cx">
</span><del>- store32(Imm32(Int32Tag), intTagFor(registerOffset + RegisterFile::ArgumentCount));
</del><ins>+ store32(TrustedImm32(Int32Tag), intTagFor(registerOffset + RegisterFile::ArgumentCount));
</ins><span class="cx"> store32(Imm32(argCount), intPayloadFor(registerOffset + RegisterFile::ArgumentCount));
</span><span class="cx"> storePtr(callFrameRegister, Address(callFrameRegister, (registerOffset + RegisterFile::CallerFrame) * static_cast<int>(sizeof(Register))));
</span><span class="cx"> storePtr(regT0, Address(callFrameRegister, (registerOffset + RegisterFile::Callee) * static_cast<int>(sizeof(Register))));
</span><span class="lines">@@ -227,7 +227,7 @@
</span><span class="cx">
</span><span class="cx"> // Fast check for JS function.
</span><span class="cx"> Jump callLinkFailNotObject = emitJumpIfNotJSCell(regT0);
</span><del>- Jump callLinkFailNotJSFunction = branchPtr(NotEqual, Address(regT0), ImmPtr(m_globalData->jsFunctionVPtr));
</del><ins>+ Jump callLinkFailNotJSFunction = branchPtr(NotEqual, Address(regT0), TrustedImmPtr(m_globalData->jsFunctionVPtr));
</ins><span class="cx">
</span><span class="cx"> // Speculatively roll the callframe, assuming argCount will match the arity.
</span><span class="cx"> storePtr(callFrameRegister, Address(callFrameRegister, (RegisterFile::CallerFrame + registerOffset) * static_cast<int>(sizeof(Register))));
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorejitJITCall32_64cpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/jit/JITCall32_64.cpp (82129 => 82130)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/jit/JITCall32_64.cpp 2011-03-28 17:10:30 UTC (rev 82129)
+++ trunk/Source/JavaScriptCore/jit/JITCall32_64.cpp 2011-03-28 17:14:57 UTC (rev 82130)
</span><span class="lines">@@ -72,12 +72,12 @@
</span><span class="cx"> addPtr(Imm32(registerOffset), regT2, regT3); // registerOffset
</span><span class="cx">
</span><span class="cx"> emitJumpSlowCaseIfNotJSCell(callee, regT1);
</span><del>- addSlowCase(branchPtr(NotEqual, Address(regT0), ImmPtr(m_globalData->jsFunctionVPtr)));
</del><ins>+ addSlowCase(branchPtr(NotEqual, Address(regT0), TrustedImmPtr(m_globalData->jsFunctionVPtr)));
</ins><span class="cx">
</span><span class="cx"> // Speculatively roll the callframe, assuming argCount will match the arity.
</span><del>- mul32(Imm32(sizeof(Register)), regT3, regT3);
</del><ins>+ mul32(TrustedImm32(sizeof(Register)), regT3, regT3);
</ins><span class="cx"> addPtr(callFrameRegister, regT3);
</span><del>- store32(Imm32(JSValue::CellTag), tagFor(RegisterFile::CallerFrame, regT3));
</del><ins>+ store32(TrustedImm32(JSValue::CellTag), tagFor(RegisterFile::CallerFrame, regT3));
</ins><span class="cx"> storePtr(callFrameRegister, payloadFor(RegisterFile::CallerFrame, regT3));
</span><span class="cx"> move(regT3, callFrameRegister);
</span><span class="cx">
</span><span class="lines">@@ -122,9 +122,9 @@
</span><span class="cx"> unsigned thisReg = currentInstruction[2].u.operand;
</span><span class="cx">
</span><span class="cx"> emitLoad(result, regT1, regT0);
</span><del>- Jump notJSCell = branch32(NotEqual, regT1, Imm32(JSValue::CellTag));
</del><ins>+ Jump notJSCell = branch32(NotEqual, regT1, TrustedImm32(JSValue::CellTag));
</ins><span class="cx"> loadPtr(Address(regT0, JSCell::structureOffset()), regT2);
</span><del>- Jump notObject = branch8(NotEqual, Address(regT2, Structure::typeInfoTypeOffset()), Imm32(ObjectType));
</del><ins>+ Jump notObject = branch8(NotEqual, Address(regT2, Structure::typeInfoTypeOffset()), TrustedImm32(ObjectType));
</ins><span class="cx">
</span><span class="cx"> emitGetFromCallFrameHeaderPtr(RegisterFile::ReturnPC, regT2);
</span><span class="cx"> emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, callFrameRegister);
</span><span class="lines">@@ -200,19 +200,19 @@
</span><span class="cx"> stubCall.addArgument(JIT::Imm32(registerOffset));
</span><span class="cx"> stubCall.addArgument(JIT::Imm32(argCount));
</span><span class="cx"> stubCall.call();
</span><del>- wasEval = branch32(NotEqual, regT1, Imm32(JSValue::EmptyValueTag));
</del><ins>+ wasEval = branch32(NotEqual, regT1, TrustedImm32(JSValue::EmptyValueTag));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> emitLoad(callee, regT1, regT0);
</span><span class="cx">
</span><span class="cx"> emitJumpSlowCaseIfNotJSCell(callee, regT1);
</span><del>- addSlowCase(branchPtr(NotEqual, Address(regT0), ImmPtr(m_globalData->jsFunctionVPtr)));
</del><ins>+ addSlowCase(branchPtr(NotEqual, Address(regT0), TrustedImmPtr(m_globalData->jsFunctionVPtr)));
</ins><span class="cx">
</span><span class="cx"> // Speculatively roll the callframe, assuming argCount will match the arity.
</span><del>- store32(Imm32(JSValue::CellTag), tagFor(RegisterFile::CallerFrame + registerOffset, callFrameRegister));
</del><ins>+ store32(TrustedImm32(JSValue::CellTag), tagFor(RegisterFile::CallerFrame + registerOffset, callFrameRegister));
</ins><span class="cx"> storePtr(callFrameRegister, payloadFor(RegisterFile::CallerFrame + registerOffset, callFrameRegister));
</span><span class="cx"> addPtr(Imm32(registerOffset * static_cast<int>(sizeof(Register))), callFrameRegister);
</span><del>- move(Imm32(argCount), regT1);
</del><ins>+ move(TrustedImm32(argCount), regT1);
</ins><span class="cx">
</span><span class="cx"> emitNakedCall(opcodeID == op_construct ? m_globalData->jitStubs->ctiVirtualConstruct() : m_globalData->jitStubs->ctiVirtualCall());
</span><span class="cx">
</span><span class="lines">@@ -257,7 +257,7 @@
</span><span class="cx"> stubCall.addArgument(JIT::Imm32(registerOffset));
</span><span class="cx"> stubCall.addArgument(JIT::Imm32(argCount));
</span><span class="cx"> stubCall.call();
</span><del>- wasEval = branch32(NotEqual, regT1, Imm32(JSValue::EmptyValueTag));
</del><ins>+ wasEval = branch32(NotEqual, regT1, TrustedImm32(JSValue::EmptyValueTag));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> emitLoad(callee, regT1, regT0);
</span><span class="lines">@@ -266,7 +266,7 @@
</span><span class="cx">
</span><span class="cx"> BEGIN_UNINTERRUPTED_SEQUENCE(sequenceOpCall);
</span><span class="cx">
</span><del>- Jump jumpToSlow = branchPtrWithPatch(NotEqual, regT0, addressOfLinkedFunctionCheck, ImmPtr(0));
</del><ins>+ Jump jumpToSlow = branchPtrWithPatch(NotEqual, regT0, addressOfLinkedFunctionCheck, TrustedImmPtr(0));
</ins><span class="cx">
</span><span class="cx"> END_UNINTERRUPTED_SEQUENCE(sequenceOpCall);
</span><span class="cx">
</span><span class="lines">@@ -274,7 +274,7 @@
</span><span class="cx"> ASSERT_JIT_OFFSET(differenceBetween(addressOfLinkedFunctionCheck, jumpToSlow), patchOffsetOpCallCompareToJump);
</span><span class="cx"> m_callStructureStubCompilationInfo[callLinkInfoIndex].hotPathBegin = addressOfLinkedFunctionCheck;
</span><span class="cx">
</span><del>- addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::CellTag)));
</del><ins>+ addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::CellTag)));
</ins><span class="cx">
</span><span class="cx"> // The following is the fast case, only used whan a callee can be linked.
</span><span class="cx">
</span><span class="lines">@@ -282,11 +282,11 @@
</span><span class="cx"> // Note that this omits to set up RegisterFile::CodeBlock, which is set in the callee
</span><span class="cx"> loadPtr(Address(regT0, OBJECT_OFFSETOF(JSFunction, m_scopeChain)), regT2);
</span><span class="cx">
</span><del>- store32(Imm32(JSValue::Int32Tag), tagFor(registerOffset + RegisterFile::ArgumentCount));
</del><ins>+ store32(TrustedImm32(JSValue::Int32Tag), tagFor(registerOffset + RegisterFile::ArgumentCount));
</ins><span class="cx"> store32(Imm32(argCount), payloadFor(registerOffset + RegisterFile::ArgumentCount));
</span><span class="cx"> storePtr(callFrameRegister, payloadFor(RegisterFile::CallerFrame + registerOffset, callFrameRegister));
</span><span class="cx"> emitStore(registerOffset + RegisterFile::Callee, regT1, regT0);
</span><del>- store32(Imm32(JSValue::CellTag), tagFor(registerOffset + RegisterFile::ScopeChain));
</del><ins>+ store32(TrustedImm32(JSValue::CellTag), tagFor(registerOffset + RegisterFile::ScopeChain));
</ins><span class="cx"> store32(regT2, payloadFor(registerOffset + RegisterFile::ScopeChain));
</span><span class="cx"> addPtr(Imm32(registerOffset * sizeof(Register)), callFrameRegister);
</span><span class="cx">
</span><span class="lines">@@ -309,11 +309,11 @@
</span><span class="cx"> linkSlowCase(iter);
</span><span class="cx">
</span><span class="cx"> // Fast check for JS function.
</span><del>- Jump callLinkFailNotObject = branch32(NotEqual, regT1, Imm32(JSValue::CellTag));
- Jump callLinkFailNotJSFunction = branchPtr(NotEqual, Address(regT0), ImmPtr(m_globalData->jsFunctionVPtr));
</del><ins>+ Jump callLinkFailNotObject = branch32(NotEqual, regT1, TrustedImm32(JSValue::CellTag));
+ Jump callLinkFailNotJSFunction = branchPtr(NotEqual, Address(regT0), TrustedImmPtr(m_globalData->jsFunctionVPtr));
</ins><span class="cx">
</span><span class="cx"> // Speculatively roll the callframe, assuming argCount will match the arity.
</span><del>- store32(Imm32(JSValue::CellTag), tagFor(RegisterFile::CallerFrame + registerOffset, callFrameRegister));
</del><ins>+ store32(TrustedImm32(JSValue::CellTag), tagFor(RegisterFile::CallerFrame + registerOffset, callFrameRegister));
</ins><span class="cx"> storePtr(callFrameRegister, payloadFor(RegisterFile::CallerFrame + registerOffset, callFrameRegister));
</span><span class="cx"> addPtr(Imm32(registerOffset * static_cast<int>(sizeof(Register))), callFrameRegister);
</span><span class="cx"> move(Imm32(argCount), regT1);
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorejitJITInlineMethodsh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/jit/JITInlineMethods.h (82129 => 82130)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/jit/JITInlineMethods.h 2011-03-28 17:10:30 UTC (rev 82129)
+++ trunk/Source/JavaScriptCore/jit/JITInlineMethods.h 2011-03-28 17:14:57 UTC (rev 82130)
</span><span class="lines">@@ -58,20 +58,20 @@
</span><span class="cx"> ALWAYS_INLINE void JIT::emitPutCellToCallFrameHeader(RegisterID from, RegisterFile::CallFrameHeaderEntry entry)
</span><span class="cx"> {
</span><span class="cx"> #if USE(JSVALUE32_64)
</span><del>- store32(Imm32(JSValue::CellTag), tagFor(entry, callFrameRegister));
</del><ins>+ store32(TrustedImm32(JSValue::CellTag), tagFor(entry, callFrameRegister));
</ins><span class="cx"> #endif
</span><span class="cx"> storePtr(from, payloadFor(entry, callFrameRegister));
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> ALWAYS_INLINE void JIT::emitPutIntToCallFrameHeader(RegisterID from, RegisterFile::CallFrameHeaderEntry entry)
</span><span class="cx"> {
</span><del>- store32(Imm32(Int32Tag), intTagFor(entry, callFrameRegister));
</del><ins>+ store32(TrustedImm32(Int32Tag), intTagFor(entry, callFrameRegister));
</ins><span class="cx"> store32(from, intPayloadFor(entry, callFrameRegister));
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> ALWAYS_INLINE void JIT::emitPutImmediateToCallFrameHeader(void* value, RegisterFile::CallFrameHeaderEntry entry)
</span><span class="cx"> {
</span><del>- storePtr(ImmPtr(value), Address(callFrameRegister, entry * sizeof(Register)));
</del><ins>+ storePtr(TrustedImmPtr(value), Address(callFrameRegister, entry * sizeof(Register)));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> ALWAYS_INLINE void JIT::emitGetFromCallFrameHeaderPtr(RegisterFile::CallFrameHeaderEntry entry, RegisterID to, RegisterID from)
</span><span class="lines">@@ -84,9 +84,9 @@
</span><span class="cx">
</span><span class="cx"> ALWAYS_INLINE void JIT::emitLoadCharacterString(RegisterID src, RegisterID dst, JumpList& failures)
</span><span class="cx"> {
</span><del>- failures.append(branchPtr(NotEqual, Address(src), ImmPtr(m_globalData->jsStringVPtr)));
</del><ins>+ failures.append(branchPtr(NotEqual, Address(src), TrustedImmPtr(m_globalData->jsStringVPtr)));
</ins><span class="cx"> failures.append(branchTest32(NonZero, Address(src, OBJECT_OFFSETOF(JSString, m_fiberCount))));
</span><del>- failures.append(branch32(NotEqual, MacroAssembler::Address(src, ThunkHelpers::jsStringLengthOffset()), Imm32(1)));
</del><ins>+ failures.append(branch32(NotEqual, MacroAssembler::Address(src, ThunkHelpers::jsStringLengthOffset()), TrustedImm32(1)));
</ins><span class="cx"> loadPtr(MacroAssembler::Address(src, ThunkHelpers::jsStringValueOffset()), dst);
</span><span class="cx"> loadPtr(MacroAssembler::Address(dst, ThunkHelpers::stringImplDataOffset()), dst);
</span><span class="cx"> load16(MacroAssembler::Address(dst, 0), dst);
</span><span class="lines">@@ -214,7 +214,7 @@
</span><span class="cx"> {
</span><span class="cx"> #if CPU(X86)
</span><span class="cx"> // Within a trampoline the return address will be on the stack at this point.
</span><del>- addPtr(Imm32(sizeof(void*)), stackPointerRegister, firstArgumentRegister);
</del><ins>+ addPtr(TrustedImm32(sizeof(void*)), stackPointerRegister, firstArgumentRegister);
</ins><span class="cx"> #elif CPU(ARM)
</span><span class="cx"> move(stackPointerRegister, firstArgumentRegister);
</span><span class="cx"> #endif
</span><span class="lines">@@ -223,7 +223,7 @@
</span><span class="cx">
</span><span class="cx"> ALWAYS_INLINE JIT::Jump JIT::checkStructure(RegisterID reg, Structure* structure)
</span><span class="cx"> {
</span><del>- return branchPtr(NotEqual, Address(reg, JSCell::structureOffset()), ImmPtr(structure));
</del><ins>+ return branchPtr(NotEqual, Address(reg, JSCell::structureOffset()), TrustedImmPtr(structure));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> ALWAYS_INLINE void JIT::linkSlowCaseIfNotJSCell(Vector<SlowCaseEntry>::iterator& iter, int vReg)
</span><span class="lines">@@ -268,14 +268,14 @@
</span><span class="cx"> {
</span><span class="cx"> ASSERT(flag >= 1);
</span><span class="cx"> ASSERT(flag <= 32);
</span><del>- or32(Imm32(1u << (flag - 1)), AbsoluteAddress(&SamplingFlags::s_flags));
</del><ins>+ or32(TrustedImm32(1u << (flag - 1)), AbsoluteAddress(&SamplingFlags::s_flags));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> ALWAYS_INLINE void JIT::clearSamplingFlag(int32_t flag)
</span><span class="cx"> {
</span><span class="cx"> ASSERT(flag >= 1);
</span><span class="cx"> ASSERT(flag <= 32);
</span><del>- and32(Imm32(~(1u << (flag - 1))), AbsoluteAddress(&SamplingFlags::s_flags));
</del><ins>+ and32(TrustedImm32(~(1u << (flag - 1))), AbsoluteAddress(&SamplingFlags::s_flags));
</ins><span class="cx"> }
</span><span class="cx"> #endif
</span><span class="cx">
</span><span class="lines">@@ -283,11 +283,11 @@
</span><span class="cx"> ALWAYS_INLINE void JIT::emitCount(AbstractSamplingCounter& counter, uint32_t count)
</span><span class="cx"> {
</span><span class="cx"> #if CPU(X86_64) // Or any other 64-bit plattform.
</span><del>- addPtr(Imm32(count), AbsoluteAddress(counter.addressOfCounter()));
</del><ins>+ addPtr(TrustedImm32(count), AbsoluteAddress(counter.addressOfCounter()));
</ins><span class="cx"> #elif CPU(X86) // Or any other little-endian 32-bit plattform.
</span><span class="cx"> intptr_t hiWord = reinterpret_cast<intptr_t>(counter.addressOfCounter()) + sizeof(int32_t);
</span><del>- add32(Imm32(count), AbsoluteAddress(counter.addressOfCounter()));
- addWithCarry32(Imm32(0), AbsoluteAddress(reinterpret_cast<void*>(hiWord)));
</del><ins>+ add32(TrustedImm32(count), AbsoluteAddress(counter.addressOfCounter()));
+ addWithCarry32(TrustedImm32(0), AbsoluteAddress(reinterpret_cast<void*>(hiWord)));
</ins><span class="cx"> #else
</span><span class="cx"> #error "SAMPLING_FLAGS not implemented on this platform."
</span><span class="cx"> #endif
</span><span class="lines">@@ -298,13 +298,13 @@
</span><span class="cx"> #if CPU(X86_64)
</span><span class="cx"> ALWAYS_INLINE void JIT::sampleInstruction(Instruction* instruction, bool inHostFunction)
</span><span class="cx"> {
</span><del>- move(ImmPtr(m_interpreter->sampler()->sampleSlot()), X86Registers::ecx);
- storePtr(ImmPtr(m_interpreter->sampler()->encodeSample(instruction, inHostFunction)), X86Registers::ecx);
</del><ins>+ move(TrustedImmPtr(m_interpreter->sampler()->sampleSlot()), X86Registers::ecx);
+ storePtr(TrustedImmPtr(m_interpreter->sampler()->encodeSample(instruction, inHostFunction)), X86Registers::ecx);
</ins><span class="cx"> }
</span><span class="cx"> #else
</span><span class="cx"> ALWAYS_INLINE void JIT::sampleInstruction(Instruction* instruction, bool inHostFunction)
</span><span class="cx"> {
</span><del>- storePtr(ImmPtr(m_interpreter->sampler()->encodeSample(instruction, inHostFunction)), m_interpreter->sampler()->sampleSlot());
</del><ins>+ storePtr(TrustedImmPtr(m_interpreter->sampler()->encodeSample(instruction, inHostFunction)), m_interpreter->sampler()->sampleSlot());
</ins><span class="cx"> }
</span><span class="cx"> #endif
</span><span class="cx"> #endif
</span><span class="lines">@@ -313,13 +313,13 @@
</span><span class="cx"> #if CPU(X86_64)
</span><span class="cx"> ALWAYS_INLINE void JIT::sampleCodeBlock(CodeBlock* codeBlock)
</span><span class="cx"> {
</span><del>- move(ImmPtr(m_interpreter->sampler()->codeBlockSlot()), X86Registers::ecx);
- storePtr(ImmPtr(codeBlock), X86Registers::ecx);
</del><ins>+ move(TrustedImmPtr(m_interpreter->sampler()->codeBlockSlot()), X86Registers::ecx);
+ storePtr(TrustedImmPtr(codeBlock), X86Registers::ecx);
</ins><span class="cx"> }
</span><span class="cx"> #else
</span><span class="cx"> ALWAYS_INLINE void JIT::sampleCodeBlock(CodeBlock* codeBlock)
</span><span class="cx"> {
</span><del>- storePtr(ImmPtr(codeBlock), m_interpreter->sampler()->codeBlockSlot());
</del><ins>+ storePtr(TrustedImmPtr(codeBlock), m_interpreter->sampler()->codeBlockSlot());
</ins><span class="cx"> }
</span><span class="cx"> #endif
</span><span class="cx"> #endif
</span><span class="lines">@@ -436,27 +436,27 @@
</span><span class="cx"> {
</span><span class="cx"> store32(payload, payloadFor(index, callFrameRegister));
</span><span class="cx"> if (!indexIsInt32)
</span><del>- store32(Imm32(JSValue::Int32Tag), tagFor(index, callFrameRegister));
</del><ins>+ store32(TrustedImm32(JSValue::Int32Tag), tagFor(index, callFrameRegister));
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-inline void JIT::emitStoreInt32(unsigned index, Imm32 payload, bool indexIsInt32)
</del><ins>+inline void JIT::emitStoreInt32(unsigned index, TrustedImm32 payload, bool indexIsInt32)
</ins><span class="cx"> {
</span><span class="cx"> store32(payload, payloadFor(index, callFrameRegister));
</span><span class="cx"> if (!indexIsInt32)
</span><del>- store32(Imm32(JSValue::Int32Tag), tagFor(index, callFrameRegister));
</del><ins>+ store32(TrustedImm32(JSValue::Int32Tag), tagFor(index, callFrameRegister));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> inline void JIT::emitStoreCell(unsigned index, RegisterID payload, bool indexIsCell)
</span><span class="cx"> {
</span><span class="cx"> store32(payload, payloadFor(index, callFrameRegister));
</span><span class="cx"> if (!indexIsCell)
</span><del>- store32(Imm32(JSValue::CellTag), tagFor(index, callFrameRegister));
</del><ins>+ store32(TrustedImm32(JSValue::CellTag), tagFor(index, callFrameRegister));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> inline void JIT::emitStoreBool(unsigned index, RegisterID tag, bool indexIsBool)
</span><span class="cx"> {
</span><span class="cx"> if (!indexIsBool)
</span><del>- store32(Imm32(0), payloadFor(index, callFrameRegister));
</del><ins>+ store32(TrustedImm32(0), payloadFor(index, callFrameRegister));
</ins><span class="cx"> store32(tag, tagFor(index, callFrameRegister));
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -564,7 +564,7 @@
</span><span class="cx"> if (m_codeBlock->isConstantRegisterIndex(virtualRegisterIndex))
</span><span class="cx"> addSlowCase(jump());
</span><span class="cx"> else
</span><del>- addSlowCase(branch32(NotEqual, tag, Imm32(JSValue::CellTag)));
</del><ins>+ addSlowCase(branch32(NotEqual, tag, TrustedImm32(JSValue::CellTag)));
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -666,7 +666,7 @@
</span><span class="cx">
</span><span class="cx"> ALWAYS_INLINE void JIT::emitInitRegister(unsigned dst)
</span><span class="cx"> {
</span><del>- storePtr(ImmPtr(JSValue::encode(jsUndefined())), Address(callFrameRegister, dst * sizeof(Register)));
</del><ins>+ storePtr(TrustedImmPtr(JSValue::encode(jsUndefined())), Address(callFrameRegister, dst * sizeof(Register)));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> ALWAYS_INLINE JIT::Jump JIT::emitJumpIfJSCell(RegisterID reg)
</span><span class="lines">@@ -674,7 +674,7 @@
</span><span class="cx"> #if USE(JSVALUE64)
</span><span class="cx"> return branchTestPtr(Zero, reg, tagMaskRegister);
</span><span class="cx"> #else
</span><del>- return branchTest32(Zero, reg, Imm32(JSImmediate::TagMask));
</del><ins>+ return branchTest32(Zero, reg, TrustedImm32(JSImmediate::TagMask));
</ins><span class="cx"> #endif
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -695,7 +695,7 @@
</span><span class="cx"> #if USE(JSVALUE64)
</span><span class="cx"> return branchTestPtr(NonZero, reg, tagMaskRegister);
</span><span class="cx"> #else
</span><del>- return branchTest32(NonZero, reg, Imm32(JSImmediate::TagMask));
</del><ins>+ return branchTest32(NonZero, reg, TrustedImm32(JSImmediate::TagMask));
</ins><span class="cx"> #endif
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -736,7 +736,7 @@
</span><span class="cx"> #if USE(JSVALUE64)
</span><span class="cx"> return branchPtr(AboveOrEqual, reg, tagTypeNumberRegister);
</span><span class="cx"> #else
</span><del>- return branchTest32(NonZero, reg, Imm32(JSImmediate::TagTypeNumber));
</del><ins>+ return branchTest32(NonZero, reg, TrustedImm32(JSImmediate::TagTypeNumber));
</ins><span class="cx"> #endif
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -745,7 +745,7 @@
</span><span class="cx"> #if USE(JSVALUE64)
</span><span class="cx"> return branchPtr(Below, reg, tagTypeNumberRegister);
</span><span class="cx"> #else
</span><del>- return branchTest32(Zero, reg, Imm32(JSImmediate::TagTypeNumber));
</del><ins>+ return branchTest32(Zero, reg, TrustedImm32(JSImmediate::TagTypeNumber));
</ins><span class="cx"> #endif
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -774,12 +774,12 @@
</span><span class="cx"> #if USE(JSVALUE32_64)
</span><span class="cx"> ALWAYS_INLINE void JIT::emitFastArithDeTagImmediate(RegisterID reg)
</span><span class="cx"> {
</span><del>- subPtr(Imm32(JSImmediate::TagTypeNumber), reg);
</del><ins>+ subPtr(TrustedImm32(JSImmediate::TagTypeNumber), reg);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> ALWAYS_INLINE JIT::Jump JIT::emitFastArithDeTagImmediateJumpIfZero(RegisterID reg)
</span><span class="cx"> {
</span><del>- return branchSubPtr(Zero, Imm32(JSImmediate::TagTypeNumber), reg);
</del><ins>+ return branchSubPtr(Zero, TrustedImm32(JSImmediate::TagTypeNumber), reg);
</ins><span class="cx"> }
</span><span class="cx"> #endif
</span><span class="cx">
</span><span class="lines">@@ -790,7 +790,7 @@
</span><span class="cx"> #else
</span><span class="cx"> if (src != dest)
</span><span class="cx"> move(src, dest);
</span><del>- addPtr(Imm32(JSImmediate::TagTypeNumber), dest);
</del><ins>+ addPtr(TrustedImm32(JSImmediate::TagTypeNumber), dest);
</ins><span class="cx"> #endif
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -810,8 +810,8 @@
</span><span class="cx">
</span><span class="cx"> ALWAYS_INLINE void JIT::emitTagAsBoolImmediate(RegisterID reg)
</span><span class="cx"> {
</span><del>- lshift32(Imm32(JSImmediate::ExtendedPayloadShift), reg);
- or32(Imm32(static_cast<int32_t>(JSImmediate::FullTagTypeBool)), reg);
</del><ins>+ lshift32(TrustedImm32(JSImmediate::ExtendedPayloadShift), reg);
+ or32(TrustedImm32(static_cast<int32_t>(JSImmediate::FullTagTypeBool)), reg);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> #endif // USE(JSVALUE32_64)
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorejitJITOpcodescpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/jit/JITOpcodes.cpp (82129 => 82130)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/jit/JITOpcodes.cpp 2011-03-28 17:10:30 UTC (rev 82129)
+++ trunk/Source/JavaScriptCore/jit/JITOpcodes.cpp 2011-03-28 17:14:57 UTC (rev 82130)
</span><span class="lines">@@ -52,12 +52,12 @@
</span><span class="cx">
</span><span class="cx"> // Check eax is a string
</span><span class="cx"> Jump string_failureCases1 = emitJumpIfNotJSCell(regT0);
</span><del>- Jump string_failureCases2 = branchPtr(NotEqual, Address(regT0), ImmPtr(m_globalData->jsStringVPtr));
</del><ins>+ Jump string_failureCases2 = branchPtr(NotEqual, Address(regT0), TrustedImmPtr(m_globalData->jsStringVPtr));
</ins><span class="cx">
</span><span class="cx"> // Checks out okay! - get the length from the Ustring.
</span><span class="cx"> load32(Address(regT0, OBJECT_OFFSETOF(JSString, m_length)), regT0);
</span><span class="cx">
</span><del>- Jump string_failureCases3 = branch32(Above, regT0, Imm32(JSImmediate::maxImmediateInt));
</del><ins>+ Jump string_failureCases3 = branch32(Above, regT0, TrustedImm32(JSImmediate::maxImmediateInt));
</ins><span class="cx">
</span><span class="cx"> // regT0 contains a 64 bit value (is positive, is zero extended) so we don't need sign extend here.
</span><span class="cx"> emitFastArithIntToImmNoCheck(regT0, regT0);
</span><span class="lines">@@ -102,7 +102,7 @@
</span><span class="cx">
</span><span class="cx"> loadPtr(Address(regT0, OBJECT_OFFSETOF(JSFunction, m_executable)), regT2);
</span><span class="cx">
</span><del>- Jump hasCodeBlock3 = branch32(GreaterThanOrEqual, Address(regT2, OBJECT_OFFSETOF(FunctionExecutable, m_numParametersForCall)), Imm32(0));
</del><ins>+ Jump hasCodeBlock3 = branch32(GreaterThanOrEqual, Address(regT2, OBJECT_OFFSETOF(FunctionExecutable, m_numParametersForCall)), TrustedImm32(0));
</ins><span class="cx"> preserveReturnAddressAfterCall(regT3);
</span><span class="cx"> restoreArgumentReference();
</span><span class="cx"> Call callCompileCall = call();
</span><span class="lines">@@ -122,7 +122,7 @@
</span><span class="cx">
</span><span class="cx"> loadPtr(Address(regT0, OBJECT_OFFSETOF(JSFunction, m_executable)), regT2);
</span><span class="cx">
</span><del>- Jump hasCodeBlock4 = branch32(GreaterThanOrEqual, Address(regT2, OBJECT_OFFSETOF(FunctionExecutable, m_numParametersForConstruct)), Imm32(0));
</del><ins>+ Jump hasCodeBlock4 = branch32(GreaterThanOrEqual, Address(regT2, OBJECT_OFFSETOF(FunctionExecutable, m_numParametersForConstruct)), TrustedImm32(0));
</ins><span class="cx"> preserveReturnAddressAfterCall(regT3);
</span><span class="cx"> restoreArgumentReference();
</span><span class="cx"> Call callCompileConstruct = call();
</span><span class="lines">@@ -141,10 +141,10 @@
</span><span class="cx"> emitGetFromCallFrameHeaderPtr(RegisterFile::ReturnPC, regT1);
</span><span class="cx"> emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, callFrameRegister);
</span><span class="cx"> restoreReturnAddressBeforeReturn(regT1);
</span><del>- move(ImmPtr(&globalData->exceptionLocation), regT2);
</del><ins>+ move(TrustedImmPtr(&globalData->exceptionLocation), regT2);
</ins><span class="cx"> storePtr(regT1, regT2);
</span><span class="cx"> poke(callFrameRegister, 1 + OBJECT_OFFSETOF(struct JITStackFrame, callFrame) / sizeof(void*));
</span><del>- poke(ImmPtr(FunctionPtr(ctiVMThrowTrampoline).value()));
</del><ins>+ poke(TrustedImmPtr(FunctionPtr(ctiVMThrowTrampoline).value()));
</ins><span class="cx"> ret();
</span><span class="cx">
</span><span class="cx"> // NativeCall Trampoline
</span><span class="lines">@@ -208,14 +208,14 @@
</span><span class="cx"> // Host function signature: f(ExecState*);
</span><span class="cx"> move(callFrameRegister, X86Registers::edi);
</span><span class="cx">
</span><del>- subPtr(Imm32(16 - sizeof(void*)), stackPointerRegister); // Align stack after call.
</del><ins>+ subPtr(TrustedImm32(16 - sizeof(void*)), stackPointerRegister); // Align stack after call.
</ins><span class="cx">
</span><span class="cx"> emitGetFromCallFrameHeaderPtr(RegisterFile::Callee, X86Registers::esi);
</span><span class="cx"> loadPtr(Address(X86Registers::esi, OBJECT_OFFSETOF(JSFunction, m_executable)), X86Registers::r9);
</span><span class="cx"> move(regT0, callFrameRegister); // Eagerly restore caller frame register to avoid loading from stack.
</span><span class="cx"> call(Address(X86Registers::r9, executableOffsetToFunction));
</span><span class="cx">
</span><del>- addPtr(Imm32(16 - sizeof(void*)), stackPointerRegister);
</del><ins>+ addPtr(TrustedImm32(16 - sizeof(void*)), stackPointerRegister);
</ins><span class="cx">
</span><span class="cx"> #elif CPU(ARM)
</span><span class="cx"> // Load caller frame's scope chain into this callframe so that whatever we call can
</span><span class="lines">@@ -253,7 +253,7 @@
</span><span class="cx">
</span><span class="cx"> // Allocate stack space for 16 bytes (8-byte aligned)
</span><span class="cx"> // 16 bytes (unused) for 4 arguments
</span><del>- subPtr(Imm32(16), stackPointerRegister);
</del><ins>+ subPtr(TrustedImm32(16), stackPointerRegister);
</ins><span class="cx">
</span><span class="cx"> // Setup arg0
</span><span class="cx"> move(callFrameRegister, MIPSRegisters::a0);
</span><span class="lines">@@ -265,7 +265,7 @@
</span><span class="cx"> call(Address(regT2, executableOffsetToFunction));
</span><span class="cx">
</span><span class="cx"> // Restore stack space
</span><del>- addPtr(Imm32(16), stackPointerRegister);
</del><ins>+ addPtr(TrustedImm32(16), stackPointerRegister);
</ins><span class="cx">
</span><span class="cx"> restoreReturnAddressBeforeReturn(regT3);
</span><span class="cx">
</span><span class="lines">@@ -289,12 +289,12 @@
</span><span class="cx"> // Grab the return address.
</span><span class="cx"> preserveReturnAddressAfterCall(regT1);
</span><span class="cx">
</span><del>- move(ImmPtr(&globalData->exceptionLocation), regT2);
</del><ins>+ move(TrustedImmPtr(&globalData->exceptionLocation), regT2);
</ins><span class="cx"> storePtr(regT1, regT2);
</span><span class="cx"> poke(callFrameRegister, OBJECT_OFFSETOF(struct JITStackFrame, callFrame) / sizeof(void*));
</span><span class="cx">
</span><span class="cx"> // Set the return address.
</span><del>- move(ImmPtr(FunctionPtr(ctiVMThrowTrampoline).value()), regT1);
</del><ins>+ move(TrustedImmPtr(FunctionPtr(ctiVMThrowTrampoline).value()), regT1);
</ins><span class="cx"> restoreReturnAddressBeforeReturn(regT1);
</span><span class="cx">
</span><span class="cx"> ret();
</span><span class="lines">@@ -379,7 +379,7 @@
</span><span class="cx">
</span><span class="cx"> // Check that baseVal 'ImplementsHasInstance'.
</span><span class="cx"> loadPtr(Address(regT0, JSCell::structureOffset()), regT0);
</span><del>- addSlowCase(branchTest8(Zero, Address(regT0, Structure::typeInfoFlagsOffset()), Imm32(ImplementsHasInstance)));
</del><ins>+ addSlowCase(branchTest8(Zero, Address(regT0, Structure::typeInfoFlagsOffset()), TrustedImm32(ImplementsHasInstance)));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void JIT::emit_op_instanceof(Instruction* currentInstruction)
</span><span class="lines">@@ -401,17 +401,17 @@
</span><span class="cx">
</span><span class="cx"> // Check that prototype is an object
</span><span class="cx"> loadPtr(Address(regT1, JSCell::structureOffset()), regT3);
</span><del>- addSlowCase(branch8(NotEqual, Address(regT3, Structure::typeInfoTypeOffset()), Imm32(ObjectType)));
</del><ins>+ addSlowCase(branch8(NotEqual, Address(regT3, Structure::typeInfoTypeOffset()), TrustedImm32(ObjectType)));
</ins><span class="cx">
</span><span class="cx"> // Fixme: this check is only needed because the JSC API allows HasInstance to be overridden; we should deprecate this.
</span><span class="cx"> // Check that baseVal 'ImplementsDefaultHasInstance'.
</span><span class="cx"> loadPtr(Address(regT0, JSCell::structureOffset()), regT0);
</span><del>- addSlowCase(branchTest8(Zero, Address(regT0, Structure::typeInfoFlagsOffset()), Imm32(ImplementsDefaultHasInstance)));
</del><ins>+ addSlowCase(branchTest8(Zero, Address(regT0, Structure::typeInfoFlagsOffset()), TrustedImm32(ImplementsDefaultHasInstance)));
</ins><span class="cx">
</span><span class="cx"> // Optimistically load the result true, and start looping.
</span><span class="cx"> // Initially, regT1 still contains proto and regT2 still contains value.
</span><span class="cx"> // As we loop regT2 will be updated with its prototype, recursively walking the prototype chain.
</span><del>- move(ImmPtr(JSValue::encode(jsBoolean(true))), regT0);
</del><ins>+ move(TrustedImmPtr(JSValue::encode(jsBoolean(true))), regT0);
</ins><span class="cx"> Label loop(this);
</span><span class="cx">
</span><span class="cx"> // Load the prototype of the object in regT2. If this is equal to regT1 - WIN!
</span><span class="lines">@@ -422,7 +422,7 @@
</span><span class="cx"> emitJumpIfJSCell(regT2).linkTo(loop, this);
</span><span class="cx">
</span><span class="cx"> // We get here either by dropping out of the loop, or if value was not an Object. Result is false.
</span><del>- move(ImmPtr(JSValue::encode(jsBoolean(false))), regT0);
</del><ins>+ move(TrustedImmPtr(JSValue::encode(jsBoolean(false))), regT0);
</ins><span class="cx">
</span><span class="cx"> // isInstance jumps right down to here, to skip setting the result to false (it has already set true).
</span><span class="cx"> isInstance.link(this);
</span><span class="lines">@@ -566,7 +566,7 @@
</span><span class="cx"> emitGetVirtualRegister(currentInstruction[1].u.operand, returnValueRegister);
</span><span class="cx"> Jump notJSCell = emitJumpIfNotJSCell(returnValueRegister);
</span><span class="cx"> loadPtr(Address(returnValueRegister, JSCell::structureOffset()), regT2);
</span><del>- Jump notObject = branch8(NotEqual, Address(regT2, Structure::typeInfoTypeOffset()), Imm32(ObjectType));
</del><ins>+ Jump notObject = branch8(NotEqual, Address(regT2, Structure::typeInfoTypeOffset()), TrustedImm32(ObjectType));
</ins><span class="cx">
</span><span class="cx"> // Grab the return address.
</span><span class="cx"> emitGetFromCallFrameHeaderPtr(RegisterFile::ReturnPC, regT1);
</span><span class="lines">@@ -605,7 +605,7 @@
</span><span class="cx"> void JIT::emit_op_resolve(Instruction* currentInstruction)
</span><span class="cx"> {
</span><span class="cx"> JITStubCall stubCall(this, cti_op_resolve);
</span><del>- stubCall.addArgument(ImmPtr(&m_codeBlock->identifier(currentInstruction[2].u.operand)));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(&m_codeBlock->identifier(currentInstruction[2].u.operand)));
</ins><span class="cx"> stubCall.call(currentInstruction[1].u.operand);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -617,7 +617,7 @@
</span><span class="cx"> emitGetVirtualRegister(src, regT0);
</span><span class="cx">
</span><span class="cx"> Jump isImm = emitJumpIfNotJSCell(regT0);
</span><del>- addSlowCase(branchPtr(NotEqual, Address(regT0), ImmPtr(m_globalData->jsStringVPtr)));
</del><ins>+ addSlowCase(branchPtr(NotEqual, Address(regT0), TrustedImmPtr(m_globalData->jsStringVPtr)));
</ins><span class="cx"> isImm.link(this);
</span><span class="cx">
</span><span class="cx"> if (dst != src)
</span><span class="lines">@@ -636,7 +636,7 @@
</span><span class="cx"> void JIT::emit_op_resolve_base(Instruction* currentInstruction)
</span><span class="cx"> {
</span><span class="cx"> JITStubCall stubCall(this, currentInstruction[3].u.operand ? cti_op_resolve_base_strict_put : cti_op_resolve_base);
</span><del>- stubCall.addArgument(ImmPtr(&m_codeBlock->identifier(currentInstruction[2].u.operand)));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(&m_codeBlock->identifier(currentInstruction[2].u.operand)));
</ins><span class="cx"> stubCall.call(currentInstruction[1].u.operand);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -644,14 +644,14 @@
</span><span class="cx"> {
</span><span class="cx"> JITStubCall stubCall(this, cti_op_ensure_property_exists);
</span><span class="cx"> stubCall.addArgument(Imm32(currentInstruction[1].u.operand));
</span><del>- stubCall.addArgument(ImmPtr(&m_codeBlock->identifier(currentInstruction[2].u.operand)));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(&m_codeBlock->identifier(currentInstruction[2].u.operand)));
</ins><span class="cx"> stubCall.call(currentInstruction[1].u.operand);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void JIT::emit_op_resolve_skip(Instruction* currentInstruction)
</span><span class="cx"> {
</span><span class="cx"> JITStubCall stubCall(this, cti_op_resolve_skip);
</span><del>- stubCall.addArgument(ImmPtr(&m_codeBlock->identifier(currentInstruction[2].u.operand)));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(&m_codeBlock->identifier(currentInstruction[2].u.operand)));
</ins><span class="cx"> stubCall.addArgument(Imm32(currentInstruction[3].u.operand));
</span><span class="cx"> stubCall.call(currentInstruction[1].u.operand);
</span><span class="cx"> }
</span><span class="lines">@@ -665,7 +665,7 @@
</span><span class="cx"> void* offsetAddr = &(m_codeBlock->globalResolveInfo(currentIndex).offset);
</span><span class="cx">
</span><span class="cx"> // Check Structure of global object
</span><del>- move(ImmPtr(globalObject), regT0);
</del><ins>+ move(TrustedImmPtr(globalObject), regT0);
</ins><span class="cx"> loadPtr(structureAddress, regT1);
</span><span class="cx"> addSlowCase(branchPtr(NotEqual, regT1, Address(regT0, JSCell::structureOffset()))); // Structures don't match
</span><span class="cx">
</span><span class="lines">@@ -686,7 +686,7 @@
</span><span class="cx">
</span><span class="cx"> linkSlowCase(iter);
</span><span class="cx"> JITStubCall stubCall(this, cti_op_resolve_global);
</span><del>- stubCall.addArgument(ImmPtr(ident));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(ident));
</ins><span class="cx"> stubCall.addArgument(Imm32(currentIndex));
</span><span class="cx"> stubCall.addArgument(regT0);
</span><span class="cx"> stubCall.call(dst);
</span><span class="lines">@@ -695,9 +695,9 @@
</span><span class="cx"> void JIT::emit_op_not(Instruction* currentInstruction)
</span><span class="cx"> {
</span><span class="cx"> emitGetVirtualRegister(currentInstruction[2].u.operand, regT0);
</span><del>- xorPtr(Imm32(static_cast<int32_t>(JSImmediate::FullTagTypeBool)), regT0);
- addSlowCase(branchTestPtr(NonZero, regT0, Imm32(static_cast<int32_t>(~JSImmediate::ExtendedPayloadBitBoolValue))));
- xorPtr(Imm32(static_cast<int32_t>(JSImmediate::FullTagTypeBool | JSImmediate::ExtendedPayloadBitBoolValue)), regT0);
</del><ins>+ xorPtr(TrustedImm32(static_cast<int32_t>(JSImmediate::FullTagTypeBool)), regT0);
+ addSlowCase(branchTestPtr(NonZero, regT0, TrustedImm32(static_cast<int32_t>(~JSImmediate::ExtendedPayloadBitBoolValue))));
+ xorPtr(TrustedImm32(static_cast<int32_t>(JSImmediate::FullTagTypeBool | JSImmediate::ExtendedPayloadBitBoolValue)), regT0);
</ins><span class="cx"> emitPutVirtualRegister(currentInstruction[1].u.operand);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -706,11 +706,11 @@
</span><span class="cx"> unsigned target = currentInstruction[2].u.operand;
</span><span class="cx"> emitGetVirtualRegister(currentInstruction[1].u.operand, regT0);
</span><span class="cx">
</span><del>- addJump(branchPtr(Equal, regT0, ImmPtr(JSValue::encode(jsNumber(0)))), target);
</del><ins>+ addJump(branchPtr(Equal, regT0, TrustedImmPtr(JSValue::encode(jsNumber(0)))), target);
</ins><span class="cx"> Jump isNonZero = emitJumpIfImmediateInteger(regT0);
</span><span class="cx">
</span><del>- addJump(branchPtr(Equal, regT0, ImmPtr(JSValue::encode(jsBoolean(false)))), target);
- addSlowCase(branchPtr(NotEqual, regT0, ImmPtr(JSValue::encode(jsBoolean(true)))));
</del><ins>+ addJump(branchPtr(Equal, regT0, TrustedImmPtr(JSValue::encode(jsBoolean(false)))), target);
+ addSlowCase(branchPtr(NotEqual, regT0, TrustedImmPtr(JSValue::encode(jsBoolean(true)))));
</ins><span class="cx">
</span><span class="cx"> isNonZero.link(this);
</span><span class="cx"> RECORD_JUMP_TARGET(target);
</span><span class="lines">@@ -726,13 +726,13 @@
</span><span class="cx">
</span><span class="cx"> // First, handle JSCell cases - check MasqueradesAsUndefined bit on the structure.
</span><span class="cx"> loadPtr(Address(regT0, JSCell::structureOffset()), regT2);
</span><del>- addJump(branchTest8(NonZero, Address(regT2, Structure::typeInfoFlagsOffset()), Imm32(MasqueradesAsUndefined)), target);
</del><ins>+ addJump(branchTest8(NonZero, Address(regT2, Structure::typeInfoFlagsOffset()), TrustedImm32(MasqueradesAsUndefined)), target);
</ins><span class="cx"> Jump wasNotImmediate = jump();
</span><span class="cx">
</span><span class="cx"> // Now handle the immediate cases - undefined & null
</span><span class="cx"> isImmediate.link(this);
</span><del>- andPtr(Imm32(~JSImmediate::ExtendedTagBitUndefined), regT0);
- addJump(branchPtr(Equal, regT0, ImmPtr(JSValue::encode(jsNull()))), target);
</del><ins>+ andPtr(TrustedImm32(~JSImmediate::ExtendedTagBitUndefined), regT0);
+ addJump(branchPtr(Equal, regT0, TrustedImmPtr(JSValue::encode(jsNull()))), target);
</ins><span class="cx">
</span><span class="cx"> wasNotImmediate.link(this);
</span><span class="cx"> RECORD_JUMP_TARGET(target);
</span><span class="lines">@@ -747,13 +747,13 @@
</span><span class="cx">
</span><span class="cx"> // First, handle JSCell cases - check MasqueradesAsUndefined bit on the structure.
</span><span class="cx"> loadPtr(Address(regT0, JSCell::structureOffset()), regT2);
</span><del>- addJump(branchTest8(Zero, Address(regT2, Structure::typeInfoFlagsOffset()), Imm32(MasqueradesAsUndefined)), target);
</del><ins>+ addJump(branchTest8(Zero, Address(regT2, Structure::typeInfoFlagsOffset()), TrustedImm32(MasqueradesAsUndefined)), target);
</ins><span class="cx"> Jump wasNotImmediate = jump();
</span><span class="cx">
</span><span class="cx"> // Now handle the immediate cases - undefined & null
</span><span class="cx"> isImmediate.link(this);
</span><del>- andPtr(Imm32(~JSImmediate::ExtendedTagBitUndefined), regT0);
- addJump(branchPtr(NotEqual, regT0, ImmPtr(JSValue::encode(jsNull()))), target);
</del><ins>+ andPtr(TrustedImm32(~JSImmediate::ExtendedTagBitUndefined), regT0);
+ addJump(branchPtr(NotEqual, regT0, TrustedImmPtr(JSValue::encode(jsNull()))), target);
</ins><span class="cx">
</span><span class="cx"> wasNotImmediate.link(this);
</span><span class="cx"> RECORD_JUMP_TARGET(target);
</span><span class="lines">@@ -766,7 +766,7 @@
</span><span class="cx"> unsigned target = currentInstruction[3].u.operand;
</span><span class="cx">
</span><span class="cx"> emitGetVirtualRegister(src, regT0);
</span><del>- addJump(branchPtr(NotEqual, regT0, ImmPtr(JSValue::encode(JSValue(ptr)))), target);
</del><ins>+ addJump(branchPtr(NotEqual, regT0, TrustedImmPtr(JSValue::encode(JSValue(ptr)))), target);
</ins><span class="cx">
</span><span class="cx"> RECORD_JUMP_TARGET(target);
</span><span class="cx"> }
</span><span class="lines">@@ -775,7 +775,7 @@
</span><span class="cx"> {
</span><span class="cx"> int retAddrDst = currentInstruction[1].u.operand;
</span><span class="cx"> int target = currentInstruction[2].u.operand;
</span><del>- DataLabelPtr storeLocation = storePtrWithPatch(ImmPtr(0), Address(callFrameRegister, sizeof(Register) * retAddrDst));
</del><ins>+ DataLabelPtr storeLocation = storePtrWithPatch(TrustedImmPtr(0), Address(callFrameRegister, sizeof(Register) * retAddrDst));
</ins><span class="cx"> addJump(jump(), target);
</span><span class="cx"> m_jsrSites.append(JSRInfo(storeLocation, label()));
</span><span class="cx"> killLastResultRegister();
</span><span class="lines">@@ -809,7 +809,7 @@
</span><span class="cx"> void JIT::emit_op_resolve_with_base(Instruction* currentInstruction)
</span><span class="cx"> {
</span><span class="cx"> JITStubCall stubCall(this, cti_op_resolve_with_base);
</span><del>- stubCall.addArgument(ImmPtr(&m_codeBlock->identifier(currentInstruction[3].u.operand)));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(&m_codeBlock->identifier(currentInstruction[3].u.operand)));
</ins><span class="cx"> stubCall.addArgument(Imm32(currentInstruction[1].u.operand));
</span><span class="cx"> stubCall.call(currentInstruction[2].u.operand);
</span><span class="cx"> }
</span><span class="lines">@@ -817,7 +817,7 @@
</span><span class="cx"> void JIT::emit_op_new_func_exp(Instruction* currentInstruction)
</span><span class="cx"> {
</span><span class="cx"> JITStubCall stubCall(this, cti_op_new_func_exp);
</span><del>- stubCall.addArgument(ImmPtr(m_codeBlock->functionExpr(currentInstruction[2].u.operand)));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(m_codeBlock->functionExpr(currentInstruction[2].u.operand)));
</ins><span class="cx"> stubCall.call(currentInstruction[1].u.operand);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -826,11 +826,11 @@
</span><span class="cx"> unsigned target = currentInstruction[2].u.operand;
</span><span class="cx"> emitGetVirtualRegister(currentInstruction[1].u.operand, regT0);
</span><span class="cx">
</span><del>- Jump isZero = branchPtr(Equal, regT0, ImmPtr(JSValue::encode(jsNumber(0))));
</del><ins>+ Jump isZero = branchPtr(Equal, regT0, TrustedImmPtr(JSValue::encode(jsNumber(0))));
</ins><span class="cx"> addJump(emitJumpIfImmediateInteger(regT0), target);
</span><span class="cx">
</span><del>- addJump(branchPtr(Equal, regT0, ImmPtr(JSValue::encode(jsBoolean(true)))), target);
- addSlowCase(branchPtr(NotEqual, regT0, ImmPtr(JSValue::encode(jsBoolean(false)))));
</del><ins>+ addJump(branchPtr(Equal, regT0, TrustedImmPtr(JSValue::encode(jsBoolean(true)))), target);
+ addSlowCase(branchPtr(NotEqual, regT0, TrustedImmPtr(JSValue::encode(jsBoolean(false)))));
</ins><span class="cx">
</span><span class="cx"> isZero.link(this);
</span><span class="cx"> RECORD_JUMP_TARGET(target);
</span><span class="lines">@@ -892,7 +892,7 @@
</span><span class="cx"> isNotObject.append(emitJumpIfNotJSCell(regT0));
</span><span class="cx"> if (base != m_codeBlock->thisRegister() || m_codeBlock->isStrictMode()) {
</span><span class="cx"> loadPtr(Address(regT0, JSCell::structureOffset()), regT2);
</span><del>- isNotObject.append(branch8(NotEqual, Address(regT2, Structure::typeInfoTypeOffset()), Imm32(ObjectType)));
</del><ins>+ isNotObject.append(branch8(NotEqual, Address(regT2, Structure::typeInfoTypeOffset()), TrustedImm32(ObjectType)));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // We could inline the case where you have a valid cache, but
</span><span class="lines">@@ -903,14 +903,14 @@
</span><span class="cx"> getPnamesStubCall.call(dst);
</span><span class="cx"> load32(Address(regT0, OBJECT_OFFSETOF(JSPropertyNameIterator, m_jsStringsSize)), regT3);
</span><span class="cx"> storePtr(tagTypeNumberRegister, payloadFor(i));
</span><del>- store32(Imm32(Int32Tag), intTagFor(size));
</del><ins>+ store32(TrustedImm32(Int32Tag), intTagFor(size));
</ins><span class="cx"> store32(regT3, intPayloadFor(size));
</span><span class="cx"> Jump end = jump();
</span><span class="cx">
</span><span class="cx"> isNotObject.link(this);
</span><span class="cx"> move(regT0, regT1);
</span><del>- and32(Imm32(~JSImmediate::ExtendedTagBitUndefined), regT1);
- addJump(branch32(Equal, regT1, Imm32(JSImmediate::FullTagTypeNull)), breakTarget);
</del><ins>+ and32(TrustedImm32(~JSImmediate::ExtendedTagBitUndefined), regT1);
+ addJump(branch32(Equal, regT1, TrustedImm32(JSImmediate::FullTagTypeNull)), breakTarget);
</ins><span class="cx">
</span><span class="cx"> JITStubCall toObjectStubCall(this, cti_to_object);
</span><span class="cx"> toObjectStubCall.addArgument(regT0);
</span><span class="lines">@@ -944,7 +944,7 @@
</span><span class="cx"> emitPutVirtualRegister(dst, regT2);
</span><span class="cx">
</span><span class="cx"> // Increment i
</span><del>- add32(Imm32(1), regT0);
</del><ins>+ add32(TrustedImm32(1), regT0);
</ins><span class="cx"> store32(regT0, intPayloadFor(i));
</span><span class="cx">
</span><span class="cx"> // Verify that i is valid:
</span><span class="lines">@@ -964,7 +964,7 @@
</span><span class="cx"> callHasProperty.append(emitJumpIfNotJSCell(regT2));
</span><span class="cx"> loadPtr(Address(regT2, JSCell::structureOffset()), regT2);
</span><span class="cx"> callHasProperty.append(branchPtr(NotEqual, regT2, Address(regT3)));
</span><del>- addPtr(Imm32(sizeof(Structure*)), regT3);
</del><ins>+ addPtr(TrustedImm32(sizeof(Structure*)), regT3);
</ins><span class="cx"> branchTestPtr(NonZero, Address(regT3)).linkTo(checkPrototype, this);
</span><span class="cx">
</span><span class="cx"> // Continue loop.
</span><span class="lines">@@ -1040,7 +1040,7 @@
</span><span class="cx">
</span><span class="cx"> emitJumpSlowCaseIfNotJSCell(regT0, srcVReg);
</span><span class="cx"> loadPtr(Address(regT0, JSCell::structureOffset()), regT2);
</span><del>- addSlowCase(branch8(NotEqual, Address(regT2, Structure::typeInfoTypeOffset()), Imm32(NumberType)));
</del><ins>+ addSlowCase(branch8(NotEqual, Address(regT2, Structure::typeInfoTypeOffset()), TrustedImm32(NumberType)));
</ins><span class="cx">
</span><span class="cx"> wasImmediate.link(this);
</span><span class="cx">
</span><span class="lines">@@ -1050,7 +1050,7 @@
</span><span class="cx"> void JIT::emit_op_push_new_scope(Instruction* currentInstruction)
</span><span class="cx"> {
</span><span class="cx"> JITStubCall stubCall(this, cti_op_push_new_scope);
</span><del>- stubCall.addArgument(ImmPtr(&m_codeBlock->identifier(currentInstruction[2].u.operand)));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(&m_codeBlock->identifier(currentInstruction[2].u.operand)));
</ins><span class="cx"> stubCall.addArgument(currentInstruction[3].u.operand, regT2);
</span><span class="cx"> stubCall.call(currentInstruction[1].u.operand);
</span><span class="cx"> }
</span><span class="lines">@@ -1061,7 +1061,7 @@
</span><span class="cx"> move(regT0, callFrameRegister);
</span><span class="cx"> peek(regT3, OBJECT_OFFSETOF(struct JITStackFrame, globalData) / sizeof(void*));
</span><span class="cx"> loadPtr(Address(regT3, OBJECT_OFFSETOF(JSGlobalData, exception)), regT0);
</span><del>- storePtr(ImmPtr(JSValue::encode(JSValue())), Address(regT3, OBJECT_OFFSETOF(JSGlobalData, exception)));
</del><ins>+ storePtr(TrustedImmPtr(JSValue::encode(JSValue())), Address(regT3, OBJECT_OFFSETOF(JSGlobalData, exception)));
</ins><span class="cx"> emitPutVirtualRegister(currentInstruction[1].u.operand);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1157,14 +1157,14 @@
</span><span class="cx"> Jump isImmediate = emitJumpIfNotJSCell(regT0);
</span><span class="cx">
</span><span class="cx"> loadPtr(Address(regT0, JSCell::structureOffset()), regT2);
</span><del>- set32Test8(NonZero, Address(regT2, Structure::typeInfoFlagsOffset()), Imm32(MasqueradesAsUndefined), regT0);
</del><ins>+ set32Test8(NonZero, Address(regT2, Structure::typeInfoFlagsOffset()), TrustedImm32(MasqueradesAsUndefined), regT0);
</ins><span class="cx">
</span><span class="cx"> Jump wasNotImmediate = jump();
</span><span class="cx">
</span><span class="cx"> isImmediate.link(this);
</span><span class="cx">
</span><del>- andPtr(Imm32(~JSImmediate::ExtendedTagBitUndefined), regT0);
- setPtr(Equal, regT0, Imm32(JSImmediate::FullTagTypeNull), regT0);
</del><ins>+ andPtr(TrustedImm32(~JSImmediate::ExtendedTagBitUndefined), regT0);
+ setPtr(Equal, regT0, TrustedImm32(JSImmediate::FullTagTypeNull), regT0);
</ins><span class="cx">
</span><span class="cx"> wasNotImmediate.link(this);
</span><span class="cx">
</span><span class="lines">@@ -1182,14 +1182,14 @@
</span><span class="cx"> Jump isImmediate = emitJumpIfNotJSCell(regT0);
</span><span class="cx">
</span><span class="cx"> loadPtr(Address(regT0, JSCell::structureOffset()), regT2);
</span><del>- set32Test8(Zero, Address(regT2, Structure::typeInfoFlagsOffset()), Imm32(MasqueradesAsUndefined), regT0);
</del><ins>+ set32Test8(Zero, Address(regT2, Structure::typeInfoFlagsOffset()), TrustedImm32(MasqueradesAsUndefined), regT0);
</ins><span class="cx">
</span><span class="cx"> Jump wasNotImmediate = jump();
</span><span class="cx">
</span><span class="cx"> isImmediate.link(this);
</span><span class="cx">
</span><del>- andPtr(Imm32(~JSImmediate::ExtendedTagBitUndefined), regT0);
- setPtr(NotEqual, regT0, Imm32(JSImmediate::FullTagTypeNull), regT0);
</del><ins>+ andPtr(TrustedImm32(~JSImmediate::ExtendedTagBitUndefined), regT0);
+ setPtr(NotEqual, regT0, TrustedImm32(JSImmediate::FullTagTypeNull), regT0);
</ins><span class="cx">
</span><span class="cx"> wasNotImmediate.link(this);
</span><span class="cx">
</span><span class="lines">@@ -1236,7 +1236,7 @@
</span><span class="cx"> {
</span><span class="cx"> unsigned dst = currentInstruction[1].u.operand;
</span><span class="cx">
</span><del>- storePtr(ImmPtr(0), Address(callFrameRegister, sizeof(Register) * dst));
</del><ins>+ storePtr(TrustedImmPtr(0), Address(callFrameRegister, sizeof(Register) * dst));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void JIT::emit_op_convert_this(Instruction* currentInstruction)
</span><span class="lines">@@ -1245,21 +1245,21 @@
</span><span class="cx">
</span><span class="cx"> emitJumpSlowCaseIfNotJSCell(regT0);
</span><span class="cx"> loadPtr(Address(regT0, JSCell::structureOffset()), regT1);
</span><del>- addSlowCase(branchTest8(NonZero, Address(regT1, Structure::typeInfoFlagsOffset()), Imm32(NeedsThisConversion)));
</del><ins>+ addSlowCase(branchTest8(NonZero, Address(regT1, Structure::typeInfoFlagsOffset()), TrustedImm32(NeedsThisConversion)));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void JIT::emit_op_convert_this_strict(Instruction* currentInstruction)
</span><span class="cx"> {
</span><span class="cx"> emitGetVirtualRegister(currentInstruction[1].u.operand, regT0);
</span><span class="cx"> Jump notNull = branchTestPtr(NonZero, regT0);
</span><del>- move(ImmPtr(JSValue::encode(jsNull())), regT0);
</del><ins>+ move(TrustedImmPtr(JSValue::encode(jsNull())), regT0);
</ins><span class="cx"> emitPutVirtualRegister(currentInstruction[1].u.operand, regT0);
</span><span class="cx"> Jump setThis = jump();
</span><span class="cx"> notNull.link(this);
</span><span class="cx"> Jump isImmediate = emitJumpIfNotJSCell(regT0);
</span><span class="cx"> loadPtr(Address(regT0, JSCell::structureOffset()), regT1);
</span><del>- Jump notAnObject = branch8(NotEqual, Address(regT1, Structure::typeInfoTypeOffset()), Imm32(ObjectType));
- addSlowCase(branchTest8(NonZero, Address(regT1, Structure::typeInfoFlagsOffset()), Imm32(NeedsThisConversion)));
</del><ins>+ Jump notAnObject = branch8(NotEqual, Address(regT1, Structure::typeInfoTypeOffset()), TrustedImm32(ObjectType));
+ addSlowCase(branchTest8(NonZero, Address(regT1, Structure::typeInfoFlagsOffset()), TrustedImm32(NeedsThisConversion)));
</ins><span class="cx"> isImmediate.link(this);
</span><span class="cx"> notAnObject.link(this);
</span><span class="cx"> setThis.link(this);
</span><span class="lines">@@ -1374,7 +1374,7 @@
</span><span class="cx"> void JIT::emitSlow_op_not(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
</span><span class="cx"> {
</span><span class="cx"> linkSlowCase(iter);
</span><del>- xorPtr(Imm32(static_cast<int32_t>(JSImmediate::FullTagTypeBool)), regT0);
</del><ins>+ xorPtr(TrustedImm32(static_cast<int32_t>(JSImmediate::FullTagTypeBool)), regT0);
</ins><span class="cx"> JITStubCall stubCall(this, cti_op_not);
</span><span class="cx"> stubCall.addArgument(regT0);
</span><span class="cx"> stubCall.call(currentInstruction[1].u.operand);
</span><span class="lines">@@ -1442,7 +1442,7 @@
</span><span class="cx"> stubCall.addArgument(regT0);
</span><span class="cx"> stubCall.addArgument(regT1);
</span><span class="cx"> stubCall.call();
</span><del>- xor32(Imm32(0x1), regT0);
</del><ins>+ xor32(TrustedImm32(0x1), regT0);
</ins><span class="cx"> emitTagAsBoolImmediate(regT0);
</span><span class="cx"> emitPutVirtualRegister(currentInstruction[1].u.operand);
</span><span class="cx"> }
</span><span class="lines">@@ -1532,7 +1532,7 @@
</span><span class="cx"> int argumentsRegister = currentInstruction[2].u.operand;
</span><span class="cx"> addSlowCase(branchTestPtr(NonZero, addressFor(argumentsRegister)));
</span><span class="cx"> emitGetFromCallFrameHeader32(RegisterFile::ArgumentCount, regT0);
</span><del>- sub32(Imm32(1), regT0);
</del><ins>+ sub32(TrustedImm32(1), regT0);
</ins><span class="cx"> emitFastArithReTagImmediate(regT0, regT0);
</span><span class="cx"> emitPutVirtualRegister(dst, regT0);
</span><span class="cx"> }
</span><span class="lines">@@ -1547,7 +1547,7 @@
</span><span class="cx"> emitGetVirtualRegister(base, regT0);
</span><span class="cx"> JITStubCall stubCall(this, cti_op_get_by_id_generic);
</span><span class="cx"> stubCall.addArgument(regT0);
</span><del>- stubCall.addArgument(ImmPtr(ident));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(ident));
</ins><span class="cx"> stubCall.call(dst);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1559,7 +1559,7 @@
</span><span class="cx"> addSlowCase(branchTestPtr(NonZero, addressFor(argumentsRegister)));
</span><span class="cx"> emitGetVirtualRegister(property, regT1);
</span><span class="cx"> addSlowCase(emitJumpIfNotImmediateInteger(regT1));
</span><del>- add32(Imm32(1), regT1);
</del><ins>+ add32(TrustedImm32(1), regT1);
</ins><span class="cx"> // regT1 now contains the integer index of the argument we want, including this
</span><span class="cx"> emitGetFromCallFrameHeader32(RegisterFile::ArgumentCount, regT2);
</span><span class="cx"> addSlowCase(branch32(AboveOrEqual, regT1, regT2));
</span><span class="lines">@@ -1575,7 +1575,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> addPtr(Imm32(static_cast<unsigned>(-(RegisterFile::CallFrameHeaderSize + numArgs) * sizeof(Register))), callFrameRegister, regT0);
</span><del>- mul32(Imm32(sizeof(Register)), regT2, regT2);
</del><ins>+ mul32(TrustedImm32(sizeof(Register)), regT2, regT2);
</ins><span class="cx"> subPtr(regT2, regT0);
</span><span class="cx"> loadPtr(BaseIndex(regT0, regT1, TimesEight, 0), regT0);
</span><span class="cx"> if (numArgs)
</span><span class="lines">@@ -1643,7 +1643,7 @@
</span><span class="cx"> while (skip--)
</span><span class="cx"> linkSlowCase(iter);
</span><span class="cx"> JITStubCall resolveStubCall(this, cti_op_resolve);
</span><del>- resolveStubCall.addArgument(ImmPtr(ident));
</del><ins>+ resolveStubCall.addArgument(TrustedImmPtr(ident));
</ins><span class="cx"> resolveStubCall.call(dst);
</span><span class="cx"> emitJumpSlowToHot(jump(), OPCODE_LENGTH(op_resolve_global_dynamic));
</span><span class="cx">
</span><span class="lines">@@ -1651,7 +1651,7 @@
</span><span class="cx">
</span><span class="cx"> linkSlowCase(iter); // We managed to skip all the nodes in the scope chain, but the cache missed.
</span><span class="cx"> JITStubCall stubCall(this, cti_op_resolve_global);
</span><del>- stubCall.addArgument(ImmPtr(ident));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(ident));
</ins><span class="cx"> stubCall.addArgument(Imm32(currentIndex));
</span><span class="cx"> stubCall.addArgument(regT0);
</span><span class="cx"> stubCall.call(dst);
</span><span class="lines">@@ -1660,7 +1660,7 @@
</span><span class="cx"> void JIT::emit_op_new_regexp(Instruction* currentInstruction)
</span><span class="cx"> {
</span><span class="cx"> JITStubCall stubCall(this, cti_op_new_regexp);
</span><del>- stubCall.addArgument(ImmPtr(m_codeBlock->regexp(currentInstruction[2].u.operand)));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(m_codeBlock->regexp(currentInstruction[2].u.operand)));
</ins><span class="cx"> stubCall.call(currentInstruction[1].u.operand);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1684,18 +1684,18 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> #if USE(JSVALUE32_64)
</span><del>- addSlowCase(branch32(NotEqual, tagFor(argsOffset), Imm32(JSValue::EmptyValueTag)));
</del><ins>+ addSlowCase(branch32(NotEqual, tagFor(argsOffset), TrustedImm32(JSValue::EmptyValueTag)));
</ins><span class="cx"> #else
</span><span class="cx"> addSlowCase(branchTestPtr(NonZero, addressFor(argsOffset)));
</span><span class="cx"> #endif
</span><span class="cx"> // Load arg count into regT0
</span><span class="cx"> emitGetFromCallFrameHeader32(RegisterFile::ArgumentCount, regT0);
</span><del>- store32(Imm32(Int32Tag), intTagFor(argCountDst));
</del><ins>+ store32(TrustedImm32(Int32Tag), intTagFor(argCountDst));
</ins><span class="cx"> store32(regT0, intPayloadFor(argCountDst));
</span><del>- Jump endBranch = branch32(Equal, regT0, Imm32(1));
</del><ins>+ Jump endBranch = branch32(Equal, regT0, TrustedImm32(1));
</ins><span class="cx">
</span><del>- mul32(Imm32(sizeof(Register)), regT0, regT3);
- addPtr(Imm32(static_cast<unsigned>(sizeof(Register) - RegisterFile::CallFrameHeaderSize * sizeof(Register))), callFrameRegister, regT1);
</del><ins>+ mul32(TrustedImm32(sizeof(Register)), regT0, regT3);
+ addPtr(TrustedImm32(static_cast<unsigned>(sizeof(Register) - RegisterFile::CallFrameHeaderSize * sizeof(Register))), callFrameRegister, regT1);
</ins><span class="cx"> subPtr(regT3, regT1); // regT1 is now the start of the out of line arguments
</span><span class="cx"> addPtr(Imm32(argsOffset * sizeof(Register)), callFrameRegister, regT2); // regT2 is the target buffer
</span><span class="cx">
</span><span class="lines">@@ -1704,7 +1704,7 @@
</span><span class="cx"> addPtr(Imm32((registerOffset - argsOffset) * sizeof(Register)), regT3);
</span><span class="cx"> addSlowCase(branchPtr(Below, AbsoluteAddress(m_globalData->interpreter->registerFile().addressOfEnd()), regT3));
</span><span class="cx">
</span><del>- sub32(Imm32(1), regT0);
</del><ins>+ sub32(TrustedImm32(1), regT0);
</ins><span class="cx"> Label loopStart = label();
</span><span class="cx"> loadPtr(BaseIndex(regT1, regT0, TimesEight, static_cast<unsigned>(0 - 2 * sizeof(Register))), regT3);
</span><span class="cx"> storePtr(regT3, BaseIndex(regT2, regT0, TimesEight, static_cast<unsigned>(0 - sizeof(Register))));
</span><span class="lines">@@ -1712,7 +1712,7 @@
</span><span class="cx"> loadPtr(BaseIndex(regT1, regT0, TimesEight, static_cast<unsigned>(sizeof(void*) - 2 * sizeof(Register))), regT3);
</span><span class="cx"> storePtr(regT3, BaseIndex(regT2, regT0, TimesEight, static_cast<unsigned>(sizeof(void*) - sizeof(Register))));
</span><span class="cx"> #endif
</span><del>- branchSubPtr(NonZero, Imm32(1), regT0).linkTo(loopStart, this);
</del><ins>+ branchSubPtr(NonZero, TrustedImm32(1), regT0).linkTo(loopStart, this);
</ins><span class="cx"> endBranch.link(this);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1730,7 +1730,7 @@
</span><span class="cx"> stubCall.addArgument(Imm32(argsOffset));
</span><span class="cx"> stubCall.call();
</span><span class="cx">
</span><del>- store32(Imm32(Int32Tag), intTagFor(argCountDst));
</del><ins>+ store32(TrustedImm32(Int32Tag), intTagFor(argCountDst));
</ins><span class="cx"> store32(returnValueRegister, intPayloadFor(argCountDst));
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1740,13 +1740,13 @@
</span><span class="cx"> int dst = currentInstruction[1].u.operand;
</span><span class="cx"> if (currentInstruction[3].u.operand) {
</span><span class="cx"> #if USE(JSVALUE32_64)
</span><del>- lazyJump = branch32(NotEqual, tagFor(dst), Imm32(JSValue::EmptyValueTag));
</del><ins>+ lazyJump = branch32(NotEqual, tagFor(dst), TrustedImm32(JSValue::EmptyValueTag));
</ins><span class="cx"> #else
</span><span class="cx"> lazyJump = branchTestPtr(NonZero, addressFor(dst));
</span><span class="cx"> #endif
</span><span class="cx"> }
</span><span class="cx"> JITStubCall stubCall(this, cti_op_new_func);
</span><del>- stubCall.addArgument(ImmPtr(m_codeBlock->functionDecl(currentInstruction[2].u.operand)));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(m_codeBlock->functionDecl(currentInstruction[2].u.operand)));
</ins><span class="cx"> stubCall.call(currentInstruction[1].u.operand);
</span><span class="cx"> if (currentInstruction[3].u.operand)
</span><span class="cx"> lazyJump.link(this);
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorejitJITOpcodes32_64cpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp (82129 => 82130)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp 2011-03-28 17:10:30 UTC (rev 82129)
+++ trunk/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp 2011-03-28 17:14:57 UTC (rev 82130)
</span><span class="lines">@@ -52,15 +52,15 @@
</span><span class="cx">
</span><span class="cx"> // regT0 holds payload, regT1 holds tag
</span><span class="cx">
</span><del>- Jump string_failureCases1 = branch32(NotEqual, regT1, Imm32(JSValue::CellTag));
- Jump string_failureCases2 = branchPtr(NotEqual, Address(regT0), ImmPtr(m_globalData->jsStringVPtr));
</del><ins>+ Jump string_failureCases1 = branch32(NotEqual, regT1, TrustedImm32(JSValue::CellTag));
+ Jump string_failureCases2 = branchPtr(NotEqual, Address(regT0), TrustedImmPtr(m_globalData->jsStringVPtr));
</ins><span class="cx">
</span><span class="cx"> // Checks out okay! - get the length from the Ustring.
</span><span class="cx"> load32(Address(regT0, OBJECT_OFFSETOF(JSString, m_length)), regT2);
</span><span class="cx">
</span><del>- Jump string_failureCases3 = branch32(Above, regT2, Imm32(INT_MAX));
</del><ins>+ Jump string_failureCases3 = branch32(Above, regT2, TrustedImm32(INT_MAX));
</ins><span class="cx"> move(regT2, regT0);
</span><del>- move(Imm32(JSValue::Int32Tag), regT1);
</del><ins>+ move(TrustedImm32(JSValue::Int32Tag), regT1);
</ins><span class="cx">
</span><span class="cx"> ret();
</span><span class="cx"> #endif
</span><span class="lines">@@ -103,7 +103,7 @@
</span><span class="cx">
</span><span class="cx"> loadPtr(Address(regT0, OBJECT_OFFSETOF(JSFunction, m_executable)), regT2);
</span><span class="cx">
</span><del>- Jump hasCodeBlock3 = branch32(GreaterThanOrEqual, Address(regT2, OBJECT_OFFSETOF(FunctionExecutable, m_numParametersForCall)), Imm32(0));
</del><ins>+ Jump hasCodeBlock3 = branch32(GreaterThanOrEqual, Address(regT2, OBJECT_OFFSETOF(FunctionExecutable, m_numParametersForCall)), TrustedImm32(0));
</ins><span class="cx"> preserveReturnAddressAfterCall(regT3);
</span><span class="cx"> restoreArgumentReference();
</span><span class="cx"> Call callCompileCall = call();
</span><span class="lines">@@ -123,7 +123,7 @@
</span><span class="cx">
</span><span class="cx"> loadPtr(Address(regT0, OBJECT_OFFSETOF(JSFunction, m_executable)), regT2);
</span><span class="cx">
</span><del>- Jump hasCodeBlock4 = branch32(GreaterThanOrEqual, Address(regT2, OBJECT_OFFSETOF(FunctionExecutable, m_numParametersForConstruct)), Imm32(0));
</del><ins>+ Jump hasCodeBlock4 = branch32(GreaterThanOrEqual, Address(regT2, OBJECT_OFFSETOF(FunctionExecutable, m_numParametersForConstruct)), TrustedImm32(0));
</ins><span class="cx"> preserveReturnAddressAfterCall(regT3);
</span><span class="cx"> restoreArgumentReference();
</span><span class="cx"> Call callCompileCconstruct = call();
</span><span class="lines">@@ -142,10 +142,10 @@
</span><span class="cx"> emitGetFromCallFrameHeaderPtr(RegisterFile::ReturnPC, regT1);
</span><span class="cx"> emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, callFrameRegister);
</span><span class="cx"> restoreReturnAddressBeforeReturn(regT1);
</span><del>- move(ImmPtr(&globalData->exceptionLocation), regT2);
</del><ins>+ move(TrustedImmPtr(&globalData->exceptionLocation), regT2);
</ins><span class="cx"> storePtr(regT1, regT2);
</span><span class="cx"> poke(callFrameRegister, 1 + OBJECT_OFFSETOF(struct JITStackFrame, callFrame) / sizeof(void*));
</span><del>- poke(ImmPtr(FunctionPtr(ctiVMThrowTrampoline).value()));
</del><ins>+ poke(TrustedImmPtr(FunctionPtr(ctiVMThrowTrampoline).value()));
</ins><span class="cx"> ret();
</span><span class="cx">
</span><span class="cx"> // NativeCall Trampoline
</span><span class="lines">@@ -214,7 +214,7 @@
</span><span class="cx"> // Host function signature: f(ExecState*);
</span><span class="cx"> move(callFrameRegister, X86Registers::ecx);
</span><span class="cx">
</span><del>- subPtr(Imm32(16 - sizeof(void*)), stackPointerRegister); // Align stack after call.
</del><ins>+ subPtr(TrustedImm32(16 - sizeof(void*)), stackPointerRegister); // Align stack after call.
</ins><span class="cx">
</span><span class="cx"> // call the function
</span><span class="cx"> emitGetFromCallFrameHeaderPtr(RegisterFile::Callee, regT1);
</span><span class="lines">@@ -222,7 +222,7 @@
</span><span class="cx"> move(regT0, callFrameRegister); // Eagerly restore caller frame register to avoid loading from stack.
</span><span class="cx"> call(Address(regT1, executableOffsetToFunction));
</span><span class="cx">
</span><del>- addPtr(Imm32(16 - sizeof(void*)), stackPointerRegister);
</del><ins>+ addPtr(TrustedImm32(16 - sizeof(void*)), stackPointerRegister);
</ins><span class="cx">
</span><span class="cx"> #elif CPU(ARM)
</span><span class="cx"> // Load caller frame's scope chain into this callframe so that whatever we call can
</span><span class="lines">@@ -261,7 +261,7 @@
</span><span class="cx">
</span><span class="cx"> // Allocate stack space for 16 bytes (8-byte aligned)
</span><span class="cx"> // 16 bytes (unused) for 4 arguments
</span><del>- subPtr(Imm32(16), stackPointerRegister);
</del><ins>+ subPtr(TrustedImm32(16), stackPointerRegister);
</ins><span class="cx">
</span><span class="cx"> // Setup arg0
</span><span class="cx"> move(callFrameRegister, MIPSRegisters::a0);
</span><span class="lines">@@ -273,7 +273,7 @@
</span><span class="cx"> call(Address(regT2, executableOffsetToFunction));
</span><span class="cx">
</span><span class="cx"> // Restore stack space
</span><del>- addPtr(Imm32(16), stackPointerRegister);
</del><ins>+ addPtr(TrustedImm32(16), stackPointerRegister);
</ins><span class="cx">
</span><span class="cx"> restoreReturnAddressBeforeReturn(regT3);
</span><span class="cx">
</span><span class="lines">@@ -285,7 +285,7 @@
</span><span class="cx"> #endif // CPU(X86)
</span><span class="cx">
</span><span class="cx"> // Check for an exception
</span><del>- Jump sawException = branch32(NotEqual, AbsoluteAddress(reinterpret_cast<char*>(&globalData->exception) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), Imm32(JSValue::EmptyValueTag));
</del><ins>+ Jump sawException = branch32(NotEqual, AbsoluteAddress(reinterpret_cast<char*>(&globalData->exception) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), TrustedImm32(JSValue::EmptyValueTag));
</ins><span class="cx">
</span><span class="cx"> // Return.
</span><span class="cx"> ret();
</span><span class="lines">@@ -296,12 +296,12 @@
</span><span class="cx"> // Grab the return address.
</span><span class="cx"> preserveReturnAddressAfterCall(regT1);
</span><span class="cx">
</span><del>- move(ImmPtr(&globalData->exceptionLocation), regT2);
</del><ins>+ move(TrustedImmPtr(&globalData->exceptionLocation), regT2);
</ins><span class="cx"> storePtr(regT1, regT2);
</span><span class="cx"> poke(callFrameRegister, OBJECT_OFFSETOF(struct JITStackFrame, callFrame) / sizeof(void*));
</span><span class="cx">
</span><span class="cx"> // Set the return address.
</span><del>- move(ImmPtr(FunctionPtr(ctiVMThrowTrampoline).value()), regT1);
</del><ins>+ move(TrustedImmPtr(FunctionPtr(ctiVMThrowTrampoline).value()), regT1);
</ins><span class="cx"> restoreReturnAddressBeforeReturn(regT1);
</span><span class="cx">
</span><span class="cx"> ret();
</span><span class="lines">@@ -330,14 +330,14 @@
</span><span class="cx"> // Host function signature: f(ExecState*);
</span><span class="cx"> move(callFrameRegister, X86Registers::ecx);
</span><span class="cx">
</span><del>- subPtr(Imm32(16 - sizeof(void*)), stackPointerRegister); // Align stack after call.
</del><ins>+ subPtr(TrustedImm32(16 - sizeof(void*)), stackPointerRegister); // Align stack after call.
</ins><span class="cx">
</span><span class="cx"> move(regT0, callFrameRegister); // Eagerly restore caller frame register to avoid loading from stack.
</span><span class="cx">
</span><span class="cx"> // call the function
</span><span class="cx"> nativeCall = call();
</span><span class="cx">
</span><del>- addPtr(Imm32(16 - sizeof(void*)), stackPointerRegister);
</del><ins>+ addPtr(TrustedImm32(16 - sizeof(void*)), stackPointerRegister);
</ins><span class="cx">
</span><span class="cx"> #elif CPU(ARM)
</span><span class="cx"> // Load caller frame's scope chain into this callframe so that whatever we call can
</span><span class="lines">@@ -377,7 +377,7 @@
</span><span class="cx">
</span><span class="cx"> // Allocate stack space for 16 bytes (8-byte aligned)
</span><span class="cx"> // 16 bytes (unused) for 4 arguments
</span><del>- subPtr(Imm32(16), stackPointerRegister);
</del><ins>+ subPtr(TrustedImm32(16), stackPointerRegister);
</ins><span class="cx">
</span><span class="cx"> // Setup arg0
</span><span class="cx"> move(callFrameRegister, MIPSRegisters::a0);
</span><span class="lines">@@ -391,7 +391,7 @@
</span><span class="cx"> nativeCall = call();
</span><span class="cx">
</span><span class="cx"> // Restore stack space
</span><del>- addPtr(Imm32(16), stackPointerRegister);
</del><ins>+ addPtr(TrustedImm32(16), stackPointerRegister);
</ins><span class="cx">
</span><span class="cx"> restoreReturnAddressBeforeReturn(regT3);
</span><span class="cx">
</span><span class="lines">@@ -402,7 +402,7 @@
</span><span class="cx"> #endif // CPU(X86)
</span><span class="cx">
</span><span class="cx"> // Check for an exception
</span><del>- Jump sawException = branch32(NotEqual, AbsoluteAddress(reinterpret_cast<char*>(&globalData->exception) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), Imm32(JSValue::EmptyValueTag));
</del><ins>+ Jump sawException = branch32(NotEqual, AbsoluteAddress(reinterpret_cast<char*>(&globalData->exception) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), TrustedImm32(JSValue::EmptyValueTag));
</ins><span class="cx">
</span><span class="cx"> // Return.
</span><span class="cx"> ret();
</span><span class="lines">@@ -413,12 +413,12 @@
</span><span class="cx"> // Grab the return address.
</span><span class="cx"> preserveReturnAddressAfterCall(regT1);
</span><span class="cx">
</span><del>- move(ImmPtr(&globalData->exceptionLocation), regT2);
</del><ins>+ move(TrustedImmPtr(&globalData->exceptionLocation), regT2);
</ins><span class="cx"> storePtr(regT1, regT2);
</span><span class="cx"> poke(callFrameRegister, OBJECT_OFFSETOF(struct JITStackFrame, callFrame) / sizeof(void*));
</span><span class="cx">
</span><span class="cx"> // Set the return address.
</span><del>- move(ImmPtr(FunctionPtr(ctiVMThrowTrampoline).value()), regT1);
</del><ins>+ move(TrustedImmPtr(FunctionPtr(ctiVMThrowTrampoline).value()), regT1);
</ins><span class="cx"> restoreReturnAddressBeforeReturn(regT1);
</span><span class="cx">
</span><span class="cx"> ret();
</span><span class="lines">@@ -470,21 +470,21 @@
</span><span class="cx">
</span><span class="cx"> if (isOperandConstantImmediateInt(op1)) {
</span><span class="cx"> emitLoad(op2, regT1, regT0);
</span><del>- addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));
</del><ins>+ addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
</ins><span class="cx"> addJump(branch32(GreaterThanOrEqual, regT0, Imm32(getConstantOperand(op1).asInt32())), target);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if (isOperandConstantImmediateInt(op2)) {
</span><span class="cx"> emitLoad(op1, regT1, regT0);
</span><del>- addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));
</del><ins>+ addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
</ins><span class="cx"> addJump(branch32(LessThanOrEqual, regT0, Imm32(getConstantOperand(op2).asInt32())), target);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> emitLoad2(op1, regT1, regT0, op2, regT3, regT2);
</span><del>- addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));
- addSlowCase(branch32(NotEqual, regT3, Imm32(JSValue::Int32Tag)));
</del><ins>+ addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
+ addSlowCase(branch32(NotEqual, regT3, TrustedImm32(JSValue::Int32Tag)));
</ins><span class="cx"> addJump(branch32(LessThanOrEqual, regT0, regT2), target);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -521,7 +521,7 @@
</span><span class="cx">
</span><span class="cx"> // Check that baseVal 'ImplementsHasInstance'.
</span><span class="cx"> loadPtr(Address(regT0, JSCell::structureOffset()), regT0);
</span><del>- addSlowCase(branchTest8(Zero, Address(regT0, Structure::typeInfoFlagsOffset()), Imm32(ImplementsHasInstance)));
</del><ins>+ addSlowCase(branchTest8(Zero, Address(regT0, Structure::typeInfoFlagsOffset()), TrustedImm32(ImplementsHasInstance)));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void JIT::emit_op_instanceof(Instruction* currentInstruction)
</span><span class="lines">@@ -543,17 +543,17 @@
</span><span class="cx">
</span><span class="cx"> // Check that prototype is an object
</span><span class="cx"> loadPtr(Address(regT1, JSCell::structureOffset()), regT3);
</span><del>- addSlowCase(branch8(NotEqual, Address(regT3, Structure::typeInfoTypeOffset()), Imm32(ObjectType)));
</del><ins>+ addSlowCase(branch8(NotEqual, Address(regT3, Structure::typeInfoTypeOffset()), TrustedImm32(ObjectType)));
</ins><span class="cx">
</span><span class="cx"> // Fixme: this check is only needed because the JSC API allows HasInstance to be overridden; we should deprecate this.
</span><span class="cx"> // Check that baseVal 'ImplementsDefaultHasInstance'.
</span><span class="cx"> loadPtr(Address(regT0, JSCell::structureOffset()), regT0);
</span><del>- addSlowCase(branchTest8(Zero, Address(regT0, Structure::typeInfoFlagsOffset()), Imm32(ImplementsDefaultHasInstance)));
</del><ins>+ addSlowCase(branchTest8(Zero, Address(regT0, Structure::typeInfoFlagsOffset()), TrustedImm32(ImplementsDefaultHasInstance)));
</ins><span class="cx">
</span><span class="cx"> // Optimistically load the result true, and start looping.
</span><span class="cx"> // Initially, regT1 still contains proto and regT2 still contains value.
</span><span class="cx"> // As we loop regT2 will be updated with its prototype, recursively walking the prototype chain.
</span><del>- move(Imm32(JSValue::TrueTag), regT0);
</del><ins>+ move(TrustedImm32(JSValue::TrueTag), regT0);
</ins><span class="cx"> Label loop(this);
</span><span class="cx">
</span><span class="cx"> // Load the prototype of the cell in regT2. If this is equal to regT1 - WIN!
</span><span class="lines">@@ -564,7 +564,7 @@
</span><span class="cx"> branchTest32(NonZero, regT2).linkTo(loop, this);
</span><span class="cx">
</span><span class="cx"> // We get here either by dropping out of the loop, or if value was not an Object. Result is false.
</span><del>- move(Imm32(JSValue::FalseTag), regT0);
</del><ins>+ move(TrustedImm32(JSValue::FalseTag), regT0);
</ins><span class="cx">
</span><span class="cx"> // isInstance jumps right down to here, to skip setting the result to false (it has already set true).
</span><span class="cx"> isInstance.link(this);
</span><span class="lines">@@ -642,7 +642,7 @@
</span><span class="cx"> if (checkTopLevel && skip--) {
</span><span class="cx"> Jump activationNotCreated;
</span><span class="cx"> if (checkTopLevel)
</span><del>- activationNotCreated = branch32(Equal, tagFor(m_codeBlock->activationRegister()), Imm32(JSValue::EmptyValueTag));
</del><ins>+ activationNotCreated = branch32(Equal, tagFor(m_codeBlock->activationRegister()), TrustedImm32(JSValue::EmptyValueTag));
</ins><span class="cx"> loadPtr(Address(regT2, OBJECT_OFFSETOF(ScopeChainNode, next)), regT2);
</span><span class="cx"> activationNotCreated.link(this);
</span><span class="cx"> }
</span><span class="lines">@@ -671,7 +671,7 @@
</span><span class="cx"> if (checkTopLevel && skip--) {
</span><span class="cx"> Jump activationNotCreated;
</span><span class="cx"> if (checkTopLevel)
</span><del>- activationNotCreated = branch32(Equal, tagFor(m_codeBlock->activationRegister()), Imm32(JSValue::EmptyValueTag));
</del><ins>+ activationNotCreated = branch32(Equal, tagFor(m_codeBlock->activationRegister()), TrustedImm32(JSValue::EmptyValueTag));
</ins><span class="cx"> loadPtr(Address(regT2, OBJECT_OFFSETOF(ScopeChainNode, next)), regT2);
</span><span class="cx"> activationNotCreated.link(this);
</span><span class="cx"> }
</span><span class="lines">@@ -689,8 +689,8 @@
</span><span class="cx"> {
</span><span class="cx"> unsigned activation = currentInstruction[1].u.operand;
</span><span class="cx"> unsigned arguments = currentInstruction[2].u.operand;
</span><del>- Jump activationCreated = branch32(NotEqual, tagFor(activation), Imm32(JSValue::EmptyValueTag));
- Jump argumentsNotCreated = branch32(Equal, tagFor(arguments), Imm32(JSValue::EmptyValueTag));
</del><ins>+ Jump activationCreated = branch32(NotEqual, tagFor(activation), TrustedImm32(JSValue::EmptyValueTag));
+ Jump argumentsNotCreated = branch32(Equal, tagFor(arguments), TrustedImm32(JSValue::EmptyValueTag));
</ins><span class="cx"> activationCreated.link(this);
</span><span class="cx"> JITStubCall stubCall(this, cti_op_tear_off_activation);
</span><span class="cx"> stubCall.addArgument(currentInstruction[1].u.operand);
</span><span class="lines">@@ -703,7 +703,7 @@
</span><span class="cx"> {
</span><span class="cx"> int dst = currentInstruction[1].u.operand;
</span><span class="cx">
</span><del>- Jump argsNotCreated = branch32(Equal, tagFor(unmodifiedArgumentsRegister(dst)), Imm32(JSValue::EmptyValueTag));
</del><ins>+ Jump argsNotCreated = branch32(Equal, tagFor(unmodifiedArgumentsRegister(dst)), TrustedImm32(JSValue::EmptyValueTag));
</ins><span class="cx"> JITStubCall stubCall(this, cti_op_tear_off_arguments);
</span><span class="cx"> stubCall.addArgument(unmodifiedArgumentsRegister(dst));
</span><span class="cx"> stubCall.call();
</span><span class="lines">@@ -721,7 +721,7 @@
</span><span class="cx"> void JIT::emit_op_resolve(Instruction* currentInstruction)
</span><span class="cx"> {
</span><span class="cx"> JITStubCall stubCall(this, cti_op_resolve);
</span><del>- stubCall.addArgument(ImmPtr(&m_codeBlock->identifier(currentInstruction[2].u.operand)));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(&m_codeBlock->identifier(currentInstruction[2].u.operand)));
</ins><span class="cx"> stubCall.call(currentInstruction[1].u.operand);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -732,8 +732,8 @@
</span><span class="cx">
</span><span class="cx"> emitLoad(src, regT1, regT0);
</span><span class="cx">
</span><del>- Jump isImm = branch32(NotEqual, regT1, Imm32(JSValue::CellTag));
- addSlowCase(branchPtr(NotEqual, Address(regT0), ImmPtr(m_globalData->jsStringVPtr)));
</del><ins>+ Jump isImm = branch32(NotEqual, regT1, TrustedImm32(JSValue::CellTag));
+ addSlowCase(branchPtr(NotEqual, Address(regT0), TrustedImmPtr(m_globalData->jsStringVPtr)));
</ins><span class="cx"> isImm.link(this);
</span><span class="cx">
</span><span class="cx"> if (dst != src)
</span><span class="lines">@@ -763,7 +763,7 @@
</span><span class="cx"> void JIT::emit_op_resolve_base(Instruction* currentInstruction)
</span><span class="cx"> {
</span><span class="cx"> JITStubCall stubCall(this, currentInstruction[3].u.operand ? cti_op_resolve_base_strict_put : cti_op_resolve_base);
</span><del>- stubCall.addArgument(ImmPtr(&m_codeBlock->identifier(currentInstruction[2].u.operand)));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(&m_codeBlock->identifier(currentInstruction[2].u.operand)));
</ins><span class="cx"> stubCall.call(currentInstruction[1].u.operand);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -771,14 +771,14 @@
</span><span class="cx"> {
</span><span class="cx"> JITStubCall stubCall(this, cti_op_ensure_property_exists);
</span><span class="cx"> stubCall.addArgument(Imm32(currentInstruction[1].u.operand));
</span><del>- stubCall.addArgument(ImmPtr(&m_codeBlock->identifier(currentInstruction[2].u.operand)));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(&m_codeBlock->identifier(currentInstruction[2].u.operand)));
</ins><span class="cx"> stubCall.call(currentInstruction[1].u.operand);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void JIT::emit_op_resolve_skip(Instruction* currentInstruction)
</span><span class="cx"> {
</span><span class="cx"> JITStubCall stubCall(this, cti_op_resolve_skip);
</span><del>- stubCall.addArgument(ImmPtr(&m_codeBlock->identifier(currentInstruction[2].u.operand)));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(&m_codeBlock->identifier(currentInstruction[2].u.operand)));
</ins><span class="cx"> stubCall.addArgument(Imm32(currentInstruction[3].u.operand));
</span><span class="cx"> stubCall.call(currentInstruction[1].u.operand);
</span><span class="cx"> }
</span><span class="lines">@@ -795,7 +795,7 @@
</span><span class="cx"> void* offsetAddr = &(m_codeBlock->globalResolveInfo(currentIndex).offset);
</span><span class="cx">
</span><span class="cx"> // Verify structure.
</span><del>- move(ImmPtr(globalObject), regT0);
</del><ins>+ move(TrustedImmPtr(globalObject), regT0);
</ins><span class="cx"> loadPtr(structureAddress, regT1);
</span><span class="cx"> addSlowCase(branchPtr(NotEqual, regT1, Address(regT0, JSCell::structureOffset())));
</span><span class="cx">
</span><span class="lines">@@ -817,7 +817,7 @@
</span><span class="cx">
</span><span class="cx"> linkSlowCase(iter);
</span><span class="cx"> JITStubCall stubCall(this, cti_op_resolve_global);
</span><del>- stubCall.addArgument(ImmPtr(ident));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(ident));
</ins><span class="cx"> stubCall.addArgument(Imm32(currentIndex));
</span><span class="cx"> stubCall.call(dst);
</span><span class="cx"> }
</span><span class="lines">@@ -829,9 +829,9 @@
</span><span class="cx">
</span><span class="cx"> emitLoadTag(src, regT0);
</span><span class="cx">
</span><del>- xor32(Imm32(JSValue::FalseTag), regT0);
- addSlowCase(branchTest32(NonZero, regT0, Imm32(~1)));
- xor32(Imm32(JSValue::TrueTag), regT0);
</del><ins>+ xor32(TrustedImm32(JSValue::FalseTag), regT0);
+ addSlowCase(branchTest32(NonZero, regT0, TrustedImm32(~1)));
+ xor32(TrustedImm32(JSValue::TrueTag), regT0);
</ins><span class="cx">
</span><span class="cx"> emitStoreBool(dst, regT0, (dst == src));
</span><span class="cx"> }
</span><span class="lines">@@ -855,17 +855,17 @@
</span><span class="cx">
</span><span class="cx"> emitLoad(cond, regT1, regT0);
</span><span class="cx">
</span><del>- Jump isTrue = branch32(Equal, regT1, Imm32(JSValue::TrueTag));
- addJump(branch32(Equal, regT1, Imm32(JSValue::FalseTag)), target);
</del><ins>+ Jump isTrue = branch32(Equal, regT1, TrustedImm32(JSValue::TrueTag));
+ addJump(branch32(Equal, regT1, TrustedImm32(JSValue::FalseTag)), target);
</ins><span class="cx">
</span><del>- Jump isNotInteger = branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag));
- Jump isTrue2 = branch32(NotEqual, regT0, Imm32(0));
</del><ins>+ Jump isNotInteger = branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag));
+ Jump isTrue2 = branch32(NotEqual, regT0, TrustedImm32(0));
</ins><span class="cx"> addJump(jump(), target);
</span><span class="cx">
</span><span class="cx"> if (supportsFloatingPoint()) {
</span><span class="cx"> isNotInteger.link(this);
</span><span class="cx">
</span><del>- addSlowCase(branch32(Above, regT1, Imm32(JSValue::LowestTag)));
</del><ins>+ addSlowCase(branch32(Above, regT1, TrustedImm32(JSValue::LowestTag)));
</ins><span class="cx">
</span><span class="cx"> emitLoadDouble(cond, fpRegT0);
</span><span class="cx"> addJump(branchDoubleZeroOrNaN(fpRegT0, fpRegT1), target);
</span><span class="lines">@@ -895,17 +895,17 @@
</span><span class="cx">
</span><span class="cx"> emitLoad(cond, regT1, regT0);
</span><span class="cx">
</span><del>- Jump isFalse = branch32(Equal, regT1, Imm32(JSValue::FalseTag));
- addJump(branch32(Equal, regT1, Imm32(JSValue::TrueTag)), target);
</del><ins>+ Jump isFalse = branch32(Equal, regT1, TrustedImm32(JSValue::FalseTag));
+ addJump(branch32(Equal, regT1, TrustedImm32(JSValue::TrueTag)), target);
</ins><span class="cx">
</span><del>- Jump isNotInteger = branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag));
- Jump isFalse2 = branch32(Equal, regT0, Imm32(0));
</del><ins>+ Jump isNotInteger = branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag));
+ Jump isFalse2 = branch32(Equal, regT0, TrustedImm32(0));
</ins><span class="cx"> addJump(jump(), target);
</span><span class="cx">
</span><span class="cx"> if (supportsFloatingPoint()) {
</span><span class="cx"> isNotInteger.link(this);
</span><span class="cx">
</span><del>- addSlowCase(branch32(Above, regT1, Imm32(JSValue::LowestTag)));
</del><ins>+ addSlowCase(branch32(Above, regT1, TrustedImm32(JSValue::LowestTag)));
</ins><span class="cx">
</span><span class="cx"> emitLoadDouble(cond, fpRegT0);
</span><span class="cx"> addJump(branchDoubleNonZero(fpRegT0, fpRegT1), target);
</span><span class="lines">@@ -935,11 +935,11 @@
</span><span class="cx">
</span><span class="cx"> emitLoad(src, regT1, regT0);
</span><span class="cx">
</span><del>- Jump isImmediate = branch32(NotEqual, regT1, Imm32(JSValue::CellTag));
</del><ins>+ Jump isImmediate = branch32(NotEqual, regT1, TrustedImm32(JSValue::CellTag));
</ins><span class="cx">
</span><span class="cx"> // First, handle JSCell cases - check MasqueradesAsUndefined bit on the structure.
</span><span class="cx"> loadPtr(Address(regT0, JSCell::structureOffset()), regT2);
</span><del>- addJump(branchTest8(NonZero, Address(regT2, Structure::typeInfoFlagsOffset()), Imm32(MasqueradesAsUndefined)), target);
</del><ins>+ addJump(branchTest8(NonZero, Address(regT2, Structure::typeInfoFlagsOffset()), TrustedImm32(MasqueradesAsUndefined)), target);
</ins><span class="cx">
</span><span class="cx"> Jump wasNotImmediate = jump();
</span><span class="cx">
</span><span class="lines">@@ -947,7 +947,7 @@
</span><span class="cx"> isImmediate.link(this);
</span><span class="cx">
</span><span class="cx"> ASSERT((JSValue::UndefinedTag + 1 == JSValue::NullTag) && !(JSValue::NullTag + 1));
</span><del>- addJump(branch32(AboveOrEqual, regT1, Imm32(JSValue::UndefinedTag)), target);
</del><ins>+ addJump(branch32(AboveOrEqual, regT1, TrustedImm32(JSValue::UndefinedTag)), target);
</ins><span class="cx">
</span><span class="cx"> wasNotImmediate.link(this);
</span><span class="cx"> }
</span><span class="lines">@@ -959,11 +959,11 @@
</span><span class="cx">
</span><span class="cx"> emitLoad(src, regT1, regT0);
</span><span class="cx">
</span><del>- Jump isImmediate = branch32(NotEqual, regT1, Imm32(JSValue::CellTag));
</del><ins>+ Jump isImmediate = branch32(NotEqual, regT1, TrustedImm32(JSValue::CellTag));
</ins><span class="cx">
</span><span class="cx"> // First, handle JSCell cases - check MasqueradesAsUndefined bit on the structure.
</span><span class="cx"> loadPtr(Address(regT0, JSCell::structureOffset()), regT2);
</span><del>- addJump(branchTest8(Zero, Address(regT2, Structure::typeInfoFlagsOffset()), Imm32(MasqueradesAsUndefined)), target);
</del><ins>+ addJump(branchTest8(Zero, Address(regT2, Structure::typeInfoFlagsOffset()), TrustedImm32(MasqueradesAsUndefined)), target);
</ins><span class="cx">
</span><span class="cx"> Jump wasNotImmediate = jump();
</span><span class="cx">
</span><span class="lines">@@ -971,7 +971,7 @@
</span><span class="cx"> isImmediate.link(this);
</span><span class="cx">
</span><span class="cx"> ASSERT((JSValue::UndefinedTag + 1 == JSValue::NullTag) && !(JSValue::NullTag + 1));
</span><del>- addJump(branch32(Below, regT1, Imm32(JSValue::UndefinedTag)), target);
</del><ins>+ addJump(branch32(Below, regT1, TrustedImm32(JSValue::UndefinedTag)), target);
</ins><span class="cx">
</span><span class="cx"> wasNotImmediate.link(this);
</span><span class="cx"> }
</span><span class="lines">@@ -983,15 +983,15 @@
</span><span class="cx"> unsigned target = currentInstruction[3].u.operand;
</span><span class="cx">
</span><span class="cx"> emitLoad(src, regT1, regT0);
</span><del>- addJump(branch32(NotEqual, regT1, Imm32(JSValue::CellTag)), target);
- addJump(branchPtr(NotEqual, regT0, ImmPtr(ptr)), target);
</del><ins>+ addJump(branch32(NotEqual, regT1, TrustedImm32(JSValue::CellTag)), target);
+ addJump(branchPtr(NotEqual, regT0, TrustedImmPtr(ptr)), target);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void JIT::emit_op_jsr(Instruction* currentInstruction)
</span><span class="cx"> {
</span><span class="cx"> int retAddrDst = currentInstruction[1].u.operand;
</span><span class="cx"> int target = currentInstruction[2].u.operand;
</span><del>- DataLabelPtr storeLocation = storePtrWithPatch(ImmPtr(0), Address(callFrameRegister, sizeof(Register) * retAddrDst));
</del><ins>+ DataLabelPtr storeLocation = storePtrWithPatch(TrustedImmPtr(0), Address(callFrameRegister, sizeof(Register) * retAddrDst));
</ins><span class="cx"> addJump(jump(), target);
</span><span class="cx"> m_jsrSites.append(JSRInfo(storeLocation, label()));
</span><span class="cx"> }
</span><span class="lines">@@ -1009,11 +1009,11 @@
</span><span class="cx">
</span><span class="cx"> emitLoad2(src1, regT1, regT0, src2, regT3, regT2);
</span><span class="cx"> addSlowCase(branch32(NotEqual, regT1, regT3));
</span><del>- addSlowCase(branch32(Equal, regT1, Imm32(JSValue::CellTag)));
- addSlowCase(branch32(Below, regT1, Imm32(JSValue::LowestTag)));
</del><ins>+ addSlowCase(branch32(Equal, regT1, TrustedImm32(JSValue::CellTag)));
+ addSlowCase(branch32(Below, regT1, TrustedImm32(JSValue::LowestTag)));
</ins><span class="cx">
</span><span class="cx"> set8Compare32(Equal, regT0, regT2, regT0);
</span><del>- or32(Imm32(JSValue::FalseTag), regT0);
</del><ins>+ or32(TrustedImm32(JSValue::FalseTag), regT0);
</ins><span class="cx">
</span><span class="cx"> emitStoreBool(dst, regT0);
</span><span class="cx"> }
</span><span class="lines">@@ -1030,8 +1030,8 @@
</span><span class="cx"> genericCase.append(getSlowCase(iter)); // tags not equal
</span><span class="cx">
</span><span class="cx"> linkSlowCase(iter); // tags equal and JSCell
</span><del>- genericCase.append(branchPtr(NotEqual, Address(regT0), ImmPtr(m_globalData->jsStringVPtr)));
- genericCase.append(branchPtr(NotEqual, Address(regT2), ImmPtr(m_globalData->jsStringVPtr)));
</del><ins>+ genericCase.append(branchPtr(NotEqual, Address(regT0), TrustedImmPtr(m_globalData->jsStringVPtr)));
+ genericCase.append(branchPtr(NotEqual, Address(regT2), TrustedImmPtr(m_globalData->jsStringVPtr)));
</ins><span class="cx">
</span><span class="cx"> // String case.
</span><span class="cx"> JITStubCall stubCallEqStrings(this, cti_op_eq_strings);
</span><span class="lines">@@ -1049,7 +1049,7 @@
</span><span class="cx"> stubCallEq.call(regT0);
</span><span class="cx">
</span><span class="cx"> storeResult.link(this);
</span><del>- or32(Imm32(JSValue::FalseTag), regT0);
</del><ins>+ or32(TrustedImm32(JSValue::FalseTag), regT0);
</ins><span class="cx"> emitStoreBool(dst, regT0);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1061,11 +1061,11 @@
</span><span class="cx">
</span><span class="cx"> emitLoad2(src1, regT1, regT0, src2, regT3, regT2);
</span><span class="cx"> addSlowCase(branch32(NotEqual, regT1, regT3));
</span><del>- addSlowCase(branch32(Equal, regT1, Imm32(JSValue::CellTag)));
- addSlowCase(branch32(Below, regT1, Imm32(JSValue::LowestTag)));
</del><ins>+ addSlowCase(branch32(Equal, regT1, TrustedImm32(JSValue::CellTag)));
+ addSlowCase(branch32(Below, regT1, TrustedImm32(JSValue::LowestTag)));
</ins><span class="cx">
</span><span class="cx"> set8Compare32(NotEqual, regT0, regT2, regT0);
</span><del>- or32(Imm32(JSValue::FalseTag), regT0);
</del><ins>+ or32(TrustedImm32(JSValue::FalseTag), regT0);
</ins><span class="cx">
</span><span class="cx"> emitStoreBool(dst, regT0);
</span><span class="cx"> }
</span><span class="lines">@@ -1080,8 +1080,8 @@
</span><span class="cx"> genericCase.append(getSlowCase(iter)); // tags not equal
</span><span class="cx">
</span><span class="cx"> linkSlowCase(iter); // tags equal and JSCell
</span><del>- genericCase.append(branchPtr(NotEqual, Address(regT0), ImmPtr(m_globalData->jsStringVPtr)));
- genericCase.append(branchPtr(NotEqual, Address(regT2), ImmPtr(m_globalData->jsStringVPtr)));
</del><ins>+ genericCase.append(branchPtr(NotEqual, Address(regT0), TrustedImmPtr(m_globalData->jsStringVPtr)));
+ genericCase.append(branchPtr(NotEqual, Address(regT2), TrustedImmPtr(m_globalData->jsStringVPtr)));
</ins><span class="cx">
</span><span class="cx"> // String case.
</span><span class="cx"> JITStubCall stubCallEqStrings(this, cti_op_eq_strings);
</span><span class="lines">@@ -1099,8 +1099,8 @@
</span><span class="cx"> stubCallEq.call(regT0);
</span><span class="cx">
</span><span class="cx"> storeResult.link(this);
</span><del>- xor32(Imm32(0x1), regT0);
- or32(Imm32(JSValue::FalseTag), regT0);
</del><ins>+ xor32(TrustedImm32(0x1), regT0);
+ or32(TrustedImm32(JSValue::FalseTag), regT0);
</ins><span class="cx"> emitStoreBool(dst, regT0);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1117,15 +1117,15 @@
</span><span class="cx"> // cells and/or Int32s.
</span><span class="cx"> move(regT0, regT2);
</span><span class="cx"> and32(regT1, regT2);
</span><del>- addSlowCase(branch32(Below, regT2, Imm32(JSValue::LowestTag)));
- addSlowCase(branch32(AboveOrEqual, regT2, Imm32(JSValue::CellTag)));
</del><ins>+ addSlowCase(branch32(Below, regT2, TrustedImm32(JSValue::LowestTag)));
+ addSlowCase(branch32(AboveOrEqual, regT2, TrustedImm32(JSValue::CellTag)));
</ins><span class="cx">
</span><span class="cx"> if (type == OpStrictEq)
</span><span class="cx"> set8Compare32(Equal, regT0, regT1, regT0);
</span><span class="cx"> else
</span><span class="cx"> set8Compare32(NotEqual, regT0, regT1, regT0);
</span><span class="cx">
</span><del>- or32(Imm32(JSValue::FalseTag), regT0);
</del><ins>+ or32(TrustedImm32(JSValue::FalseTag), regT0);
</ins><span class="cx">
</span><span class="cx"> emitStoreBool(dst, regT0);
</span><span class="cx"> }
</span><span class="lines">@@ -1176,22 +1176,22 @@
</span><span class="cx"> unsigned src = currentInstruction[2].u.operand;
</span><span class="cx">
</span><span class="cx"> emitLoad(src, regT1, regT0);
</span><del>- Jump isImmediate = branch32(NotEqual, regT1, Imm32(JSValue::CellTag));
</del><ins>+ Jump isImmediate = branch32(NotEqual, regT1, TrustedImm32(JSValue::CellTag));
</ins><span class="cx">
</span><span class="cx"> loadPtr(Address(regT0, JSCell::structureOffset()), regT1);
</span><del>- set32Test8(NonZero, Address(regT1, Structure::typeInfoFlagsOffset()), Imm32(MasqueradesAsUndefined), regT1);
</del><ins>+ set32Test8(NonZero, Address(regT1, Structure::typeInfoFlagsOffset()), TrustedImm32(MasqueradesAsUndefined), regT1);
</ins><span class="cx">
</span><span class="cx"> Jump wasNotImmediate = jump();
</span><span class="cx">
</span><span class="cx"> isImmediate.link(this);
</span><span class="cx">
</span><del>- set8Compare32(Equal, regT1, Imm32(JSValue::NullTag), regT2);
- set8Compare32(Equal, regT1, Imm32(JSValue::UndefinedTag), regT1);
</del><ins>+ set8Compare32(Equal, regT1, TrustedImm32(JSValue::NullTag), regT2);
+ set8Compare32(Equal, regT1, TrustedImm32(JSValue::UndefinedTag), regT1);
</ins><span class="cx"> or32(regT2, regT1);
</span><span class="cx">
</span><span class="cx"> wasNotImmediate.link(this);
</span><span class="cx">
</span><del>- or32(Imm32(JSValue::FalseTag), regT1);
</del><ins>+ or32(TrustedImm32(JSValue::FalseTag), regT1);
</ins><span class="cx">
</span><span class="cx"> emitStoreBool(dst, regT1);
</span><span class="cx"> }
</span><span class="lines">@@ -1202,22 +1202,22 @@
</span><span class="cx"> unsigned src = currentInstruction[2].u.operand;
</span><span class="cx">
</span><span class="cx"> emitLoad(src, regT1, regT0);
</span><del>- Jump isImmediate = branch32(NotEqual, regT1, Imm32(JSValue::CellTag));
</del><ins>+ Jump isImmediate = branch32(NotEqual, regT1, TrustedImm32(JSValue::CellTag));
</ins><span class="cx">
</span><span class="cx"> loadPtr(Address(regT0, JSCell::structureOffset()), regT1);
</span><del>- set32Test8(Zero, Address(regT1, Structure::typeInfoFlagsOffset()), Imm32(MasqueradesAsUndefined), regT1);
</del><ins>+ set32Test8(Zero, Address(regT1, Structure::typeInfoFlagsOffset()), TrustedImm32(MasqueradesAsUndefined), regT1);
</ins><span class="cx">
</span><span class="cx"> Jump wasNotImmediate = jump();
</span><span class="cx">
</span><span class="cx"> isImmediate.link(this);
</span><span class="cx">
</span><del>- set8Compare32(NotEqual, regT1, Imm32(JSValue::NullTag), regT2);
- set8Compare32(NotEqual, regT1, Imm32(JSValue::UndefinedTag), regT1);
</del><ins>+ set8Compare32(NotEqual, regT1, TrustedImm32(JSValue::NullTag), regT2);
+ set8Compare32(NotEqual, regT1, TrustedImm32(JSValue::UndefinedTag), regT1);
</ins><span class="cx"> and32(regT2, regT1);
</span><span class="cx">
</span><span class="cx"> wasNotImmediate.link(this);
</span><span class="cx">
</span><del>- or32(Imm32(JSValue::FalseTag), regT1);
</del><ins>+ or32(TrustedImm32(JSValue::FalseTag), regT1);
</ins><span class="cx">
</span><span class="cx"> emitStoreBool(dst, regT1);
</span><span class="cx"> }
</span><span class="lines">@@ -1225,7 +1225,7 @@
</span><span class="cx"> void JIT::emit_op_resolve_with_base(Instruction* currentInstruction)
</span><span class="cx"> {
</span><span class="cx"> JITStubCall stubCall(this, cti_op_resolve_with_base);
</span><del>- stubCall.addArgument(ImmPtr(&m_codeBlock->identifier(currentInstruction[3].u.operand)));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(&m_codeBlock->identifier(currentInstruction[3].u.operand)));
</ins><span class="cx"> stubCall.addArgument(Imm32(currentInstruction[1].u.operand));
</span><span class="cx"> stubCall.call(currentInstruction[2].u.operand);
</span><span class="cx"> }
</span><span class="lines">@@ -1233,7 +1233,7 @@
</span><span class="cx"> void JIT::emit_op_new_func_exp(Instruction* currentInstruction)
</span><span class="cx"> {
</span><span class="cx"> JITStubCall stubCall(this, cti_op_new_func_exp);
</span><del>- stubCall.addArgument(ImmPtr(m_codeBlock->functionExpr(currentInstruction[2].u.operand)));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(m_codeBlock->functionExpr(currentInstruction[2].u.operand)));
</ins><span class="cx"> stubCall.call(currentInstruction[1].u.operand);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1263,10 +1263,10 @@
</span><span class="cx">
</span><span class="cx"> emitLoad(base, regT1, regT0);
</span><span class="cx"> if (!m_codeBlock->isKnownNotImmediate(base))
</span><del>- isNotObject.append(branch32(NotEqual, regT1, Imm32(JSValue::CellTag)));
</del><ins>+ isNotObject.append(branch32(NotEqual, regT1, TrustedImm32(JSValue::CellTag)));
</ins><span class="cx"> if (base != m_codeBlock->thisRegister() || m_codeBlock->isStrictMode()) {
</span><span class="cx"> loadPtr(Address(regT0, JSCell::structureOffset()), regT2);
</span><del>- isNotObject.append(branch8(NotEqual, Address(regT2, Structure::typeInfoTypeOffset()), Imm32(ObjectType)));
</del><ins>+ isNotObject.append(branch8(NotEqual, Address(regT2, Structure::typeInfoTypeOffset()), TrustedImm32(ObjectType)));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // We could inline the case where you have a valid cache, but
</span><span class="lines">@@ -1276,15 +1276,15 @@
</span><span class="cx"> getPnamesStubCall.addArgument(regT0);
</span><span class="cx"> getPnamesStubCall.call(dst);
</span><span class="cx"> load32(Address(regT0, OBJECT_OFFSETOF(JSPropertyNameIterator, m_jsStringsSize)), regT3);
</span><del>- store32(Imm32(Int32Tag), intTagFor(i));
- store32(Imm32(0), intPayloadFor(i));
- store32(Imm32(Int32Tag), intTagFor(size));
</del><ins>+ store32(TrustedImm32(Int32Tag), intTagFor(i));
+ store32(TrustedImm32(0), intPayloadFor(i));
+ store32(TrustedImm32(Int32Tag), intTagFor(size));
</ins><span class="cx"> store32(regT3, payloadFor(size));
</span><span class="cx"> Jump end = jump();
</span><span class="cx">
</span><span class="cx"> isNotObject.link(this);
</span><del>- addJump(branch32(Equal, regT1, Imm32(JSValue::NullTag)), breakTarget);
- addJump(branch32(Equal, regT1, Imm32(JSValue::UndefinedTag)), breakTarget);
</del><ins>+ addJump(branch32(Equal, regT1, TrustedImm32(JSValue::NullTag)), breakTarget);
+ addJump(branch32(Equal, regT1, TrustedImm32(JSValue::UndefinedTag)), breakTarget);
</ins><span class="cx"> JITStubCall toObjectStubCall(this, cti_to_object);
</span><span class="cx"> toObjectStubCall.addArgument(regT1, regT0);
</span><span class="cx"> toObjectStubCall.call(base);
</span><span class="lines">@@ -1312,11 +1312,11 @@
</span><span class="cx"> loadPtr(payloadFor(it), regT1);
</span><span class="cx"> loadPtr(Address(regT1, OBJECT_OFFSETOF(JSPropertyNameIterator, m_jsStrings)), regT2);
</span><span class="cx"> load32(BaseIndex(regT2, regT0, TimesEight), regT2);
</span><del>- store32(Imm32(JSValue::CellTag), tagFor(dst));
</del><ins>+ store32(TrustedImm32(JSValue::CellTag), tagFor(dst));
</ins><span class="cx"> store32(regT2, payloadFor(dst));
</span><span class="cx">
</span><span class="cx"> // Increment i
</span><del>- add32(Imm32(1), regT0);
</del><ins>+ add32(TrustedImm32(1), regT0);
</ins><span class="cx"> store32(regT0, intPayloadFor(i));
</span><span class="cx">
</span><span class="cx"> // Verify that i is valid:
</span><span class="lines">@@ -1332,11 +1332,11 @@
</span><span class="cx"> addJump(branchTestPtr(Zero, Address(regT3)), target);
</span><span class="cx">
</span><span class="cx"> Label checkPrototype(this);
</span><del>- callHasProperty.append(branch32(Equal, Address(regT2, Structure::prototypeOffset() + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), Imm32(JSValue::NullTag)));
</del><ins>+ callHasProperty.append(branch32(Equal, Address(regT2, Structure::prototypeOffset() + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), TrustedImm32(JSValue::NullTag)));
</ins><span class="cx"> loadPtr(Address(regT2, Structure::prototypeOffset() + OBJECT_OFFSETOF(JSValue, u.asBits.payload)), regT2);
</span><span class="cx"> loadPtr(Address(regT2, JSCell::structureOffset()), regT2);
</span><span class="cx"> callHasProperty.append(branchPtr(NotEqual, regT2, Address(regT3)));
</span><del>- addPtr(Imm32(sizeof(Structure*)), regT3);
</del><ins>+ addPtr(TrustedImm32(sizeof(Structure*)), regT3);
</ins><span class="cx"> branchTestPtr(NonZero, Address(regT3)).linkTo(checkPrototype, this);
</span><span class="cx">
</span><span class="cx"> // Continue loop.
</span><span class="lines">@@ -1377,8 +1377,8 @@
</span><span class="cx">
</span><span class="cx"> emitLoad(src, regT1, regT0);
</span><span class="cx">
</span><del>- Jump isInt32 = branch32(Equal, regT1, Imm32(JSValue::Int32Tag));
- addSlowCase(branch32(AboveOrEqual, regT1, Imm32(JSValue::EmptyValueTag)));
</del><ins>+ Jump isInt32 = branch32(Equal, regT1, TrustedImm32(JSValue::Int32Tag));
+ addSlowCase(branch32(AboveOrEqual, regT1, TrustedImm32(JSValue::EmptyValueTag)));
</ins><span class="cx"> isInt32.link(this);
</span><span class="cx">
</span><span class="cx"> if (src != dst)
</span><span class="lines">@@ -1400,7 +1400,7 @@
</span><span class="cx"> void JIT::emit_op_push_new_scope(Instruction* currentInstruction)
</span><span class="cx"> {
</span><span class="cx"> JITStubCall stubCall(this, cti_op_push_new_scope);
</span><del>- stubCall.addArgument(ImmPtr(&m_codeBlock->identifier(currentInstruction[2].u.operand)));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(&m_codeBlock->identifier(currentInstruction[2].u.operand)));
</ins><span class="cx"> stubCall.addArgument(currentInstruction[3].u.operand);
</span><span class="cx"> stubCall.call(currentInstruction[1].u.operand);
</span><span class="cx"> }
</span><span class="lines">@@ -1414,8 +1414,8 @@
</span><span class="cx"> loadPtr(Address(stackPointerRegister, OBJECT_OFFSETOF(struct JITStackFrame, globalData)), regT3);
</span><span class="cx"> load32(Address(regT3, OBJECT_OFFSETOF(JSGlobalData, exception) + OBJECT_OFFSETOF(JSValue, u.asBits.payload)), regT0);
</span><span class="cx"> load32(Address(regT3, OBJECT_OFFSETOF(JSGlobalData, exception) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), regT1);
</span><del>- store32(Imm32(JSValue().payload()), Address(regT3, OBJECT_OFFSETOF(JSGlobalData, exception) + OBJECT_OFFSETOF(JSValue, u.asBits.payload)));
- store32(Imm32(JSValue().tag()), Address(regT3, OBJECT_OFFSETOF(JSGlobalData, exception) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)));
</del><ins>+ store32(TrustedImm32(JSValue().payload()), Address(regT3, OBJECT_OFFSETOF(JSGlobalData, exception) + OBJECT_OFFSETOF(JSValue, u.asBits.payload)));
+ store32(TrustedImm32(JSValue().tag()), Address(regT3, OBJECT_OFFSETOF(JSGlobalData, exception) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)));
</ins><span class="cx">
</span><span class="cx"> unsigned exception = currentInstruction[1].u.operand;
</span><span class="cx"> emitStore(exception, regT1, regT0);
</span><span class="lines">@@ -1520,7 +1520,7 @@
</span><span class="cx"> {
</span><span class="cx"> unsigned activation = currentInstruction[1].u.operand;
</span><span class="cx">
</span><del>- Jump activationCreated = branch32(NotEqual, tagFor(activation), Imm32(JSValue::EmptyValueTag));
</del><ins>+ Jump activationCreated = branch32(NotEqual, tagFor(activation), TrustedImm32(JSValue::EmptyValueTag));
</ins><span class="cx"> JITStubCall(this, cti_op_push_activation).call(activation);
</span><span class="cx"> activationCreated.link(this);
</span><span class="cx"> }
</span><span class="lines">@@ -1529,7 +1529,7 @@
</span><span class="cx"> {
</span><span class="cx"> unsigned dst = currentInstruction[1].u.operand;
</span><span class="cx">
</span><del>- Jump argsCreated = branch32(NotEqual, tagFor(dst), Imm32(JSValue::EmptyValueTag));
</del><ins>+ Jump argsCreated = branch32(NotEqual, tagFor(dst), TrustedImm32(JSValue::EmptyValueTag));
</ins><span class="cx">
</span><span class="cx"> if (m_codeBlock->m_numParameters == 1)
</span><span class="cx"> JITStubCall(this, cti_op_create_arguments_no_params).call();
</span><span class="lines">@@ -1571,10 +1571,10 @@
</span><span class="cx">
</span><span class="cx"> emitLoad(thisRegister, regT1, regT0);
</span><span class="cx">
</span><del>- addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::CellTag)));
</del><ins>+ addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::CellTag)));
</ins><span class="cx">
</span><span class="cx"> loadPtr(Address(regT0, JSCell::structureOffset()), regT2);
</span><del>- addSlowCase(branchTest8(NonZero, Address(regT2, Structure::typeInfoFlagsOffset()), Imm32(NeedsThisConversion)));
</del><ins>+ addSlowCase(branchTest8(NonZero, Address(regT2, Structure::typeInfoFlagsOffset()), TrustedImm32(NeedsThisConversion)));
</ins><span class="cx">
</span><span class="cx"> map(m_bytecodeOffset + OPCODE_LENGTH(op_convert_this), thisRegister, regT1, regT0);
</span><span class="cx"> }
</span><span class="lines">@@ -1585,14 +1585,14 @@
</span><span class="cx">
</span><span class="cx"> emitLoad(thisRegister, regT1, regT0);
</span><span class="cx">
</span><del>- Jump notNull = branch32(NotEqual, regT1, Imm32(JSValue::EmptyValueTag));
</del><ins>+ Jump notNull = branch32(NotEqual, regT1, TrustedImm32(JSValue::EmptyValueTag));
</ins><span class="cx"> emitStore(thisRegister, jsNull());
</span><span class="cx"> Jump setThis = jump();
</span><span class="cx"> notNull.link(this);
</span><del>- Jump isImmediate = branch32(NotEqual, regT1, Imm32(JSValue::CellTag));
</del><ins>+ Jump isImmediate = branch32(NotEqual, regT1, TrustedImm32(JSValue::CellTag));
</ins><span class="cx"> loadPtr(Address(regT0, JSCell::structureOffset()), regT2);
</span><del>- Jump notAnObject = branch8(NotEqual, Address(regT2, Structure::typeInfoTypeOffset()), Imm32(ObjectType));
- addSlowCase(branchTest8(NonZero, Address(regT2, Structure::typeInfoFlagsOffset()), Imm32(NeedsThisConversion)));
</del><ins>+ Jump notAnObject = branch8(NotEqual, Address(regT2, Structure::typeInfoTypeOffset()), TrustedImm32(ObjectType));
+ addSlowCase(branchTest8(NonZero, Address(regT2, Structure::typeInfoFlagsOffset()), TrustedImm32(NeedsThisConversion)));
</ins><span class="cx"> isImmediate.link(this);
</span><span class="cx"> notAnObject.link(this);
</span><span class="cx"> setThis.link(this);
</span><span class="lines">@@ -1648,9 +1648,9 @@
</span><span class="cx"> {
</span><span class="cx"> int dst = currentInstruction[1].u.operand;
</span><span class="cx"> int argumentsRegister = currentInstruction[2].u.operand;
</span><del>- addSlowCase(branch32(NotEqual, tagFor(argumentsRegister), Imm32(JSValue::EmptyValueTag)));
</del><ins>+ addSlowCase(branch32(NotEqual, tagFor(argumentsRegister), TrustedImm32(JSValue::EmptyValueTag)));
</ins><span class="cx"> emitGetFromCallFrameHeader32(RegisterFile::ArgumentCount, regT0);
</span><del>- sub32(Imm32(1), regT0);
</del><ins>+ sub32(TrustedImm32(1), regT0);
</ins><span class="cx"> emitStoreInt32(dst, regT0);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1663,7 +1663,7 @@
</span><span class="cx">
</span><span class="cx"> JITStubCall stubCall(this, cti_op_get_by_id_generic);
</span><span class="cx"> stubCall.addArgument(base);
</span><del>- stubCall.addArgument(ImmPtr(&(m_codeBlock->identifier(ident))));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(&(m_codeBlock->identifier(ident))));
</ins><span class="cx"> stubCall.call(dst);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1672,10 +1672,10 @@
</span><span class="cx"> int dst = currentInstruction[1].u.operand;
</span><span class="cx"> int argumentsRegister = currentInstruction[2].u.operand;
</span><span class="cx"> int property = currentInstruction[3].u.operand;
</span><del>- addSlowCase(branch32(NotEqual, tagFor(argumentsRegister), Imm32(JSValue::EmptyValueTag)));
</del><ins>+ addSlowCase(branch32(NotEqual, tagFor(argumentsRegister), TrustedImm32(JSValue::EmptyValueTag)));
</ins><span class="cx"> emitLoad(property, regT1, regT2);
</span><del>- addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::Int32Tag)));
- add32(Imm32(1), regT2);
</del><ins>+ addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
+ add32(TrustedImm32(1), regT2);
</ins><span class="cx"> // regT2 now contains the integer index of the argument we want, including this
</span><span class="cx"> emitGetFromCallFrameHeader32(RegisterFile::ArgumentCount, regT3);
</span><span class="cx"> addSlowCase(branch32(AboveOrEqual, regT2, regT3));
</span><span class="lines">@@ -1692,7 +1692,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> addPtr(Imm32(static_cast<unsigned>(-(RegisterFile::CallFrameHeaderSize + numArgs) * sizeof(Register))), callFrameRegister, regT1);
</span><del>- mul32(Imm32(sizeof(Register)), regT3, regT3);
</del><ins>+ mul32(TrustedImm32(sizeof(Register)), regT3, regT3);
</ins><span class="cx"> subPtr(regT3, regT1);
</span><span class="cx"> loadPtr(BaseIndex(regT1, regT2, TimesEight, OBJECT_OFFSETOF(JSValue, u.asBits.payload)), regT0);
</span><span class="cx"> loadPtr(BaseIndex(regT1, regT2, TimesEight, OBJECT_OFFSETOF(JSValue, u.asBits.tag)), regT1);
</span><span class="lines">@@ -1734,17 +1734,17 @@
</span><span class="cx"> push(regT3);
</span><span class="cx"> move(regT2, regT3);
</span><span class="cx"> move(regT0, regT2);
</span><del>- move(Imm32(0), regT1);
</del><ins>+ move(TrustedImm32(0), regT1);
</ins><span class="cx">
</span><span class="cx"> // Check for negative result reminder
</span><del>- Jump positiveRegT3 = branch32(GreaterThanOrEqual, regT3, Imm32(0));
</del><ins>+ Jump positiveRegT3 = branch32(GreaterThanOrEqual, regT3, TrustedImm32(0));
</ins><span class="cx"> neg32(regT3);
</span><del>- xor32(Imm32(1), regT1);
</del><ins>+ xor32(TrustedImm32(1), regT1);
</ins><span class="cx"> positiveRegT3.link(this);
</span><span class="cx">
</span><del>- Jump positiveRegT2 = branch32(GreaterThanOrEqual, regT2, Imm32(0));
</del><ins>+ Jump positiveRegT2 = branch32(GreaterThanOrEqual, regT2, TrustedImm32(0));
</ins><span class="cx"> neg32(regT2);
</span><del>- xor32(Imm32(2), regT1);
</del><ins>+ xor32(TrustedImm32(2), regT1);
</ins><span class="cx"> positiveRegT2.link(this);
</span><span class="cx">
</span><span class="cx"> // Save the condition for negative reminder
</span><span class="lines">@@ -1754,7 +1754,7 @@
</span><span class="cx">
</span><span class="cx"> // Power of two fast case
</span><span class="cx"> move(regT3, regT0);
</span><del>- sub32(Imm32(1), regT0);
</del><ins>+ sub32(TrustedImm32(1), regT0);
</ins><span class="cx"> Jump powerOfTwo = branchTest32(NotEqual, regT0, regT3);
</span><span class="cx"> and32(regT0, regT2);
</span><span class="cx"> powerOfTwo.link(this);
</span><span class="lines">@@ -1767,10 +1767,10 @@
</span><span class="cx"> countLeadingZeros32(regT3, regT1);
</span><span class="cx"> sub32(regT0, regT1);
</span><span class="cx">
</span><del>- Jump useFullTable = branch32(Equal, regT1, Imm32(31));
</del><ins>+ Jump useFullTable = branch32(Equal, regT1, TrustedImm32(31));
</ins><span class="cx">
</span><span class="cx"> neg32(regT1);
</span><del>- add32(Imm32(31), regT1);
</del><ins>+ add32(TrustedImm32(31), regT1);
</ins><span class="cx">
</span><span class="cx"> int elementSizeByShift = -1;
</span><span class="cx"> #if CPU(ARM)
</span><span class="lines">@@ -1805,7 +1805,7 @@
</span><span class="cx">
</span><span class="cx"> // Check for negative reminder
</span><span class="cx"> pop(regT1);
</span><del>- Jump positiveResult = branch32(Equal, regT1, Imm32(0));
</del><ins>+ Jump positiveResult = branch32(Equal, regT1, TrustedImm32(0));
</ins><span class="cx"> neg32(regT2);
</span><span class="cx"> positiveResult.link(this);
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorejitJITPropertyAccesscpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/jit/JITPropertyAccess.cpp (82129 => 82130)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/jit/JITPropertyAccess.cpp 2011-03-28 17:10:30 UTC (rev 82129)
+++ trunk/Source/JavaScriptCore/jit/JITPropertyAccess.cpp 2011-03-28 17:14:57 UTC (rev 82130)
</span><span class="lines">@@ -54,7 +54,7 @@
</span><span class="cx"> {
</span><span class="cx"> JSInterfaceJIT jit;
</span><span class="cx"> JumpList failures;
</span><del>- failures.append(jit.branchPtr(NotEqual, Address(regT0), ImmPtr(globalData->jsStringVPtr)));
</del><ins>+ failures.append(jit.branchPtr(NotEqual, Address(regT0), TrustedImmPtr(globalData->jsStringVPtr)));
</ins><span class="cx"> failures.append(jit.branchTest32(NonZero, Address(regT0, OBJECT_OFFSETOF(JSString, m_fiberCount))));
</span><span class="cx">
</span><span class="cx"> // Load string length to regT1, and start the process of loading the data pointer into regT0
</span><span class="lines">@@ -68,13 +68,13 @@
</span><span class="cx"> // Load the character
</span><span class="cx"> jit.load16(BaseIndex(regT0, regT1, TimesTwo, 0), regT0);
</span><span class="cx">
</span><del>- failures.append(jit.branch32(AboveOrEqual, regT0, Imm32(0x100)));
- jit.move(ImmPtr(globalData->smallStrings.singleCharacterStrings()), regT1);
</del><ins>+ failures.append(jit.branch32(AboveOrEqual, regT0, TrustedImm32(0x100)));
+ jit.move(TrustedImmPtr(globalData->smallStrings.singleCharacterStrings()), regT1);
</ins><span class="cx"> jit.loadPtr(BaseIndex(regT1, regT0, ScalePtr, 0), regT0);
</span><span class="cx"> jit.ret();
</span><span class="cx">
</span><span class="cx"> failures.link(&jit);
</span><del>- jit.move(Imm32(0), regT0);
</del><ins>+ jit.move(TrustedImm32(0), regT0);
</ins><span class="cx"> jit.ret();
</span><span class="cx">
</span><span class="cx"> LinkBuffer patchBuffer(&jit, pool, 0);
</span><span class="lines">@@ -99,7 +99,7 @@
</span><span class="cx"> zeroExtend32ToPtr(regT1, regT1);
</span><span class="cx">
</span><span class="cx"> emitJumpSlowCaseIfNotJSCell(regT0, base);
</span><del>- addSlowCase(branchPtr(NotEqual, Address(regT0), ImmPtr(m_globalData->jsArrayVPtr)));
</del><ins>+ addSlowCase(branchPtr(NotEqual, Address(regT0), TrustedImmPtr(m_globalData->jsArrayVPtr)));
</ins><span class="cx">
</span><span class="cx"> loadPtr(Address(regT0, JSArray::storageOffset()), regT2);
</span><span class="cx"> addSlowCase(branch32(AboveOrEqual, regT1, Address(regT0, JSArray::vectorLengthOffset())));
</span><span class="lines">@@ -120,7 +120,7 @@
</span><span class="cx"> linkSlowCaseIfNotJSCell(iter, base); // base cell check
</span><span class="cx"> Jump nonCell = jump();
</span><span class="cx"> linkSlowCase(iter); // base array check
</span><del>- Jump notString = branchPtr(NotEqual, Address(regT0), ImmPtr(m_globalData->jsStringVPtr));
</del><ins>+ Jump notString = branchPtr(NotEqual, Address(regT0), TrustedImmPtr(m_globalData->jsStringVPtr));
</ins><span class="cx"> emitNakedCall(m_globalData->getCTIStub(stringGetByValStubGenerator));
</span><span class="cx"> Jump failed = branchTestPtr(Zero, regT0);
</span><span class="cx"> emitPutVirtualRegister(dst, regT0);
</span><span class="lines">@@ -162,7 +162,7 @@
</span><span class="cx"> loadPtr(Address(regT0, JSCell::structureOffset()), regT2);
</span><span class="cx"> addSlowCase(branchPtr(NotEqual, regT2, Address(regT1, OBJECT_OFFSETOF(JSPropertyNameIterator, m_cachedStructure))));
</span><span class="cx"> load32(addressFor(i), regT3);
</span><del>- sub32(Imm32(1), regT3);
</del><ins>+ sub32(TrustedImm32(1), regT3);
</ins><span class="cx"> addSlowCase(branch32(AboveOrEqual, regT3, Address(regT1, OBJECT_OFFSETOF(JSPropertyNameIterator, m_numCacheableSlots))));
</span><span class="cx"> compileGetDirectOffset(regT0, regT0, regT3, regT1);
</span><span class="cx">
</span><span class="lines">@@ -197,7 +197,7 @@
</span><span class="cx"> // See comment in op_get_by_val.
</span><span class="cx"> zeroExtend32ToPtr(regT1, regT1);
</span><span class="cx"> emitJumpSlowCaseIfNotJSCell(regT0, base);
</span><del>- addSlowCase(branchPtr(NotEqual, Address(regT0), ImmPtr(m_globalData->jsArrayVPtr)));
</del><ins>+ addSlowCase(branchPtr(NotEqual, Address(regT0), TrustedImmPtr(m_globalData->jsArrayVPtr)));
</ins><span class="cx"> addSlowCase(branch32(AboveOrEqual, regT1, Address(regT0, JSArray::vectorLengthOffset())));
</span><span class="cx">
</span><span class="cx"> loadPtr(Address(regT0, JSArray::storageOffset()), regT2);
</span><span class="lines">@@ -209,11 +209,11 @@
</span><span class="cx"> Jump end = jump();
</span><span class="cx">
</span><span class="cx"> empty.link(this);
</span><del>- add32(Imm32(1), Address(regT2, OBJECT_OFFSETOF(ArrayStorage, m_numValuesInVector)));
</del><ins>+ add32(TrustedImm32(1), Address(regT2, OBJECT_OFFSETOF(ArrayStorage, m_numValuesInVector)));
</ins><span class="cx"> branch32(Below, regT1, Address(regT2, OBJECT_OFFSETOF(ArrayStorage, m_length))).linkTo(storeResult, this);
</span><span class="cx">
</span><span class="cx"> move(regT1, regT0);
</span><del>- add32(Imm32(1), regT0);
</del><ins>+ add32(TrustedImm32(1), regT0);
</ins><span class="cx"> store32(regT0, Address(regT2, OBJECT_OFFSETOF(ArrayStorage, m_length)));
</span><span class="cx"> jump().linkTo(storeResult, this);
</span><span class="cx">
</span><span class="lines">@@ -224,7 +224,7 @@
</span><span class="cx"> {
</span><span class="cx"> JITStubCall stubCall(this, cti_op_put_by_index);
</span><span class="cx"> stubCall.addArgument(currentInstruction[1].u.operand, regT2);
</span><del>- stubCall.addArgument(Imm32(currentInstruction[2].u.operand));
</del><ins>+ stubCall.addArgument(TrustedImm32(currentInstruction[2].u.operand));
</ins><span class="cx"> stubCall.addArgument(currentInstruction[3].u.operand, regT2);
</span><span class="cx"> stubCall.call();
</span><span class="cx"> }
</span><span class="lines">@@ -233,7 +233,7 @@
</span><span class="cx"> {
</span><span class="cx"> JITStubCall stubCall(this, cti_op_put_getter);
</span><span class="cx"> stubCall.addArgument(currentInstruction[1].u.operand, regT2);
</span><del>- stubCall.addArgument(ImmPtr(&m_codeBlock->identifier(currentInstruction[2].u.operand)));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(&m_codeBlock->identifier(currentInstruction[2].u.operand)));
</ins><span class="cx"> stubCall.addArgument(currentInstruction[3].u.operand, regT2);
</span><span class="cx"> stubCall.call();
</span><span class="cx"> }
</span><span class="lines">@@ -242,7 +242,7 @@
</span><span class="cx"> {
</span><span class="cx"> JITStubCall stubCall(this, cti_op_put_setter);
</span><span class="cx"> stubCall.addArgument(currentInstruction[1].u.operand, regT2);
</span><del>- stubCall.addArgument(ImmPtr(&m_codeBlock->identifier(currentInstruction[2].u.operand)));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(&m_codeBlock->identifier(currentInstruction[2].u.operand)));
</ins><span class="cx"> stubCall.addArgument(currentInstruction[3].u.operand, regT2);
</span><span class="cx"> stubCall.call();
</span><span class="cx"> }
</span><span class="lines">@@ -251,7 +251,7 @@
</span><span class="cx"> {
</span><span class="cx"> JITStubCall stubCall(this, cti_op_del_by_id);
</span><span class="cx"> stubCall.addArgument(currentInstruction[2].u.operand, regT2);
</span><del>- stubCall.addArgument(ImmPtr(&m_codeBlock->identifier(currentInstruction[3].u.operand)));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(&m_codeBlock->identifier(currentInstruction[3].u.operand)));
</ins><span class="cx"> stubCall.call(currentInstruction[1].u.operand);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -276,7 +276,7 @@
</span><span class="cx"> emitGetVirtualRegister(baseVReg, regT0);
</span><span class="cx"> JITStubCall stubCall(this, cti_op_get_by_id_generic);
</span><span class="cx"> stubCall.addArgument(regT0);
</span><del>- stubCall.addArgument(ImmPtr(ident));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(ident));
</ins><span class="cx"> stubCall.call(resultVReg);
</span><span class="cx">
</span><span class="cx"> m_propertyAccessInstructionIndex++;
</span><span class="lines">@@ -298,7 +298,7 @@
</span><span class="cx">
</span><span class="cx"> JITStubCall stubCall(this, direct ? cti_op_put_by_id_direct_generic, cti_op_put_by_id_generic);
</span><span class="cx"> stubCall.addArgument(regT0);
</span><del>- stubCall.addArgument(ImmPtr(ident));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(ident));
</ins><span class="cx"> stubCall.addArgument(regT1);
</span><span class="cx"> stubCall.call();
</span><span class="cx">
</span><span class="lines">@@ -336,12 +336,12 @@
</span><span class="cx">
</span><span class="cx"> BEGIN_UNINTERRUPTED_SEQUENCE(sequenceMethodCheck);
</span><span class="cx">
</span><del>- Jump structureCheck = branchPtrWithPatch(NotEqual, Address(regT0, JSCell::structureOffset()), info.structureToCompare, ImmPtr(reinterpret_cast<void*>(patchGetByIdDefaultStructure)));
- DataLabelPtr protoStructureToCompare, protoObj = moveWithPatch(ImmPtr(0), regT1);
- Jump protoStructureCheck = branchPtrWithPatch(NotEqual, Address(regT1, JSCell::structureOffset()), protoStructureToCompare, ImmPtr(reinterpret_cast<void*>(patchGetByIdDefaultStructure)));
</del><ins>+ Jump structureCheck = branchPtrWithPatch(NotEqual, Address(regT0, JSCell::structureOffset()), info.structureToCompare, TrustedImmPtr(reinterpret_cast<void*>(patchGetByIdDefaultStructure)));
+ DataLabelPtr protoStructureToCompare, protoObj = moveWithPatch(TrustedImmPtr(0), regT1);
+ Jump protoStructureCheck = branchPtrWithPatch(NotEqual, Address(regT1, JSCell::structureOffset()), protoStructureToCompare, TrustedImmPtr(reinterpret_cast<void*>(patchGetByIdDefaultStructure)));
</ins><span class="cx">
</span><span class="cx"> // This will be relinked to load the function without doing a load.
</span><del>- DataLabelPtr putFunction = moveWithPatch(ImmPtr(0), regT0);
</del><ins>+ DataLabelPtr putFunction = moveWithPatch(TrustedImmPtr(0), regT0);
</ins><span class="cx">
</span><span class="cx"> END_UNINTERRUPTED_SEQUENCE(sequenceMethodCheck);
</span><span class="cx">
</span><span class="lines">@@ -414,7 +414,7 @@
</span><span class="cx"> m_propertyAccessCompilationInfo[propertyAccessInstructionIndex].hotPathBegin = hotPathBegin;
</span><span class="cx">
</span><span class="cx"> DataLabelPtr structureToCompare;
</span><del>- Jump structureCheck = branchPtrWithPatch(NotEqual, Address(regT0, JSCell::structureOffset()), structureToCompare, ImmPtr(reinterpret_cast<void*>(patchGetByIdDefaultStructure)));
</del><ins>+ Jump structureCheck = branchPtrWithPatch(NotEqual, Address(regT0, JSCell::structureOffset()), structureToCompare, TrustedImmPtr(reinterpret_cast<void*>(patchGetByIdDefaultStructure)));
</ins><span class="cx"> addSlowCase(structureCheck);
</span><span class="cx"> ASSERT_JIT_OFFSET(differenceBetween(hotPathBegin, structureToCompare), patchOffsetGetByIdStructure);
</span><span class="cx"> ASSERT_JIT_OFFSET(differenceBetween(hotPathBegin, structureCheck), patchOffsetGetByIdBranchToSlowCase)
</span><span class="lines">@@ -457,7 +457,7 @@
</span><span class="cx"> #endif
</span><span class="cx"> JITStubCall stubCall(this, isMethodCheck ? cti_op_get_by_id_method_check : cti_op_get_by_id);
</span><span class="cx"> stubCall.addArgument(regT0);
</span><del>- stubCall.addArgument(ImmPtr(ident));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(ident));
</ins><span class="cx"> Call call = stubCall.call(resultVReg);
</span><span class="cx">
</span><span class="cx"> END_UNINTERRUPTED_SEQUENCE(sequenceGetByIdSlowCase);
</span><span class="lines">@@ -492,7 +492,7 @@
</span><span class="cx">
</span><span class="cx"> // It is important that the following instruction plants a 32bit immediate, in order that it can be patched over.
</span><span class="cx"> DataLabelPtr structureToCompare;
</span><del>- addSlowCase(branchPtrWithPatch(NotEqual, Address(regT0, JSCell::structureOffset()), structureToCompare, ImmPtr(reinterpret_cast<void*>(patchGetByIdDefaultStructure))));
</del><ins>+ addSlowCase(branchPtrWithPatch(NotEqual, Address(regT0, JSCell::structureOffset()), structureToCompare, TrustedImmPtr(reinterpret_cast<void*>(patchGetByIdDefaultStructure))));
</ins><span class="cx"> ASSERT_JIT_OFFSET(differenceBetween(hotPathBegin, structureToCompare), patchOffsetPutByIdStructure);
</span><span class="cx">
</span><span class="cx"> loadPtr(Address(regT0, OBJECT_OFFSETOF(JSObject, m_propertyStorage)), regT0);
</span><span class="lines">@@ -516,7 +516,7 @@
</span><span class="cx">
</span><span class="cx"> JITStubCall stubCall(this, direct ? cti_op_put_by_id_direct : cti_op_put_by_id);
</span><span class="cx"> stubCall.addArgument(regT0);
</span><del>- stubCall.addArgument(ImmPtr(ident));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(ident));
</ins><span class="cx"> stubCall.addArgument(regT1);
</span><span class="cx"> Call call = stubCall.call();
</span><span class="cx">
</span><span class="lines">@@ -564,10 +564,10 @@
</span><span class="cx"> // values. In the non X86_64 case, the generated code is slightly more efficient because it uses
</span><span class="cx"> // two less instructions and doesn't require any scratch registers.
</span><span class="cx"> #if CPU(X86_64)
</span><del>- move(ImmPtr(prototype.asCell()->structure()), regT3);
</del><ins>+ move(TrustedImmPtr(prototype.asCell()->structure()), regT3);
</ins><span class="cx"> failureCases.append(branchPtr(NotEqual, AbsoluteAddress(prototype.asCell()->addressOfStructure()), regT3));
</span><span class="cx"> #else
</span><del>- failureCases.append(branchPtr(NotEqual, AbsoluteAddress(prototype.asCell()->addressOfStructure()), ImmPtr(prototype.asCell()->structure())));
</del><ins>+ failureCases.append(branchPtr(NotEqual, AbsoluteAddress(prototype.asCell()->addressOfStructure()), TrustedImmPtr(prototype.asCell()->structure())));
</ins><span class="cx"> #endif
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -576,7 +576,7 @@
</span><span class="cx"> JumpList failureCases;
</span><span class="cx"> // Check eax is an object of the right Structure.
</span><span class="cx"> failureCases.append(emitJumpIfNotJSCell(regT0));
</span><del>- failureCases.append(branchPtr(NotEqual, Address(regT0, JSCell::structureOffset()), ImmPtr(oldStructure)));
</del><ins>+ failureCases.append(branchPtr(NotEqual, Address(regT0, JSCell::structureOffset()), TrustedImmPtr(oldStructure)));
</ins><span class="cx"> testPrototype(oldStructure->storedPrototype(), failureCases);
</span><span class="cx">
</span><span class="cx"> // ecx = baseObject->m_structure
</span><span class="lines">@@ -598,8 +598,8 @@
</span><span class="cx"> stubCall.skipArgument(); // base
</span><span class="cx"> stubCall.skipArgument(); // ident
</span><span class="cx"> stubCall.skipArgument(); // value
</span><del>- stubCall.addArgument(Imm32(oldStructure->propertyStorageCapacity()));
- stubCall.addArgument(Imm32(newStructure->propertyStorageCapacity()));
</del><ins>+ stubCall.addArgument(TrustedImm32(oldStructure->propertyStorageCapacity()));
+ stubCall.addArgument(TrustedImm32(newStructure->propertyStorageCapacity()));
</ins><span class="cx"> stubCall.call(regT0);
</span><span class="cx"> emitGetJITStubArg(2, regT1);
</span><span class="cx">
</span><span class="lines">@@ -608,9 +608,9 @@
</span><span class="cx">
</span><span class="cx"> // Assumes m_refCount can be decremented easily, refcount decrement is safe as
</span><span class="cx"> // codeblock should ensure oldStructure->m_refCount > 0
</span><del>- sub32(Imm32(1), AbsoluteAddress(oldStructure->addressOfCount()));
- add32(Imm32(1), AbsoluteAddress(newStructure->addressOfCount()));
- storePtr(ImmPtr(newStructure), Address(regT0, JSCell::structureOffset()));
</del><ins>+ sub32(TrustedImm32(1), AbsoluteAddress(oldStructure->addressOfCount()));
+ add32(TrustedImm32(1), AbsoluteAddress(newStructure->addressOfCount()));
+ storePtr(TrustedImmPtr(newStructure), Address(regT0, JSCell::structureOffset()));
</ins><span class="cx">
</span><span class="cx"> // write the value
</span><span class="cx"> compilePutDirectOffset(regT0, regT1, newStructure, cachedOffset);
</span><span class="lines">@@ -692,12 +692,12 @@
</span><span class="cx"> StructureStubInfo* stubInfo = &m_codeBlock->getStubInfo(returnAddress);
</span><span class="cx">
</span><span class="cx"> // Check eax is an array
</span><del>- Jump failureCases1 = branchPtr(NotEqual, Address(regT0), ImmPtr(m_globalData->jsArrayVPtr));
</del><ins>+ Jump failureCases1 = branchPtr(NotEqual, Address(regT0), TrustedImmPtr(m_globalData->jsArrayVPtr));
</ins><span class="cx">
</span><span class="cx"> // Checks out okay! - get the length from the storage
</span><span class="cx"> loadPtr(Address(regT0, JSArray::storageOffset()), regT3);
</span><span class="cx"> load32(Address(regT3, OBJECT_OFFSETOF(ArrayStorage, m_length)), regT2);
</span><del>- Jump failureCases2 = branch32(Above, regT2, Imm32(JSImmediate::maxImmediateInt));
</del><ins>+ Jump failureCases2 = branch32(Above, regT2, TrustedImm32(JSImmediate::maxImmediateInt));
</ins><span class="cx">
</span><span class="cx"> emitFastArithIntToImmNoCheck(regT2, regT0);
</span><span class="cx"> Jump success = jump();
</span><span class="lines">@@ -737,10 +737,10 @@
</span><span class="cx"> // Check the prototype object's Structure had not changed.
</span><span class="cx"> Structure* const * prototypeStructureAddress = protoObject->addressOfStructure();
</span><span class="cx"> #if CPU(X86_64)
</span><del>- move(ImmPtr(prototypeStructure), regT3);
</del><ins>+ move(TrustedImmPtr(prototypeStructure), regT3);
</ins><span class="cx"> Jump failureCases2 = branchPtr(NotEqual, AbsoluteAddress(prototypeStructureAddress), regT3);
</span><span class="cx"> #else
</span><del>- Jump failureCases2 = branchPtr(NotEqual, AbsoluteAddress(prototypeStructureAddress), ImmPtr(prototypeStructure));
</del><ins>+ Jump failureCases2 = branchPtr(NotEqual, AbsoluteAddress(prototypeStructureAddress), TrustedImmPtr(prototypeStructure));
</ins><span class="cx"> #endif
</span><span class="cx">
</span><span class="cx"> bool needsStubLink = false;
</span><span class="lines">@@ -752,15 +752,15 @@
</span><span class="cx"> JITStubCall stubCall(this, cti_op_get_by_id_getter_stub);
</span><span class="cx"> stubCall.addArgument(regT1);
</span><span class="cx"> stubCall.addArgument(regT0);
</span><del>- stubCall.addArgument(ImmPtr(stubInfo->callReturnLocation.executableAddress()));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(stubInfo->callReturnLocation.executableAddress()));
</ins><span class="cx"> stubCall.call();
</span><span class="cx"> } else if (slot.cachedPropertyType() == PropertySlot::Custom) {
</span><span class="cx"> needsStubLink = true;
</span><span class="cx"> JITStubCall stubCall(this, cti_op_get_by_id_custom_stub);
</span><del>- stubCall.addArgument(ImmPtr(protoObject));
- stubCall.addArgument(ImmPtr(FunctionPtr(slot.customGetter()).executableAddress()));
- stubCall.addArgument(ImmPtr(const_cast<Identifier*>(&ident)));
- stubCall.addArgument(ImmPtr(stubInfo->callReturnLocation.executableAddress()));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(protoObject));
+ stubCall.addArgument(TrustedImmPtr(FunctionPtr(slot.customGetter()).executableAddress()));
+ stubCall.addArgument(TrustedImmPtr(const_cast<Identifier*>(&ident)));
+ stubCall.addArgument(TrustedImmPtr(stubInfo->callReturnLocation.executableAddress()));
</ins><span class="cx"> stubCall.call();
</span><span class="cx"> } else
</span><span class="cx"> compileGetDirectOffset(protoObject, regT0, cachedOffset);
</span><span class="lines">@@ -804,15 +804,15 @@
</span><span class="cx"> JITStubCall stubCall(this, cti_op_get_by_id_getter_stub);
</span><span class="cx"> stubCall.addArgument(regT1);
</span><span class="cx"> stubCall.addArgument(regT0);
</span><del>- stubCall.addArgument(ImmPtr(stubInfo->callReturnLocation.executableAddress()));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(stubInfo->callReturnLocation.executableAddress()));
</ins><span class="cx"> stubCall.call();
</span><span class="cx"> } else if (slot.cachedPropertyType() == PropertySlot::Custom) {
</span><span class="cx"> needsStubLink = true;
</span><span class="cx"> JITStubCall stubCall(this, cti_op_get_by_id_custom_stub);
</span><span class="cx"> stubCall.addArgument(regT0);
</span><del>- stubCall.addArgument(ImmPtr(FunctionPtr(slot.customGetter()).executableAddress()));
- stubCall.addArgument(ImmPtr(const_cast<Identifier*>(&ident)));
- stubCall.addArgument(ImmPtr(stubInfo->callReturnLocation.executableAddress()));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(FunctionPtr(slot.customGetter()).executableAddress()));
+ stubCall.addArgument(TrustedImmPtr(const_cast<Identifier*>(&ident)));
+ stubCall.addArgument(TrustedImmPtr(stubInfo->callReturnLocation.executableAddress()));
</ins><span class="cx"> stubCall.call();
</span><span class="cx"> } else
</span><span class="cx"> compileGetDirectOffset(regT0, regT0, structure, cachedOffset);
</span><span class="lines">@@ -860,10 +860,10 @@
</span><span class="cx"> // Check the prototype object's Structure had not changed.
</span><span class="cx"> Structure* const * prototypeStructureAddress = protoObject->addressOfStructure();
</span><span class="cx"> #if CPU(X86_64)
</span><del>- move(ImmPtr(prototypeStructure), regT3);
</del><ins>+ move(TrustedImmPtr(prototypeStructure), regT3);
</ins><span class="cx"> Jump failureCases2 = branchPtr(NotEqual, AbsoluteAddress(prototypeStructureAddress), regT3);
</span><span class="cx"> #else
</span><del>- Jump failureCases2 = branchPtr(NotEqual, AbsoluteAddress(prototypeStructureAddress), ImmPtr(prototypeStructure));
</del><ins>+ Jump failureCases2 = branchPtr(NotEqual, AbsoluteAddress(prototypeStructureAddress), TrustedImmPtr(prototypeStructure));
</ins><span class="cx"> #endif
</span><span class="cx">
</span><span class="cx"> // Checks out okay!
</span><span class="lines">@@ -874,15 +874,15 @@
</span><span class="cx"> JITStubCall stubCall(this, cti_op_get_by_id_getter_stub);
</span><span class="cx"> stubCall.addArgument(regT1);
</span><span class="cx"> stubCall.addArgument(regT0);
</span><del>- stubCall.addArgument(ImmPtr(stubInfo->callReturnLocation.executableAddress()));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(stubInfo->callReturnLocation.executableAddress()));
</ins><span class="cx"> stubCall.call();
</span><span class="cx"> } else if (slot.cachedPropertyType() == PropertySlot::Custom) {
</span><span class="cx"> needsStubLink = true;
</span><span class="cx"> JITStubCall stubCall(this, cti_op_get_by_id_custom_stub);
</span><del>- stubCall.addArgument(ImmPtr(protoObject));
- stubCall.addArgument(ImmPtr(FunctionPtr(slot.customGetter()).executableAddress()));
- stubCall.addArgument(ImmPtr(const_cast<Identifier*>(&ident)));
- stubCall.addArgument(ImmPtr(stubInfo->callReturnLocation.executableAddress()));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(protoObject));
+ stubCall.addArgument(TrustedImmPtr(FunctionPtr(slot.customGetter()).executableAddress()));
+ stubCall.addArgument(TrustedImmPtr(const_cast<Identifier*>(&ident)));
+ stubCall.addArgument(TrustedImmPtr(stubInfo->callReturnLocation.executableAddress()));
</ins><span class="cx"> stubCall.call();
</span><span class="cx"> } else
</span><span class="cx"> compileGetDirectOffset(protoObject, regT0, cachedOffset);
</span><span class="lines">@@ -944,15 +944,15 @@
</span><span class="cx"> JITStubCall stubCall(this, cti_op_get_by_id_getter_stub);
</span><span class="cx"> stubCall.addArgument(regT1);
</span><span class="cx"> stubCall.addArgument(regT0);
</span><del>- stubCall.addArgument(ImmPtr(stubInfo->callReturnLocation.executableAddress()));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(stubInfo->callReturnLocation.executableAddress()));
</ins><span class="cx"> stubCall.call();
</span><span class="cx"> } else if (slot.cachedPropertyType() == PropertySlot::Custom) {
</span><span class="cx"> needsStubLink = true;
</span><span class="cx"> JITStubCall stubCall(this, cti_op_get_by_id_custom_stub);
</span><del>- stubCall.addArgument(ImmPtr(protoObject));
- stubCall.addArgument(ImmPtr(FunctionPtr(slot.customGetter()).executableAddress()));
- stubCall.addArgument(ImmPtr(const_cast<Identifier*>(&ident)));
- stubCall.addArgument(ImmPtr(stubInfo->callReturnLocation.executableAddress()));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(protoObject));
+ stubCall.addArgument(TrustedImmPtr(FunctionPtr(slot.customGetter()).executableAddress()));
+ stubCall.addArgument(TrustedImmPtr(const_cast<Identifier*>(&ident)));
+ stubCall.addArgument(TrustedImmPtr(stubInfo->callReturnLocation.executableAddress()));
</ins><span class="cx"> stubCall.call();
</span><span class="cx"> } else
</span><span class="cx"> compileGetDirectOffset(protoObject, regT0, cachedOffset);
</span><span class="lines">@@ -979,7 +979,6 @@
</span><span class="cx">
</span><span class="cx"> // Track the stub we have created so that it will be deleted later.
</span><span class="cx"> structure->ref();
</span><del>- chain->ref();
</del><span class="cx"> prototypeStructures->list[currentIndex].set(entryLabel, structure, chain);
</span><span class="cx">
</span><span class="cx"> // Finally patch the jump to slow case back in the hot path to jump here instead.
</span><span class="lines">@@ -1014,15 +1013,15 @@
</span><span class="cx"> JITStubCall stubCall(this, cti_op_get_by_id_getter_stub);
</span><span class="cx"> stubCall.addArgument(regT1);
</span><span class="cx"> stubCall.addArgument(regT0);
</span><del>- stubCall.addArgument(ImmPtr(stubInfo->callReturnLocation.executableAddress()));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(stubInfo->callReturnLocation.executableAddress()));
</ins><span class="cx"> stubCall.call();
</span><span class="cx"> } else if (slot.cachedPropertyType() == PropertySlot::Custom) {
</span><span class="cx"> needsStubLink = true;
</span><span class="cx"> JITStubCall stubCall(this, cti_op_get_by_id_custom_stub);
</span><del>- stubCall.addArgument(ImmPtr(protoObject));
- stubCall.addArgument(ImmPtr(FunctionPtr(slot.customGetter()).executableAddress()));
- stubCall.addArgument(ImmPtr(const_cast<Identifier*>(&ident)));
- stubCall.addArgument(ImmPtr(stubInfo->callReturnLocation.executableAddress()));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(protoObject));
+ stubCall.addArgument(TrustedImmPtr(FunctionPtr(slot.customGetter()).executableAddress()));
+ stubCall.addArgument(TrustedImmPtr(const_cast<Identifier*>(&ident)));
+ stubCall.addArgument(TrustedImmPtr(stubInfo->callReturnLocation.executableAddress()));
</ins><span class="cx"> stubCall.call();
</span><span class="cx"> } else
</span><span class="cx"> compileGetDirectOffset(protoObject, regT0, cachedOffset);
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorejitJITPropertyAccess32_64cpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/jit/JITPropertyAccess32_64.cpp (82129 => 82130)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/jit/JITPropertyAccess32_64.cpp 2011-03-28 17:10:30 UTC (rev 82129)
+++ trunk/Source/JavaScriptCore/jit/JITPropertyAccess32_64.cpp 2011-03-28 17:14:57 UTC (rev 82130)
</span><span class="lines">@@ -70,7 +70,7 @@
</span><span class="cx">
</span><span class="cx"> JITStubCall stubCall(this, cti_op_put_getter);
</span><span class="cx"> stubCall.addArgument(base);
</span><del>- stubCall.addArgument(ImmPtr(&m_codeBlock->identifier(property)));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(&m_codeBlock->identifier(property)));
</ins><span class="cx"> stubCall.addArgument(function);
</span><span class="cx"> stubCall.call();
</span><span class="cx"> }
</span><span class="lines">@@ -83,7 +83,7 @@
</span><span class="cx">
</span><span class="cx"> JITStubCall stubCall(this, cti_op_put_setter);
</span><span class="cx"> stubCall.addArgument(base);
</span><del>- stubCall.addArgument(ImmPtr(&m_codeBlock->identifier(property)));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(&m_codeBlock->identifier(property)));
</ins><span class="cx"> stubCall.addArgument(function);
</span><span class="cx"> stubCall.call();
</span><span class="cx"> }
</span><span class="lines">@@ -96,7 +96,7 @@
</span><span class="cx">
</span><span class="cx"> JITStubCall stubCall(this, cti_op_del_by_id);
</span><span class="cx"> stubCall.addArgument(base);
</span><del>- stubCall.addArgument(ImmPtr(&m_codeBlock->identifier(property)));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(&m_codeBlock->identifier(property)));
</ins><span class="cx"> stubCall.call(dst);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -155,7 +155,7 @@
</span><span class="cx">
</span><span class="cx"> JITStubCall stubCall(this, cti_op_get_by_id_generic);
</span><span class="cx"> stubCall.addArgument(base);
</span><del>- stubCall.addArgument(ImmPtr(&(m_codeBlock->identifier(ident))));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(&(m_codeBlock->identifier(ident))));
</ins><span class="cx"> stubCall.call(dst);
</span><span class="cx">
</span><span class="cx"> m_propertyAccessInstructionIndex++;
</span><span class="lines">@@ -175,7 +175,7 @@
</span><span class="cx">
</span><span class="cx"> JITStubCall stubCall(this, cti_op_put_by_id_generic);
</span><span class="cx"> stubCall.addArgument(base);
</span><del>- stubCall.addArgument(ImmPtr(&(m_codeBlock->identifier(ident))));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(&(m_codeBlock->identifier(ident))));
</ins><span class="cx"> stubCall.addArgument(value);
</span><span class="cx"> stubCall.call();
</span><span class="cx">
</span><span class="lines">@@ -213,16 +213,16 @@
</span><span class="cx">
</span><span class="cx"> BEGIN_UNINTERRUPTED_SEQUENCE(sequenceMethodCheck);
</span><span class="cx">
</span><del>- Jump structureCheck = branchPtrWithPatch(NotEqual, Address(regT0, JSCell::structureOffset()), info.structureToCompare, ImmPtr(reinterpret_cast<void*>(patchGetByIdDefaultStructure)));
- DataLabelPtr protoStructureToCompare, protoObj = moveWithPatch(ImmPtr(0), regT2);
- Jump protoStructureCheck = branchPtrWithPatch(NotEqual, Address(regT2, JSCell::structureOffset()), protoStructureToCompare, ImmPtr(reinterpret_cast<void*>(patchGetByIdDefaultStructure)));
</del><ins>+ Jump structureCheck = branchPtrWithPatch(NotEqual, Address(regT0, JSCell::structureOffset()), info.structureToCompare, TrustedImmPtr(reinterpret_cast<void*>(patchGetByIdDefaultStructure)));
+ DataLabelPtr protoStructureToCompare, protoObj = moveWithPatch(TrustedImmPtr(0), regT2);
+ Jump protoStructureCheck = branchPtrWithPatch(NotEqual, Address(regT2, JSCell::structureOffset()), protoStructureToCompare, TrustedImmPtr(reinterpret_cast<void*>(patchGetByIdDefaultStructure)));
</ins><span class="cx">
</span><span class="cx"> // This will be relinked to load the function without doing a load.
</span><del>- DataLabelPtr putFunction = moveWithPatch(ImmPtr(0), regT0);
</del><ins>+ DataLabelPtr putFunction = moveWithPatch(TrustedImmPtr(0), regT0);
</ins><span class="cx">
</span><span class="cx"> END_UNINTERRUPTED_SEQUENCE(sequenceMethodCheck);
</span><span class="cx">
</span><del>- move(Imm32(JSValue::CellTag), regT1);
</del><ins>+ move(TrustedImm32(JSValue::CellTag), regT1);
</ins><span class="cx"> Jump match = jump();
</span><span class="cx">
</span><span class="cx"> ASSERT_JIT_OFFSET(differenceBetween(info.structureToCompare, protoObj), patchOffsetMethodCheckProtoObj);
</span><span class="lines">@@ -271,7 +271,7 @@
</span><span class="cx"> {
</span><span class="cx"> JSInterfaceJIT jit;
</span><span class="cx"> JumpList failures;
</span><del>- failures.append(jit.branchPtr(NotEqual, Address(regT0), ImmPtr(globalData->jsStringVPtr)));
</del><ins>+ failures.append(jit.branchPtr(NotEqual, Address(regT0), TrustedImmPtr(globalData->jsStringVPtr)));
</ins><span class="cx"> failures.append(jit.branchTest32(NonZero, Address(regT0, OBJECT_OFFSETOF(JSString, m_fiberCount))));
</span><span class="cx">
</span><span class="cx"> // Load string length to regT1, and start the process of loading the data pointer into regT0
</span><span class="lines">@@ -285,14 +285,14 @@
</span><span class="cx"> // Load the character
</span><span class="cx"> jit.load16(BaseIndex(regT0, regT2, TimesTwo, 0), regT0);
</span><span class="cx">
</span><del>- failures.append(jit.branch32(AboveOrEqual, regT0, Imm32(0x100)));
- jit.move(ImmPtr(globalData->smallStrings.singleCharacterStrings()), regT1);
</del><ins>+ failures.append(jit.branch32(AboveOrEqual, regT0, TrustedImm32(0x100)));
+ jit.move(TrustedImmPtr(globalData->smallStrings.singleCharacterStrings()), regT1);
</ins><span class="cx"> jit.loadPtr(BaseIndex(regT1, regT0, ScalePtr, 0), regT0);
</span><del>- jit.move(Imm32(JSValue::CellTag), regT1); // We null check regT0 on return so this is safe
</del><ins>+ jit.move(TrustedImm32(JSValue::CellTag), regT1); // We null check regT0 on return so this is safe
</ins><span class="cx"> jit.ret();
</span><span class="cx">
</span><span class="cx"> failures.link(&jit);
</span><del>- jit.move(Imm32(0), regT0);
</del><ins>+ jit.move(TrustedImm32(0), regT0);
</ins><span class="cx"> jit.ret();
</span><span class="cx">
</span><span class="cx"> LinkBuffer patchBuffer(&jit, pool, 0);
</span><span class="lines">@@ -307,16 +307,16 @@
</span><span class="cx">
</span><span class="cx"> emitLoad2(base, regT1, regT0, property, regT3, regT2);
</span><span class="cx">
</span><del>- addSlowCase(branch32(NotEqual, regT3, Imm32(JSValue::Int32Tag)));
</del><ins>+ addSlowCase(branch32(NotEqual, regT3, TrustedImm32(JSValue::Int32Tag)));
</ins><span class="cx"> emitJumpSlowCaseIfNotJSCell(base, regT1);
</span><del>- addSlowCase(branchPtr(NotEqual, Address(regT0), ImmPtr(m_globalData->jsArrayVPtr)));
</del><ins>+ addSlowCase(branchPtr(NotEqual, Address(regT0), TrustedImmPtr(m_globalData->jsArrayVPtr)));
</ins><span class="cx">
</span><span class="cx"> loadPtr(Address(regT0, JSArray::storageOffset()), regT3);
</span><span class="cx"> addSlowCase(branch32(AboveOrEqual, regT2, Address(regT0, JSArray::vectorLengthOffset())));
</span><span class="cx">
</span><span class="cx"> load32(BaseIndex(regT3, regT2, TimesEight, OBJECT_OFFSETOF(ArrayStorage, m_vector[0]) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), regT1); // tag
</span><span class="cx"> load32(BaseIndex(regT3, regT2, TimesEight, OBJECT_OFFSETOF(ArrayStorage, m_vector[0]) + OBJECT_OFFSETOF(JSValue, u.asBits.payload)), regT0); // payload
</span><del>- addSlowCase(branch32(Equal, regT1, Imm32(JSValue::EmptyValueTag)));
</del><ins>+ addSlowCase(branch32(Equal, regT1, TrustedImm32(JSValue::EmptyValueTag)));
</ins><span class="cx">
</span><span class="cx"> emitStore(dst, regT1, regT0);
</span><span class="cx"> map(m_bytecodeOffset + OPCODE_LENGTH(op_get_by_val), dst, regT1, regT0);
</span><span class="lines">@@ -333,7 +333,7 @@
</span><span class="cx">
</span><span class="cx"> Jump nonCell = jump();
</span><span class="cx"> linkSlowCase(iter); // base array check
</span><del>- Jump notString = branchPtr(NotEqual, Address(regT0), ImmPtr(m_globalData->jsStringVPtr));
</del><ins>+ Jump notString = branchPtr(NotEqual, Address(regT0), TrustedImmPtr(m_globalData->jsStringVPtr));
</ins><span class="cx"> emitNakedCall(m_globalData->getCTIStub(stringGetByValStubGenerator));
</span><span class="cx"> Jump failed = branchTestPtr(Zero, regT0);
</span><span class="cx"> emitStore(dst, regT1, regT0);
</span><span class="lines">@@ -359,14 +359,14 @@
</span><span class="cx">
</span><span class="cx"> emitLoad2(base, regT1, regT0, property, regT3, regT2);
</span><span class="cx">
</span><del>- addSlowCase(branch32(NotEqual, regT3, Imm32(JSValue::Int32Tag)));
</del><ins>+ addSlowCase(branch32(NotEqual, regT3, TrustedImm32(JSValue::Int32Tag)));
</ins><span class="cx"> emitJumpSlowCaseIfNotJSCell(base, regT1);
</span><del>- addSlowCase(branchPtr(NotEqual, Address(regT0), ImmPtr(m_globalData->jsArrayVPtr)));
</del><ins>+ addSlowCase(branchPtr(NotEqual, Address(regT0), TrustedImmPtr(m_globalData->jsArrayVPtr)));
</ins><span class="cx"> addSlowCase(branch32(AboveOrEqual, regT2, Address(regT0, JSArray::vectorLengthOffset())));
</span><span class="cx">
</span><span class="cx"> loadPtr(Address(regT0, JSArray::storageOffset()), regT3);
</span><span class="cx">
</span><del>- Jump empty = branch32(Equal, BaseIndex(regT3, regT2, TimesEight, OBJECT_OFFSETOF(ArrayStorage, m_vector[0]) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), Imm32(JSValue::EmptyValueTag));
</del><ins>+ Jump empty = branch32(Equal, BaseIndex(regT3, regT2, TimesEight, OBJECT_OFFSETOF(ArrayStorage, m_vector[0]) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), TrustedImm32(JSValue::EmptyValueTag));
</ins><span class="cx">
</span><span class="cx"> Label storeResult(this);
</span><span class="cx"> emitLoad(value, regT1, regT0);
</span><span class="lines">@@ -375,10 +375,10 @@
</span><span class="cx"> Jump end = jump();
</span><span class="cx">
</span><span class="cx"> empty.link(this);
</span><del>- add32(Imm32(1), Address(regT3, OBJECT_OFFSETOF(ArrayStorage, m_numValuesInVector)));
</del><ins>+ add32(TrustedImm32(1), Address(regT3, OBJECT_OFFSETOF(ArrayStorage, m_numValuesInVector)));
</ins><span class="cx"> branch32(Below, regT2, Address(regT3, OBJECT_OFFSETOF(ArrayStorage, m_length))).linkTo(storeResult, this);
</span><span class="cx">
</span><del>- add32(Imm32(1), regT2, regT0);
</del><ins>+ add32(TrustedImm32(1), regT2, regT0);
</ins><span class="cx"> store32(regT0, Address(regT3, OBJECT_OFFSETOF(ArrayStorage, m_length)));
</span><span class="cx"> jump().linkTo(storeResult, this);
</span><span class="cx">
</span><span class="lines">@@ -429,7 +429,7 @@
</span><span class="cx"> m_propertyAccessInstructionIndex++;
</span><span class="cx">
</span><span class="cx"> DataLabelPtr structureToCompare;
</span><del>- Jump structureCheck = branchPtrWithPatch(NotEqual, Address(regT0, JSCell::structureOffset()), structureToCompare, ImmPtr(reinterpret_cast<void*>(patchGetByIdDefaultStructure)));
</del><ins>+ Jump structureCheck = branchPtrWithPatch(NotEqual, Address(regT0, JSCell::structureOffset()), structureToCompare, TrustedImmPtr(reinterpret_cast<void*>(patchGetByIdDefaultStructure)));
</ins><span class="cx"> addSlowCase(structureCheck);
</span><span class="cx"> ASSERT_JIT_OFFSET(differenceBetween(hotPathBegin, structureToCompare), patchOffsetGetByIdStructure);
</span><span class="cx"> ASSERT_JIT_OFFSET(differenceBetween(hotPathBegin, structureCheck), patchOffsetGetByIdBranchToSlowCase);
</span><span class="lines">@@ -472,7 +472,7 @@
</span><span class="cx"> #endif
</span><span class="cx"> JITStubCall stubCall(this, isMethodCheck ? cti_op_get_by_id_method_check : cti_op_get_by_id);
</span><span class="cx"> stubCall.addArgument(regT1, regT0);
</span><del>- stubCall.addArgument(ImmPtr(ident));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(ident));
</ins><span class="cx"> Call call = stubCall.call(dst);
</span><span class="cx">
</span><span class="cx"> END_UNINTERRUPTED_SEQUENCE(sequenceGetByIdSlowCase);
</span><span class="lines">@@ -505,7 +505,7 @@
</span><span class="cx">
</span><span class="cx"> // It is important that the following instruction plants a 32bit immediate, in order that it can be patched over.
</span><span class="cx"> DataLabelPtr structureToCompare;
</span><del>- addSlowCase(branchPtrWithPatch(NotEqual, Address(regT0, JSCell::structureOffset()), structureToCompare, ImmPtr(reinterpret_cast<void*>(patchGetByIdDefaultStructure))));
</del><ins>+ addSlowCase(branchPtrWithPatch(NotEqual, Address(regT0, JSCell::structureOffset()), structureToCompare, TrustedImmPtr(reinterpret_cast<void*>(patchGetByIdDefaultStructure))));
</ins><span class="cx"> ASSERT_JIT_OFFSET(differenceBetween(hotPathBegin, structureToCompare), patchOffsetPutByIdStructure);
</span><span class="cx">
</span><span class="cx"> loadPtr(Address(regT0, OBJECT_OFFSETOF(JSObject, m_propertyStorage)), regT0);
</span><span class="lines">@@ -529,7 +529,7 @@
</span><span class="cx">
</span><span class="cx"> JITStubCall stubCall(this, direct ? cti_op_put_by_id_direct : cti_op_put_by_id);
</span><span class="cx"> stubCall.addArgument(regT1, regT0);
</span><del>- stubCall.addArgument(ImmPtr(&(m_codeBlock->identifier(ident))));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(&(m_codeBlock->identifier(ident))));
</ins><span class="cx"> stubCall.addArgument(regT3, regT2);
</span><span class="cx"> Call call = stubCall.call();
</span><span class="cx">
</span><span class="lines">@@ -579,10 +579,10 @@
</span><span class="cx"> // values. In the non X86_64 case, the generated code is slightly more efficient because it uses
</span><span class="cx"> // two less instructions and doesn't require any scratch registers.
</span><span class="cx"> #if CPU(X86_64)
</span><del>- move(ImmPtr(prototype.asCell()->structure()), regT3);
</del><ins>+ move(TrustedImmPtr(prototype.asCell()->structure()), regT3);
</ins><span class="cx"> failureCases.append(branchPtr(NotEqual, AbsoluteAddress(prototype.asCell()->addressOfStructure()), regT3));
</span><span class="cx"> #else
</span><del>- failureCases.append(branchPtr(NotEqual, AbsoluteAddress(prototype.asCell()->addressOfStructure()), ImmPtr(prototype.asCell()->structure())));
</del><ins>+ failureCases.append(branchPtr(NotEqual, AbsoluteAddress(prototype.asCell()->addressOfStructure()), TrustedImmPtr(prototype.asCell()->structure())));
</ins><span class="cx"> #endif
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -591,8 +591,8 @@
</span><span class="cx"> // It is assumed that regT0 contains the basePayload and regT1 contains the baseTag. The value can be found on the stack.
</span><span class="cx">
</span><span class="cx"> JumpList failureCases;
</span><del>- failureCases.append(branch32(NotEqual, regT1, Imm32(JSValue::CellTag)));
- failureCases.append(branchPtr(NotEqual, Address(regT0, JSCell::structureOffset()), ImmPtr(oldStructure)));
</del><ins>+ failureCases.append(branch32(NotEqual, regT1, TrustedImm32(JSValue::CellTag)));
+ failureCases.append(branchPtr(NotEqual, Address(regT0, JSCell::structureOffset()), TrustedImmPtr(oldStructure)));
</ins><span class="cx"> testPrototype(oldStructure->storedPrototype(), failureCases);
</span><span class="cx">
</span><span class="cx"> if (!direct) {
</span><span class="lines">@@ -613,16 +613,16 @@
</span><span class="cx"> stubCall.skipArgument(); // base
</span><span class="cx"> stubCall.skipArgument(); // ident
</span><span class="cx"> stubCall.skipArgument(); // value
</span><del>- stubCall.addArgument(Imm32(oldStructure->propertyStorageCapacity()));
- stubCall.addArgument(Imm32(newStructure->propertyStorageCapacity()));
</del><ins>+ stubCall.addArgument(TrustedImm32(oldStructure->propertyStorageCapacity()));
+ stubCall.addArgument(TrustedImm32(newStructure->propertyStorageCapacity()));
</ins><span class="cx"> stubCall.call(regT0);
</span><span class="cx">
</span><span class="cx"> restoreReturnAddressBeforeReturn(regT3);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- sub32(Imm32(1), AbsoluteAddress(oldStructure->addressOfCount()));
- add32(Imm32(1), AbsoluteAddress(newStructure->addressOfCount()));
- storePtr(ImmPtr(newStructure), Address(regT0, JSCell::structureOffset()));
</del><ins>+ sub32(TrustedImm32(1), AbsoluteAddress(oldStructure->addressOfCount()));
+ add32(TrustedImm32(1), AbsoluteAddress(newStructure->addressOfCount()));
+ storePtr(TrustedImmPtr(newStructure), Address(regT0, JSCell::structureOffset()));
</ins><span class="cx">
</span><span class="cx"> #if CPU(MIPS)
</span><span class="cx"> // For MIPS, we don't add sizeof(void*) to the stack offset.
</span><span class="lines">@@ -717,15 +717,15 @@
</span><span class="cx"> // regT0 holds a JSCell*
</span><span class="cx">
</span><span class="cx"> // Check for array
</span><del>- Jump failureCases1 = branchPtr(NotEqual, Address(regT0), ImmPtr(m_globalData->jsArrayVPtr));
</del><ins>+ Jump failureCases1 = branchPtr(NotEqual, Address(regT0), TrustedImmPtr(m_globalData->jsArrayVPtr));
</ins><span class="cx">
</span><span class="cx"> // Checks out okay! - get the length from the storage
</span><span class="cx"> loadPtr(Address(regT0, JSArray::storageOffset()), regT2);
</span><span class="cx"> load32(Address(regT2, OBJECT_OFFSETOF(ArrayStorage, m_length)), regT2);
</span><span class="cx">
</span><del>- Jump failureCases2 = branch32(Above, regT2, Imm32(INT_MAX));
</del><ins>+ Jump failureCases2 = branch32(Above, regT2, TrustedImm32(INT_MAX));
</ins><span class="cx"> move(regT2, regT0);
</span><del>- move(Imm32(JSValue::Int32Tag), regT1);
</del><ins>+ move(TrustedImm32(JSValue::Int32Tag), regT1);
</ins><span class="cx"> Jump success = jump();
</span><span class="cx">
</span><span class="cx"> LinkBuffer patchBuffer(this, m_codeBlock->executablePool(), 0);
</span><span class="lines">@@ -764,10 +764,10 @@
</span><span class="cx"> // Check the prototype object's Structure had not changed.
</span><span class="cx"> Structure* const * prototypeStructureAddress = protoObject->addressOfStructure();
</span><span class="cx"> #if CPU(X86_64)
</span><del>- move(ImmPtr(prototypeStructure), regT3);
</del><ins>+ move(TrustedImmPtr(prototypeStructure), regT3);
</ins><span class="cx"> Jump failureCases2 = branchPtr(NotEqual, AbsoluteAddress(prototypeStructureAddress), regT3);
</span><span class="cx"> #else
</span><del>- Jump failureCases2 = branchPtr(NotEqual, AbsoluteAddress(prototypeStructureAddress), ImmPtr(prototypeStructure));
</del><ins>+ Jump failureCases2 = branchPtr(NotEqual, AbsoluteAddress(prototypeStructureAddress), TrustedImmPtr(prototypeStructure));
</ins><span class="cx"> #endif
</span><span class="cx"> bool needsStubLink = false;
</span><span class="cx"> // Checks out okay!
</span><span class="lines">@@ -777,15 +777,15 @@
</span><span class="cx"> JITStubCall stubCall(this, cti_op_get_by_id_getter_stub);
</span><span class="cx"> stubCall.addArgument(regT1);
</span><span class="cx"> stubCall.addArgument(regT0);
</span><del>- stubCall.addArgument(ImmPtr(stubInfo->callReturnLocation.executableAddress()));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(stubInfo->callReturnLocation.executableAddress()));
</ins><span class="cx"> stubCall.call();
</span><span class="cx"> } else if (slot.cachedPropertyType() == PropertySlot::Custom) {
</span><span class="cx"> needsStubLink = true;
</span><span class="cx"> JITStubCall stubCall(this, cti_op_get_by_id_custom_stub);
</span><del>- stubCall.addArgument(ImmPtr(protoObject));
- stubCall.addArgument(ImmPtr(FunctionPtr(slot.customGetter()).executableAddress()));
- stubCall.addArgument(ImmPtr(const_cast<Identifier*>(&ident)));
- stubCall.addArgument(ImmPtr(stubInfo->callReturnLocation.executableAddress()));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(protoObject));
+ stubCall.addArgument(TrustedImmPtr(FunctionPtr(slot.customGetter()).executableAddress()));
+ stubCall.addArgument(TrustedImmPtr(const_cast<Identifier*>(&ident)));
+ stubCall.addArgument(TrustedImmPtr(stubInfo->callReturnLocation.executableAddress()));
</ins><span class="cx"> stubCall.call();
</span><span class="cx"> } else
</span><span class="cx"> compileGetDirectOffset(protoObject, regT1, regT0, cachedOffset);
</span><span class="lines">@@ -834,15 +834,15 @@
</span><span class="cx"> JITStubCall stubCall(this, cti_op_get_by_id_getter_stub);
</span><span class="cx"> stubCall.addArgument(regT1);
</span><span class="cx"> stubCall.addArgument(regT0);
</span><del>- stubCall.addArgument(ImmPtr(stubInfo->callReturnLocation.executableAddress()));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(stubInfo->callReturnLocation.executableAddress()));
</ins><span class="cx"> stubCall.call();
</span><span class="cx"> } else if (slot.cachedPropertyType() == PropertySlot::Custom) {
</span><span class="cx"> needsStubLink = true;
</span><span class="cx"> JITStubCall stubCall(this, cti_op_get_by_id_custom_stub);
</span><span class="cx"> stubCall.addArgument(regT0);
</span><del>- stubCall.addArgument(ImmPtr(FunctionPtr(slot.customGetter()).executableAddress()));
- stubCall.addArgument(ImmPtr(const_cast<Identifier*>(&ident)));
- stubCall.addArgument(ImmPtr(stubInfo->callReturnLocation.executableAddress()));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(FunctionPtr(slot.customGetter()).executableAddress()));
+ stubCall.addArgument(TrustedImmPtr(const_cast<Identifier*>(&ident)));
+ stubCall.addArgument(TrustedImmPtr(stubInfo->callReturnLocation.executableAddress()));
</ins><span class="cx"> stubCall.call();
</span><span class="cx"> } else
</span><span class="cx"> compileGetDirectOffset(regT0, regT1, regT0, structure, cachedOffset);
</span><span class="lines">@@ -891,10 +891,10 @@
</span><span class="cx"> // Check the prototype object's Structure had not changed.
</span><span class="cx"> Structure* const * prototypeStructureAddress = protoObject->addressOfStructure();
</span><span class="cx"> #if CPU(X86_64)
</span><del>- move(ImmPtr(prototypeStructure), regT3);
</del><ins>+ move(TrustedImmPtr(prototypeStructure), regT3);
</ins><span class="cx"> Jump failureCases2 = branchPtr(NotEqual, AbsoluteAddress(prototypeStructureAddress), regT3);
</span><span class="cx"> #else
</span><del>- Jump failureCases2 = branchPtr(NotEqual, AbsoluteAddress(prototypeStructureAddress), ImmPtr(prototypeStructure));
</del><ins>+ Jump failureCases2 = branchPtr(NotEqual, AbsoluteAddress(prototypeStructureAddress), TrustedImmPtr(prototypeStructure));
</ins><span class="cx"> #endif
</span><span class="cx">
</span><span class="cx"> bool needsStubLink = false;
</span><span class="lines">@@ -904,15 +904,15 @@
</span><span class="cx"> JITStubCall stubCall(this, cti_op_get_by_id_getter_stub);
</span><span class="cx"> stubCall.addArgument(regT1);
</span><span class="cx"> stubCall.addArgument(regT0);
</span><del>- stubCall.addArgument(ImmPtr(stubInfo->callReturnLocation.executableAddress()));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(stubInfo->callReturnLocation.executableAddress()));
</ins><span class="cx"> stubCall.call();
</span><span class="cx"> } else if (slot.cachedPropertyType() == PropertySlot::Custom) {
</span><span class="cx"> needsStubLink = true;
</span><span class="cx"> JITStubCall stubCall(this, cti_op_get_by_id_custom_stub);
</span><del>- stubCall.addArgument(ImmPtr(protoObject));
- stubCall.addArgument(ImmPtr(FunctionPtr(slot.customGetter()).executableAddress()));
- stubCall.addArgument(ImmPtr(const_cast<Identifier*>(&ident)));
- stubCall.addArgument(ImmPtr(stubInfo->callReturnLocation.executableAddress()));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(protoObject));
+ stubCall.addArgument(TrustedImmPtr(FunctionPtr(slot.customGetter()).executableAddress()));
+ stubCall.addArgument(TrustedImmPtr(const_cast<Identifier*>(&ident)));
+ stubCall.addArgument(TrustedImmPtr(stubInfo->callReturnLocation.executableAddress()));
</ins><span class="cx"> stubCall.call();
</span><span class="cx"> } else
</span><span class="cx"> compileGetDirectOffset(protoObject, regT1, regT0, cachedOffset);
</span><span class="lines">@@ -973,15 +973,15 @@
</span><span class="cx"> JITStubCall stubCall(this, cti_op_get_by_id_getter_stub);
</span><span class="cx"> stubCall.addArgument(regT1);
</span><span class="cx"> stubCall.addArgument(regT0);
</span><del>- stubCall.addArgument(ImmPtr(stubInfo->callReturnLocation.executableAddress()));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(stubInfo->callReturnLocation.executableAddress()));
</ins><span class="cx"> stubCall.call();
</span><span class="cx"> } else if (slot.cachedPropertyType() == PropertySlot::Custom) {
</span><span class="cx"> needsStubLink = true;
</span><span class="cx"> JITStubCall stubCall(this, cti_op_get_by_id_custom_stub);
</span><del>- stubCall.addArgument(ImmPtr(protoObject));
- stubCall.addArgument(ImmPtr(FunctionPtr(slot.customGetter()).executableAddress()));
- stubCall.addArgument(ImmPtr(const_cast<Identifier*>(&ident)));
- stubCall.addArgument(ImmPtr(stubInfo->callReturnLocation.executableAddress()));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(protoObject));
+ stubCall.addArgument(TrustedImmPtr(FunctionPtr(slot.customGetter()).executableAddress()));
+ stubCall.addArgument(TrustedImmPtr(const_cast<Identifier*>(&ident)));
+ stubCall.addArgument(TrustedImmPtr(stubInfo->callReturnLocation.executableAddress()));
</ins><span class="cx"> stubCall.call();
</span><span class="cx"> } else
</span><span class="cx"> compileGetDirectOffset(protoObject, regT1, regT0, cachedOffset);
</span><span class="lines">@@ -1007,7 +1007,6 @@
</span><span class="cx">
</span><span class="cx"> // Track the stub we have created so that it will be deleted later.
</span><span class="cx"> structure->ref();
</span><del>- chain->ref();
</del><span class="cx"> prototypeStructures->list[currentIndex].set(entryLabel, structure, chain);
</span><span class="cx">
</span><span class="cx"> // Finally patch the jump to slow case back in the hot path to jump here instead.
</span><span class="lines">@@ -1043,15 +1042,15 @@
</span><span class="cx"> JITStubCall stubCall(this, cti_op_get_by_id_getter_stub);
</span><span class="cx"> stubCall.addArgument(regT1);
</span><span class="cx"> stubCall.addArgument(regT0);
</span><del>- stubCall.addArgument(ImmPtr(stubInfo->callReturnLocation.executableAddress()));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(stubInfo->callReturnLocation.executableAddress()));
</ins><span class="cx"> stubCall.call();
</span><span class="cx"> } else if (slot.cachedPropertyType() == PropertySlot::Custom) {
</span><span class="cx"> needsStubLink = true;
</span><span class="cx"> JITStubCall stubCall(this, cti_op_get_by_id_custom_stub);
</span><del>- stubCall.addArgument(ImmPtr(protoObject));
- stubCall.addArgument(ImmPtr(FunctionPtr(slot.customGetter()).executableAddress()));
- stubCall.addArgument(ImmPtr(const_cast<Identifier*>(&ident)));
- stubCall.addArgument(ImmPtr(stubInfo->callReturnLocation.executableAddress()));
</del><ins>+ stubCall.addArgument(TrustedImmPtr(protoObject));
+ stubCall.addArgument(TrustedImmPtr(FunctionPtr(slot.customGetter()).executableAddress()));
+ stubCall.addArgument(TrustedImmPtr(const_cast<Identifier*>(&ident)));
+ stubCall.addArgument(TrustedImmPtr(stubInfo->callReturnLocation.executableAddress()));
</ins><span class="cx"> stubCall.call();
</span><span class="cx"> } else
</span><span class="cx"> compileGetDirectOffset(protoObject, regT1, regT0, cachedOffset);
</span><span class="lines">@@ -1116,7 +1115,7 @@
</span><span class="cx"> loadPtr(Address(regT2, JSCell::structureOffset()), regT0);
</span><span class="cx"> addSlowCase(branchPtr(NotEqual, regT0, Address(regT1, OBJECT_OFFSETOF(JSPropertyNameIterator, m_cachedStructure))));
</span><span class="cx"> load32(addressFor(i), regT3);
</span><del>- sub32(Imm32(1), regT3);
</del><ins>+ sub32(TrustedImm32(1), regT3);
</ins><span class="cx"> addSlowCase(branch32(AboveOrEqual, regT3, Address(regT1, OBJECT_OFFSETOF(JSPropertyNameIterator, m_numCacheableSlots))));
</span><span class="cx"> compileGetDirectOffset(regT2, regT1, regT0, regT3);
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorejitJITStubCallh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/jit/JITStubCall.h (82129 => 82130)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/jit/JITStubCall.h 2011-03-28 17:10:30 UTC (rev 82129)
+++ trunk/Source/JavaScriptCore/jit/JITStubCall.h 2011-03-28 17:14:57 UTC (rev 82130)
</span><span class="lines">@@ -99,13 +99,13 @@
</span><span class="cx"> m_stackIndex += stackIndexStep;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void addArgument(JIT::Imm32 argument)
</del><ins>+ void addArgument(JIT::TrustedImm32 argument)
</ins><span class="cx"> {
</span><span class="cx"> m_jit->poke(argument, m_stackIndex);
</span><span class="cx"> m_stackIndex += stackIndexStep;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void addArgument(JIT::ImmPtr argument)
</del><ins>+ void addArgument(JIT::TrustedImmPtr argument)
</ins><span class="cx"> {
</span><span class="cx"> m_jit->poke(argument, m_stackIndex);
</span><span class="cx"> m_stackIndex += stackIndexStep;
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorejitJSInterfaceJITh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/jit/JSInterfaceJIT.h (82129 => 82130)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/jit/JSInterfaceJIT.h 2011-03-28 17:10:30 UTC (rev 82129)
+++ trunk/Source/JavaScriptCore/jit/JSInterfaceJIT.h 2011-03-28 17:14:57 UTC (rev 82130)
</span><span class="lines">@@ -202,14 +202,14 @@
</span><span class="cx"> inline JSInterfaceJIT::Jump JSInterfaceJIT::emitJumpIfNotJSCell(unsigned virtualRegisterIndex)
</span><span class="cx"> {
</span><span class="cx"> ASSERT(static_cast<int>(virtualRegisterIndex) < FirstConstantRegisterIndex);
</span><del>- return branch32(NotEqual, tagFor(virtualRegisterIndex), Imm32(JSValue::CellTag));
</del><ins>+ return branch32(NotEqual, tagFor(virtualRegisterIndex), TrustedImm32(JSValue::CellTag));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> inline JSInterfaceJIT::Jump JSInterfaceJIT::emitLoadInt32(unsigned virtualRegisterIndex, RegisterID dst)
</span><span class="cx"> {
</span><span class="cx"> ASSERT(static_cast<int>(virtualRegisterIndex) < FirstConstantRegisterIndex);
</span><span class="cx"> loadPtr(payloadFor(virtualRegisterIndex), dst);
</span><del>- return branch32(NotEqual, tagFor(static_cast<int>(virtualRegisterIndex)), Imm32(JSValue::Int32Tag));
</del><ins>+ return branch32(NotEqual, tagFor(static_cast<int>(virtualRegisterIndex)), TrustedImm32(JSValue::Int32Tag));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> inline JSInterfaceJIT::Address JSInterfaceJIT::tagFor(int virtualRegisterIndex, RegisterID base)
</span><span class="lines">@@ -238,8 +238,8 @@
</span><span class="cx"> {
</span><span class="cx"> ASSERT(static_cast<int>(virtualRegisterIndex) < FirstConstantRegisterIndex);
</span><span class="cx"> loadPtr(tagFor(virtualRegisterIndex), scratch);
</span><del>- Jump isDouble = branch32(Below, scratch, Imm32(JSValue::LowestTag));
- Jump notInt = branch32(NotEqual, scratch, Imm32(JSValue::Int32Tag));
</del><ins>+ Jump isDouble = branch32(Below, scratch, TrustedImm32(JSValue::LowestTag));
+ Jump notInt = branch32(NotEqual, scratch, TrustedImm32(JSValue::Int32Tag));
</ins><span class="cx"> loadPtr(payloadFor(virtualRegisterIndex), scratch);
</span><span class="cx"> convertInt32ToDouble(scratch, dst);
</span><span class="cx"> Jump done = jump();
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorejitSpecializedThunkJITh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/jit/SpecializedThunkJIT.h (82129 => 82130)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/jit/SpecializedThunkJIT.h 2011-03-28 17:10:30 UTC (rev 82129)
+++ trunk/Source/JavaScriptCore/jit/SpecializedThunkJIT.h 2011-03-28 17:14:57 UTC (rev 82130)
</span><span class="lines">@@ -43,7 +43,7 @@
</span><span class="cx"> , m_pool(pool)
</span><span class="cx"> {
</span><span class="cx"> // Check that we have the expected number of arguments
</span><del>- m_failures.append(branch32(NotEqual, Address(callFrameRegister, RegisterFile::ArgumentCount * (int)sizeof(Register)), Imm32(expectedArgCount + 1)));
</del><ins>+ m_failures.append(branch32(NotEqual, Address(callFrameRegister, RegisterFile::ArgumentCount * (int)sizeof(Register)), TrustedImm32(expectedArgCount + 1)));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void loadDoubleArgument(int argument, FPRegisterID dst, RegisterID scratch)
</span><span class="lines">@@ -61,7 +61,7 @@
</span><span class="cx"> void loadJSStringArgument(int argument, RegisterID dst)
</span><span class="cx"> {
</span><span class="cx"> loadCellArgument(argument, dst);
</span><del>- m_failures.append(branchPtr(NotEqual, Address(dst, 0), ImmPtr(m_globalData->jsStringVPtr)));
</del><ins>+ m_failures.append(branchPtr(NotEqual, Address(dst, 0), TrustedImmPtr(m_globalData->jsStringVPtr)));
</ins><span class="cx"> m_failures.append(branchTest32(NonZero, Address(dst, OBJECT_OFFSETOF(JSString, m_fiberCount))));
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -141,14 +141,14 @@
</span><span class="cx"> #if USE(JSVALUE64)
</span><span class="cx"> orPtr(tagTypeNumberRegister, regT0);
</span><span class="cx"> #else
</span><del>- move(Imm32(JSValue::Int32Tag), regT1);
</del><ins>+ move(TrustedImm32(JSValue::Int32Tag), regT1);
</ins><span class="cx"> #endif
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void tagReturnAsJSCell()
</span><span class="cx"> {
</span><span class="cx"> #if USE(JSVALUE32_64)
</span><del>- move(Imm32(JSValue::CellTag), regT1);
</del><ins>+ move(TrustedImm32(JSValue::CellTag), regT1);
</ins><span class="cx"> #endif
</span><span class="cx"> }
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorejitThunkGeneratorscpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/jit/ThunkGenerators.cpp (82129 => 82130)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/jit/ThunkGenerators.cpp 2011-03-28 17:10:30 UTC (rev 82129)
+++ trunk/Source/JavaScriptCore/jit/ThunkGenerators.cpp 2011-03-28 17:14:57 UTC (rev 82130)
</span><span class="lines">@@ -57,8 +57,8 @@
</span><span class="cx">
</span><span class="cx"> static void charToString(SpecializedThunkJIT& jit, JSGlobalData* globalData, MacroAssembler::RegisterID src, MacroAssembler::RegisterID dst, MacroAssembler::RegisterID scratch)
</span><span class="cx"> {
</span><del>- jit.appendFailure(jit.branch32(MacroAssembler::AboveOrEqual, src, MacroAssembler::Imm32(0x100)));
- jit.move(MacroAssembler::ImmPtr(globalData->smallStrings.singleCharacterStrings()), scratch);
</del><ins>+ jit.appendFailure(jit.branch32(MacroAssembler::AboveOrEqual, src, MacroAssembler::TrustedImm32(0x100)));
+ jit.move(MacroAssembler::TrustedImmPtr(globalData->smallStrings.singleCharacterStrings()), scratch);
</ins><span class="cx"> jit.loadPtr(MacroAssembler::BaseIndex(scratch, src, MacroAssembler::ScalePtr, 0), dst);
</span><span class="cx"> jit.appendFailure(jit.branchTestPtr(MacroAssembler::Zero, dst));
</span><span class="cx"> }
</span><span class="lines">@@ -115,16 +115,16 @@
</span><span class="cx"> jit.loadDoubleArgument(0, SpecializedThunkJIT::fpRegT0, SpecializedThunkJIT::regT0);
</span><span class="cx"> MacroAssembler::Jump nonIntExponent;
</span><span class="cx"> jit.loadInt32Argument(1, SpecializedThunkJIT::regT0, nonIntExponent);
</span><del>- jit.appendFailure(jit.branch32(MacroAssembler::LessThan, SpecializedThunkJIT::regT0, MacroAssembler::Imm32(0)));
</del><ins>+ jit.appendFailure(jit.branch32(MacroAssembler::LessThan, SpecializedThunkJIT::regT0, MacroAssembler::TrustedImm32(0)));
</ins><span class="cx">
</span><span class="cx"> MacroAssembler::Jump exponentIsZero = jit.branchTest32(MacroAssembler::Zero, SpecializedThunkJIT::regT0);
</span><span class="cx"> MacroAssembler::Label startLoop(jit.label());
</span><span class="cx">
</span><del>- MacroAssembler::Jump exponentIsEven = jit.branchTest32(MacroAssembler::Zero, SpecializedThunkJIT::regT0, MacroAssembler::Imm32(1));
</del><ins>+ MacroAssembler::Jump exponentIsEven = jit.branchTest32(MacroAssembler::Zero, SpecializedThunkJIT::regT0, MacroAssembler::TrustedImm32(1));
</ins><span class="cx"> jit.mulDouble(SpecializedThunkJIT::fpRegT0, SpecializedThunkJIT::fpRegT1);
</span><span class="cx"> exponentIsEven.link(&jit);
</span><span class="cx"> jit.mulDouble(SpecializedThunkJIT::fpRegT0, SpecializedThunkJIT::fpRegT0);
</span><del>- jit.rshift32(MacroAssembler::Imm32(1), SpecializedThunkJIT::regT0);
</del><ins>+ jit.rshift32(MacroAssembler::TrustedImm32(1), SpecializedThunkJIT::regT0);
</ins><span class="cx"> jit.branchTest32(MacroAssembler::NonZero, SpecializedThunkJIT::regT0).linkTo(startLoop, &jit);
</span><span class="cx">
</span><span class="cx"> exponentIsZero.link(&jit);
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreyarrYarrJITcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/yarr/YarrJIT.cpp (82129 => 82130)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/yarr/YarrJIT.cpp 2011-03-28 17:10:30 UTC (rev 82129)
+++ trunk/Source/JavaScriptCore/yarr/YarrJIT.cpp 2011-03-28 17:14:57 UTC (rev 82130)
</span><span class="lines">@@ -157,7 +157,7 @@
</span><span class="cx"> }
</span><span class="cx"> Jump unicodeFail;
</span><span class="cx"> if (charClass->m_matchesUnicode.size() || charClass->m_rangesUnicode.size()) {
</span><del>- Jump isAscii = branch32(LessThanOrEqual, character, Imm32(0x7f));
</del><ins>+ Jump isAscii = branch32(LessThanOrEqual, character, TrustedImm32(0x7f));
</ins><span class="cx">
</span><span class="cx"> if (charClass->m_matchesUnicode.size()) {
</span><span class="cx"> for (unsigned i = 0; i < charClass->m_matchesUnicode.size(); ++i) {
</span><span class="lines">@@ -207,9 +207,9 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if (unsigned countAZaz = matchesAZaz.size()) {
</span><del>- or32(Imm32(32), character);
</del><ins>+ or32(TrustedImm32(32), character);
</ins><span class="cx"> for (unsigned i = 0; i < countAZaz; ++i)
</span><del>- matchDest.append(branch32(Equal, character, Imm32(matchesAZaz[i])));
</del><ins>+ matchDest.append(branch32(Equal, character, TrustedImm32(matchesAZaz[i])));
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -265,14 +265,14 @@
</span><span class="cx"> poke(reg, frameLocation);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void storeToFrame(Imm32 imm, unsigned frameLocation)
</del><ins>+ void storeToFrame(TrustedImm32 imm, unsigned frameLocation)
</ins><span class="cx"> {
</span><span class="cx"> poke(imm, frameLocation);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> DataLabelPtr storeToFrameWithPatch(unsigned frameLocation)
</span><span class="cx"> {
</span><del>- return storePtrWithPatch(ImmPtr(0), Address(stackPointerRegister, frameLocation * sizeof(void*)));
</del><ins>+ return storePtrWithPatch(TrustedImmPtr(0), Address(stackPointerRegister, frameLocation * sizeof(void*)));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void loadFromFrame(unsigned frameLocation, RegisterID reg)
</span><span class="lines">@@ -1109,11 +1109,11 @@
</span><span class="cx"> if (m_term.quantityType == QuantifierGreedy) {
</span><span class="cx"> // If this is -1 we have now tested with both with and without the parens.
</span><span class="cx"> generator->loadFromFrame(parenthesesFrameLocation, indexTemporary);
</span><del>- m_backtrack.jumpToBacktrack(generator, generator->branch32(Equal, indexTemporary, Imm32(-1)));
</del><ins>+ m_backtrack.jumpToBacktrack(generator, generator->branch32(Equal, indexTemporary, TrustedImm32(-1)));
</ins><span class="cx"> } else if (m_term.quantityType == QuantifierNonGreedy) {
</span><span class="cx"> // If this is -1 we have now tested with both with and without the parens.
</span><span class="cx"> generator->loadFromFrame(parenthesesFrameLocation, indexTemporary);
</span><del>- generator->branch32(Equal, indexTemporary, Imm32(-1)).linkTo(m_nonGreedyTryParentheses, generator);
</del><ins>+ generator->branch32(Equal, indexTemporary, TrustedImm32(-1)).linkTo(m_nonGreedyTryParentheses, generator);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if (!m_doDirectBacktrack)
</span><span class="lines">@@ -1126,10 +1126,10 @@
</span><span class="cx"> m_withinBacktrackJumps.link(generator);
</span><span class="cx">
</span><span class="cx"> if (m_term.capture())
</span><del>- generator->store32(Imm32(-1), Address(output, (m_term.parentheses.subpatternId << 1) * sizeof(int)));
</del><ins>+ generator->store32(TrustedImm32(-1), Address(output, (m_term.parentheses.subpatternId << 1) * sizeof(int)));
</ins><span class="cx">
</span><span class="cx"> if (m_term.quantityType == QuantifierGreedy) {
</span><del>- generator->storeToFrame(Imm32(-1), parenthesesFrameLocation);
</del><ins>+ generator->storeToFrame(TrustedImm32(-1), parenthesesFrameLocation);
</ins><span class="cx"> generator->jump().linkTo(m_fallThrough, generator);
</span><span class="cx"> nextBacktrackFallThrough = false;
</span><span class="cx"> } else if (!nextBacktrackFallThrough)
</span><span class="lines">@@ -1271,7 +1271,7 @@
</span><span class="cx">
</span><span class="cx"> if (m_pattern.m_ignoreCase && isASCIIAlpha(ch)) {
</span><span class="cx"> readCharacter(state.inputOffset(), character);
</span><del>- or32(Imm32(32), character);
</del><ins>+ or32(TrustedImm32(32), character);
</ins><span class="cx"> state.jumpToBacktrack(this, branch32(NotEqual, character, Imm32(Unicode::toLower(ch))));
</span><span class="cx"> } else {
</span><span class="cx"> ASSERT(!m_pattern.m_ignoreCase || (Unicode::toLower(ch) == Unicode::toUpper(ch)));
</span><span class="lines">@@ -1316,13 +1316,13 @@
</span><span class="cx"> Label loop(this);
</span><span class="cx"> if (m_pattern.m_ignoreCase && isASCIIAlpha(ch)) {
</span><span class="cx"> load16(BaseIndex(input, countRegister, TimesTwo, (state.inputOffset() + term.quantityCount) * sizeof(UChar)), character);
</span><del>- or32(Imm32(32), character);
</del><ins>+ or32(TrustedImm32(32), character);
</ins><span class="cx"> state.jumpToBacktrack(this, branch32(NotEqual, character, Imm32(Unicode::toLower(ch))));
</span><span class="cx"> } else {
</span><span class="cx"> ASSERT(!m_pattern.m_ignoreCase || (Unicode::toLower(ch) == Unicode::toUpper(ch)));
</span><span class="cx"> state.jumpToBacktrack(this, branch16(NotEqual, BaseIndex(input, countRegister, TimesTwo, (state.inputOffset() + term.quantityCount) * sizeof(UChar)), Imm32(ch)));
</span><span class="cx"> }
</span><del>- add32(Imm32(1), countRegister);
</del><ins>+ add32(TrustedImm32(1), countRegister);
</ins><span class="cx"> branch32(NotEqual, countRegister, index).linkTo(loop, this);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1333,22 +1333,22 @@
</span><span class="cx"> PatternTerm& term = state.term();
</span><span class="cx"> UChar ch = term.patternCharacter;
</span><span class="cx">
</span><del>- move(Imm32(0), countRegister);
</del><ins>+ move(TrustedImm32(0), countRegister);
</ins><span class="cx">
</span><span class="cx"> JumpList failures;
</span><span class="cx"> Label loop(this);
</span><span class="cx"> failures.append(atEndOfInput());
</span><span class="cx"> if (m_pattern.m_ignoreCase && isASCIIAlpha(ch)) {
</span><span class="cx"> readCharacter(state.inputOffset(), character);
</span><del>- or32(Imm32(32), character);
</del><ins>+ or32(TrustedImm32(32), character);
</ins><span class="cx"> failures.append(branch32(NotEqual, character, Imm32(Unicode::toLower(ch))));
</span><span class="cx"> } else {
</span><span class="cx"> ASSERT(!m_pattern.m_ignoreCase || (Unicode::toLower(ch) == Unicode::toUpper(ch)));
</span><span class="cx"> failures.append(jumpIfCharNotEquals(ch, state.inputOffset()));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- add32(Imm32(1), countRegister);
- add32(Imm32(1), index);
</del><ins>+ add32(TrustedImm32(1), countRegister);
+ add32(TrustedImm32(1), index);
</ins><span class="cx"> if (term.quantityCount != quantifyInfinite) {
</span><span class="cx"> branch32(NotEqual, countRegister, Imm32(term.quantityCount)).linkTo(loop, this);
</span><span class="cx"> failures.append(jump());
</span><span class="lines">@@ -1358,8 +1358,8 @@
</span><span class="cx"> Label backtrackBegin(this);
</span><span class="cx"> loadFromFrame(term.frameLocation, countRegister);
</span><span class="cx"> state.jumpToBacktrack(this, branchTest32(Zero, countRegister));
</span><del>- sub32(Imm32(1), countRegister);
- sub32(Imm32(1), index);
</del><ins>+ sub32(TrustedImm32(1), countRegister);
+ sub32(TrustedImm32(1), index);
</ins><span class="cx">
</span><span class="cx"> failures.link(this);
</span><span class="cx">
</span><span class="lines">@@ -1375,7 +1375,7 @@
</span><span class="cx"> PatternTerm& term = state.term();
</span><span class="cx"> UChar ch = term.patternCharacter;
</span><span class="cx">
</span><del>- move(Imm32(0), countRegister);
</del><ins>+ move(TrustedImm32(0), countRegister);
</ins><span class="cx">
</span><span class="cx"> Jump firstTimeDoNothing = jump();
</span><span class="cx">
</span><span class="lines">@@ -1391,15 +1391,15 @@
</span><span class="cx"> branch32(Equal, countRegister, Imm32(term.quantityCount), hardFail);
</span><span class="cx"> if (m_pattern.m_ignoreCase && isASCIIAlpha(ch)) {
</span><span class="cx"> readCharacter(state.inputOffset(), character);
</span><del>- or32(Imm32(32), character);
</del><ins>+ or32(TrustedImm32(32), character);
</ins><span class="cx"> branch32(NotEqual, character, Imm32(Unicode::toLower(ch))).linkTo(hardFail, this);
</span><span class="cx"> } else {
</span><span class="cx"> ASSERT(!m_pattern.m_ignoreCase || (Unicode::toLower(ch) == Unicode::toUpper(ch)));
</span><span class="cx"> jumpIfCharNotEquals(ch, state.inputOffset()).linkTo(hardFail, this);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- add32(Imm32(1), countRegister);
- add32(Imm32(1), index);
</del><ins>+ add32(TrustedImm32(1), countRegister);
+ add32(TrustedImm32(1), index);
</ins><span class="cx">
</span><span class="cx"> firstTimeDoNothing.link(this);
</span><span class="cx"> storeToFrame(countRegister, term.frameLocation);
</span><span class="lines">@@ -1445,7 +1445,7 @@
</span><span class="cx"> matchDest.link(this);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- add32(Imm32(1), countRegister);
</del><ins>+ add32(TrustedImm32(1), countRegister);
</ins><span class="cx"> branch32(NotEqual, countRegister, index).linkTo(loop, this);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1455,7 +1455,7 @@
</span><span class="cx"> const RegisterID countRegister = regT1;
</span><span class="cx"> PatternTerm& term = state.term();
</span><span class="cx">
</span><del>- move(Imm32(0), countRegister);
</del><ins>+ move(TrustedImm32(0), countRegister);
</ins><span class="cx">
</span><span class="cx"> JumpList failures;
</span><span class="cx"> Label loop(this);
</span><span class="lines">@@ -1472,8 +1472,8 @@
</span><span class="cx"> matchDest.link(this);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- add32(Imm32(1), countRegister);
- add32(Imm32(1), index);
</del><ins>+ add32(TrustedImm32(1), countRegister);
+ add32(TrustedImm32(1), index);
</ins><span class="cx"> if (term.quantityCount != quantifyInfinite) {
</span><span class="cx"> branch32(NotEqual, countRegister, Imm32(term.quantityCount)).linkTo(loop, this);
</span><span class="cx"> failures.append(jump());
</span><span class="lines">@@ -1483,8 +1483,8 @@
</span><span class="cx"> Label backtrackBegin(this);
</span><span class="cx"> loadFromFrame(term.frameLocation, countRegister);
</span><span class="cx"> state.jumpToBacktrack(this, branchTest32(Zero, countRegister));
</span><del>- sub32(Imm32(1), countRegister);
- sub32(Imm32(1), index);
</del><ins>+ sub32(TrustedImm32(1), countRegister);
+ sub32(TrustedImm32(1), index);
</ins><span class="cx">
</span><span class="cx"> failures.link(this);
</span><span class="cx">
</span><span class="lines">@@ -1499,7 +1499,7 @@
</span><span class="cx"> const RegisterID countRegister = regT1;
</span><span class="cx"> PatternTerm& term = state.term();
</span><span class="cx">
</span><del>- move(Imm32(0), countRegister);
</del><ins>+ move(TrustedImm32(0), countRegister);
</ins><span class="cx">
</span><span class="cx"> Jump firstTimeDoNothing = jump();
</span><span class="cx">
</span><span class="lines">@@ -1524,8 +1524,8 @@
</span><span class="cx"> matchDest.link(this);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- add32(Imm32(1), countRegister);
- add32(Imm32(1), index);
</del><ins>+ add32(TrustedImm32(1), countRegister);
+ add32(TrustedImm32(1), index);
</ins><span class="cx">
</span><span class="cx"> firstTimeDoNothing.link(this);
</span><span class="cx"> storeToFrame(countRegister, term.frameLocation);
</span><span class="lines">@@ -1669,7 +1669,7 @@
</span><span class="cx"> if (term.quantityType == QuantifierGreedy)
</span><span class="cx"> storeToFrame(index, parenthesesFrameLocation);
</span><span class="cx"> else if (term.quantityType == QuantifierNonGreedy) {
</span><del>- storeToFrame(Imm32(-1), parenthesesFrameLocation);
</del><ins>+ storeToFrame(TrustedImm32(-1), parenthesesFrameLocation);
</ins><span class="cx"> nonGreedySkipParentheses = jump();
</span><span class="cx"> nonGreedyTryParentheses = label();
</span><span class="cx"> storeToFrame(index, parenthesesFrameLocation);
</span><span class="lines">@@ -2140,7 +2140,7 @@
</span><span class="cx"> if (m_pattern.m_body->m_callFrameSize)
</span><span class="cx"> addPtr(Imm32(m_pattern.m_body->m_callFrameSize * sizeof(void*)), stackPointerRegister);
</span><span class="cx">
</span><del>- move(Imm32(-1), returnRegister);
</del><ins>+ move(TrustedImm32(-1), returnRegister);
</ins><span class="cx">
</span><span class="cx"> generateReturn();
</span><span class="cx">
</span></span></pre>
</div>
</div>
</body>
</html>