AvmCore.h

Go to the documentation of this file.

/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is [Open Source Virtual Machine.].
 *
 * The Initial Developer of the Original Code is
 * Adobe System Incorporated.
 * Portions created by the Initial Developer are Copyright (C) 2004-2006
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *   Adobe AS3 Team
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

#ifndef __avmplus_AvmCore__
#define __avmplus_AvmCore__

namespace avmplus
{

#define DECLARE_NATIVE_SCRIPTS() static const NativeScriptInfo scriptEntries[];

#define BEGIN_NATIVE_SCRIPTS(_Class) /*static*/ const  NativeScriptInfo _Class::scriptEntries[] = {

#define NATIVE_SCRIPT(script_id, _Script) { (NativeScriptInfo::Handler)_Script::createGlobalObject, _Script::natives, script_id, sizeof(_Script) },

#define END_NATIVE_SCRIPTS() { NULL, NULL, -1, 0 } };

#define DECLARE_NATIVE_CLASSES() static const NativeClassInfo classEntries[];

#define BEGIN_NATIVE_CLASSES(_Class) /*static*/ const NativeClassInfo _Class::classEntries[] = {

#define NATIVE_CLASS(class_id, _Class, _Instance) { (NativeClassInfo::Handler)_Class::createClassClosure, _Class::natives, avmplus::NativeID::class_id, sizeof(_Class), sizeof(_Instance) },

#define END_NATIVE_CLASSES() { NULL, NULL, -1, 0, 0 } };

#define OBJECT_TYPE     (core->traits.object_itraits)
#define CLASS_TYPE      (core->traits.class_itraits)
#define FUNCTION_TYPE   (core->traits.function_itraits)
#define ARRAY_TYPE      (core->traits.array_itraits)
#define STRING_TYPE     (core->traits.string_itraits)
#define NUMBER_TYPE     (core->traits.number_itraits)
#define INT_TYPE        (core->traits.int_itraits)
#define UINT_TYPE       (core->traits.uint_itraits)
#define BOOLEAN_TYPE    (core->traits.boolean_itraits)
#define VOID_TYPE       (core->traits.void_itraits)
#define NULL_TYPE       (core->traits.null_itraits)
#define NAMESPACE_TYPE  (core->traits.namespace_itraits)
#define VECTORINT_TYPE  (core->traits.vectorint_itraits)
#define VECTORUINT_TYPE (core->traits.vectoruint_itraits)
#define VECTORDOUBLE_TYPE       (core->traits.vectordouble_itraits)
#define VECTOROBJ_TYPE  (core->traits.vectorobj_itraits)

const int kBufferPadding = 16;

    struct Config
    {
        #ifdef AVMPLUS_VERBOSE

        bool verbose;
        bool verbose_addrs;
        #endif /* AVMPLUS_VERBOSE */

        bool turbo;

        #ifdef AVMPLUS_MIR
        bool dceopt;
        #ifdef AVMPLUS_VERBOSE
        bool bbgraph;
        #endif //AVMPLUS_VERBOSE
        #endif

        #if defined AVMPLUS_MIR || defined FEATURE_NANOJIT

        bool jit;
        bool cseopt;

        #if defined (AVMPLUS_IA32) || defined(AVMPLUS_AMD64)
        bool sse2;
        #endif

        #endif // AVMPLUS_MIR || FEATURE_NANOJIT

        bool interrupts;

#ifdef AVMPLUS_VERIFYALL
        bool verifyall;
#endif

#ifdef FEATURE_NANOJIT
        bool show_stats;
        bool tree_opt;
        bool verbose_live;
        bool verbose_exits;
#endif
    };

    class AvmCore : public MMgc::GCRoot
    {
    public:
        PrintWriter console;

#ifdef VTUNE
        iJIT_IsProfilingActiveFlags VTuneStatus;

        iJIT_IsProfilingActiveFlags CheckVTuneStatus() 
        {
            iJIT_IsProfilingActiveFlags profiler = iJIT_IsProfilingActive();    
            return profiler;
        }
#endif // VTUNE

        MMgc::GC * const gc;

        #ifdef DEBUGGER

