Add tracking of endColumn for Executables.
https://bugs.webkit.org/show_bug.cgi?id=124245.

Reviewed by Geoffrey Garen.

Source/JavaScriptCore: 

1. Fixed computation of columns to take into account the startColumn from
   <script> tags. Previously, we were only computing the column relative
   to the char after the <script> tag. Now, the column number that JSC
   computes is always the column number you'll see when viewing the source
   in a text editor (assuming the first column position is 1, not 0).

2. Previously, unlinkedExecutables kept the a base-1 startColumn for
   ProgramExecutables and EvalExecutables, but uses base-0 columns for
   FunctionExecutables. This has been fixed so that they all use base-0
   columns. When the executable gets linked, the column is adjusted into
   a base-1 value.

3. In the UnlinkedFunctionExecutable, renamed m_functionStartOffset to
   m_unlinkedFunctionNameStart because it actually points to the start
   column in the name part of the function declaration.

   Similarly, renamed m_functionStartColumn to m_unlinkedBodyStartColumn
   because it points to the first character in the function body. This is
   usually '{' except for functions created from "global code" which
   excludes its braces. See FunctionExecutable::fromGlobalCode().

       The exclusion of braces for the global code case is needed so that
   computed start and end columns will more readily map to what a JS
   developer would expect them to be. Otherwise, the first column of the
   function source will not be 1 (includes prepended characters added in
   constructFunctionSkippingEvalEnabledCheck()).

   Also, similarly, a m_unlinkedBodyEndColumn has been added to track the
   end column of the UnlinkedFunctionExecutable.

4. For unlinked executables, end column values are either:
   a. Relative to the start of the last line if (last line != first line).
   b. Relative to the start column position if (last line == first line).

   The second case is needed so that we can add an appropriate adjustment
   to the end column value (just like we do for the start column) when we
   link the executable.

5. This is not new to this patch, but it worth noting that the lineCount
   values used through this patch has the following meaning:
   - a lineCount of 0 means the source for this code block is on 1 line.
   - a lineCount of N means there are N + l lines of source.

   This interpretation is janky, but was present before this patch. We can
   clean that up later in another patch.


* JavaScriptCore.xcodeproj/project.pbxproj:
- In order to implement WebCore::Internals::parserMetaData(), we need to
  move some seemingly unrelated header files from the Project section to
  the Private section so that they can be #include'd by the forwarding
  CodeBlock.h from WebCore.
* bytecode/CodeBlock.cpp:
(JSC::CodeBlock::sourceCodeForTools):
(JSC::CodeBlock::CodeBlock):
* bytecode/UnlinkedCodeBlock.cpp:
(JSC::generateFunctionCodeBlock):
(JSC::UnlinkedFunctionExecutable::UnlinkedFunctionExecutable):
- m_isFromGlobalCode is needed to support the exclusion of the open brace /
  prepended code for functions created from "global code".
(JSC::UnlinkedFunctionExecutable::link):
(JSC::UnlinkedFunctionExecutable::fromGlobalCode):
(JSC::UnlinkedCodeBlock::UnlinkedCodeBlock):
* bytecode/UnlinkedCodeBlock.h:
(JSC::UnlinkedFunctionExecutable::create):
(JSC::UnlinkedFunctionExecutable::unlinkedFunctionNameStart):
(JSC::UnlinkedFunctionExecutable::unlinkedBodyStartColumn):
(JSC::UnlinkedFunctionExecutable::unlinkedBodyEndColumn):
(JSC::UnlinkedFunctionExecutable::recordParse):
(JSC::UnlinkedCodeBlock::recordParse):
(JSC::UnlinkedCodeBlock::endColumn):
* bytecompiler/NodesCodegen.cpp:
(JSC::FunctionBodyNode::emitBytecode):
* parser/ASTBuilder.h:
(JSC::ASTBuilder::createFunctionBody):
(JSC::ASTBuilder::setFunctionNameStart):
* parser/Lexer.cpp:
(JSC::::shiftLineTerminator):
- Removed an unused SourceCode Lexer<T>::sourceCode() function.
* parser/Lexer.h:
(JSC::Lexer::positionBeforeLastNewline):
(JSC::Lexer::prevTerminator):
- Added tracking of m_positionBeforeLastNewline in the Lexer to enable us
  to exclude the close brace / appended code for functions created from "global
  code".
* parser/Nodes.cpp:
(JSC::ProgramNode::ProgramNode):
(JSC::ProgramNode::create):
(JSC::EvalNode::EvalNode):
(JSC::EvalNode::create):
(JSC::FunctionBodyNode::FunctionBodyNode):
(JSC::FunctionBodyNode::create):
(JSC::FunctionBodyNode::setEndPosition):
- setEndPosition() is needed to fixed up the end position so that we can
  exclude the close brace / appended code for functions created from "global
  code".
* parser/Nodes.h:
(JSC::ProgramNode::startColumn):
(JSC::ProgramNode::endColumn):
(JSC::EvalNode::startColumn):
(JSC::EvalNode::endColumn):
(JSC::FunctionBodyNode::setFunctionNameStart):
(JSC::FunctionBodyNode::functionNameStart):
(JSC::FunctionBodyNode::endColumn):
* parser/Parser.cpp:
(JSC::::parseFunctionBody):
(JSC::::parseFunctionInfo):
* parser/Parser.h:
(JSC::Parser::positionBeforeLastNewline):
(JSC::::parse):
- Subtracted 1 from startColumn here to keep the node column values consistently
  base-0. See note 2 above.
(JSC::parse):
* parser/SourceProviderCacheItem.h:
(JSC::SourceProviderCacheItem::SourceProviderCacheItem):
* parser/SyntaxChecker.h:
(JSC::SyntaxChecker::createFunctionBody):
(JSC::SyntaxChecker::setFunctionNameStart):
* runtime/CodeCache.cpp:
(JSC::CodeCache::getGlobalCodeBlock):
(JSC::CodeCache::getProgramCodeBlock):
(JSC::CodeCache::getEvalCodeBlock):
(JSC::CodeCache::getFunctionExecutableFromGlobalCode):
* runtime/CodeCache.h:
* runtime/Executable.cpp:
(JSC::ScriptExecutable::newCodeBlockFor):
(JSC::FunctionExecutable::FunctionExecutable):
(JSC::ProgramExecutable::initializeGlobalProperties):
(JSC::FunctionExecutable::fromGlobalCode):
* runtime/Executable.h:
(JSC::ExecutableBase::isEvalExecutable):
(JSC::ExecutableBase::isProgramExecutable):
(JSC::ScriptExecutable::ScriptExecutable):
(JSC::ScriptExecutable::endColumn):
(JSC::ScriptExecutable::recordParse):
(JSC::FunctionExecutable::create):
(JSC::FunctionExecutable::bodyIncludesBraces):
* runtime/FunctionConstructor.cpp:
(JSC::constructFunctionSkippingEvalEnabledCheck):
* runtime/FunctionPrototype.cpp:
(JSC::insertSemicolonIfNeeded):
(JSC::functionProtoFuncToString):
* runtime/JSGlobalObject.cpp:
(JSC::JSGlobalObject::createProgramCodeBlock):
(JSC::JSGlobalObject::createEvalCodeBlock):

Source/WebCore: 

