Revision control
++ /*
++ * Copyright (C) 2009 Apple Inc. All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions
++ * are met:
++ * 1. Redistributions of source code must retain the above copyright
++ * notice, this list of conditions and the following disclaimer.
++ * 2. Redistributions in binary form must reproduce the above copyright
++ * notice, this list of conditions and the following disclaimer in the
++ * documentation and/or other materials provided with the distribution.
++ *
++ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
++ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
++ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
++ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
++ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
++ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
++ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
++ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
++ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
++ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++ */
++
++ #ifndef CodeLocation_h
++ #define CodeLocation_h
++
++ #include "MacroAssemblerCodeRef.h"
++
++ #if ENABLE(ASSEMBLER)
++
++ namespace JSC {
++
++ class CodeLocationInstruction;
++ class CodeLocationLabel;
++ class CodeLocationJump;
++ class CodeLocationCall;
++ class CodeLocationNearCall;
++ class CodeLocationDataLabelCompact;
++ class CodeLocationDataLabel32;
++ class CodeLocationDataLabelPtr;
++ class CodeLocationConvertibleLoad;
++
++ // The CodeLocation* types are all pretty much do-nothing wrappers around
++ // CodePtr (or MacroAssemblerCodePtr, to give it its full name). These
++ // classes only exist to provide type-safety when linking and patching code.
++ //
++ // The one new piece of functionallity introduced by these classes is the
++ // ability to create (or put another way, to re-discover) another CodeLocation
++ // at an offset from one you already know. When patching code to optimize it
++ // we often want to patch a number of instructions that are short, fixed
++ // offsets apart. To reduce memory overhead we will only retain a pointer to
++ // one of the instructions, and we will use the *AtOffset methods provided by
++ // CodeLocationCommon to find the other points in the code to modify.
++ class CodeLocationCommon : public MacroAssemblerCodePtr {
++ public:
++ CodeLocationInstruction instructionAtOffset(int offset);
++ CodeLocationLabel labelAtOffset(int offset);
++ CodeLocationJump jumpAtOffset(int offset);
++ CodeLocationCall callAtOffset(int offset);
++ CodeLocationNearCall nearCallAtOffset(int offset);
++ CodeLocationDataLabelPtr dataLabelPtrAtOffset(int offset);
++ CodeLocationDataLabel32 dataLabel32AtOffset(int offset);
++ CodeLocationDataLabelCompact dataLabelCompactAtOffset(int offset);
++ CodeLocationConvertibleLoad convertibleLoadAtOffset(int offset);
++
++ protected:
++ CodeLocationCommon()
++ {
++ }
++
++ CodeLocationCommon(MacroAssemblerCodePtr location)
++ : MacroAssemblerCodePtr(location)
++ {
++ }
++ };
++
++ class CodeLocationInstruction : public CodeLocationCommon {
++ public:
++ CodeLocationInstruction() {}
++ explicit CodeLocationInstruction(MacroAssemblerCodePtr location)
++ : CodeLocationCommon(location) {}
++ explicit CodeLocationInstruction(void* location)
++ : CodeLocationCommon(MacroAssemblerCodePtr(location)) {}
++ };
++
++ class CodeLocationLabel : public CodeLocationCommon {
++ public:
++ CodeLocationLabel() {}
++ explicit CodeLocationLabel(MacroAssemblerCodePtr location)
++ : CodeLocationCommon(location) {}
++ explicit CodeLocationLabel(void* location)
++ : CodeLocationCommon(MacroAssemblerCodePtr(location)) {}
++ };
++
++ class CodeLocationJump : public CodeLocationCommon {
++ public:
++ CodeLocationJump() {}
++ explicit CodeLocationJump(MacroAssemblerCodePtr location)
++ : CodeLocationCommon(location) {}
++ explicit CodeLocationJump(void* location)
++ : CodeLocationCommon(MacroAssemblerCodePtr(location)) {}
++ };
++
++ class CodeLocationCall : public CodeLocationCommon {
++ public:
++ CodeLocationCall() {}
++ explicit CodeLocationCall(MacroAssemblerCodePtr location)
++ : CodeLocationCommon(location) {}
++ explicit CodeLocationCall(void* location)
++ : CodeLocationCommon(MacroAssemblerCodePtr(location)) {}
++ };
++
++ class CodeLocationNearCall : public CodeLocationCommon {
++ public:
++ CodeLocationNearCall() {}
++ explicit CodeLocationNearCall(MacroAssemblerCodePtr location)
++ : CodeLocationCommon(location) {}
++ explicit CodeLocationNearCall(void* location)
++ : CodeLocationCommon(MacroAssemblerCodePtr(location)) {}
++ };
++
++ class CodeLocationDataLabel32 : public CodeLocationCommon {
++ public:
++ CodeLocationDataLabel32() {}
++ explicit CodeLocationDataLabel32(MacroAssemblerCodePtr location)
++ : CodeLocationCommon(location) {}
++ explicit CodeLocationDataLabel32(void* location)
++ : CodeLocationCommon(MacroAssemblerCodePtr(location)) {}
++ };
++
++ class CodeLocationDataLabelCompact : public CodeLocationCommon {
++ public:
++ CodeLocationDataLabelCompact() { }
++ explicit CodeLocationDataLabelCompact(MacroAssemblerCodePtr location)
++ : CodeLocationCommon(location) { }
++ explicit CodeLocationDataLabelCompact(void* location)
++ : CodeLocationCommon(MacroAssemblerCodePtr(location)) { }
++ };
++
++ class CodeLocationDataLabelPtr : public CodeLocationCommon {
++ public:
++ CodeLocationDataLabelPtr() {}
++ explicit CodeLocationDataLabelPtr(MacroAssemblerCodePtr location)
++ : CodeLocationCommon(location) {}
++ explicit CodeLocationDataLabelPtr(void* location)
++ : CodeLocationCommon(MacroAssemblerCodePtr(location)) {}
++ };
++
++ class CodeLocationConvertibleLoad : public CodeLocationCommon {
++ public:
++ CodeLocationConvertibleLoad() { }
++ explicit CodeLocationConvertibleLoad(MacroAssemblerCodePtr location)
++ : CodeLocationCommon(location) { }
++ explicit CodeLocationConvertibleLoad(void* location)
++ : CodeLocationCommon(MacroAssemblerCodePtr(location)) { }
++ };
++
++ inline CodeLocationInstruction CodeLocationCommon::instructionAtOffset(int offset)
++ {
++ ASSERT_VALID_CODE_OFFSET(offset);
++ return CodeLocationInstruction(reinterpret_cast<char*>(dataLocation()) + offset);
++ }
++
++ inline CodeLocationLabel CodeLocationCommon::labelAtOffset(int offset)
++ {
++ ASSERT_VALID_CODE_OFFSET(offset);
++ return CodeLocationLabel(reinterpret_cast<char*>(dataLocation()) + offset);
++ }
++
++ inline CodeLocationJump CodeLocationCommon::jumpAtOffset(int offset)
++ {
++ ASSERT_VALID_CODE_OFFSET(offset);
++ return CodeLocationJump(reinterpret_cast<char*>(dataLocation()) + offset);
++ }
++
++ inline CodeLocationCall CodeLocationCommon::callAtOffset(int offset)
++ {
++ ASSERT_VALID_CODE_OFFSET(offset);
++ return CodeLocationCall(reinterpret_cast<char*>(dataLocation()) + offset);
++ }
++
++ inline CodeLocationNearCall CodeLocationCommon::nearCallAtOffset(int offset)
++ {
++ ASSERT_VALID_CODE_OFFSET(offset);
++ return CodeLocationNearCall(reinterpret_cast<char*>(dataLocation()) + offset);
++ }
++
++ inline CodeLocationDataLabelPtr CodeLocationCommon::dataLabelPtrAtOffset(int offset)
++ {
++ ASSERT_VALID_CODE_OFFSET(offset);
++ return CodeLocationDataLabelPtr(reinterpret_cast<char*>(dataLocation()) + offset);
++ }
++
++ inline CodeLocationDataLabel32 CodeLocationCommon::dataLabel32AtOffset(int offset)
++ {
++ ASSERT_VALID_CODE_OFFSET(offset);
++ return CodeLocationDataLabel32(reinterpret_cast<char*>(dataLocation()) + offset);
++ }
++
++ inline CodeLocationDataLabelCompact CodeLocationCommon::dataLabelCompactAtOffset(int offset)
++ {
++ ASSERT_VALID_CODE_OFFSET(offset);
++ return CodeLocationDataLabelCompact(reinterpret_cast<char*>(dataLocation()) + offset);
++ }
++
++ inline CodeLocationConvertibleLoad CodeLocationCommon::convertibleLoadAtOffset(int offset)
++ {
++ ASSERT_VALID_CODE_OFFSET(offset);
++ return CodeLocationConvertibleLoad(reinterpret_cast<char*>(dataLocation()) + offset);
++ }
++
++ } // namespace JSC
++
++ #endif // ENABLE(ASSEMBLER)
++
++ #endif // CodeLocation_h