        Debugger *debugger;
        Profiler *profiler;
        #endif

        void branchCheck(MethodEnv *env, bool interruptable, int go)
        {
            if(go < 0)
            {
#ifdef DEBUGGER
                sampleCheck();
#endif
                if (interruptable && interrupted)
                        interrupt(env);
            }
        }

        #ifdef AVMPLUS_MIR
        // MIR intermediate buffer pool
        List<GrowableBuffer*> mirBuffers; // mir buffer pool
        GrowableBuffer* requestNewMirBuffer();   // create a new buffer
        GrowableBuffer* requestMirBuffer();      // get next buffer in list or a create a new one
        void releaseMirBuffer(GrowableBuffer* buffer);
        //GCSpinLock mirBufferLock;

        #ifdef AVMPLUS_VERBOSE
        MMgc::GCHashtable* codegenMethodNames;
        #endif /* AVMPLUS_VERBOSE */
        #endif /* MIR */

        #if defined AVMPLUS_MIR || defined FEATURE_NANOJIT
        void initMultinameLate(Multiname& name, Atom index);
        #endif

        void setConsoleStream(OutputStream *stream);

        virtual void presweep();
        virtual void postsweep();
        
        Config config;
        
        #ifdef FEATURE_NANOJIT // accessors
            bool quiet_opt() { return false; } 
            bool use_sse2() { return config.sse2; }
            #ifdef AVMPLUS_VERBOSE
                bool verbose() { return config.verbose; }
                bool verbose_exits() { return config.verbose_exits; }
                bool verbose_live() { return config.verbose_live; }
            #endif
        #endif

        inline void SetMIREnabled(bool isEnabled)
        {
            config.turbo = isEnabled;
        }

        inline bool IsMIREnabled() const
        {
            return config.turbo;
        }

        uintptr minstack;

        virtual void setStackBase() {}

        DRC(Stringp) booleanStrings[2];

        BuiltinTraits traits;

        PoolObject* builtinPool;

        Domain* builtinDomain;
        
        Namespace *const*dxnsAddr;

        int interrupted;
        
        DRC(Namespace*) publicNamespace;
        VTable* namespaceVTable;

        #ifdef FEATURE_JNI
        Java* java;     /* java vm control */
        #endif

        Atom handleActionPool(PoolObject* pool,
                                   DomainEnv* domainEnv,
                                   Toplevel* &toplevel,
                                   CodeContext *codeContext);

        ScriptEnv* prepareActionPool(PoolObject* pool,
                                     DomainEnv* domainEnv,
                                     Toplevel*& toplevel,
                                     CodeContext *codeContext);
        
        void exportDefs(Traits* traits, ScriptEnv* scriptEnv);

        PoolObject* parseActionBlock(ScriptBuffer code,
                                     int start,
                                     Toplevel* toplevel,
                                     Domain* domain,
                                     AbstractFunction *nativeMethods[],
                                     NativeClassInfop nativeClasses[],
                                     NativeScriptInfop nativeScripts[],
                                     List<Stringp>* include_versions = NULL);
        
        Atom handleActionBlock(ScriptBuffer code,
                                    int start,
                                    DomainEnv* domainEnv,
                                    Toplevel* &toplevel,
                                    AbstractFunction *nativeMethods[],
                                    NativeClassInfop nativeClasses[],
                                    NativeScriptInfop nativeScripts[],
                                    CodeContext *codeContext);

                
        void initNativeTables(NativeClassInfop classEntries,
                             NativeScriptInfop scriptEntries,
                             AbstractFunction *nativeMethods[],
                             NativeClassInfop nativeClasses[],
                             NativeScriptInfop nativeScripts[]);

        Traits* makeParameterizedITraits(Stringp name, Namespace* ns, Traits* t );
        Traits* makeParameterizedCTraits(Stringp name, Namespace* ns, Traits* t );


        Atom equals(Atom lhs, Atom rhs);
        
        Atom compare(Atom lhs, Atom rhs);

        Atom stricteq(Atom lhs, Atom rhs);

        static bool isObject(Atom atom)
        {
            return (atom&7) == kObjectType && !isNull(atom);
        }