Test: js/dom/script-start-end-locations.html

* ForwardingHeaders/bytecode: Added.
* ForwardingHeaders/bytecode/CodeBlock.h: Added.
* WebCore.exp.in:
* testing/Internals.cpp:
(WebCore::GetCallerCodeBlockFunctor::GetCallerCodeBlockFunctor):
(WebCore::GetCallerCodeBlockFunctor::operator()):
(WebCore::GetCallerCodeBlockFunctor::codeBlock):
(WebCore::Internals::parserMetaData):
* testing/Internals.h:
* testing/Internals.idl:

Source/WebKit: 

* WebKit.vcxproj/WebKitExportGenerator/WebKitExports.def.in:
- Added an exported symbol to make the Win32 build happy. The Win64 symbol
  is currently a copy of the Win32 one. It'll need to be updated if the
  mangled symbol is different for Win64.

LayoutTests: 

* fast/events/window-onerror2-expected.txt:
* inspector-protocol/debugger/setBreakpoint-actions-expected.txt:
* js/dom/script-start-end-locations-expected.txt: Added.
* js/dom/script-start-end-locations.html: Added.
* js/dom/script-tests/script-start-end-locations.js: Added.
* js/dom/stack-trace-expected.txt:
* js/dom/stack-trace.html:
- Changed tabs to spaces. The tabs were making it hard to visually confirm
  the exected column values for 2 functions.



git-svn-id: http://svn.webkit.org/repository/webkit/trunk@159520 268f45cc-cd09-0410-ab3c-d52691b4dbfc
REGRESSION (r159395): Error compiling for ARMv7
https://bugs.webkit.org/show_bug.cgi?id=124552

Reviewed by Geoffrey Garen.

Fixed the implementation of branch8(RelationalCondition cond, AbsoluteAddress address, TrustedImm32 right)
to materialize and use address similar to other ARMv7 branchXX() functions.

* assembler/MacroAssemblerARMv7.h:
(JSC::MacroAssemblerARMv7::branch8):


git-svn-id: http://svn.webkit.org/repository/webkit/trunk@159521 268f45cc-cd09-0410-ab3c-d52691b4dbfc
<rdar://problem/15139479> Reenable the JSC Objective-C API tests on Mountain Lion once the bots are running Xcode 5

Rubber-stamped by Mark Rowe.

Reverted r156840.

* TestWebKitAPI/Tests/mac/WebViewDidCreateJavaScriptContext.mm:



git-svn-id: http://svn.webkit.org/repository/webkit/trunk@159522 268f45cc-cd09-0410-ab3c-d52691b4dbfc
Web Speech API crashes onboundary event handling with reload
https://bugs.webkit.org/show_bug.cgi?id=124607

Reviewed by Tim Horton.

If the page goes away, we need to cleanup the Mac platform synthesizer object, because
NSSpeechSynthesizer is retained elsewhere to handle the callbacks (so it doesn't automatically
get torn down).

The layout tests for speech rely on a Mock synthesizer, so there is no good way to test this
Mac platform specific behavior.       

* platform/mac/PlatformSpeechSynthesizerMac.mm:
(-[WebSpeechSynthesisWrapper invalidate]):
(WebCore::PlatformSpeechSynthesizer::~PlatformSpeechSynthesizer):



git-svn-id: http://svn.webkit.org/repository/webkit/trunk@159523 268f45cc-cd09-0410-ab3c-d52691b4dbfc
[Mac] 9 WebGL conformance failures after r159518.
https://bugs.webkit.org/show_bug.cgi?id=124608

Reviewed by Dean Jackson.

Once we removed the CIImage drawing path, there was no longer any reason to flip the
CGImageRef before drawing to the provided GraphicsContext.

* platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.mm:
(WebCore::MediaPlayerPrivateAVFoundationObjC::paintWithVideoOutput):

git-svn-id: http://svn.webkit.org/repository/webkit/trunk@159525 268f45cc-cd09-0410-ab3c-d52691b4dbfc
[CSS Shapes] Parse [<box> || <shape>] values
https://bugs.webkit.org/show_bug.cgi?id=124426

Reviewed by Dirk Schulze.

Source/WebCore:

Shape values can now have an optional box specifying the coordinate sytem to use
for sizing and positioning the shape. This patch adds the functionality to support
parsing these new values.

* css/BasicShapeFunctions.cpp:
(WebCore::valueForBox): Added function to convert between BasicShape::ReferenceBox
and CSSPrimitiveValue (which wraps a CSSValueID).
(WebCore::boxForValue): Ditto.
(WebCore::valueForBasicShape): Translations between CSSBasicShape and BasicShape
must now include the reference box.
(WebCore::basicShapeForValue): Ditto.
* css/BasicShapeFunctions.h:
* css/CSSBasicShapes.cpp:
(WebCore::buildRectangleString): Include the box in the built CSS string.
(WebCore::CSSBasicShapeRectangle::cssText): Ditto.
(WebCore::CSSBasicShapeRectangle::equals): Include the box in comparisions.
(WebCore::buildCircleString):
(WebCore::CSSBasicShapeCircle::cssText):
(WebCore::CSSBasicShapeCircle::equals):
(WebCore::buildEllipseString):
(WebCore::CSSBasicShapeEllipse::cssText):
(WebCore::CSSBasicShapeEllipse::equals):
(WebCore::buildPolygonString):
(WebCore::CSSBasicShapePolygon::cssText):
(WebCore::CSSBasicShapePolygon::equals):
(WebCore::buildInsetRectangleString):
(WebCore::CSSBasicShapeInsetRectangle::cssText):
(WebCore::CSSBasicShapeInsetRectangle::equals):
* css/CSSBasicShapes.h:
(WebCore::CSSBasicShape::box): BasicShapes now have an reference box.
(WebCore::CSSBasicShape::setBox): Ditto.
* css/CSSComputedStyleDeclaration.cpp:
(WebCore::ComputedStyleExtractor::propertyValue): Shape-inside can also
parse the box values.
* css/CSSParser.cpp:
(WebCore::CSSParser::parseValue): The shape properties use parseShapeProperty,
while minor adjustments were made to parseBasicShape's return type.
(WebCore::isBoxValue): Is the CSSValueID one of  the box values.
(WebCore::CSSParser::parseShapeProperty): Parse one of the shape properties
and return an appropriate CSSValue.
(WebCore::CSSParser::parseBasicShape): Return a CSSBasicShape rather than
adding a ShapeValue to the style.
* css/CSSParser.h:
* rendering/style/BasicShapes.h:
(WebCore::BasicShape::box): Add a box to BasicShape and getters/setters.
(WebCore::BasicShape::setBox): Ditto.
(WebCore::BasicShape::BasicShape): Ditto.

LayoutTests:

Test that <box> <shape> and <shape> <box> values are both supported and successfully parsed.
Currently, we order the parsed result as <shape> <box> when the value is output through
the CSSOM. Also test that other combinations with shapes and boxes are not parsed.

* fast/shapes/parsing/parsing-shape-inside-expected.txt:
* fast/shapes/parsing/parsing-shape-inside.html:
* fast/shapes/parsing/parsing-shape-outside-expected.txt:
* fast/shapes/parsing/parsing-shape-outside.html:
* fast/shapes/parsing/parsing-test-utils.js:


