johnson 1.2.0 → 2.0.0.pre0

data/vendor/tracemonkey/nanojit/Assembler.h

@@ -0,0 +1,375 @@
+/* -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: t; tab-width: 4 -*- */
+/* ***** 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-2007
+ * 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 __nanojit_Assembler__
+#define __nanojit_Assembler__
+
+
+namespace nanojit
+{
+	/**
+	 * Some notes on this Assembler (Emitter).
+	 * 
+	 *     LIR_call is a generic call operation that is encoded using form [2].  The 24bit
+	 *     integer is used as an index into a function look-up table that contains information
+	 *     about the target that is to be called; including address, # parameters, etc.
+	 * 
+	 *   The class RegAlloc is essentially the register allocator from MIR
+	 * 
+	 *   The Assembler class parses the LIR instructions starting at any point and converts 
+	 *   them to machine code.  It does the translation using expression trees which are simply
+	 *   LIR instructions in the stream that have side-effects.  Any other instruction in the 
+	 *   stream is simply ignored.  
+	 *   This approach is interesting in that dead code elimination occurs for 'free', strength
+	 *   reduction occurs fairly naturally, along with some other optimizations.
+	 * 
+	 *   A negative is that we require state as we 'push' and 'pop' nodes along the tree.  
+	 *   Also, this is most easily performed using recursion which may not be desirable in 
+	 *   the mobile environment. 
+	 *   
+	 */
+
+	#define STACK_GRANULARITY		sizeof(void *)
+
+	/**
+	 * The Assembler is only concerned with transforming LIR to native instructions
+	 */
+    struct Reservation
+	{
+		uint32_t arIndex:16;	/* index into stack frame.  displ is -4*arIndex */
+		Register reg:15;			/* register UnkownReg implies not in register */
+        uint32_t used:1;
+	};
+
+	struct AR
+	{
+		LIns*			entry[ NJ_MAX_STACK_ENTRY ];	/* maps to 4B contiguous locations relative to the frame pointer */
+		uint32_t		tos;							/* current top of stack entry */
+		uint32_t		highwatermark;					/* max tos hit */
+		uint32_t		lowwatermark;					/* we pre-allocate entries from 0 upto this index-1; so dynamic entries are added above this index */
+	};
+
+	#ifdef AVMPLUS_WIN32
+		#define AVMPLUS_ALIGN16(type) __declspec(align(16)) type
+	#else
+		#define AVMPLUS_ALIGN16(type) type __attribute__ ((aligned (16)))
+	#endif
+
+	struct Stats
+	{
+		counter_define(steals;)
+		counter_define(remats;)
+		counter_define(spills;)
+		counter_define(native;)
+        counter_define(exitnative;)
+		
+		int32_t pages;
+		NIns* codeStart;
+		NIns* codeExitStart;
+
+		DECLARE_PLATFORM_STATS()
+#ifdef __GNUC__
+		// inexplicably, gnuc gives padding/alignment warnings without this. pacify it.
+		bool pad[4];
+#endif
+	};
+
+	class Fragmento;
+	
+	// error codes
+	enum AssmError
+	{
+		 None = 0
+		,OutOMem
+		,StackFull
+		,ResvFull
+		,RegionFull
+        ,MaxLength
+        ,MaxExit
+        ,MaxXJump
+        ,UnknownPrim
+        ,UnknownBranch
+	};
+
+	typedef avmplus::List<NIns*, avmplus::LIST_NonGCObjects> NInsList;
+	typedef avmplus::SortedMap<LIns*,NIns*,avmplus::LIST_NonGCObjects> InsMap;
+	typedef avmplus::SortedMap<NIns*,LIns*,avmplus::LIST_NonGCObjects> NInsMap;
+
+    class LabelState MMGC_SUBCLASS_DECL
+    {
+    public:
+        RegAlloc regs;
+        NIns *addr;
+        LabelState(NIns *a, RegAlloc &r) : regs(r), addr(a)
+        {}
+    };
+
+    class LabelStateMap
+    {
+        avmplus::GC *gc;
+        avmplus::SortedMap<LIns*, LabelState*, avmplus::LIST_GCObjects> labels;
+    public:
+        LabelStateMap(avmplus::GC *gc) : gc(gc), labels(gc)
+        {}
+        ~LabelStateMap();
+
+        void clear();
+        void add(LIns *label, NIns *addr, RegAlloc &regs);
+        LabelState *get(LIns *);
+    };
+    /**
+ 	 * Information about the activation record for the method is built up 
+ 	 * as we generate machine code.  As part of the prologue, we issue
+	 * a stack adjustment instruction and then later patch the adjustment
+	 * value.  Temporary values can be placed into the AR as method calls
+	 * are issued.   Also MIR_alloc instructions will consume space.
+	 */
+	class Assembler MMGC_SUBCLASS_DECL
+	{
+		friend class DeadCodeFilter;
+		friend class VerboseBlockReader;
+		public:
+			#ifdef NJ_VERBOSE
+			static char  outline[8192]; 
+			static char  outlineEOL[512];  // string to be added to the end of the line
+			static char* outputAlign(char* s, int col); 
+
+			void FASTCALL outputForEOL(const char* format, ...);
+			void FASTCALL output(const char* s); 
+			void FASTCALL outputf(const char* format, ...); 
+			void FASTCALL output_asm(const char* s); 
+			
+			bool _verbose, outputAddr, vpad[2];  // if outputAddr=true then next asm instr. will include address in output
+			void printActivationState();
+
+			StringList* _outputCache;
+			#endif
+
+			Assembler(Fragmento* frago);
+            ~Assembler() {}
+
+			void		assemble(Fragment* frag, NInsList& loopJumps);
+			void		endAssembly(Fragment* frag, NInsList& loopJumps);
+			void		beginAssembly(Fragment *frag, RegAllocMap* map);
+			void		copyRegisters(RegAlloc* copyTo);
+			void		releaseRegisters();
+            void        patch(GuardRecord *lr);
+            void        patch(SideExit *exit);
+#ifdef NANOJIT_IA32
+			void        patch(SideExit* exit, SwitchInfo* si);
+#endif
+			AssmError   error()	{ return _err; }
+			void		setError(AssmError e) { _err = e; }
+			void		setCallTable(const CallInfo *functions);
+			void		pageReset();
+			int32_t		codeBytes();
+			Page*		handoverPages(bool exitPages=false);
+
+			debug_only ( void		pageValidate(); )
+			debug_only ( bool		onPage(NIns* where, bool exitPages=false); )
+			
+			// support calling out from a fragment ; used to debug the jit
+			debug_only( void		resourceConsistencyCheck(); )
+			debug_only( void		registerConsistencyCheck(); )
+			
+			Stats		_stats;		
+            int hasLoop;
+
+		private:
+			
+			void		gen(LirFilter* toCompile, NInsList& loopJumps);
+			NIns*		genPrologue();
+			NIns*		genEpilogue();
+
+			uint32_t	arReserve(LIns* l);
+			void    	arFree(uint32_t idx);
+			void		arReset();
+
+			Register	registerAlloc(RegisterMask allow);
+			void		registerResetAll();
+			void		evictRegs(RegisterMask regs);
+            void        evictScratchRegs();
+			void		intersectRegisterState(RegAlloc& saved);
+			void		unionRegisterState(RegAlloc& saved);
+            void        assignSaved(RegAlloc &saved, RegisterMask skip);
+	        LInsp       findVictim(RegAlloc& regs, RegisterMask allow);
+
+            Register    getBaseReg(LIns *i, int &d, RegisterMask allow);
+            int			findMemFor(LIns* i);
+			Register	findRegFor(LIns* i, RegisterMask allow);
+			void		findRegFor2(RegisterMask allow, LIns* ia, Reservation* &ra, LIns *ib, Reservation* &rb);
+			Register	findSpecificRegFor(LIns* i, Register w);
+			Register	prepResultReg(LIns *i, RegisterMask allow);
+			void		freeRsrcOf(LIns *i, bool pop);
+			void		evict(Register r);
+			RegisterMask hint(LIns*i, RegisterMask allow);
+
+			NIns*		pageAlloc(bool exitPage=false);
+			void		pagesFree(Page*& list);
+			void		internalReset();
+            bool        canRemat(LIns*);
+
+			Reservation* reserveAlloc(LInsp i);
+			void		reserveFree(LInsp i);
+			void		reserveReset();
+
+			Reservation* getresv(LIns *x) {
+                uint32_t resv_index = x->resv();
+                return resv_index ? &_resvTable[resv_index] : 0;
+            }
+
+			DWB(Fragmento*)		_frago;
+			avmplus::GC*		_gc;
+            DWB(Fragment*)		_thisfrag;
+			RegAllocMap*		_branchStateMap;
+		
+			const CallInfo	*_functions;
+			
+			NIns*		_nIns;			// current native instruction
+			NIns*		_nExitIns;		// current instruction in exit fragment page
+			NIns*		_startingIns;	// starting location of code compilation for error handling
+			NIns*       _epilogue;
+			Page*		_nativePages;	// list of NJ_PAGE_SIZE pages that have been alloc'd
+			Page*		_nativeExitPages; // list of pages that have been allocated for exit code
+			AssmError	_err;			// 0 = means assemble() appears ok, otherwise it failed
+
+			AR			_activation;
+			RegAlloc	_allocator;
+
+			LabelStateMap	_labels; 
+			NInsMap		_patches;
+			Reservation _resvTable[ NJ_MAX_STACK_ENTRY ]; // table where we house stack and register information
+			uint32_t	_resvFree;
+			bool		_inExit, vpad2[3];
+            InsList     pending_lives;
+
+			void		asm_cmp(LIns *cond);
+			void		asm_fcmp(LIns *cond);
+            void        asm_setcc(Register res, LIns *cond);
+            NIns *      asm_jmpcc(bool brOnFalse, LIns *cond, NIns *target);
+			void		asm_mmq(Register rd, int dd, Register rs, int ds);
+            NIns*       asm_exit(LInsp guard);
+			NIns*		asm_leave_trace(LInsp guard);
+            void        asm_qjoin(LIns *ins);
+            void        asm_store32(LIns *val, int d, LIns *base);
+            void        asm_store64(LIns *val, int d, LIns *base);
+			void		asm_restore(LInsp, Reservation*, Register);
+			void		asm_load(int d, Register r);
+			void		asm_spilli(LInsp i, Reservation *resv, bool pop);
+			void		asm_spill(Register rr, int d, bool pop, bool quad);
+			void		asm_load64(LInsp i);
+			void		asm_pusharg(LInsp p);
+			void		asm_quad(LInsp i);
+			void		asm_loop(LInsp i, NInsList& loopJumps);
+			void		asm_fcond(LInsp i);
+			void		asm_cond(LInsp i);
+			void		asm_arith(LInsp i);
+			void		asm_neg_not(LInsp i);
+			void		asm_ld(LInsp i);
+			void		asm_cmov(LInsp i);
+			void		asm_param(LInsp i);
+			void		asm_int(LInsp i);
+			void		asm_short(LInsp i);
+			void		asm_qlo(LInsp i);
+			void		asm_qhi(LInsp i);
+			void		asm_fneg(LInsp ins);
+			void		asm_fop(LInsp ins);
+			void		asm_i2f(LInsp ins);
+			void		asm_u2f(LInsp ins);
+			Register	asm_prep_fcall(Reservation *rR, LInsp ins);
+			void		asm_nongp_copy(Register r, Register s);
+			void		asm_call(LInsp);
+            void        asm_arg(ArgSize, LInsp, Register);
+			Register	asm_binop_rhs_reg(LInsp ins);
+			NIns*		asm_branch(bool branchOnFalse, LInsp cond, NIns* targ, bool isfar);
+			void        asm_switch(LIns* ins, NIns* target);
+			void        emitJumpTable(SwitchInfo* si, NIns* target);
+            void        assignSavedRegs();
+            void        reserveSavedRegs();
+            void        assignParamRegs();
+            void        handleLoopCarriedExprs();
+			
+			// flag values for nMarkExecute
+			enum 
+			{
+				PAGE_READ = 0x0,	// here only for clarity: all permissions include READ
+				PAGE_WRITE = 0x01,
+				PAGE_EXEC = 0x02
+			};
+			
+			// platform specific implementation (see NativeXXX.cpp file)
+			void		nInit(AvmCore *);
+			Register	nRegisterAllocFromSet(int32_t set);
+			void		nRegisterResetAll(RegAlloc& a);
+			void		nMarkExecute(Page* page, int flags);
+			void		nFrameRestore(RegisterMask rmask);
+			NIns*    	nPatchBranch(NIns* branch, NIns* location);
+			void		nFragExit(LIns* guard);
+
+			// platform specific methods
+        public:
+			const static Register savedRegs[NumSavedRegs];
+			DECLARE_PLATFORM_ASSEMBLER()
+
+		private:
+			debug_only( int32_t	_fpuStkDepth; )
+			debug_only( int32_t	_sv_fpuStkDepth; )
+
+			// since we generate backwards the depth is negative
+			inline void fpu_push() {
+				debug_only( ++_fpuStkDepth; /*char foo[8]= "FPUSTK0"; foo[6]-=_fpuStkDepth; output_asm(foo);*/ NanoAssert(_fpuStkDepth<=0); )
+			} 
+			inline void fpu_pop() { 
+				debug_only( --_fpuStkDepth; /*char foo[8]= "FPUSTK0"; foo[6]-=_fpuStkDepth; output_asm(foo);*/ NanoAssert(_fpuStkDepth<=0); )
+			}
+	#ifdef AVMPLUS_PORTING_API
+			// these pointers are required to store
+			// the address range where code has been
+			// modified so we can flush the instruction cache.
+			void* _endJit2Addr;
+	#endif // AVMPLUS_PORTING_API
+			avmplus::Config &config;
+	};
+
+	inline int32_t disp(Reservation* r) 
+	{
+		return stack_direction((int32_t)STACK_GRANULARITY) * int32_t(r->arIndex) + NJ_STACK_OFFSET; 
+	}
+}
+#endif // __nanojit_Assembler__