        static bool isPointer(Atom atom)
        {
            return (atom&7) < kSpecialType || (atom&7) == kDoubleType;
        }

        static bool isTraits(Atom type)
        {
            return type != 0 && (type&7) == 0;
        }

        static bool isNamespace(Atom atom)
        {
            return (atom&7) == kNamespaceType && !isNull(atom);
        }

        static bool isMethodBinding(Binding b)
        {
            return (b&7) == BIND_METHOD;
        }

        static bool isAccessorBinding(Binding b)
        {
            return (b&7) >= BIND_GET;
        }

        static bool hasSetterBinding(Binding b)
        {
            return (b&6) == BIND_SET;
        }

        static bool hasGetterBinding(Binding b)
        {
            return (b&5) == BIND_GET;
        }

        static int bindingToGetterId(Binding b)
        {
            AvmAssert(hasGetterBinding(b));
            return urshift(b,3);
        }

        static int bindingToSetterId(Binding b)
        {
            AvmAssert(hasSetterBinding(b));
            return 1+urshift(b,3);
        }

        static int bindingToMethodId(Binding b)
        {
            AvmAssert(isMethodBinding(b));
            return urshift(b,3);
        }

        static int bindingToSlotId(Binding b)
        {
            AvmAssert(isSlotBinding(b));
            return urshift(b,3);
        }

        static int isSlotBinding(Binding b)
        {
            AvmAssert((BIND_CONST&6)==BIND_VAR);
            return (b&6)==BIND_VAR;
        }

        static int isVarBinding(Binding b)
        {
            return (b&7)==BIND_VAR;
        }
        static int isConstBinding(Binding b)
        {
            return (b&7)==BIND_CONST;
        }
        
        bool isFunction(Atom atom)
        {
            return istype(atom, traits.function_itraits);
        }

        static bool isDouble(Atom atom)
        {
            return (atom&7) == kDoubleType;
        }

        static bool isInteger(Atom atom)
        {
            return (atom&7) == kIntegerType;
        }

        static bool isNumber(Atom atom)
        {
            // accept kIntegerType(6) or kDoubleType(7)
            return (atom&6) == kIntegerType;
        }

        static bool isBoolean(Atom atom)
        {
            return (atom&7) == kBooleanType;
        }

        static bool isNull(Atom atom)
        {
            return ISNULL(atom);
        }

        static bool isUndefined(Atom atom)
        {
            return (atom == undefinedAtom);
        }

        static bool isNullOrUndefined(Atom atom)
        {
            return ((uintptr)atom) <= (uintptr)kSpecialType;
        }

#ifdef AVMPLUS_VERBOSE

        void formatOpcode(PrintWriter& out, const byte *pc, AbcOpcode opcode, ptrdiff_t off, PoolObject* pool);
        static void formatMultiname(PrintWriter& out, uint32 index, PoolObject* pool);
#endif

        Hashtable *resources;


        DRC(Stringp) kconstructor;
        DRC(Stringp) kEmptyString;
        DRC(Stringp) ktrue;
        DRC(Stringp) kfalse;
        DRC(Stringp) kundefined;
        DRC(Stringp) knull;
        DRC(Stringp) ktoString;
        DRC(Stringp) ktoLocaleString;
        DRC(Stringp) kvalueOf;
        DRC(Stringp) klength;
        DRC(Stringp) kobject;
        DRC(Stringp) kfunction;
        DRC(Stringp) kxml;
        DRC(Stringp) kboolean;
        DRC(Stringp) knumber;
        DRC(Stringp) kstring;
        DRC(Stringp) kuri;
        DRC(Stringp) kprefix;
        DRC(Stringp) kglobal;
        DRC(Stringp) kcallee;
        DRC(Stringp) kNeedsDxns;
        DRC(Stringp) kAsterisk;
        DRC(Stringp) kVersion;
        DRC(Stringp) kVector;
#ifdef AVMPLUS_VERBOSE
        DRC(Stringp) knewline;
        DRC(Stringp) krightbracket;
        DRC(Stringp) kleftbracket;
        DRC(Stringp) kcolon;
        DRC(Stringp) ktabat;
        DRC(Stringp) kparens;
#endif
#if defined AVMPLUS_VERBOSE || defined FEATURE_SAMPLER
        DRC(Stringp) kanonymousFunc;
#endif
        Atom kNaN;