git-svn-id: http://svn.webkit.org/repository/webkit/trunk@159526 268f45cc-cd09-0410-ab3c-d52691b4dbfc
Rename WatchpointSet::notifyWrite() should be renamed to WatchpointSet::fireAll()
https://bugs.webkit.org/show_bug.cgi?id=124609

Source/JavaScriptCore: 

Rubber stamped by Mark Lam.
        
notifyWrite() is a thing that SymbolTable does. WatchpointSet uses that terminology
because it was original designed to match exactly SymbolTable's semantics. But now
it's a confusing term.

* bytecode/Watchpoint.cpp:
(JSC::WatchpointSet::fireAllSlow):
* bytecode/Watchpoint.h:
(JSC::WatchpointSet::fireAll):
(JSC::InlineWatchpointSet::fireAll):
* interpreter/Interpreter.cpp:
(JSC::Interpreter::execute):
* runtime/JSFunction.cpp:
(JSC::JSFunction::put):
(JSC::JSFunction::defineOwnProperty):
* runtime/JSGlobalObject.cpp:
(JSC::JSGlobalObject::haveABadTime):
* runtime/Structure.h:
(JSC::Structure::notifyTransitionFromThisStructure):
* runtime/SymbolTable.cpp:
(JSC::SymbolTableEntry::notifyWriteSlow):

Source/WebCore: 

Rubber stamped by Mark Lam.

No new tests because no new behavior.

* bindings/scripts/CodeGeneratorJS.pm:
(GenerateHeader):
* bindings/scripts/test/JS/JSTestEventTarget.h:
(WebCore::JSTestEventTarget::create):



git-svn-id: http://svn.webkit.org/repository/webkit/trunk@159528 268f45cc-cd09-0410-ab3c-d52691b4dbfc
Unreviewed, rolling out r159459.
http://trac.webkit.org/changeset/159459
https://bugs.webkit.org/show_bug.cgi?id=124616