data/vendor/tracemonkey/nanojit/Fragmento.cpp

@@ -0,0 +1,651 @@
+/* -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: t; tab-width: 4 -*- */
+/* ***** 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-2007
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Adobe AS3 Team
+ *   Mozilla TraceMonkey Team
+ *   Asko Tontti <atontti@cc.hut.fi>
+ *
+ * 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 ***** */
+
+#include "nanojit.h"
+#undef MEMORY_INFO
+
+namespace nanojit
+{	
+	#ifdef FEATURE_NANOJIT
+
+	using namespace avmplus;
+
+	static uint32_t calcSaneCacheSize(uint32_t in)
+	{
+		if (in < uint32_t(NJ_LOG2_PAGE_SIZE)) return NJ_LOG2_PAGE_SIZE;	// at least 1 page
+		if (in > 32) return 32;	// 4GB should be enough for anyone
+		return in;
+	}
+
+	/**
+	 * This is the main control center for creating and managing fragments.
+	 */
+	Fragmento::Fragmento(AvmCore* core, uint32_t cacheSizeLog2) 
+		:
+#ifdef NJ_VERBOSE
+		  enterCounts(NULL),
+		  mergeCounts(NULL),
+		  labels(NULL),
+#endif
+		  _frags(core->GetGC()),
+		  _freePages(core->GetGC(), 1024),
+		  _allocList(core->GetGC()),
+		  _gcHeap(NULL),
+		  _max_pages(1 << (calcSaneCacheSize(cacheSizeLog2) - NJ_LOG2_PAGE_SIZE)),
+		  _pagesGrowth(1)
+	{
+#ifdef _DEBUG
+		{
+			// XXX These belong somewhere else, but I can't find the
+			//     right location right now.
+			NanoStaticAssert((LIR_lt ^ 3) == LIR_ge);
+			NanoStaticAssert((LIR_le ^ 3) == LIR_gt);
+			NanoStaticAssert((LIR_ult ^ 3) == LIR_uge);
+			NanoStaticAssert((LIR_ule ^ 3) == LIR_ugt);
+			NanoStaticAssert((LIR_flt ^ 3) == LIR_fge);
+			NanoStaticAssert((LIR_fle ^ 3) == LIR_fgt);
+
+			/* Opcodes must be strictly increasing without holes. */
+			uint32_t count = 0;
+			#define OPDEF(op, number, operands) \
+				NanoAssertMsg(LIR_##op == count++, "misnumbered opcode");
+			#define OPDEF64(op, number, operands) OPDEF(op, number, operands)
+			#include "LIRopcode.tbl"
+			#undef OPDEF
+			#undef OPDEF64
+		}
+#endif
+
+#ifdef MEMORY_INFO
+		_allocList.set_meminfo_name("Fragmento._allocList");
+#endif
+		NanoAssert(_max_pages > _pagesGrowth); // shrink growth if needed 
+		_core = core;
+		GC *gc = core->GetGC();
+		_assm = NJ_NEW(gc, nanojit::Assembler)(this);
+		verbose_only( enterCounts = NJ_NEW(gc, BlockHist)(gc); )
+		verbose_only( mergeCounts = NJ_NEW(gc, BlockHist)(gc); )
+
+		memset(&_stats, 0, sizeof(_stats));
+	}
+
+	Fragmento::~Fragmento()
+	{
+        AllocEntry *entry;
+
+		clearFrags();
+        _frags.clear();		
+		_freePages.clear();
+		while( _allocList.size() > 0 )
+		{
+			//fprintf(stderr,"dealloc %x\n", (intptr_t)_allocList.get(_allocList.size()-1));
+#ifdef MEMORY_INFO
+			ChangeSizeExplicit("NanoJitMem", -1, _gcHeap->Size(_allocList.last()));
+#endif
+            entry = _allocList.removeLast();
+			_gcHeap->Free( entry->page, entry->allocSize );
+            NJ_DELETE(entry);
+		}
+        NJ_DELETE(_assm);
+#if defined(NJ_VERBOSE)
+        NJ_DELETE(enterCounts);
+        NJ_DELETE(mergeCounts);
+#endif
+	}
+
+	void Fragmento::trackPages()
+	{
+		const uint32_t pageUse = _stats.pages - _freePages.size();
+		if (_stats.maxPageUse < pageUse)
+			_stats.maxPageUse = pageUse;
+	}
+
+	Page* Fragmento::pageAlloc()
+	{
+        NanoAssert(sizeof(Page) == NJ_PAGE_SIZE);
+        if (!_freePages.size()) {
+            pagesGrow(_pagesGrowth);    // try to get more mem
+            if ((_pagesGrowth << 1) < _max_pages)
+                _pagesGrowth <<= 1;
+        }
+
+		trackPages();
+		Page* page = 0;
+		if (_freePages.size()) 
+			page = _freePages.removeLast();
+		return page;
+		}
+	
+	void Fragmento::pagesRelease(PageList& l)
+		{
+		_freePages.add(l);
+		l.clear();
+		NanoAssert(_freePages.size() <= _stats.pages);
+	}
+	
+	void Fragmento::pageFree(Page* page)
+	{ 
+		_freePages.add(page);
+		NanoAssert(_freePages.size() <= _stats.pages);
+	}
+
+	void Fragmento::pagesGrow(int32_t count)
+	{
+		NanoAssert(!_freePages.size());
+		MMGC_MEM_TYPE("NanojitFragmentoMem"); 
+		Page* memory = 0;
+        GC *gc = _core->GetGC();
+		if (_stats.pages < _max_pages)
+		{
+            AllocEntry *entry;
+
+            // make sure we don't grow beyond _max_pages
+            if (_stats.pages + count > _max_pages)
+                count = _max_pages - _stats.pages;
+            if (count < 0)
+                count = 0;
+			// @todo nastiness that needs a fix'n
+			_gcHeap = gc->GetGCHeap();
+			NanoAssert(int32_t(NJ_PAGE_SIZE)<=_gcHeap->kNativePageSize);
+			
+			// convert _max_pages to gc page count 
+			int32_t gcpages = (count*NJ_PAGE_SIZE) / _gcHeap->kNativePageSize;
+			MMGC_MEM_TYPE("NanoJitMem"); 
+			memory = (Page*)_gcHeap->Alloc(gcpages);
+#ifdef MEMORY_INFO
+			ChangeSizeExplicit("NanoJitMem", 1, _gcHeap->Size(memory));
+#endif
+			NanoAssert((int*)memory == pageTop(memory));
+			//fprintf(stderr,"head alloc of %d at %x of %d pages using nj page size of %d\n", gcpages, (intptr_t)memory, (intptr_t)_gcHeap->kNativePageSize, NJ_PAGE_SIZE);
+
+            entry = NJ_NEW(gc, AllocEntry);
+            entry->page = memory;
+            entry->allocSize = gcpages;
+            _allocList.add(entry);
+
+			_stats.pages += count;
+			Page* page = memory;
+			while(--count >= 0)
+			{
+				//fprintf(stderr,"Fragmento::pageGrow adding page %x ; %d\n", (unsigned)page, _freePages.size()+1);
+				_freePages.add(page++);
+			}
+			trackPages();
+		}
+	}
+	
+	// Clear the fragment. This *does not* remove the fragment from the
+	// map--the caller must take care of this.
+	void Fragmento::clearFragment(Fragment* f)
+	{
+		Fragment *peer = f->peer;
+		while (peer) {
+			Fragment *next = peer->peer;
+			peer->releaseTreeMem(this);
+			NJ_DELETE(peer);
+			peer = next;
+		}
+		f->releaseTreeMem(this);
+		NJ_DELETE(f);
+	}
+
+	void Fragmento::clearFrag(const void* ip)
+	{
+		if (_frags.containsKey(ip)) {
+			clearFragment(_frags.remove(ip));
+		}
+	}
+
+	void Fragmento::clearFrags()
+	{
+		// reclaim any dangling native pages
+		_assm->pageReset();
+
+        while (!_frags.isEmpty()) {
+            clearFragment(_frags.removeLast());
+		}
+
+		verbose_only( enterCounts->clear();)
+		verbose_only( mergeCounts->clear();)
+		verbose_only( _stats.flushes++ );
+		verbose_only( _stats.compiles = 0 );
+		//fprintf(stderr, "Fragmento.clearFrags %d free pages of %d\n", _stats.freePages, _stats.pages);
+	}
+
+	Assembler* Fragmento::assm()
+	{
+		return _assm;
+	}
+
+	AvmCore* Fragmento::core()
+	{
+		return _core;
+	}
+
+    Fragment* Fragmento::getAnchor(const void* ip)
+	{
+        Fragment *f = newFrag(ip);
+        Fragment *p = _frags.get(ip);
+        if (p) {
+            f->first = p;
+            /* append at the end of the peer list */
+            Fragment* next;
+            while ((next = p->peer) != NULL)
+                p = next;
+            p->peer = f;
+        } else {
+            f->first = f;
+            _frags.put(ip, f); /* this is the first fragment */
+        }
+        f->anchor = f;
+        f->root = f;
+        f->kind = LoopTrace;
+        verbose_only( addLabel(f, "T", _frags.size()); )
+        return f;
+	}
+	
+    Fragment* Fragmento::getLoop(const void* ip)
+	{
+        return _frags.get(ip);
+	}
+
+#ifdef NJ_VERBOSE
+	void Fragmento::addLabel(Fragment *f, const char *prefix, int id)
+	{
+		char fragname[20];
+		sprintf(fragname,"%s%d", prefix, id);
+		labels->add(f, sizeof(Fragment), 0, fragname);
+	}
+#endif
+
+	Fragment *Fragmento::getMerge(GuardRecord *lr, const void* ip)
+    {
+		Fragment *anchor = lr->exit->from->anchor;
+		for (Fragment *f = anchor->branches; f != 0; f = f->nextbranch) {
+			if (f->kind == MergeTrace && f->ip == ip /*&& f->calldepth == lr->calldepth*/) {
+				// found existing shared branch on anchor
+				return f;
+			}
+		}
+
+		Fragment *f = newBranch(anchor, ip);
+		f->root = f;
+		f->kind = MergeTrace;
+		verbose_only(
+			int mergeid = 1;
+			for (Fragment *g = anchor->branches; g != 0; g = g->nextbranch)
+				if (g->kind == MergeTrace)
+					mergeid++;
+			addLabel(f, "M", mergeid); 
+		)
+        return f;
+    }
+
+	Fragment *Fragmento::createBranch(SideExit* exit, const void* ip)
+    {
+        Fragment *f = newBranch(exit->from, ip);
+		f->kind = BranchTrace;
+		f->treeBranches = f->root->treeBranches;
+		f->root->treeBranches = f;
+        return f;
+    }
+
+#ifdef NJ_VERBOSE
+	struct fragstats {
+		int size;
+		uint64_t traceDur;
+		uint64_t interpDur;
+		int lir, lirbytes;
+	};
+
+	void Fragmento::dumpFragStats(Fragment *f, int level, fragstats &stat)
+    {
+        char buf[50];
+        sprintf(buf, "%*c%s", 1+level, ' ', labels->format(f));
+
+        int called = f->hits();
+        if (called >= 0)
+            called += f->_called;
+        else
+            called = -(1<<f->blacklistLevel) - called - 1;
+
+        uint32_t main = f->_native - f->_exitNative;
+
+        char cause[200];
+        if (f->_token && strcmp(f->_token,"loop")==0)
+            sprintf(cause,"%s %d", f->_token, f->xjumpCount);
+		else if (f->_token) {
+			if (f->eot_target) {
+				sprintf(cause,"%s %s", f->_token, labels->format(f->eot_target));
+			} else {
+	            strcpy(cause, f->_token);
+			}
+		}
+        else
+            cause[0] = 0;
+        
+        _assm->outputf("%-10s %7d %6d %6d %6d %4d %9llu %9llu %-12s %s", buf,
+            called, f->guardCount, main, f->_native, f->compileNbr, f->traceTicks/1000, f->interpTicks/1000,
+			cause, labels->format(f->ip));
+        
+        stat.size += main;
+		stat.traceDur += f->traceTicks;
+		stat.interpDur += f->interpTicks;
+		stat.lir += f->_lir;
+		stat.lirbytes += f->_lirbytes;
+
+		for (Fragment *x = f->branches; x != 0; x = x->nextbranch)
+			if (x->kind != MergeTrace)
+	            dumpFragStats(x,level+1,stat);
+        for (Fragment *x = f->branches; x != 0; x = x->nextbranch)
+			if (x->kind == MergeTrace)
+	            dumpFragStats(x,level+1,stat);
+
+        if (f->isAnchor() && f->branches != 0) {
+            _assm->output("");
+        }
+    }
+
+    class DurData { public:
+        DurData(): frag(0), traceDur(0), interpDur(0), size(0) {}
+        DurData(int): frag(0), traceDur(0), interpDur(0), size(0) {}
+        DurData(Fragment* f, uint64_t td, uint64_t id, int32_t s)
+			: frag(f), traceDur(td), interpDur(id), size(s) {}
+        Fragment* frag;
+        uint64_t traceDur;
+        uint64_t interpDur;
+		int32_t size;
+    };
+
+	void Fragmento::dumpRatio(const char *label, BlockHist *hist)
+	{
+		int total=0, unique=0;
+		for (int i = 0, n=hist->size(); i < n; i++) {
+			const void * id = hist->keyAt(i);
+			int c = hist->get(id);
+			if (c > 1) {
+				//_assm->outputf("%d %X", c, id);
+				unique += 1;
+			}
+			else if (c == 1) {
+				unique += 1;
+			}
+			total += c;
+		}
+		_assm->outputf("%s total %d unique %d ratio %.1f%", label, total, unique, double(total)/unique);
+	}
+
+	void Fragmento::dumpStats()
+	{
+		bool vsave = _assm->_verbose;
+		_assm->_verbose = true;
+
+		_assm->output("");
+		dumpRatio("inline", enterCounts);
+		dumpRatio("merges", mergeCounts);
+		_assm->outputf("abc %d il %d (%.1fx) abc+il %d (%.1fx)",
+			_stats.abcsize, _stats.ilsize, (double)_stats.ilsize/_stats.abcsize,
+			_stats.abcsize + _stats.ilsize,
+			double(_stats.abcsize+_stats.ilsize)/_stats.abcsize);
+
+		int32_t count = _frags.size();
+		int32_t pages =  _stats.pages;
+		int32_t maxPageUse =  _stats.maxPageUse;
+		int32_t free = _freePages.size();
+		int32_t flushes = _stats.flushes;
+		if (!count)
+		{
+			_assm->outputf("No fragments in cache, %d flushes", flushes);
+    		_assm->_verbose = vsave;
+            return;
+		}
+
+        _assm->outputf("\nFragment statistics");
+		_assm->outputf("  loop trees:     %d", count);
+		_assm->outputf("  flushes:        %d", flushes);
+		_assm->outputf("  compiles:       %d / %d", _stats.compiles, _stats.totalCompiles);
+		_assm->outputf("  used:           %dk / %dk", (pages-free)<<(NJ_LOG2_PAGE_SIZE-10), pages<<(NJ_LOG2_PAGE_SIZE-10));
+		_assm->outputf("  maxPageUse:     %dk", (maxPageUse)<<(NJ_LOG2_PAGE_SIZE-10));
+		_assm->output("\ntrace         calls guards   main native  gen   T-trace  T-interp");
+
+		avmplus::SortedMap<uint64_t, DurData, avmplus::LIST_NonGCObjects> durs(_core->gc);
+		uint64_t totaldur=0;
+		fragstats totalstat = { 0,0,0,0,0 };
+        for (int32_t i=0; i<count; i++)
+        {
+            Fragment *f = _frags.at(i);
+            while (true) {
+                fragstats stat = { 0,0,0,0,0 };
+                dumpFragStats(f, 0, stat);
+                if (stat.lir) {
+                    totalstat.lir += stat.lir;
+                    totalstat.lirbytes += stat.lirbytes;
+                }
+                uint64_t bothDur = stat.traceDur + stat.interpDur;
+                if (bothDur) {
+                    totalstat.interpDur += stat.interpDur;
+                    totalstat.traceDur += stat.traceDur;
+                    totalstat.size += stat.size;
+                    totaldur += bothDur;
+                    while (durs.containsKey(bothDur)) bothDur++;
+                    DurData d(f, stat.traceDur, stat.interpDur, stat.size);
+                    durs.put(bothDur, d);
+                }
+                if (!f->peer)
+                    break;
+                f = f->peer;
+            }
+        }
+		uint64_t totaltrace = totalstat.traceDur;
+		int totalsize = totalstat.size;
+
+		_assm->outputf("");
+		_assm->outputf("lirbytes %d / lir %d = %.1f bytes/lir", totalstat.lirbytes,
+            totalstat.lir, double(totalstat.lirbytes)/totalstat.lir);
+		_assm->outputf("       trace         interp");
+		_assm->outputf("%9lld (%2d%%)  %9lld (%2d%%)",
+			totaltrace/1000, int(100.0*totaltrace/totaldur),
+			(totaldur-totaltrace)/1000, int(100.0*(totaldur-totaltrace)/totaldur));
+		_assm->outputf("");
+		_assm->outputf("trace      ticks            trace           interp           size");
+		for (int32_t i=durs.size()-1; i >= 0; i--) {
+			uint64_t bothDur = durs.keyAt(i);
+			DurData d = durs.get(bothDur);
+			int size = d.size;
+			_assm->outputf("%-4s %9lld (%2d%%)  %9lld (%2d%%)  %9lld (%2d%%)  %6d (%2d%%)  %s", 
+				labels->format(d.frag),
+				bothDur/1000, int(100.0*bothDur/totaldur),
+				d.traceDur/1000, int(100.0*d.traceDur/totaldur),
+				d.interpDur/1000, int(100.0*d.interpDur/totaldur),
+				size, int(100.0*size/totalsize),
+				labels->format(d.frag->ip));
+		}
+
+		_assm->_verbose = vsave;
+
+	}
+
+	void Fragmento::countBlock(BlockHist *hist, const void* ip)
+	{
+		int c = hist->count(ip);
+		if (_assm->_verbose)
+			_assm->outputf("++ %s %d", labels->format(ip), c);
+	}
+
+	void Fragmento::countIL(uint32_t il, uint32_t abc)
+	{
+		_stats.ilsize += il;
+		_stats.abcsize += abc;
+	}
+	
+#ifdef AVMPLUS_VERBOSE
+	void Fragmento::drawTrees(char *fileName) {
+		drawTraceTrees(this, this->_frags, this->_core, fileName);
+	}
+#endif
+#endif // NJ_VERBOSE
+
+	//
+	// Fragment
+	//
+	Fragment::Fragment(const void* _ip)
+		:
+#ifdef NJ_VERBOSE
+		  _called(0),
+		  _native(0),
+		  _exitNative(0),
+		  _lir(0),
+		  _lirbytes(0),
+		  _token(NULL),
+		  traceTicks(0),
+		  interpTicks(0),
+		  eot_target(NULL),
+		  sid(0),
+		  compileNbr(0),
+#endif
+		  treeBranches(NULL),
+		  branches(NULL),
+		  nextbranch(NULL),
+		  anchor(NULL),
+		  root(NULL),
+		  parent(NULL),
+		  first(NULL),
+		  peer(NULL),
+		  lirbuf(NULL),
+		  lastIns(NULL),
+		  spawnedFrom(NULL),
+		  kind(LoopTrace),
+		  ip(_ip),
+		  guardCount(0),
+		  xjumpCount(0),
+		  recordAttempts(0),
+		  blacklistLevel(0),
+		  fragEntry(NULL),
+		  loopEntry(NULL),
+		  vmprivate(NULL),
+		  _code(NULL),
+		  _links(NULL),
+		  _hits(0),
+		  _pages(NULL)
+	{
+    }
+
+	Fragment::~Fragment()
+	{
+		onDestroy();
+		NanoAssert(_pages == 0);
+    }
+
+    void Fragment::resetHits()
+    {
+        blacklistLevel >>= 1;
+        _hits = 0;
+    }
+	
+    void Fragment::blacklist()
+    {
+        blacklistLevel++;
+        _hits = -(1<<blacklistLevel);
+    }
+
+    Fragment *Fragmento::newFrag(const void* ip)
+    {
+		GC *gc = _core->gc;
+        Fragment *f = NJ_NEW(gc, Fragment)(ip);
+		f->blacklistLevel = 5;
+        return f;
+    }
+
+	Fragment *Fragmento::newBranch(Fragment *from, const void* ip)
+	{
+		Fragment *f = newFrag(ip);
+		f->anchor = from->anchor;
+		f->root = from->root;
+        f->xjumpCount = from->xjumpCount;
+		/*// prepend
+		f->nextbranch = from->branches;
+		from->branches = f;*/
+		// append
+		if (!from->branches) {
+			from->branches = f;
+		} else {
+			Fragment *p = from->branches;
+			while (p->nextbranch != 0)
+				p = p->nextbranch;
+			p->nextbranch = f;
+		}
+		return f;
+	}
+
+	void Fragment::releaseLirBuffer()
+	{
+		lastIns = 0;	
+	}
+
+	void Fragment::releaseCode(Fragmento* frago)
+	{
+		_code = 0;
+		while(_pages)
+		{
+			Page* next = _pages->next;
+			frago->pageFree(_pages);
+			_pages = next;
+		}
+	}
+	
+	void Fragment::releaseTreeMem(Fragmento* frago)
+	{
+		releaseLirBuffer();
+		releaseCode(frago);
+			
+		// now do it for all branches 
+		Fragment* branch = branches;
+		while(branch)
+		{
+			Fragment* next = branch->nextbranch;
+			branch->releaseTreeMem(frago);  // @todo safer here to recurse in case we support nested trees
+            NJ_DELETE(branch);
+			branch = next;
+		}
+	}
+	#endif /* FEATURE_NANOJIT */
+}
+
+