        DRC(Stringp) cachedChars[128];
        AvmCore(MMgc::GC *gc);

        ~AvmCore();

        void initBuiltinPool();
        
        Toplevel* initTopLevel();       

        virtual size_t getToplevelSize() const;
        virtual Toplevel* createToplevel(VTable *vtable);
        
    public:
        uint32 toUInt32(Atom atom) const
        {
            return (uint32)integer(atom);
        }

        double toInteger(Atom atom) const
        {
            if ((atom & 7) == kIntegerType) {
                return (double) (atom>>3);
            } else {
                return MathUtils::toInt(number(atom));
            }
        }

#ifdef AVMPLUS_64BIT
        int64   integer64(Atom atom)            { return (int64)integer(atom); }
        static  int64 integer64_i(Atom atom)    { return (int64)integer_i(atom); }
        static  int64 integer64_d(double d)     { return (int64)integer_d_sse2(d); }
        static  int64 integer64_d_sse2(double d){ return (int64)integer_d_sse2(d); }
#endif
        int integer(Atom atom) const;

        // convert atom to integer when we know it is already a legal signed-32 bit int value
        static int integer_i(Atom a)
        {
            if ((a&7) == kIntegerType)
                return int(a>>3);
            else
                // TODO since we know value is legal int, use faster d->i
                return MathUtils::real2int(atomToDouble(a));
        }

        // convert atom to integer when we know it is already a legal unsigned-32 bit int value
        static uint32 integer_u(Atom a)
        {
            if ((a&7) == kIntegerType)
            {
                return uint32(a>>3);
            }
            else
            {
                // TODO figure out real2int for unsigned
                return (uint32) atomToDouble(a);
            }
        }

#ifdef AVMPLUS_AMD64
        static int integer_d(double d) {
            return integer_d_sse2(d);
        }
        Atom doubleToAtom(double n) {
            return doubleToAtom_sse2(n);
        }
#else
        static int integer_d(double d);
        Atom doubleToAtom(double n);
#endif

#if defined (AVMPLUS_IA32) || defined(AVMPLUS_AMD64)
        static int integer_d_sse2(double d);
        Atom doubleToAtom_sse2(double n);
#endif

    private:
        static int doubleToInt32(double d);

    public:
        static double number_d(Atom a)
        {
            AvmAssert(isNumber(a));

            if ((a&7) == kIntegerType)
                return (int)(a>>3);
            else
                return atomToDouble(a);
        }

        Atom intAtom(Atom atom)
        {
            return intToAtom(integer(atom));
        }

        Atom uintAtom(Atom atom)
        {
            return uintToAtom(toUInt32(atom));
        }

        int boolean(Atom atom);

        Stringp string(Atom atom);

        Stringp coerce_s(Atom atom);

        static bool isString(Atom atom)
        {
            return (atom&0x7) == kStringType && !isNull(atom);
        }

        static bool isName(Atom atom)
        {
            return isString(atom) && atomToString(atom)->isInterned();
        }

        Stringp intern(Atom atom);

        Namespace* internNamespace(Namespace* ns);

        static int readS24(const byte *pc)
        {
            #ifdef AVMPLUS_UNALIGNED_ACCESS
                // unaligned short access still faster than 2 byte accesses
                return ((uint16_t*)pc)[0] | ((int8_t*)pc)[2]<<16;
            #else
                return pc[0] | pc[1]<<8 | ((int8_t*)pc)[2]<<16;
            #endif
        }

        static int calculateInstructionWidth(const byte* p)
        {
            int a, b;
            unsigned int c, d;
            const byte* p2 = p;
            readOperands(p2, c, a, d, b);
            return int(p2-p);
        }