tons of assertions on launch (Requested by thorton on
#webkit).

* API/JSContext.mm:
(-[JSContext setException:]):
(-[JSContext wrapperForObjCObject:]):
(-[JSContext wrapperForJSObject:]):
* API/JSContextRef.cpp:
(JSContextGroupRelease):
(JSGlobalContextRelease):
* API/JSManagedValue.mm:
(-[JSManagedValue initWithValue:]):
(-[JSManagedValue value]):
* API/JSObjectRef.cpp:
(JSObjectIsFunction):
(JSObjectCopyPropertyNames):
* API/JSValue.mm:
(containerValueToObject):
* API/JSWrapperMap.mm:
(tryUnwrapObjcObject):

git-svn-id: http://svn.webkit.org/repository/webkit/trunk@159531 268f45cc-cd09-0410-ab3c-d52691b4dbfc
REGRESSION(158384) ARMv7 point checks too restrictive for native calls to traditional ARM code
https://bugs.webkit.org/show_bug.cgi?id=124612

Reviewed by Geoffrey Garen.

Removed ASSERT checks (i.e. lower bit set) for ARM Thumb2 destination addresses related to
calls since we are calling native ARM traditional functions like sin() and cos().

* assembler/ARMv7Assembler.h:
(JSC::ARMv7Assembler::linkCall):
(JSC::ARMv7Assembler::relinkCall):
* assembler/MacroAssemblerCodeRef.h:


git-svn-id: http://svn.webkit.org/repository/webkit/trunk@159532 268f45cc-cd09-0410-ab3c-d52691b4dbfc
Update ANGLE sources.
https://bugs.webkit.org/show_bug.cgi?id=124615.

Reviewed by Dean Jackson.

Tests covered by Khronos WebGL conformance tests.

Update ANGLE to checkout a60e0805721f62c28a55faf2df74472cc5fc91fc.
Modify xcodeproj files as necessary, update plist.
Stop using DerivedSources.make and just use the generated sources that are checked into ANGLE.
Add a note to bison generated files indicating that Apple elects to distribute said files under the BSD license: 
ExpressionParser.cpp, glslang_tab.cpp, glslang_tab.h.

* ANGLE.plist:
* ANGLE.xcodeproj/project.pbxproj:
* DerivedSources.make: Removed.
* platform/graphics/ANGLEWebKitBridge.cpp: Resolve a build error that resulted from updating ANGLE.
(WebCore::getSymbolInfo):
(WebCore::ANGLEWebKitBridge::compileShaderSource):
* include/EGL/egl.h:
* include/EGL/eglsoftlinking.h: Removed.
* include/GLES2/gl2.h:
* include/GLES2/gl2softlinking.h: Removed.
* include/GLSLANG/ShaderLang.h:
* include/KHR/khrplatform.h:
* src/ANGLE.sln: Added.
* src/build_angle.gypi:
* src/common/debug.h:
* src/common/event_tracer.cpp: Added.
(gl::TraceGetTraceCategoryEnabledFlag):
(gl::TraceAddTraceEvent):
* src/common/event_tracer.h: Added.
* src/common/version.h:
* src/compiler/CodeGen.cpp: Added.
(ConstructCompiler):
(DeleteCompiler):
* src/compiler/CodeGenGLSL.cpp: Removed.
* src/compiler/CodeGenHLSL.cpp: Removed.
* src/compiler/Common.h:
(NewPoolTString):
* src/compiler/Compiler.cpp:
(TCompiler::Init):
(TCompiler::compile):
(TCompiler::InitBuiltInSymbolTable):
(TCompiler::clearResults):
(TCompiler::collectVariables):
* src/compiler/ConstantUnion.h:
* src/compiler/DetectDiscontinuity.cpp:
* src/compiler/InfoSink.h:
* src/compiler/InitializeDll.cpp:
(InitProcess):
(DetachProcess):
* src/compiler/InitializeDll.h:
* src/compiler/InitializeGLPosition.cpp: Added.
(InitializeGLPosition::visitAggregate):
(InitializeGLPosition::insertCode):
* src/compiler/InitializeGLPosition.h: Added.
(InitializeGLPosition::InitializeGLPosition):
(InitializeGLPosition::visitBinary):
(InitializeGLPosition::visitUnary):
(InitializeGLPosition::visitSelection):
(InitializeGLPosition::visitLoop):
(InitializeGLPosition::visitBranch):
* src/compiler/InitializeGlobals.h:
* src/compiler/InitializeParseContext.cpp:
(InitializeParseContextIndex):
(FreeParseContextIndex):
(SetGlobalParseContext):
(GetGlobalParseContext):
* src/compiler/InitializeParseContext.h:
* src/compiler/IntermTraverse.cpp:
(TIntermSymbol::traverse):
(TIntermConstantUnion::traverse):
(TIntermBinary::traverse):
(TIntermUnary::traverse):
(TIntermAggregate::traverse):
(TIntermSelection::traverse):
(TIntermLoop::traverse):
(TIntermBranch::traverse):
* src/compiler/Intermediate.cpp:
(GetHigherPrecision):
(getOperatorString):
(TIntermLoop::replaceChildNode):
(TIntermBranch::replaceChildNode):
(TIntermBinary::replaceChildNode):
(TIntermUnary::replaceChildNode):
(TIntermAggregate::replaceChildNode):
(TIntermSelection::replaceChildNode):
(TIntermOperator::isAssignment):
(TIntermediate::promoteConstantUnion):
* src/compiler/MapLongVariableNames.cpp:
* src/compiler/MapLongVariableNames.h:
* src/compiler/NodeSearch.h: Added.
(sh::NodeSearchTraverser::NodeSearchTraverser):
(sh::NodeSearchTraverser::found):
(sh::NodeSearchTraverser::search):
(sh::FindDiscard::visitBranch):
(sh::FindSideEffectRewriting::visitBinary):
* src/compiler/OutputGLSLBase.cpp:
(TOutputGLSLBase::visitSelection):
(TOutputGLSLBase::visitAggregate):
(TOutputGLSLBase::visitLoop):
* src/compiler/OutputGLSLBase.h:
* src/compiler/OutputHLSL.cpp:
(sh::OutputHLSL::OutputHLSL):
(sh::OutputHLSL::header):
(sh::OutputHLSL::visitBinary):
(sh::OutputHLSL::visitSelection):
(sh::OutputHLSL::visitBranch):
(sh::OutputHLSL::handleExcessiveLoop):
(sh::OutputHLSL::addConstructor):
* src/compiler/OutputHLSL.h:
* src/compiler/ParseContext.cpp: Added.
(TParseContext::parseVectorFields):
(TParseContext::parseMatrixFields):
(TParseContext::recover):
(TParseContext::error):
(TParseContext::warning):
(TParseContext::trace):
(TParseContext::assignError):
(TParseContext::unaryOpError):
(TParseContext::binaryOpError):
(TParseContext::precisionErrorCheck):
(TParseContext::lValueErrorCheck):
(TParseContext::constErrorCheck):
(TParseContext::integerErrorCheck):
(TParseContext::globalErrorCheck):
(TParseContext::reservedErrorCheck):
(TParseContext::constructorErrorCheck):
(TParseContext::voidErrorCheck):
(TParseContext::boolErrorCheck):
(TParseContext::samplerErrorCheck):
(TParseContext::structQualifierErrorCheck):
(TParseContext::parameterSamplerErrorCheck):
(TParseContext::containsSampler):
(TParseContext::arraySizeErrorCheck):
(TParseContext::arrayQualifierErrorCheck):
(TParseContext::arrayTypeErrorCheck):
(TParseContext::arrayErrorCheck):
(TParseContext::nonInitConstErrorCheck):
(TParseContext::nonInitErrorCheck):
(TParseContext::paramErrorCheck):
(TParseContext::extensionErrorCheck):
(TParseContext::supportsExtension):
(TParseContext::isExtensionEnabled):
(TParseContext::findFunction):
(TParseContext::executeInitializer):
(TParseContext::areAllChildConst):
(TParseContext::addConstructor):
(TParseContext::foldConstConstructor):
(TParseContext::constructBuiltIn):
(TParseContext::constructStruct):
(TParseContext::addConstVectorNode):
(TParseContext::addConstMatrixNode):
(TParseContext::addConstArrayNode):
(TParseContext::addConstStruct):
(TParseContext::enterStructDeclaration):
(TParseContext::exitStructDeclaration):
(TParseContext::structNestingErrorCheck):
(TParseContext::addIndexExpression):
(PaParseStrings):
* src/compiler/ParseContext.h: Added.
(TParseContext::TParseContext):
(TParseContext::numErrors):
(TParseContext::infoSink):
(TParseContext::pragma):
(TParseContext::extensionBehavior):
* src/compiler/ParseHelper.cpp: Removed.
* src/compiler/ParseHelper.h: Removed.
* src/compiler/PoolAlloc.cpp:
(InitializePoolIndex):
(FreePoolIndex):
(GetGlobalPoolAllocator):
(SetGlobalPoolAllocator):
* src/compiler/PoolAlloc.h:
(pool_allocator::pool_allocator):
* src/compiler/SearchSymbol.h:
* src/compiler/ShHandle.h:
(TCompiler::getVaryings):
* src/compiler/ShaderLang.cpp:
(checkVariableMaxLengths):
(ShInitialize):
(ShFinalize):
(ShConstructCompiler):
(ShCompile):
(ShGetInfo):
(ShGetVariableInfo):
(ShCheckVariablesWithinPackingLimits):
* src/compiler/SymbolTable.cpp:
(TSymbolTable::~TSymbolTable):
* src/compiler/SymbolTable.h:
(TSymbol::TSymbol):
(TSymbolTableLevel::insert):
(TSymbolTable::push):
(TSymbolTable::pop):
(TSymbolTable::findBuiltIn):
(TSymbolTable::relateToExtension):
(TSymbolTable::setDefaultPrecision):
(TSymbolTable::getDefaultPrecision):
(TSymbolTable::supportsPrecision):
* src/compiler/Types.h:
(NewPoolTFieldList):
(TType::TType):
(TType::setNominalSize):
(TPublicType::setAggregate):
* src/compiler/UnfoldShortCircuit.cpp:
(sh::UnfoldShortCircuit::visitBinary):
(sh::UnfoldShortCircuit::visitSelection):
* src/compiler/UnfoldShortCircuit.h:
* src/compiler/UnfoldShortCircuitAST.cpp: Added.
(UnfoldShortCircuitAST::visitBinary):
(UnfoldShortCircuitAST::updateTree):
* src/compiler/UnfoldShortCircuitAST.h: Added.
(UnfoldShortCircuitAST::UnfoldShortCircuitAST):
(UnfoldShortCircuitAST::NodeUpdateEntry::NodeUpdateEntry):
* src/compiler/Uniform.cpp:
(sh::Uniform::Uniform):
* src/compiler/Uniform.h:
* src/compiler/ValidateLimitations.cpp:
(ValidateLimitations::validateFunctionCall):
(ValidateLimitations::validateOperation):
* src/compiler/VariableInfo.cpp:
(TVariableInfo::TVariableInfo):
(CollectVariables::CollectVariables):
(CollectVariables::visitSymbol):
(CollectVariables::visitAggregate):
* src/compiler/VariableInfo.h:
* src/compiler/debug.cpp:
* src/compiler/depgraph/DependencyGraph.cpp:
* src/compiler/depgraph/DependencyGraphBuilder.cpp:
(TDependencyGraphBuilder::visitBinary):
* src/compiler/generate_parser.sh:
* src/compiler/glslang.l:
* src/compiler/glslang.y:
* src/compiler/glslang_lex.cpp:
(input):
(yyerror):
(int_constant):
(float_constant):
(glslang_scan):
* src/compiler/glslang_tab.cpp:
(yysyntax_error):
(glslang_parse):
* src/compiler/glslang_tab.h:
* src/compiler/intermediate.h:
(TIntermSymbol::hasSideEffects):
(TIntermSymbol::replaceChildNode):
(TIntermConstantUnion::hasSideEffects):
(TIntermConstantUnion::getIConst):
(TIntermConstantUnion::getFConst):
(TIntermConstantUnion::getBConst):
(TIntermConstantUnion::replaceChildNode):
(TIntermOperator::hasSideEffects):
(TIntermBinary::hasSideEffects):
(TIntermUnary::hasSideEffects):
(TIntermAggregate::hasSideEffects):
(TIntermSelection::hasSideEffects):
(TIntermTraverser::~TIntermTraverser):
(TIntermTraverser::incrementDepth):
(TIntermTraverser::decrementDepth):
(TIntermTraverser::getParentNode):
* src/compiler/localintermediate.h:
* src/compiler/parseConst.cpp:
* src/compiler/preprocessor/ExpressionParser.cpp:
(yy_symbol_print):
(yy_stack_print):
(yy_reduce_print):
(yystrlen):
(yystpcpy):
(yytnamerr):
(yysyntax_error):
(yydestruct):
(yyparse):
* src/compiler/preprocessor/ExpressionParser.y:
* src/compiler/preprocessor/Preprocessor.cpp:
(pp::Preprocessor::setMaxTokenLength):
(pp::Preprocessor::lex):
* src/compiler/preprocessor/Preprocessor.h:
* src/compiler/preprocessor/Tokenizer.cpp:
(pp::Tokenizer::Tokenizer):
(pp::Tokenizer::lex):
* src/compiler/preprocessor/Tokenizer.h:
(pp::Tokenizer::setMaxTokenLength):
* src/compiler/preprocessor/Tokenizer.l:
* src/compiler/preprocessor/generate_parser.sh:
* src/compiler/preprocessor/preprocessor.vcxproj: Added.
* src/compiler/preprocessor/preprocessor.vcxproj.filters: Added.
* src/compiler/timing/RestrictFragmentShaderTiming.cpp:
* src/compiler/translator.vcxproj: Added.
* src/compiler/translator.vcxproj.filters: Added.
* src/compiler/util.cpp:
(atof_clamp):
(atoi_clamp):
* src/compiler/util.h:
* src/libEGL/Surface.cpp:
(egl::Surface::checkForOutOfDateSwapChain):
* src/libEGL/libEGL.cpp:
* src/libEGL/libEGL.rc:
* src/libEGL/libEGL.vcxproj: Added.
* src/libEGL/libEGL.vcxproj.filters: Added.
* src/libGLESv2/Buffer.cpp:
(gl::Buffer::bufferData):
(gl::Buffer::bufferSubData):
(gl::Buffer::size):
(gl::Buffer::getIndexRangeCache):
* src/libGLESv2/Buffer.h:
* src/libGLESv2/Context.cpp:
(gl::Context::applyTextures):
(gl::Context::getBoundFramebufferTextureSerials):
* src/libGLESv2/Context.h:
(gl::Context::getRenderer):
* src/libGLESv2/Framebuffer.h:
* src/libGLESv2/ProgramBinary.cpp:
(gl::DiscardWorkaround):
(gl::ProgramBinary::load):
(gl::ProgramBinary::link):
(gl::ProgramBinary::linkAttributes):
(gl::AttributeSorter::AttributeSorter):
(gl::ProgramBinary::initAttributesByLayout):
(gl::ProgramBinary::sortAttributesByLayout):
* src/libGLESv2/ProgramBinary.h:
* src/libGLESv2/Renderbuffer.cpp:
(gl::RenderbufferTexture2D::getTextureSerial):
(gl::RenderbufferTextureCubeMap::getTextureSerial):
(gl::Renderbuffer::getTextureSerial):
* src/libGLESv2/Renderbuffer.h:
(gl::RenderbufferStorage::getTextureSerial):
* src/libGLESv2/Shader.cpp:
(gl::Shader::parseVaryings):
(gl::Shader::uncompile):
* src/libGLESv2/Shader.h:
* src/libGLESv2/Texture.cpp:
(gl::TextureCubeMap::storage):
* src/libGLESv2/Uniform.cpp:
(gl::Uniform::Uniform):
(gl::Uniform::~Uniform):
(gl::Uniform::isArray):
(gl::Uniform::elementCount):
* src/libGLESv2/Uniform.h:
* src/libGLESv2/constants.h: Removed.
* src/libGLESv2/libGLESv2.def:
* src/libGLESv2/libGLESv2.rc:
* src/libGLESv2/libGLESv2.vcxproj: Added.
* src/libGLESv2/libGLESv2.vcxproj.filters: Added.
* src/libGLESv2/precompiled.h:
* src/libGLESv2/renderer/Image11.cpp:
(rx::Image11::generateMipmap):
(rx::Image11::loadData):
(rx::Image11::loadCompressedData):
(rx::Image11::copy):
(rx::Image11::createStagingTexture):
(rx::Image11::map):
* src/libGLESv2/renderer/Image11.h:
* src/libGLESv2/renderer/IndexBuffer.cpp:
(rx::IndexBufferInterface::mapBuffer):
(rx::StaticIndexBufferInterface::getIndexRangeCache):
* src/libGLESv2/renderer/IndexBuffer.h:
* src/libGLESv2/renderer/IndexBuffer11.cpp:
(rx::IndexBuffer11::mapBuffer):
* src/libGLESv2/renderer/IndexDataManager.cpp:
(rx::IndexDataManager::prepareIndexData):
(rx::IndexDataManager::getCountingIndices):
* src/libGLESv2/renderer/IndexRangeCache.cpp: Added.
(rx::IndexRangeCache::addRange):
(rx::IndexRangeCache::invalidateRange):
(rx::IndexRangeCache::findRange):
(rx::IndexRangeCache::clear):
(rx::IndexRangeCache::IndexRange::IndexRange):
(rx::IndexRangeCache::IndexRange::operator<):
(rx::IndexRangeCache::IndexBounds::IndexBounds):
* src/libGLESv2/renderer/IndexRangeCache.h: Added.
* src/libGLESv2/renderer/InputLayoutCache.cpp:
(rx::InputLayoutCache::InputLayoutCache):
(rx::InputLayoutCache::clear):
(rx::InputLayoutCache::markDirty):
(rx::InputLayoutCache::applyVertexBuffers):
(rx::InputLayoutCache::hashInputLayout):
(rx::InputLayoutCache::compareInputLayouts):
* src/libGLESv2/renderer/InputLayoutCache.h:
(rx::InputLayoutCache::InputLayoutKey::begin):
(rx::InputLayoutCache::InputLayoutKey::end):
* src/libGLESv2/renderer/RenderTarget11.cpp:
(rx::RenderTarget11::getTexture):
(rx::RenderTarget11::getRenderTargetView):
(rx::RenderTarget11::getDepthStencilView):
(rx::RenderTarget11::getShaderResourceView):
* src/libGLESv2/renderer/RenderTarget11.h:
* src/libGLESv2/renderer/Renderer.cpp:
(rx::Renderer::initializeCompiler):
* src/libGLESv2/renderer/Renderer.h:
* src/libGLESv2/renderer/Renderer11.cpp:
(rx::Renderer11::initialize):
(rx::Renderer11::applyPrimitiveType):
(rx::Renderer11::applyRenderTarget):
(rx::Renderer11::drawLineLoop):
(rx::Renderer11::drawTriangleFan):
(rx::Renderer11::applyUniforms):
(rx::Renderer11::clear):
(rx::Renderer11::markAllStateDirty):
(rx::Renderer11::copyImage):
(rx::Renderer11::compileToExecutable):
(rx::Renderer11::getRenderTargetResource):
(rx::Renderer11::blitRenderbufferRect):
* src/libGLESv2/renderer/Renderer11.h:
* src/libGLESv2/renderer/Renderer9.cpp:
(rx::Renderer9::initialize):
(rx::Renderer9::setViewport):
(rx::Renderer9::drawLineLoop):
(rx::Renderer9::compileToExecutable):
* src/libGLESv2/renderer/Renderer9.h:
* src/libGLESv2/renderer/SwapChain.h:
* src/libGLESv2/renderer/SwapChain11.cpp:
(rx::SwapChain11::resetOffscreenTexture):
(rx::SwapChain11::reset):
(rx::SwapChain11::swapRect):
* src/libGLESv2/renderer/SwapChain9.cpp:
(rx::convertInterval):
* src/libGLESv2/renderer/TextureStorage11.cpp:
(rx::TextureStorage11::IsTextureFormatRenderable):
(rx::TextureStorage11::generateMipmapLayer):
(rx::TextureStorage11_Cube::getRenderTarget):
* src/libGLESv2/renderer/VertexBuffer.cpp:
(rx::VertexBufferInterface::storeVertexAttributes):
(rx::VertexBufferInterface::storeRawData):
(rx::VertexBufferInterface::reserveVertexSpace):
(rx::StaticVertexBufferInterface::lookupAttribute):
(rx::StaticVertexBufferInterface::storeVertexAttributes):
* src/libGLESv2/renderer/VertexBuffer.h:
* src/libGLESv2/renderer/VertexBuffer11.cpp:
(rx::VertexBuffer11::getSpaceRequired):
* src/libGLESv2/renderer/VertexBuffer11.h:
* src/libGLESv2/renderer/VertexBuffer9.cpp:
(rx::VertexBuffer9::storeVertexAttributes):
(rx::VertexBuffer9::getSpaceRequired):
(rx::VertexBuffer9::requiresConversion):
(rx::VertexBuffer9::getVertexSize):
(rx::VertexBuffer9::spaceRequired):
* src/libGLESv2/renderer/VertexBuffer9.h:
* src/libGLESv2/renderer/VertexDataManager.cpp:
(rx::elementsInBuffer):
(rx::StreamingBufferElementCount):
(rx::VertexDataManager::prepareVertexData):
* src/libGLESv2/renderer/VertexDataManager.h:
* src/libGLESv2/renderer/renderer11_utils.cpp:
(gl_d3d11::ConvertTextureFormat):
* src/libGLESv2/renderer/shaders/compiled/clear11vs.h:
* src/libGLESv2/renderer/shaders/compiled/clearmultiple11ps.h:
* src/libGLESv2/renderer/shaders/compiled/clearsingle11ps.h:
* src/libGLESv2/renderer/shaders/compiled/componentmaskps.h:
* src/libGLESv2/renderer/shaders/compiled/flipyvs.h:
* src/libGLESv2/renderer/shaders/compiled/luminanceps.h:
* src/libGLESv2/renderer/shaders/compiled/passthrough11vs.h:
* src/libGLESv2/renderer/shaders/compiled/passthroughlum11ps.h:
* src/libGLESv2/renderer/shaders/compiled/passthroughlumalpha11ps.h:
* src/libGLESv2/renderer/shaders/compiled/passthroughps.h:
* src/libGLESv2/renderer/shaders/compiled/passthroughrgb11ps.h:
* src/libGLESv2/renderer/shaders/compiled/passthroughrgba11ps.h:
* src/libGLESv2/renderer/shaders/compiled/standardvs.h:
* src/libGLESv2/renderer/shaders/generate_shaders.bat:
* src/libGLESv2/utilities.cpp:
(gl::ComputeTypeSize):
* src/libGLESv2/utilities.h:
* src/third_party/murmurhash/MurmurHash3.cpp:
(rotl32):
(rotl64):
(getblock):
(fmix):
(MurmurHash3_x86_32):
(MurmurHash3_x86_128):
(MurmurHash3_x64_128):
* src/third_party/murmurhash/MurmurHash3.h:
* src/third_party/trace_event: Added.
* src/third_party/trace_event/trace_event.h: Added.
(gl::TraceEvent::TraceID::TraceID):
(gl::TraceEvent::TraceID::data):
(gl::TraceEvent::TraceStringWithCopy::TraceStringWithCopy):
(gl::TraceEvent::TraceStringWithCopy::operator const char* ):
(gl::TraceEvent::setTraceValue):
(gl::TraceEvent::addTraceEvent):
(gl::TraceEvent::TraceEndOnScopeClose::TraceEndOnScopeClose):
(gl::TraceEvent::TraceEndOnScopeClose::~TraceEndOnScopeClose):
(gl::TraceEvent::TraceEndOnScopeClose::initialize):
(gl::TraceEvent::TraceEndOnScopeClose::addEventIfEnabled):
(gl::TraceEvent::SamplingStateScope::SamplingStateScope):
(gl::TraceEvent::SamplingStateScope::~SamplingStateScope):
(gl::TraceEvent::SamplingStateScope::current):
(gl::TraceEvent::SamplingStateScope::set):

git-svn-id: http://svn.webkit.org/repository/webkit/trunk@159533 268f45cc-cd09-0410-ab3c-d52691b4dbfc
Implement spin control on WinCE port.
https://bugs.webkit.org/show_bug.cgi?id=123254

Patch by Zhuang Zhigang <zhuangzg@cn.fujitsu.com> on 2013-11-19
Reviewed by Brent Fulgham.

* rendering/RenderThemeWinCE.cpp:
(WebCore::RenderThemeWinCE::adjustInnerSpinButtonStyle):
(WebCore::RenderThemeWinCE::paintInnerSpinButton):
* rendering/RenderThemeWinCE.h:

git-svn-id: http://svn.webkit.org/repository/webkit/trunk@159534 268f45cc-cd09-0410-ab3c-d52691b4dbfc
[EFL] Layout tests need to be rebaselined.
https://bugs.webkit.org/show_bug.cgi?id=124622

Unreviewed, EFL rebaseline.

EFL tests are rebaselined after r106181, r128728 and r133754.

Patch by Sun-woo Nam <sunny.nam@samsung.com> on 2013-11-19

* platform/efl-wk2/TestExpectations:
* platform/efl/fast/replaced/applet-disabled-positioned-expected.txt:
* platform/efl/fast/replaced/applet-rendering-java-disabled-expected.txt:
* platform/efl/fast/text/shaping/shaping-script-order-expected.txt:
* platform/efl/fast/writing-mode/japanese-ruby-horizontal-bt-expected.txt:

git-svn-id: http://svn.webkit.org/repository/webkit/trunk@159535 268f45cc-cd09-0410-ab3c-d52691b4dbfc
run-jsc-stress-tests should be able to package its tests and move them places
https://bugs.webkit.org/show_bug.cgi?id=124549

Reviewed by Geoff Garen and Filip Pizlo.

* Scripts/jsc-stress-test-helpers/check-mozilla-failure: Removed. This script was just a ruby reimplementation 
of grep -i -q 
* Scripts/run-javascriptcore-tests: Pass through the --make-bundle flag.
* Scripts/run-jsc-stress-tests: Added the new concept of a "bundle", which is a collection of all tests and any
other files that those tests require to run in any environment along with a fixed root directory into which these
files and their expected directory structure are cloned. The default Bundle class is basically 
a no-op so that it functions like run-jsc-stress-tests prior to this patch. MovableBundle is a Bundle that knows 
how to translate local paths to bundle paths and does all the work of moving each test file into the right place 
inside the .tests directory. After all the test files have been created in jsc-stress-results MovableBundle 
creates a tarball of the entire directory for easy relocation. The --make-bundle flag causes run-jsc-stress-tests 
to use MovableBundle instead of just Bundle. 


git-svn-id: http://svn.webkit.org/repository/webkit/trunk@159538 268f45cc-cd09-0410-ab3c-d52691b4dbfc
Unreviewed. Prospective build fix for GTK port following r159533.

* GNUmakefile.am:


git-svn-id: http://svn.webkit.org/repository/webkit/trunk@159539 268f45cc-cd09-0410-ab3c-d52691b4dbfc
Unreviewed, rolling out r159538.
http://trac.webkit.org/changeset/159538
https://bugs.webkit.org/show_bug.cgi?id=124627

it broke run-jsc-stress-tests (Requested by mhahnenberg on
#webkit).

* Scripts/jsc-stress-test-helpers/check-mozilla-failure: Added.
* Scripts/run-javascriptcore-tests:
* Scripts/run-jsc-stress-tests:

git-svn-id: http://svn.webkit.org/repository/webkit/trunk@159540 268f45cc-cd09-0410-ab3c-d52691b4dbfc
Fix build break after r159533.

* CMakeLists.txt: Update ANGLE files.

git-svn-id: http://svn.webkit.org/repository/webkit/trunk@159541 268f45cc-cd09-0410-ab3c-d52691b4dbfc
Fix the GTK+ build after the ANGLE update in r159533

* GNUmakefile.am: Update the source list.

git-svn-id: http://svn.webkit.org/repository/webkit/trunk@159542 268f45cc-cd09-0410-ab3c-d52691b4dbfc
Unreviewed. Build fix for Mac.

* src/compiler/glslang_tab.cpp:
(yysyntax_error):
(yyerror):
* src/compiler/glslang_tab.h:
* src/compiler/preprocessor/ExpressionParser.cpp:
(yysyntax_error):


git-svn-id: http://svn.webkit.org/repository/webkit/trunk@159543 268f45cc-cd09-0410-ab3c-d52691b4dbfc
Removal of redundant function call in Editor::insertTextWithoutSendingTextEvent
https://bugs.webkit.org/show_bug.cgi?id=124563

Reviewed by Brent Fulgham.

No new tests needed, no behavior change.

* editing/Editor.cpp:
(WebCore::Editor::insertTextWithoutSendingTextEvent):


git-svn-id: http://svn.webkit.org/repository/webkit/trunk@159544 268f45cc-cd09-0410-ab3c-d52691b4dbfc
Infer constant global variables
https://bugs.webkit.org/show_bug.cgi?id=124464

Source/JavaScriptCore: 

Reviewed by Sam Weinig.
        
All global variables that are candidates for watchpoint-based constant inference (i.e.
not 'const' variables) will now have WatchpointSet's associated with them and those
are used to drive the inference by tracking three states of each variable:
        
Uninitialized: the variable's value is Undefined and the WatchpointSet state is
    ClearWatchpoint.
        
Initialized: the variable's value was set to something (could even be explicitly set
    to Undefined) and the WatchpointSet state is IsWatching.
        
Invalidated: the variable's value was set to something else (could even be the same
    thing as before but the point is that a put operation did execute again) and the
    WatchpointSet is IsInvalidated.
        
If the compiler tries to compile a GetGlobalVar and the WatchpointSet state is
IsWatching, then the current value of the variable can be folded in place of the get,
and a watchpoint on the variable can be registered.
        
We handle race conditions between the mutator and compiler by mandating that:
        
- The mutator changes the WatchpointSet state after executing the put.
        
- There is no opportunity to install code or call functions between when the mutator
  executes a put and changes the WatchpointSet state.
        
- The compiler checks the WatchpointSet state prior to reading the value.
        
The concrete algorithm used by the mutator is:
        
    1. Store the new value into the variable.
    --- Execute a store-store fence.
    2. Bump the state (ClearWatchpoing becomes IsWatching, IsWatching becomes
       IsInvalidated); the IsWatching->IsInvalidated transition may end up firing
       watchpoints.
        
The concrete algorithm that the compiler uses is:
        
    1. Load the state. If it's *not* IsWatching, then give up on constant inference.
    --- Execute a load-load fence.
    2. Load the value of the variable and use that for folding, while also registering
       a DesiredWatchpoint. The various parts of this step can be done in any order.
        
The desired watchpoint registration will fail if the watchpoint set is already
invalidated. Now consider the following interesting interleavings:
        
Uninitialized->M1->M2->C1->C2: Compiler sees IsWatching because of the mutator's store
    operation, and the variable is folded. The fencing ensures that C2 sees the value
    stored in M1 - i.e. we fold on the value that will actually be watchpointed. If
    before the compilation is installed the mutator executes another store then we
    will be sure that it will be a complete sequence of M1+M2 since compilations get
    installed at safepoints and never "in the middle" of a put_to_scope. Hence that
    compilation installation will be invalidated. If the M1+M2 sequence happens after
    the code is installed, then the code will be invalidated by triggering a jettison.
        