        static void readOperands(const byte* &pc, unsigned int& imm32, int& imm24, unsigned int& imm32b, int& imm8 )
        {
            AbcOpcode opcode = (AbcOpcode)*pc++;
            int op_count = opOperandCount[opcode];

            imm8 = pc[0];
            if( opcode == OP_pushbyte || opcode == OP_debug )
            {
                // these two operands have a byte as their first operand, which is not encoded
                // with the variable length encoding scheme for bigger numbers, because it will
                // never be larger than a byte.
                --op_count;
                pc++;
            }

            if( op_count > 0 )
            {
                if( opcode >= OP_ifnlt && opcode <= OP_lookupswitch )
                {
                    imm24 = AvmCore::readS24(pc);
                    pc += 3;
                }
                else
                {
                    imm32 = AvmCore::readU30(pc);
                }

                if( opcode == OP_debug )
                {
                    --op_count; //OP_debug has a third operand of a byte
                    pc++;
                }
                if( op_count > 1 )
                {
                    imm32b = AvmCore::readU30(pc);
                }
            }
        }
        static uint32 readU30(const byte *&p)
        {
            unsigned int result = p[0];
            if (!(result & 0x00000080))
            {
                p++;
                return result;
            }
            result = (result & 0x0000007f) | p[1]<<7;
            if (!(result & 0x00004000))
            {
                p += 2;
                return result;
            }
            result = (result & 0x00003fff) | p[2]<<14;
            if (!(result & 0x00200000))
            {
                p += 3;
                return result;
            }
            result = (result & 0x001fffff) | p[3]<<21;
            if (!(result & 0x10000000))
            {
                p += 4;
                return result;
            }
            result = (result & 0x0fffffff) | p[4]<<28;
            p += 5;
            return result;
        }

        static int32_t readU16(const byte *pc)
        {
            #ifdef AVMPLUS_UNALIGNED_ACCESS
                // unaligned short access still faster than 2 byte accesses
                return *((uint16_t*)pc);
            #else
                return pc[0] | pc[1]<<8;
            #endif
        }

        bool istype(Atom atom, Traits* itraits);

        Atom istypeAtom(Atom atom, Traits* itraits) { 
            return istype(atom, itraits) ? trueAtom : falseAtom; 
        }

        void increment_d(Atom *atom, int delta);

        void increment_i(Atom *atom, int delta);
        
        Atom primitive(Atom atom);

        Atom booleanAtom(Atom atom);

        Atom numberAtom(Atom atom);
        
        double number(Atom atom) const;

        Atom constant(const char *s)
        {
            return constantString(s)->atom();
        }

        Stringp constantString(const char *s);

        virtual void interrupt(MethodEnv *env) = 0;

        virtual void stackOverflow(MethodEnv *env) = 0;

        void _stackOverflow(MethodEnv *env) { stackOverflow(env); }
        
        void throwAtom(Atom atom);

        void throwException(Exception *exception);

        void throwErrorV(ClassClosure *type, int errorID, Stringp arg1=0, Stringp arg2=0, Stringp arg3=0);

        String* formatErrorMessageV( int errorID, Stringp arg1=0, Stringp arg2=0, Stringp arg3=0);

        String* toErrorString(int d);
        String* toErrorString(AbstractFunction* m);
        String* toErrorString(const Multiname* n);
        String* toErrorString(Namespace* ns);
        String* toErrorString(Traits* t);
        String* toErrorString(const char* s);
        String* toErrorString(const wchar* s);
        String* atomToErrorString(Atom a);

        virtual String* getErrorMessage(int errorID);

        #ifdef DEBUGGER

        bool willExceptionBeCaught(Exception* exception);

        String* findErrorMessage(int errorID,
                                 int* mapTable,
                                 const char** errorTable,
                                 int numErrors);

        virtual int determineLanguage();
        int langID;
        

        StackTrace* newStackTrace();

        #ifdef _DEBUG
        void dumpStackTrace();
        #endif
#endif /* DEBUGGER */

        CallStackNode *callStack;

#ifdef FEATURE_SAMPLER

        Sampler *sampler() { return &_sampler; }
        void sampleCheck() { _sampler.sampleCheck(); }
        bool sampling() { return _sampler.sampling; }
        bool passAllExceptionsToDebugger;

#endif

        CodeContextAtom codeContextAtom;

        CodeContext* codeContext() const;

        ExceptionFrame *exceptionFrame;
        
        Exception *exceptionAddr;

        ExceptionHandler* findExceptionHandler(MethodInfo *info,
                                               sintptr pc,
                                               Exception *exception);
        
        ExceptionHandler* beginCatch(ExceptionFrame *ef,
                MethodInfo *info, sintptr pc, Exception *exception);

        ExceptionHandler* findExceptionHandlerNoRethrow(MethodInfo *info,
                                                        sintptr pc,
                                                        Exception *exception);

        bool isXML (Atom atm);

        /* Returns tru if the atom is a Date object */
        bool isDate(Atom atm);

        // From http://www.w3.org/TR/2004/REC-xml-20040204/#NT-Name
        bool isLetter (wchar c);
        bool isDigit (wchar c);
        bool isCombiningChar (wchar c);
        bool isExtender (wchar c);

        Stringp ToXMLString (Atom a);
        Stringp EscapeElementValue (const Stringp s, bool removeLeadingTrailingWhitespace);
        Stringp EscapeAttributeValue (Atom v);

        E4XNode *atomToXML (Atom atm);

        XMLObject *atomToXMLObject (Atom atm);

        bool isXMLList (Atom atm);

        XMLListObject *atomToXMLList (Atom atm);

        bool isQName (Atom atm);

        bool isDictionary (Atom atm);

        bool isDictionaryLookup(Atom key, Atom obj)
        {
            return isObject(key) && isDictionary(obj);
        }

        bool isXMLName(Atom arg);

        QNameObject *atomToQName (Atom atm);

        Stringp _typeof (Atom arg);

        Hashtable *xmlEntities;
        
    private:
        DECLARE_NATIVE_CLASSES()
        DECLARE_NATIVE_SCRIPTS()

        void registerNatives(NativeTableEntryp nativeMap, AbstractFunction *nativeMethods[]);

        //
        // this used to be Heap
        //

        int stringCount;

        int deletedCount;
        #define AVMPLUS_STRING_DELETED ((Stringp)(1))

        int nsCount;

        int numStrings;
        int numNamespaces;
                
    public:

        static Namespace *atomToNamespace(Atom atom)
        {
            AvmAssert((atom&7)==kNamespaceType);
            return (Namespace*)(atom&~7);
        }
        
        static double atomToDouble(Atom atom)
        {
            AvmAssert((atom&7)==kDoubleType);

            double* obj = (double*)(atom&~7);
            return *obj;
        }

        static Stringp atomToString(Atom atom)
        {
            AvmAssert((atom&7)==kStringType);
            return (Stringp)(atom&~7);
        }

        // Avoid adding validation checks here and returning NULL.  If this
        // is returning a bad value, the higher level function should be fixed
        // or AbcParser/Verifier should be enhanced to catch this case.
        static ScriptObject* atomToScriptObject(const Atom atom)
        {
            AvmAssert((atom&7)==kObjectType);
            return (ScriptObject*)(atom&~7);
        }
    
        // helper function, allows generic objects to work with Hashtable
        // and AtomArray, uses double type which is the only non-RC
        // GCObject type
        static Atom gcObjectToAtom(const void* obj);
        static const void* atomToGCObject(Atom a) { return (const void*)(a&~7); }
        static bool isGCObject(Atom a) { return (a&7)==kDoubleType; }

    private:
        int findString(const wchar *s, int len);

        int findNamespace(const Namespace *ns);

    public:
        Stringp internString(Stringp s);
        Stringp internString(Atom atom);
        Stringp internInt(int n);
        Stringp internDouble(double d);
        Stringp internUint32(uint32 ui);

        Stringp internAlloc(const wchar *s, int len);
        Stringp internAllocUtf8(const byte *s, int len);

#ifdef FEATURE_SAMPLER

        Stringp findInternedString(const char *s, int len);
#endif

        bool getIndexFromAtom (Atom a, uint32 *result) const
        {
            if (AvmCore::isInteger(a))
            {
                *result = uint32(a >> 3);
                return true;
            }
            else
            {
                AvmAssert (AvmCore::isString(a));
                return AvmCore::getIndexFromString (atomToString (a), result); 
            }
        }