Uninitialized->M1->C1->C2->M2: Compiler sees Uninitialized and will not fold. This is
    a sensible outcome since if the compiler read the variable's value, it would have
    seen Undefined.
        
Uninitialized->C1->C2->M1->M2: Compiler sees Uninitialized and will not fold.
Uninitialized->C1->M1->C2->M2: Compiler sees Uninitialized and will not fold.
Uninitialized->C1->M1->M2->C2: Compiler sees Uninitialized and will not fold.
Uninitialized->M1->C1->M2->C2: Compiler sees Uninitialized and will not fold.
        
IsWatched->M1->M2->C1->C2: Compiler sees IsInvalidated and will not fold.
        
IsWatched->M1->C1->C2->M2: Compiler will fold, but will also register a desired
    watchpoint, and that watchpoint will get invalidated before the code is installed.
        
IsWatched->M1->C1->M2->C2: As above, will fold but the code will get invalidated.
IsWatched->C1->C2->M1->M2: As above, will fold but the code will get invalidated.
IsWatched->C1->M1->C2->M2: As above, will fold but the code will get invalidated.
IsWatched->C1->M1->M2->C2: As above, will fold but the code will get invalidated.
        
Note that this kind of reasoning shows why having the mutator first bump the state and
then store the new value would be wrong. If we had done that (M1 = bump state, M2 =
execute put) then we could have the following deadly interleavings:
        