        static bool getIndexFromString(Stringp s, uint32 *result);
            
        ScriptBufferImpl* newScriptBuffer(size_t size);
        VTable* newVTable(Traits* traits, VTable* base, ScopeChain* scope, AbcEnv* abcEnv, Toplevel* toplevel);

        RegExpObject* newRegExp(RegExpClass* regExpClass,
                                Stringp pattern,
                                Stringp options);

        ScriptObject* newObject(VTable* ivtable, ScriptObject *delegate);

        Traits* newTraits(Traits *base,
                          int nameCount,
                          int interfaceCount,
                          uint32 sizeofInstance);
        
        Namespace* newNamespace(Atom prefix, Atom uri, Namespace::NamespaceType type = Namespace::NS_Public);
        Namespace* newNamespace(Atom uri, Namespace::NamespaceType type = Namespace::NS_Public);
        Namespace* newNamespace(Stringp uri, Namespace::NamespaceType type = Namespace::NS_Public);
        Namespace* newPublicNamespace(Stringp uri) { return newNamespace(uri); }
        NamespaceSet* newNamespaceSet(int nsCount);

        // String creation
        Stringp newString(const char *str) const;
        Stringp newString(const wchar *str) const;
        Stringp newString(const char *str, int len) const;      

        Stringp uintToString(uint32 i);
        Stringp intToString(int i);
        Stringp doubleToString(double d);
        Stringp concatStrings(Stringp s1, Stringp s2) const;
        
        Atom uintToAtom(uint32 n);
        Atom intToAtom(int n);

        Atom allocDouble(double n)
        {
            union { 
                double *d;
                void *v;
            };
            v = GetGC()->Alloc(sizeof(double), 0);
            *d = n;
            return kDoubleType | (uintptr)v;
        }
        
        void rehashStrings(int newlen);
        void rehashNamespaces(int newlen);

        // static version for smart pointers
        static void atomWriteBarrier(MMgc::GC *gc, const void *container, Atom *address, Atom atomNew);
#ifdef MMGC_DRC
        static void decrementAtomRegion(Atom *ar, int length);
#endif

#ifdef AVMPLUS_VERBOSE
    public:
        Stringp format(Atom atom);
        Stringp formatAtomPtr(Atom atom);
#endif

    private:
        // hash set containing intern'ed strings
        DRC(Stringp) * strings;
        // hash set containing namespaces
        DRC(Namespacep) * namespaces;

#ifdef AVMPLUS_INTERNINT_CACHE
        // See code in AvmCore::internInt
        // cache of interned names of nonnegative integers (numeric value % 256)
        class IndexString : public MMgc::GCObject {
        public:
            int value;
            DRCWB(Stringp) string;
        };
        
        IndexString* index_strings[256];
#endif
        
#ifdef AVMPLUS_WORD_CODE
    private:
        // Saturating counter.  
        uint32 lookup_cache_timestamp;
    public:
        uint32 lookupCacheTimestamp() { return lookup_cache_timestamp == ~0U ? 0 : lookup_cache_timestamp; }
        bool   lookupCacheIsValid(uint32 t) { return t == lookup_cache_timestamp; }
        void   invalidateLookupCache() { if (lookup_cache_timestamp != ~0U) ++lookup_cache_timestamp; }
#endif
        
        // avoid multiple inheritance issues
        class GCInterface : MMgc::GCCallback
        {
        public:
            GCInterface(MMgc::GC * _gc) : MMgc::GCCallback(_gc), core(NULL) {}
            void SetCore(AvmCore* _core) { this->core = _core; }
            void presweep() { if(core) core->presweep(); }
            void postsweep() { if(core) core->postsweep(); }
            void log(const char *str) { if(core) core->console << str; }
        private:
            AvmCore *core;
        };
        GCInterface gcInterface;

#ifdef FEATURE_SAMPLER
    private:
        Sampler _sampler;
#endif
    };
}

#endif /* __avmplus_AvmCore__ */

---