Uninitialized->M1->C1->C2->M2:
Uninitialized->M1->C1->M2->C2: Mutator bumps the state to IsWatched and then the
    compiler folds Undefined, since M2 hasn't executed yet. Although C2 will set the
    watchpoint, M1 didn't notify it - it mearly initiated watching. M2 then stores a
    value other than Undefined, and you're toast.
        
You could fix this sort of thing by making the Desired Watchpoints machinery more
sophisticated, for example having it track the value that was folded; if the global
variable's value was later found to be different then we could invalidate the
compilation. You could also fix it by having the compiler also check that the value of
the variable is not Undefined before folding. While those all sound great, I decided
to instead just use the right interleaving since that results in less code and feels
more intuitive.
        
This is a 0.5% speed-up on SunSpider, mostly due to a 20% speed-up on math-cordic.
It's a 0.6% slow-down on LongSpider, mostly due to a 25% slow-down on 3d-cube. This is
because 3d-cube takes global variable assignment slow paths very often. Note that this
3d-cube slow-down doesn't manifest as much in SunSpider (only 6% there). This patch is
also a 1.5% speed-up on V8v7 and a 2.8% speed-up on Octane v1, mostly due to deltablue
(3.7%), richards (4%), and mandreel (26%). This is a 2% speed-up on Kraken, mostly due
to a 17.5% speed-up on imaging-gaussian-blur. Something that really illustrates the
slam-dunk-itude of this patch is the wide range of speed-ups on JSRegress. Casual JS
programming often leads to global-var-based idioms and those variables tend to be
assigned once, leading to excellent constant folding opportunities in an optimizing
JIT. This is very evident in the speed-ups on JSRegress.

* assembler/ARM64Assembler.h:
(JSC::ARM64Assembler::dmbSY):
* assembler/ARMv7Assembler.h:
(JSC::ARMv7Assembler::dmbSY):
* assembler/MacroAssemblerARM64.h:
(JSC::MacroAssemblerARM64::memfence):
* assembler/MacroAssemblerARMv7.h:
(JSC::MacroAssemblerARMv7::load8):
(JSC::MacroAssemblerARMv7::memfence):
* assembler/MacroAssemblerX86.h:
(JSC::MacroAssemblerX86::load8):
(JSC::MacroAssemblerX86::store8):
* assembler/MacroAssemblerX86Common.h:
(JSC::MacroAssemblerX86Common::getUnusedRegister):
(JSC::MacroAssemblerX86Common::store8):
(JSC::MacroAssemblerX86Common::memoryFence):
* assembler/MacroAssemblerX86_64.h:
(JSC::MacroAssemblerX86_64::load8):
(JSC::MacroAssemblerX86_64::store8):
* assembler/X86Assembler.h:
(JSC::X86Assembler::movb_rm):
(JSC::X86Assembler::movzbl_mr):
(JSC::X86Assembler::mfence):
(JSC::X86Assembler::X86InstructionFormatter::threeByteOp):
(JSC::X86Assembler::X86InstructionFormatter::oneByteOp8):
* bytecode/CodeBlock.cpp:
(JSC::CodeBlock::CodeBlock):
* bytecode/Watchpoint.cpp:
(JSC::WatchpointSet::WatchpointSet):
(JSC::WatchpointSet::add):
(JSC::WatchpointSet::notifyWriteSlow):
* bytecode/Watchpoint.h:
(JSC::WatchpointSet::state):
(JSC::WatchpointSet::isStillValid):
(JSC::WatchpointSet::addressOfSetIsNotEmpty):
* dfg/DFGAbstractInterpreterInlines.h:
(JSC::DFG::::executeEffects):
* dfg/DFGByteCodeParser.cpp:
(JSC::DFG::ByteCodeParser::getJSConstantForValue):
(JSC::DFG::ByteCodeParser::getJSConstant):
(JSC::DFG::ByteCodeParser::parseBlock):
* dfg/DFGClobberize.h:
(JSC::DFG::clobberize):
* dfg/DFGFixupPhase.cpp:
(JSC::DFG::FixupPhase::fixupNode):
* dfg/DFGNode.h:
(JSC::DFG::Node::isStronglyProvedConstantIn):
(JSC::DFG::Node::hasIdentifierNumberForCheck):
(JSC::DFG::Node::hasRegisterPointer):
* dfg/DFGNodeFlags.h:
* dfg/DFGNodeType.h:
* dfg/DFGOperations.cpp:
* dfg/DFGOperations.h:
* dfg/DFGPredictionPropagationPhase.cpp:
(JSC::DFG::PredictionPropagationPhase::propagate):
* dfg/DFGSafeToExecute.h:
(JSC::DFG::safeToExecute):
* dfg/DFGSpeculativeJIT.cpp:
(JSC::DFG::SpeculativeJIT::compileNotifyPutGlobalVar):
* dfg/DFGSpeculativeJIT.h:
(JSC::DFG::SpeculativeJIT::callOperation):
* dfg/DFGSpeculativeJIT32_64.cpp:
(JSC::DFG::SpeculativeJIT::compile):
* dfg/DFGSpeculativeJIT64.cpp:
(JSC::DFG::SpeculativeJIT::compile):
* ftl/FTLAbbreviatedTypes.h:
* ftl/FTLAbbreviations.h:
(JSC::FTL::buildFence):
* ftl/FTLCapabilities.cpp:
(JSC::FTL::canCompile):
* ftl/FTLIntrinsicRepository.h:
* ftl/FTLLowerDFGToLLVM.cpp:
(JSC::FTL::LowerDFGToLLVM::compileNode):
(JSC::FTL::LowerDFGToLLVM::compileNotifyPutGlobalVar):
* ftl/FTLOutput.h:
(JSC::FTL::Output::fence):
* jit/JIT.h:
* jit/JITOperations.h:
* jit/JITPropertyAccess.cpp:
(JSC::JIT::emitPutGlobalVar):
(JSC::JIT::emit_op_put_to_scope):
(JSC::JIT::emitSlow_op_put_to_scope):
* jit/JITPropertyAccess32_64.cpp:
(JSC::JIT::emitPutGlobalVar):
(JSC::JIT::emit_op_put_to_scope):
(JSC::JIT::emitSlow_op_put_to_scope):
* llint/LowLevelInterpreter32_64.asm:
* llint/LowLevelInterpreter64.asm:
* llvm/LLVMAPIFunctions.h:
* offlineasm/arm.rb:
* offlineasm/arm64.rb:
* offlineasm/cloop.rb:
* offlineasm/instructions.rb:
* offlineasm/x86.rb:
* runtime/JSGlobalObject.cpp:
(JSC::JSGlobalObject::addGlobalVar):
(JSC::JSGlobalObject::addFunction):
* runtime/JSGlobalObject.h:
(JSC::JSGlobalObject::addVar):
(JSC::JSGlobalObject::addConst):
* runtime/JSScope.cpp:
(JSC::abstractAccess):
* runtime/JSSymbolTableObject.h:
(JSC::symbolTablePut):
(JSC::symbolTablePutWithAttributes):
* runtime/SymbolTable.cpp:
(JSC::SymbolTableEntry::couldBeWatched):
(JSC::SymbolTableEntry::prepareToWatch):
(JSC::SymbolTableEntry::notifyWriteSlow):
* runtime/SymbolTable.h:

LayoutTests: 

Reviewed by Sam Weinig.

* js/regress/global-var-const-infer-expected.txt: Added.
* js/regress/global-var-const-infer-fire-from-opt-expected.txt: Added.
* js/regress/global-var-const-infer-fire-from-opt.html: Added.
* js/regress/global-var-const-infer.html: Added.
* js/regress/script-tests/global-var-const-infer-fire-from-opt.js: Added.
(foo):
(setA):
(setB):
(check):
* js/regress/script-tests/global-var-const-infer.js: Added.
(foo):
(check):



git-svn-id: http://svn.webkit.org/repository/webkit/trunk@159545 268f45cc-cd09-0410-ab3c-d52691b4dbfc