This is a copy of regalloc_code2_BRANCH from Netscape's private repository,

as it existed in January of 1998.


git-svn-id: svn://10.0.0.236/branches/regalloc_code2_BRANCH@22571 18797224-902f-48f8-a5cc-f745e15eee43

mozilla/ef/Compiler/RegisterAllocator/BitSet.cpp

@@ -0,0 +1,134 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include "BitSet.h"
+
+// Return the next bit after index set to true or -1 if none.
+//
+Int32 BitSet::nextOne(Int32 pos) const
+{
+	++pos;
+
+	if (pos < 0 || Uint32(pos) >= universeSize)
+		return -1;
+
+	Uint32 offset = getWordOffset(pos);
+	Uint8 index = getBitOffset(pos);
+	Word* ptr = &word[offset];
+	Word currentWord = *ptr++ >> index;
+	
+	if (currentWord != Word(0)) {
+		while ((currentWord & Word(1)) == 0) {
+			++index;
+			currentWord >>= 1;
+		}
+		return (offset << nBitsInWordLog2) + index;
+	}
+
+	Word* limit = &word[getSizeInWords(universeSize)];
+	while (ptr < limit) {
+		++offset;
+		currentWord = *ptr++;
+		if (currentWord != Word(0)) {
+			index = 0;
+			while ((currentWord & Word(1)) == 0) {
+				++index;
+				currentWord >>= 1;
+			}
+			return (offset << nBitsInWordLog2) + index;
+		}
+	}
+	return -1;
+}
+
+// Return the next bit after index set to false or -1 if none.
+//
+Int32 BitSet::nextZero(Int32 pos) const
+{
+	++pos;
+
+	if (pos < 0 || Uint32(pos) >= universeSize)
+		return -1;
+
+	Uint32 offset = getWordOffset(pos);
+	Uint8 index = getBitOffset(pos);
+	Word* ptr = &word[offset];
+	Word currentWord = *ptr++ >> index;
+	
+	if (currentWord != Word(~0)) {
+		for (; index < nBitsInWord; ++index) {
+			if ((currentWord & Word(1)) == 0) {
+				Int32 ret = (offset << nBitsInWordLog2) + index;
+				return (Uint32(ret) < universeSize) ? ret : -1;
+			}
+			currentWord >>= 1;
+		}
+	}
+
+	Word* limit = &word[getSizeInWords(universeSize)];
+	while (ptr < limit) {
+		++offset;
+		currentWord = *ptr++;
+		if (currentWord != Word(~0)) {
+			for (index = 0; index < nBitsInWord; ++index) {
+				if ((currentWord & Word(1)) == 0) {
+					Int32 ret = (offset << nBitsInWordLog2) + index;
+					return (Uint32(ret) < universeSize) ? ret : -1;
+				}
+				currentWord >>= 1;
+			}
+		}
+	}
+	return -1;
+}
+
+#ifdef DEBUG_LOG
+
+// Print the set.
+//
+void BitSet::printPretty(LogModuleObject log)
+{
+	UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("[ "));
+
+	for (Int32 i = firstOne(); i != -1; i = nextOne(i)) {
+		Int32 currentBit = i;
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("%d", currentBit));
+
+		Int32 nextBit = nextOne(currentBit);
+		if (nextBit != currentBit + 1) {
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, (" "));
+			continue;
+		}
+		  
+		while ((nextBit != -1) && (nextBit == (currentBit + 1))) {
+			currentBit = nextBit;
+			nextBit = nextOne(nextBit);
+		}
+
+		if (currentBit > (i+1))
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("-%d ", currentBit));
+		else
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, (" %d ", currentBit));
+
+		i = currentBit;
+	}
+	UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("]\n"));
+}
+
+#endif // DEBUG_LOG

mozilla/ef/Compiler/RegisterAllocator/BitSet.h

@@ -0,0 +1,195 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _BITSET_H_
+#define _BITSET_H_
+
+#include "Fundamentals.h"
+#include "LogModule.h"
+#include "Pool.h"
+#include <string.h>
+
+//------------------------------------------------------------------------------
+// BitSet -
+
+class BitSet
+{
+private:
+
+#if (PR_BITS_PER_WORD == 64)
+	typedef Uint64 Word;
+#elif (PR_BITS_PER_WORD == 32)
+	typedef Uint32 Word;
+#endif
+
+	static const nBitsInWord = 		PR_BITS_PER_WORD;
+	static const nBytesInWord = 	PR_BYTES_PER_WORD;
+	static const nBitsInWordLog2 =	PR_BITS_PER_WORD_LOG2;
+	static const nBytesInWordLog2 = PR_BYTES_PER_WORD_LOG2;
+
+	// Return the number of Word need to store the universe.
+	static Uint32 getSizeInWords(Uint32 sizeOfUniverse) {return (sizeOfUniverse + (nBitsInWord - 1)) >> nBitsInWordLog2;}
+	// Return the given element offset in its containing Word.
+	static Uint32 getBitOffset(Uint32 element) {return element & (nBitsInWord - 1);}
+	// Return the Word offset for the given element int the universe.
+	static Uint32 getWordOffset(Uint32 element) {return element >> nBitsInWordLog2;}
+	// Return the mask for the given bit index.
+	static Word getMask(Uint8 index) {return Word(1) << index;}
+	
+private:
+
+	Uint32							universeSize;			// Size of the universe
+	Word*							word;					// universe memory.
+
+private:
+
+	// No copy constructor.
+	BitSet(const BitSet&);
+
+	// Check if the given set's universe is of the same size than this universe.
+	void checkUniverseCompatibility(const BitSet& set) const {assert(set.universeSize == universeSize);}
+	// Check if pos is valid for this set's universe.
+	void checkMember(Int32 pos) const {assert(pos >=0 && Uint32(pos) < universeSize);}
+
+public:
+
+	// Create a bitset of universeSize bits.
+	BitSet(Pool& pool, Uint32 universeSize) : universeSize(universeSize) {word = new(pool) Word[getSizeInWords(universeSize)]; clear();}
+
+	// Return the size of this bitset.
+	Uint32 getSize() const {return universeSize;}
+
+	// Clear the bitset.
+	void clear() {memset(word, 0x00, getSizeInWords(universeSize) << nBytesInWordLog2);}
+	// Clear the bit at index.
+	void clear(Uint32 index) {checkMember(index); word[getWordOffset(index)] &= ~getMask(index);}
+	// Set the bitset.
+	void set() {memset(word, 0xFF, getSizeInWords(universeSize) << nBytesInWordLog2);}
+	// Set the bit at index.
+	void set(Uint32 index) {checkMember(index); word[getWordOffset(index)] |= getMask(index);}
+	// Return true if the bit at index is set.
+	bool test(Uint32 index) const {checkMember(index); return (word[getWordOffset(index)] & getMask(index)) != 0;}
+	// Union with the given bitset.
+	inline void or(const BitSet& set);
+	// Intersection with the given bitset.
+	inline void and(const BitSet& set);
+	// Difference with the given bitset.
+	inline void difference(const BitSet& set);
+	// Copy set.
+	inline BitSet& operator = (const BitSet& set);
+	// Return true if the bitset are identical.
+	friend bool operator == (const BitSet& set1, const BitSet& set2);
+	// Return true if the bitset are different.
+	friend bool operator != (const BitSet& set1, const BitSet& set2);
+
+	// Logical operators.
+	BitSet& operator |= (const BitSet& set) {or(set); return *this;}
+	BitSet& operator &= (const BitSet& set) {and(set); return *this;}
+	BitSet& operator -= (const BitSet& set) {difference(set); return *this;}
+
+	// Return the first bit at set to true or -1 if none.
+	Int32 firstOne() const {return nextOne(-1);}
+	// Return the next bit after index set to true or -1 if none.
+	Int32 nextOne(Int32 pos) const;
+	// Return the first bit at set to false or -1 if none.
+	Int32 firstZero() const {return nextZero(-1);}
+	// Return the next bit after index set to false or -1 if none.
+	Int32 nextZero(Int32 pos) const;
+
+	// Iterator to conform with the set API.
+	typedef Int32 iterator;
+	// Return true if the walk is ordered.
+	static bool isOrdered() {return true;}
+	// Return the iterator for the first element of this set.
+	iterator begin() const {return firstOne();}
+	// Return the next iterator.
+	iterator advance(iterator pos) const {return nextOne(pos);}
+	// Return true if the iterator is at the end of the set.
+	bool done(iterator pos) const {return pos == -1;}
+	// Return the element corresponding to the given iterator.
+	Uint32 get(iterator pos) const {return pos;}
+
+#ifdef DEBUG_LOG
+	// Print the set.
+	void printPretty(LogModuleObject log);
+#endif // DEBUG_LOG
+};
+
+// Union with the given bitset.
+//
+inline void  BitSet::or(const BitSet& set)
+{
+	checkUniverseCompatibility(set);
+	Word* src = set.word;
+	Word* dst = word;
+	Word* limit = &src[getSizeInWords(universeSize)];
+
+	while (src < limit)
+		*dst++ |= *src++;
+}
+
+// Intersection with the given bitset.
+//
+inline void  BitSet::and(const BitSet& set)
+{
+	checkUniverseCompatibility(set);
+	Word* src = set.word;
+	Word* dst = word;
+	Word* limit = &src[getSizeInWords(universeSize)];
+
+	while (src < limit)
+		*dst++ &= *src++;
+}
+
+// Difference with the given bitset.
+//
+inline void BitSet::difference(const BitSet& set)
+{
+	checkUniverseCompatibility(set);
+	Word* src = set.word;
+	Word* dst = word;
+	Word* limit = &src[getSizeInWords(universeSize)];
+
+	while (src < limit)
+		*dst++ &= ~*src++;
+}
+
+// Copy the given set into this set.
+//
+inline BitSet& BitSet::operator = (const BitSet& set)
+{
+	checkUniverseCompatibility(set);
+	if (this != &set)
+		memcpy(word, set.word, getSizeInWords(universeSize) << nBytesInWordLog2);
+	return *this;
+}
+
+// Return true if the given set is identical to this set.
+inline bool operator == (const BitSet& set1, const BitSet& set2)
+{
+	set1.checkUniverseCompatibility(set2);
+
+	if (&set1 == &set2)
+		return true;
+
+	return memcmp(set1.word, set2.word, BitSet::getSizeInWords(set1.universeSize) << BitSet::nBytesInWordLog2) == 0;
+}
+
+inline bool operator != (const BitSet& set1, const BitSet& set2) {return !(set1 == set2);}
+
+#endif // _BITSET_H

mozilla/ef/Compiler/RegisterAllocator/Coalescing.h

@@ -0,0 +1,159 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _COALESCING_H_
+#define _COALESCING_H_
+
+#include "Fundamentals.h"
+#include "Pool.h"
+#include "RegisterPressure.h"
+#include "InterferenceGraph.h"
+#include "ControlGraph.h"
+#include "ControlNodes.h"
+#include "Instruction.h"
+#include "SparseSet.h"
+#include "RegisterAllocator.h"
+#include "RegisterAllocatorTools.h"
+
+#if 1
+// Performing an ultra conservative coalescing meens that when we look at
+// candidates (source,destination) for coalescing we need to make sure
+// that the combined interference of the source and destination register
+// will not exceed the total number of register available for the register
+// class. 
+#define ULTRA_CONSERVATIVE_COALESCING
+#else
+// If we are not doing an ultra conservative coalescing we have to make sure 
+// that the total number of neighbor whose degree is greater than the total 
+// number of register is not greater than the total number of register.
+#undef ULTRA_CONSERVATIVE_COALESCING
+#endif
+
+template <class RegisterPressure>
+struct Coalescing
+{
+	static bool coalesce(RegisterAllocator& registerAllocator);
+};
+
+template <class RegisterPressure>
+bool Coalescing<RegisterPressure>::coalesce(RegisterAllocator& registerAllocator)
+{
+	Pool& pool = registerAllocator.pool;
+
+   	// Initialize the lookup table
+	//
+	Uint32 rangeCount = registerAllocator.rangeCount;
+	RegisterName* newRange = new RegisterName[2 * rangeCount];
+	RegisterName* coalescedRange = &newRange[rangeCount];
+	RegisterName* name2range = registerAllocator.name2range;
+
+	init(coalescedRange, rangeCount);
+
+	SparseSet interferences(pool, rangeCount);
+	InterferenceGraph<RegisterPressure>& iGraph = registerAllocator.iGraph;
+	bool removedInstructions = false;
+
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	ControlNode** nodes = controlGraph.lndList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+
+	// Walk the nodes in the loop nesting depth list.
+	for (Int32 n = nNodes - 1; n >= 0; n--) {
+		InstructionList& instructions = nodes[n]->getInstructions();
+
+		InstructionList::iterator it = instructions.begin();
+		while (!instructions.done(it)) {
+			Instruction& instruction = instructions.get(it);
+			it = instructions.advance(it);
+
+			if ((instruction.getFlags() & ifCopy) != 0) {
+				assert(instruction.getInstructionUseBegin() != instruction.getInstructionUseEnd() && instruction.getInstructionUseBegin()[0].isRegister());
+				assert(instruction.getInstructionDefineBegin() != instruction.getInstructionDefineEnd() && instruction.getInstructionDefineBegin()[0].isRegister());
+
+				RegisterName source = findRoot(name2range[instruction.getInstructionUseBegin()[0].getRegisterName()], coalescedRange);
+				RegisterName destination = findRoot(name2range[instruction.getInstructionDefineBegin()[0].getRegisterName()], coalescedRange);
+
+				if (source == destination) {
+					instruction.remove();
+				} else if (!iGraph.interfere(source, destination)) {
+					InterferenceVector* sourceVector = iGraph.getInterferenceVector(source);
+					InterferenceVector* destinationVector = iGraph.getInterferenceVector(destination);
+
+#ifdef ULTRA_CONSERVATIVE_COALESCING
+					interferences.clear();
+
+					InterferenceVector* vector;
+					for (vector = sourceVector; vector != NULL; vector = vector->next) {
+						RegisterName* neighbors = vector->neighbors;
+						for (Uint32 i = 0; i < vector->count; i++)
+							interferences.set(findRoot(neighbors[i], coalescedRange));
+					}
+					for (vector = destinationVector; vector != NULL; vector = vector->next) {
+						RegisterName* neighbors = vector->neighbors;
+						for (Uint32 i = 0; i < vector->count; i++)
+							interferences.set(findRoot(neighbors[i], coalescedRange));
+					}
+
+					Uint32 count = interferences.getSize();
+#else // ULTRA_CONSERVATIVE_COALESCING
+					trespass("not implemented");
+					Uint32 count = 0;
+#endif // ULTRA_CONSERVATIVE_COALESCING
+
+					if (count < 6 /* FIX: should get the number from the class */) {
+						// Update the interferences vector.
+						if (sourceVector == NULL) {
+							iGraph.setInterferenceVector(source, destinationVector);
+							sourceVector = destinationVector;
+						} else if (destinationVector == NULL)
+							iGraph.setInterferenceVector(destination, sourceVector);
+						else {
+							InterferenceVector* last = NULL;
+							for (InterferenceVector* v = sourceVector; v != NULL; v = v->next)
+								last = v;
+							assert(last);
+							last->next = destinationVector;
+							iGraph.setInterferenceVector(destination, sourceVector);
+						}
+						// Update the interference matrix.
+						for (InterferenceVector* v = sourceVector; v != NULL; v = v->next) {
+							RegisterName* neighbors = v->neighbors;
+							for (Uint32 i = 0; i < v->count; i++) {
+								RegisterName neighbor = findRoot(neighbors[i], coalescedRange);
+								iGraph.setInterference(neighbor, source);
+								iGraph.setInterference(neighbor, destination);
+							}
+						}
+
+						instruction.remove();
+						coalescedRange[source] = destination;
+						removedInstructions = true;
+					}
+				}
+			}
+		}
+	}
+
+	registerAllocator.rangeCount = compress(registerAllocator.name2range, coalescedRange, registerAllocator.nameCount, rangeCount);
+	delete newRange;
+
+	return removedInstructions;
+}
+
+#endif // _COALESCING_H_

mozilla/ef/Compiler/RegisterAllocator/Coloring.cpp

@@ -0,0 +1,283 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef NEW_LAURENTM_CODE
+
+#include "Coloring.h"
+#include "VirtualRegister.h"
+#include "FastBitSet.h"
+#include "FastBitMatrix.h"
+#include "CpuInfo.h"
+
+bool Coloring::
+assignRegisters(FastBitMatrix& interferenceMatrix)
+{
+  PRUint32 *stackPtr = new(pool) PRUint32[vRegManager.count()];
+
+  return select(interferenceMatrix, stackPtr, simplify(interferenceMatrix, stackPtr));
+}
+
+PRInt32 Coloring::
+getLowestSpillCostRegister(FastBitSet& bitset)
+{
+  PRInt32 lowest = bitset.firstOne();
+  if (lowest != -1)
+	{
+	  Flt32 cost = vRegManager.getVirtualRegister(lowest).spillInfo.spillCost;
+	  for (PRInt32 r = bitset.nextOne(lowest); r != -1; r = bitset.nextOne(r))
+		{
+		  VirtualRegister& vReg = vRegManager.getVirtualRegister(r);
+		  if (!vReg.spillInfo.infiniteSpillCost && (vReg.spillInfo.spillCost < cost))
+			{
+			  cost = vReg.spillInfo.spillCost;
+			  lowest = r;
+			}
+		}
+	}
+  return lowest;
+}
+
+PRUint32* Coloring::
+simplify(FastBitMatrix interferenceMatrix, PRUint32* stackPtr)
+{
+  // first we construct the sets low and high. low contains all nodes of degree
+  // inferior to the number of register available on the processor. All the
+  // nodes with an high degree and a finite spill cost are placed in high.
+  // Nodes of high degree and infinite spill cost are not included in either sets.
+
+  PRUint32 nRegisters = vRegManager.count();
+  FastBitSet low(pool, nRegisters);
+  FastBitSet high(pool, nRegisters);
+  FastBitSet stack(pool, nRegisters);
+
+  for (VirtualRegisterManager::iterator i = vRegManager.begin(); !vRegManager.done(i); i = vRegManager.advance(i))
+	{
+	  VirtualRegister& vReg = vRegManager.getVirtualRegister(i);
+	  
+	  if (vReg.getClass() == vrcStackSlot)
+		{
+		  stack.set(i);
+		  vReg.colorRegister(nRegisters);
+		}
+	  else
+		{
+		  if (vReg.colorInfo.interferenceDegree < NUMBER_OF_REGISTERS)
+			low.set(i);
+		  else // if (!vReg.spillInfo.infiniteSpillCost)
+			high.set(i);
+
+		  // Set coloring info.
+		  vReg.spillInfo.willSpill = false;
+
+		  switch(vReg.getClass())
+			{
+			case vrcInteger:
+			  vReg.colorRegister(LAST_GREGISTER + 1);
+			  break;
+			case vrcFloatingPoint:
+			case vrcFixedPoint:
+			  vReg.colorRegister(LAST_FPREGISTER + 1);
+			  break;
+			default:
+			  PR_ASSERT(false); // Cannot happen.
+			}
+		}
+	}
+
+  // push the stack registers
+  PRInt32 j;
+  for (j = stack.firstOne(); j != -1; j = stack.nextOne(j))
+	*stackPtr++ = j;
+
+  // simplify
+  while (true)
+	{
+	  PRInt32 r;
+	  while ((r = getLowestSpillCostRegister(low)) != -1)
+		{
+		  VirtualRegister& vReg = vRegManager.getVirtualRegister(r);
+
+		  /* update low and high */
+		  FastBitSet inter(interferenceMatrix.getRow(r), nRegisters);
+		  for (j = inter.firstOne(); j != -1; j = inter.nextOne(j))
+			{
+			  VirtualRegister& neighbor = vRegManager.getVirtualRegister(j);
+			  // if the new interference degree of one of his neighbor becomes
+			  // NUMBER_OF_REGISTERS - 1 then it is added to the set 'low'.
+			  
+			  PRUint32 maxInterference = 0;
+			  switch (neighbor.getClass())
+				{
+				case vrcInteger:
+				  maxInterference = NUMBER_OF_GREGISTERS;
+				  break;
+				case vrcFloatingPoint:
+				case vrcFixedPoint:
+				  maxInterference = NUMBER_OF_FPREGISTERS;
+				  break;
+				default:
+				  PR_ASSERT(false);
+				}
+			  if ((vRegManager.getVirtualRegister(j).colorInfo.interferenceDegree-- == maxInterference))
+				{
+				  high.clear(j);
+				  low.set(j);
+				}
+			  vReg.colorInfo.interferenceDegree--;
+			  interferenceMatrix.clear(r, j);
+			  interferenceMatrix.clear(j, r);
+			}
+		  low.clear(r);
+
+		  // Push this register.
+		  *stackPtr++ = r;
+		}
+	  if ((r = getLowestSpillCostRegister(high)) != -1)
+		{
+		  high.clear(r);
+		  low.set(r);
+		}
+	  else
+		break;
+	}
+
+  return stackPtr;
+}
+
+bool Coloring::
+select(FastBitMatrix& interferenceMatrix, PRUint32* stackBase, PRUint32* stackPtr)
+{
+  PRUint32 nRegisters = vRegManager.count();
+  FastBitSet usedRegisters(NUMBER_OF_REGISTERS + 1); // usedRegisters if used for both GR & FPR.
+  FastBitSet preColoredRegisters(NUMBER_OF_REGISTERS + 1);
+  FastBitSet usedStack(nRegisters + 1);
+  bool success = true;
+  Int32 lastUsedSSR = -1;
+
+  // select
+  while (stackPtr != stackBase)
+	{
+	  // Pop one register.
+	  PRUint32 r = *--stackPtr;
+	  VirtualRegister& vReg = vRegManager.getVirtualRegister(r);
+
+	  FastBitSet neighbors(interferenceMatrix.getRow(r), nRegisters);
+		  
+	  if (vReg.getClass() == vrcStackSlot)
+		// Stack slots coloring.
+		{
+		  usedStack.clear();
+
+		  for (PRInt32 i = neighbors.firstOne(); i != -1; i = neighbors.nextOne(i))
+			usedStack.set(vRegManager.getVirtualRegister(i).getColor());
+
+		  Int32 color = usedStack.firstZero();
+		  vReg.colorRegister(color);
+		  if (color > lastUsedSSR)
+			  lastUsedSSR = color;
+		}
+	  else
+		// Integer & Floating point register coloring.
+		{
+		  usedRegisters.clear();
+		  preColoredRegisters.clear();
+		  
+		  for (PRInt32 i = neighbors.firstOne(); i != -1; i = neighbors.nextOne(i))
+			{
+			  VirtualRegister& nvReg = vRegManager.getVirtualRegister(i);
+			  usedRegisters.set(nvReg.getColor());
+			  if (nvReg.isPreColored())
+				preColoredRegisters.set(nvReg.getPreColor());
+			}
+		  if (vReg.hasSpecialInterference)
+			usedRegisters |= vReg.specialInterference;
+
+		  PRInt8 c = -1;
+		  PRInt8 maxColor = 0;
+		  PRInt8 firstColor = 0;
+		  switch (vReg.getClass())
+			{
+			case vrcInteger:
+			  firstColor = FIRST_GREGISTER;
+			  maxColor = LAST_GREGISTER;
+			  break;
+			case vrcFloatingPoint:
+			case vrcFixedPoint:
+			  firstColor = FIRST_FPREGISTER;
+			  maxColor = LAST_FPREGISTER;
+			  break;
+			default:
+			  PR_ASSERT(false);
+			}
+
+		  if (vReg.isPreColored())
+			{
+			  c = vReg.getPreColor();
+			  if (usedRegisters.test(c))
+				c = -1;
+			}
+		  else
+			{
+			  for (c = usedRegisters.nextZero(firstColor - 1); (c >= 0) && (c <= maxColor) && (preColoredRegisters.test(c)); 
+				   c = usedRegisters.nextZero(c)) {}
+			}
+
+		  if ((c >= 0) && (c <= maxColor))
+			{
+			  vReg.colorRegister(c);
+			}
+		  else
+			{
+			  VirtualRegister& stackRegister = vRegManager.newVirtualRegister(vrcStackSlot);
+			  vReg.equivalentRegister[vrcStackSlot] = &stackRegister;	  
+			  vReg.spillInfo.willSpill = true;
+			  success = false;
+			}
+		}
+	}
+  
+#ifdef DEBUG
+  if (success)
+	{
+	  for (VirtualRegisterManager::iterator i = vRegManager.begin(); !vRegManager.done(i); i = vRegManager.advance(i))
+		{
+		  VirtualRegister& vReg = vRegManager.getVirtualRegister(i);
+		  switch (vReg.getClass())
+			{
+			case vrcInteger:
+			  if (vReg.getColor() > LAST_GREGISTER)
+				PR_ASSERT(false);
+			  break;
+			case vrcFloatingPoint:
+			case vrcFixedPoint:
+#if NUMBER_OF_FPREGISTERS != 0
+			  if (vReg.getColor() > LAST_FPREGISTER)
+				PR_ASSERT(false);
+#endif
+			  break;
+			default:
+			  break;
+			}
+		}
+	}
+#endif
+
+  vRegManager.nUsedStackSlots = lastUsedSSR + 1;
+  return success;
+}
+#endif // NEW_LAURENTM_CODE

mozilla/ef/Compiler/RegisterAllocator/Coloring.h

@@ -0,0 +1,284 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include "ControlGraph.h"
+#include "ControlNodes.h"
+#include "Instruction.h"
+#include "RegisterAllocator.h"
+#include "VirtualRegister.h"
+#include "InterferenceGraph.h"
+#include "SparseSet.h"
+#include "Spilling.h"
+#include "Splits.h"
+
+UT_EXTERN_LOG_MODULE(RegAlloc);
+
+template <class RegisterPressure>
+class Coloring
+{
+private:
+	static RegisterName* simplify(RegisterAllocator& registerAllocator, RegisterName* coloringStack);
+	static bool select(RegisterAllocator& registerAllocator, RegisterName* coloringStack, RegisterName* coloringStackPtr);
+
+public:
+	static bool color(RegisterAllocator& registerAllocator);
+	static void finalColoring(RegisterAllocator& registerAllocator);
+};
+
+
+template <class RegisterPressure>
+void Coloring<RegisterPressure>::finalColoring(RegisterAllocator& registerAllocator)
+{
+	RegisterName* color = registerAllocator.color;
+	RegisterName* name2range = registerAllocator.name2range;
+
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+		InstructionList& instructions = nodes[n]->getInstructions();
+
+		for (InstructionList::iterator i = instructions.begin(); !instructions.done(i); i = instructions.advance(i)) {
+			Instruction& instruction = instructions.get(i);
+
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister()) {
+					usePtr->setRegisterName(color[name2range[usePtr->getRegisterName()]]);
+#ifdef DEBUG
+					RegisterID rid = usePtr->getRegisterID();
+					setColoredRegister(rid);
+					usePtr->setRegisterID(rid);
+#endif // DEBUG
+				}
+
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			for (InstructionDefine* definePtr = instruction.getInstructionDefineBegin(); definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister()) {
+					definePtr->setRegisterName(color[name2range[definePtr->getRegisterName()]]);
+#ifdef DEBUG
+					RegisterID rid = definePtr->getRegisterID();
+					setColoredRegister(rid);
+					definePtr->setRegisterID(rid);
+#endif // DEBUG
+				}
+		}
+	}
+}
+
+template <class RegisterPressure>
+bool Coloring<RegisterPressure>::select(RegisterAllocator& registerAllocator, RegisterName* coloringStack, RegisterName* coloringStackPtr)
+{
+	Uint32 rangeCount = registerAllocator.rangeCount;
+	RegisterName* color = new RegisterName[rangeCount];
+	registerAllocator.color = color;
+
+	for (Uint32 r = 1; r < rangeCount; r++)
+		color[r] = RegisterName(6); // FIX;
+
+	// Color the preColored registers.
+	//
+	VirtualRegisterManager& vrManager = registerAllocator.vrManager;
+	RegisterName* name2range = registerAllocator.name2range;
+	PreColoredRegister* machineEnd = vrManager.getMachineRegistersEnd();
+	for (PreColoredRegister* machinePtr = vrManager.getMachineRegistersBegin(); machinePtr < machineEnd; machinePtr++)
+		if (machinePtr->id != invalidID) {
+			color[name2range[getName(machinePtr->id)]] = machinePtr->color;
+			UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\twill preColor range %d as %d\n", name2range[getName(machinePtr->id)], machinePtr->color));
+		}
+
+	SpillCost* cost = registerAllocator.spillCost;
+	Pool& pool = registerAllocator.pool;
+	SparseSet& spill = *new(pool) SparseSet(pool, rangeCount);
+	registerAllocator.willSpill = &spill;
+	SparseSet neighborColors(pool, 6); // FIX
+	InterferenceGraph<RegisterPressure>& iGraph = registerAllocator.iGraph;
+
+	bool coloringFailed = false;
+	while (coloringStackPtr > coloringStack) {
+		RegisterName range = *--coloringStackPtr;
+
+		if (!cost[range].infinite && cost[range].cost < 0) {
+			coloringFailed = true;
+			spill.set(range);
+			UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\tfailed to color %d, will spill.\n", range));
+		} else {
+			neighborColors.clear();
+
+			for (InterferenceVector* vector = iGraph.getInterferenceVector(range); vector != NULL; vector = vector->next)
+				for (Int32 i = vector->count - 1; i >= 0; --i) {
+					RegisterName neighborColor = color[vector->neighbors[i]];
+					if (neighborColor < 6) // FIX
+						neighborColors.set(neighborColor);
+				}
+
+			if (neighborColors.getSize() == 6) { // FIX
+				coloringFailed = true;
+				UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\tfailed to color %d, ", range));
+
+				if (!Splits<RegisterPressure>::findSplit(registerAllocator, color, range)) {
+					UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("will spill.\n"));
+					spill.set(range);
+				} else
+					UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("will split.\n"));
+			} else {
+				for (Uint32 i = 0; i < 6; i++) // FIX
+					if (!neighborColors.test(i)) {
+						fprintf(stdout, "\twill color %d as %d\n", range, i);
+						color[range] = RegisterName(i);
+						break;
+					}
+			}
+		}
+	}
+
+#ifdef DEBUG_LOG
+	if (coloringFailed) {
+		UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("Coloring failed:\n"));
+		UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\twill spill: "));
+		spill.printPretty(UT_LOG_MODULE(RegAlloc));
+	} else {
+		UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("Coloring succeeded:\n"));
+		for (Uint32 i = 1; i < rangeCount; i++)
+			UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\trange %d colored as %d\n", i, color[i]));
+	}
+#endif
+
+	return !coloringFailed;
+}
+
+template <class RegisterPressure>
+RegisterName* Coloring<RegisterPressure>::simplify(RegisterAllocator& registerAllocator, RegisterName* coloringStack)
+{
+	InterferenceGraph<RegisterPressure>& iGraph = registerAllocator.iGraph;
+	SpillCost* spillCost = registerAllocator.spillCost;
+	Uint32 rangeCount = registerAllocator.rangeCount;
+
+	Uint32* degree = new Uint32[rangeCount];
+	for (RegisterName i = RegisterName(1); i < rangeCount; i = RegisterName(i + 1)) {
+		InterferenceVector* vector = iGraph.getInterferenceVector(i);
+		degree[i] = (vector != NULL) ? vector->count : 0;
+	}
+
+	Pool& pool = registerAllocator.pool;
+	SparseSet low(pool, rangeCount);
+	SparseSet high(pool, rangeCount);
+	SparseSet highInfinite(pool, rangeCount);
+	SparseSet preColored(pool, rangeCount);
+
+	// Get the precolored registers.
+	//
+	VirtualRegisterManager& vrManager = registerAllocator.vrManager;
+	RegisterName* name2range = registerAllocator.name2range;
+	PreColoredRegister* machineEnd = vrManager.getMachineRegistersEnd();
+	for (PreColoredRegister* machinePtr = vrManager.getMachineRegistersBegin(); machinePtr < machineEnd; machinePtr++)
+		if (machinePtr->id != invalidID)
+			preColored.set(name2range[getName(machinePtr->id)]);
+
+	// Insert the live ranges in the sets.
+	//
+	for (Uint32 range = 1; range < rangeCount; range++)
+		if (!preColored.test(range))
+			if (degree[range] < 6) // FIX
+				low.set(range);
+			else if (!spillCost[range].infinite)
+				high.set(range);
+			else
+				highInfinite.set(range);
+
+#ifdef DEBUG_LOG
+	UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("Coloring sets:\n\tlow = "));
+	low.printPretty(UT_LOG_MODULE(RegAlloc));
+	UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\thigh = "));
+	high.printPretty(UT_LOG_MODULE(RegAlloc));
+	UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\thighInfinite = "));
+	highInfinite.printPretty(UT_LOG_MODULE(RegAlloc));
+	UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\tpreColored = "));
+	preColored.printPretty(UT_LOG_MODULE(RegAlloc));
+#endif // DEBUG_LOG
+
+	RegisterName* coloringStackPtr = coloringStack;
+
+	while (low.getSize() != 0 || high.getSize() != 0) {
+		while (low.getSize() != 0) {
+			RegisterName range = RegisterName(low.getOne());
+			low.clear(range);
+			*coloringStackPtr++ = range;
+
+			for (InterferenceVector* vector = iGraph.getInterferenceVector(range); vector != NULL; vector = vector->next)
+				for (Int32 i = (vector->count - 1); i >= 0; --i) {
+					RegisterName neighbor = vector->neighbors[i];
+					degree[neighbor]--;
+
+					if (degree[neighbor] < 6) // FIX
+						if (high.test(neighbor)) {
+							high.clear(neighbor);
+							low.set(neighbor);
+						} else if (highInfinite.test(neighbor)) {
+							highInfinite.clear(neighbor);
+							low.set(neighbor);
+						}
+				}
+		}
+
+		if (high.getSize() != 0) {
+			RegisterName best = RegisterName(high.getOne());
+			double bestCost = spillCost[best].cost;
+			double bestDegree = degree[best];
+
+			// Choose the next best candidate.
+			//
+			for (SparseSet::iterator i = high.begin(); !high.done(i); i = high.advance(i)) {
+				RegisterName range = RegisterName(high.get(i));
+				double thisCost = spillCost[range].cost;
+				double thisDegree = degree[range];
+
+				if (thisCost * bestDegree < bestCost * thisDegree) {
+					best = range;
+					bestCost = thisCost;
+					bestDegree = thisDegree;
+				}
+			}
+			
+			high.clear(best);
+			low.set(best);
+		}
+ 	}
+	assert(highInfinite.getSize() == 0);
+
+	delete degree;
+
+#ifdef DEBUG_LOG
+	UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("Coloring stack:\n\t"));
+	for (RegisterName* sp = coloringStack; sp < coloringStackPtr; ++sp)
+		UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("%d ", *sp));
+	UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\n"));
+#endif // DEBUG_LOG
+
+	return coloringStackPtr;
+}
+
+
+template <class RegisterPressure>
+bool Coloring<RegisterPressure>::color(RegisterAllocator& registerAllocator)
+{
+	RegisterName* coloringStack = new RegisterName[registerAllocator.rangeCount];
+	return select(registerAllocator, coloringStack, simplify(registerAllocator, coloringStack));
+}

mozilla/ef/Compiler/RegisterAllocator/DominatorGraph.cpp

@@ -0,0 +1,212 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include <string.h>
+#include "ControlGraph.h"
+#include "ControlNodes.h"
+
+#include "DominatorGraph.h"
+
+DominatorGraph::DominatorGraph(ControlGraph& controlGraph) : controlGraph(controlGraph)
+{
+	Uint32 nNodes = controlGraph.nNodes;
+
+	GtoV = new Uint32[nNodes + 1];
+	VtoG = new Uint32[nNodes + 1];
+
+	Uint32 v = 1;
+	for (Uint32 n = 0; n < nNodes; n++) {
+		VtoG[v] = n;
+		GtoV[n] = v++;
+	}
+
+	// Initialize all the 1-based arrays.
+	//
+	parent =	new Uint32[v];
+	semi =		new Uint32[v];
+	vertex =	new Uint32[v];
+	label =		new Uint32[v];
+	size =		new Uint32[v];
+	ancestor =	new Uint32[v];
+	child =		new Uint32[v];
+	dom =		new Uint32[v];
+	bucket =	new DGLinkedList*[v];
+
+	memset(semi, '\0', v * sizeof(Uint32));
+	memset(bucket, '\0', v * sizeof(DGLinkedList*));
+
+	vCount = v;
+
+	build();
+
+	delete parent;
+	delete semi;
+	delete vertex;
+	delete label;
+	delete size;
+	delete ancestor;
+	delete child;
+	delete dom;
+	delete bucket;
+}
+
+Uint32 DominatorGraph::DFS(Uint32 vx, Uint32 n)
+{
+	semi[vx] = ++n;
+	vertex[n] = label[vx] = vx;
+	ancestor[vx] = child[vx] = 0;
+	size[vx] = 1;
+
+
+	ControlNode& node = *controlGraph.dfsList[VtoG[vx]];
+	ControlEdge* successorEnd = node.getSuccessorsEnd();
+	for (ControlEdge* successorPtr = node.getSuccessorsBegin(); successorPtr < successorEnd; successorPtr++) {
+		Uint32 w = GtoV[successorPtr->getTarget().dfsNum];
+		if (semi[w] == 0) {
+			parent[w] = vx;
+			n = DFS(w, n);
+		}
+	}
+	return n;
+}
+
+void DominatorGraph::LINK(Uint32 vx, Uint32 w)
+{
+    Uint32 s = w;
+
+	while (semi[label[w]] < semi[label[child[s]]]) {
+		if (size[s] + size[child[child[s]]] >= (size[child[s]] << 1)) {
+			ancestor[child[s]] = s;
+			child[s] = child[child[s]];
+		} else {
+			size[child[s]] = size[s];
+			s = ancestor[s] = child[s];
+		}
+	}
+	label[s] = label[w];
+	size[vx] += size[w];
+	if(size[vx] < (size[w] << 1)) {
+		Uint32 t = s;
+		s = child[vx]; 
+		child[vx] = t;
+	}
+	while( s != 0 ) {
+		ancestor[s] = vx;
+		s = child[s];
+	}
+}
+
+
+void DominatorGraph::COMPRESS(Uint32 vx)
+{
+	if(ancestor[ancestor[vx]] != 0) {
+		COMPRESS(ancestor[vx]);
+		if(semi[label[ancestor[vx]]] < semi[label[vx]])
+			label[vx] = label[ancestor[vx]];
+		ancestor[vx] = ancestor[ancestor[vx]];
+	}
+}
+
+Uint32 DominatorGraph::EVAL(Uint32 vx)
+{
+	if(ancestor[vx] == 0) 
+		return label[vx];
+	COMPRESS(vx);
+	return (semi[label[ancestor[vx]]] >= semi[label[vx]]) ? label[vx] : label[ancestor[vx]];
+}
+
+void DominatorGraph::build()
+{
+	Uint32 n = DFS(GtoV[0], 0);
+	size[0] = label[0] = semi[0];
+
+	for (Uint32 i = n; i >= 2; i--) {
+		Uint32 w = vertex[i];
+
+		ControlNode& node = *controlGraph.dfsList[VtoG[w]];
+		const DoublyLinkedList<ControlEdge>& predecessors = node.getPredecessors();
+		for (DoublyLinkedList<ControlEdge>::iterator p = predecessors.begin(); !predecessors.done(p); p = predecessors.advance(p)) {
+			Uint32 vx = GtoV[predecessors.get(p).getSource().dfsNum];
+			Uint32 u = EVAL(vx);
+
+			if(semi[u] < semi[w])
+				semi[w] = semi[u];
+		}
+
+		DGLinkedList* elem = new DGLinkedList();
+		elem->next = bucket[vertex[semi[w]]];
+		elem->index = w;
+		bucket[vertex[semi[w]]] = elem;
+
+		LINK(parent[w], w);
+
+		elem = bucket[parent[w]];
+		while(elem != NULL) {
+			Uint32 vx = elem->index;
+			Uint32 u = EVAL(vx);
+			dom[vx] = (semi[u] < semi[vx]) ? u : parent[w];
+			elem = elem->next;
+		}
+	}
+
+	memset(size, '\0', n * sizeof(Uint32));
+	Pool& pool = controlGraph.pool;
+	nodes = new(pool) DGNode[n];
+
+	for(Uint32 j = 2; j <= n; j++) {
+		Uint32 w = vertex[j];
+		Uint32 d = dom[w];
+		if(d != vertex[semi[w]]) {
+			d = dom[d];
+			dom[w] = d;
+		}
+		size[d]++;
+	}
+	dom[GtoV[0]] = 0;
+
+	for (Uint32 k = 1; k <= n; k++) {
+		DGNode& node = nodes[VtoG[k]];
+		Uint32 count = size[k];
+		node.successorsEnd = node.successorsBegin = (count) ? new(pool) Uint32[count] : (Uint32*) 0;
+	}
+
+	for (Uint32 l = 2; l <= n; l++)
+		*(nodes[VtoG[dom[l]]].successorsEnd)++ = VtoG[l];
+}
+
+#ifdef DEBUG_LOG
+void DominatorGraph::printPretty(LogModuleObject log)
+{
+	UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("Dominator Graph:\n"));
+	Uint32 nNodes = controlGraph.nNodes;
+	for (Uint32 i = 0; i < nNodes; i++) {
+		DGNode& node = nodes[i];
+		if (node.successorsBegin !=  node.successorsEnd) {
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\tN%d dominates ", i));
+			for (Uint32* successorsPtr = node.successorsBegin; successorsPtr < node.successorsEnd; successorsPtr++)
+				UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("N%d ", *successorsPtr));
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\n"));
+		}
+	}
+}
+
+#endif // DEBUG_LOG
+
+
+

mozilla/ef/Compiler/RegisterAllocator/DominatorGraph.h

@@ -0,0 +1,80 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _DOMINATOR_GRAPH_H_
+#define _DOMINATOR_GRAPH_H_
+
+#include "LogModule.h"
+
+class ControlGraph;
+
+struct DGNode
+{
+	Uint32* successorsBegin;
+	Uint32* successorsEnd;
+};
+
+struct DGLinkedList
+{
+	DGLinkedList* next;
+	Uint32 index;
+};
+
+class DominatorGraph
+{
+private:
+
+	ControlGraph&	controlGraph;
+
+	Uint32			vCount;
+
+	Uint32*			VtoG;
+	Uint32*			GtoV;
+	Uint32*			parent;
+	Uint32*			semi;
+	Uint32*			vertex;
+	Uint32*			label;
+	Uint32*			size;
+	Uint32*			ancestor;
+	Uint32*			child;
+	Uint32*			dom;
+	DGLinkedList**	bucket;
+	DGNode*			nodes;
+	
+private:
+
+	void build();
+
+	Uint32 DFS(Uint32 vx, Uint32 n);
+	void LINK(Uint32 vx, Uint32 w);
+	void COMPRESS(Uint32 vx);
+	Uint32 EVAL(Uint32 vx);
+
+public:
+
+	DominatorGraph(ControlGraph& controlGraph);
+
+	Uint32* getSuccessorsBegin(Uint32 n) const {return nodes[n].successorsBegin;}
+	Uint32* getSuccessorsEnd(Uint32 n) const {return nodes[n].successorsEnd;}
+
+#ifdef DEBUG_LOG
+	void printPretty(LogModuleObject log);
+#endif // DEBUG_LOG
+};
+
+#endif // _DOMINATOR_GRAPH_H_

mozilla/ef/Compiler/RegisterAllocator/HashSet.cpp

@@ -0,0 +1,20 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include "HashSet.h"

mozilla/ef/Compiler/RegisterAllocator/HashSet.h

@@ -0,0 +1,97 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _HASH_SET_H_
+#define _HASH_SET_H_
+
+#include "Fundamentals.h"
+#include "Pool.h"
+#include <string.h>
+
+struct HashSetElement
+{
+	Uint32 index;
+	HashSetElement* next;
+};
+
+class HashSet
+{
+private:
+
+	static const hashSize = 64;
+
+	// Return the hash code for the given element index.
+	static Uint32 getHashCode(Uint32 index) {return index & (hashSize - 1);} // Could be better !
+
+private:
+
+	Pool&					allocationPool;
+	HashSetElement**		bucket;
+	HashSetElement*			free;
+
+private:
+
+	// No copy constructor.
+	HashSet(const HashSet&);
+	// No copy operator.
+	void operator = (const HashSet&);
+
+public:
+
+	// Create a new HashSet.
+	inline HashSet(Pool& pool, Uint32 universeSize);
+
+	// Clear the hashset.
+	void clear();
+	// Clear the element for the given index.
+	void clear(Uint32 index);
+	// Set the element for the given index.
+	void set(Uint32 index);
+	// Return true if the element at index is a member.
+	bool test(Uint32 index) const;
+	// Union with the given hashset.
+	inline void or(const HashSet& set);
+	// Intersection with the given hashset.
+	inline void and(const HashSet& set);
+	// Difference with the given hashset.
+	inline void difference(const HashSet& set);
+
+	// Logical operators.
+	HashSet& operator |= (const HashSet& set) {or(set); return *this;}
+	HashSet& operator &= (const HashSet& set) {and(set); return *this;}
+	HashSet& operator -= (const HashSet& set) {difference(set); return *this;}
+
+	// Iterator to conform with the set API.
+	typedef HashSetElement* iterator;
+	// Return the iterator for the first element of this set.
+	iterator begin() const;
+	// Return the next iterator.
+	iterator advance(iterator pos) const;
+	// Return true if the iterator is at the end of the set.
+	bool done(iterator pos) const {return pos == NULL;}
+};
+
+
+inline HashSet::HashSet(Pool& pool, Uint32 /*universeSize*/)
+	: allocationPool(pool), free(NULL)
+{
+	bucket = new(pool) HashSetElement*[hashSize];
+	memset(bucket, '\0', sizeof(HashSetElement*));
+}
+
+#endif // _HASH_SET_H_

mozilla/ef/Compiler/RegisterAllocator/IndexedPool.h

@@ -0,0 +1,213 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _INDEXED_POOL_H_
+#define _INDEXED_POOL_H_
+
+#include "Fundamentals.h"
+#include <string.h>
+#include <stdlib.h>
+
+//------------------------------------------------------------------------------
+// IndexedPool<IndexedObjectSubclass> is an indexed pool of objects. The
+// template parameter 'IndexedObjectSubclass' must be a subclass of the struct
+// IndexedObject.
+// 
+// When the indexed pool is ask to allocate and initialize a new object (using
+// the operator new(anIndexedPool) it will zero the memory used to store the
+// object and initialize the field 'index' of this object to its position in
+// the pool.
+//
+// An object allocated by the indexed pool can be freed by calling the method
+// IndexedPool::release(IndexedElement& objectIndex).
+//
+// example:
+//
+//   IndexedPool<IndexedElement> elementPool;
+//
+//   IndexedElement& element1 = *new(elementPool) IndexedElement();
+//   IndexedElement& element2 = *new(elementPool) IndexedElement();
+//
+//   indexedPool.release(element1);
+//   IndexedElement& element3 = *new(elementPool) IndexedElement();
+//
+//  At this point element1 is no longer a valid object, element2 is at
+//  index 2 and element3 is at index 1.
+//
+
+//------------------------------------------------------------------------------
+// IndexedObject -
+//
+
+template<class Object>
+struct IndexedObject
+{
+	Uint32			index;				// Index in the pool.
+	Object*			next;				// Used to link IndexedObject together.
+
+	Uint32 getIndex() {return index;}
+};
+
+//------------------------------------------------------------------------------
+// IndexedPool<IndexedObject> -
+//
+
+template <class IndexedObject>
+class IndexedPool
+{
+private:
+
+	static const	blockSize = 4;		// Size of one block.
+
+	Uint32			nBlocks;			// Number of blocks in the pool.
+	IndexedObject**	block;				// Array of block pointers.
+	IndexedObject*  freeObjects;		// Chained list of free IndexedObjects.
+	Uint32			nextIndex;			// Index of the next free object in the last block. 
+
+private:
+
+	void allocateAnotherBlock();
+	IndexedObject& newObject();
+
+public:
+
+	IndexedPool() : nBlocks(0), block(NULL), freeObjects(NULL), nextIndex(1) {}
+	~IndexedPool();
+
+	IndexedObject& get(Uint32 index) const;
+	void release(IndexedObject& object);
+
+	void setSize(Uint32 size) {assert(size < nextIndex); nextIndex = size;}
+
+	// Return the universe size.
+	Uint32 getSize() {return nextIndex;}
+
+	friend void* operator new(size_t, IndexedPool<IndexedObject>& pool); // Needs to call newObject().
+};
+
+// Free all the memory allocated for this object.
+//
+template <class IndexedObject>
+IndexedPool<IndexedObject>::~IndexedPool()
+{
+	for (Uint32 n = 0; n < nBlocks; n++)
+		free(&((IndexedObject **) &block[n][n*blockSize])[-(n + 1)]);
+}
+
+// Release the given. This object will be iserted in the chained
+// list of free IndexedObjects. To minimize the fragmentation the chained list 
+// is ordered by ascending indexes.
+//
+template <class IndexedObject>
+void IndexedPool<IndexedObject>::release(IndexedObject& object)
+{
+	Uint32 index = object.index;
+	IndexedObject* list = freeObjects;
+
+	assert(&object == &get(index)); // Make sure that object is owned by this pool.
+
+	if (list == NULL) { // The list is empty.
+		freeObjects = &object;
+		object.next = NULL;
+	} else { // The list contains at least 1 element.
+		if (index < list->index) { // insert as first element.
+			freeObjects = &object;
+			object.next = list;
+		} else { // Find this object's place.
+			while ((list->next) != NULL && (list->next->index < index))
+				list = list->next;
+
+			object.next = list->next;
+			list->next = &object;
+		}
+	}
+
+#ifdef DEBUG
+	// Sanity check to be sure that the list is correctly ordered.
+	for (IndexedObject* obj = freeObjects; obj != NULL; obj = obj->next)
+		if (obj->next != NULL)
+			assert(obj->index < obj->next->index);
+#endif
+}
+
+// Create a new block of IndexedObjects. We will allocate the memory to
+// store IndexedPool::blockSize IndexedObject and the new Array of block
+// pointers.
+// The newly created IndexedObjects will not be initialized.
+//
+template <class IndexedObject>
+void IndexedPool<IndexedObject>::allocateAnotherBlock()
+{
+	void* memory = (void *) malloc((nBlocks + 1) * sizeof(Uint32) + blockSize * sizeof(IndexedObject));
+
+	memcpy(memory, block, nBlocks * sizeof(Uint32));
+
+	block = (IndexedObject **) memory;
+	IndexedObject* objects = (IndexedObject *) &block[nBlocks + 1];
+
+	block[nBlocks] = &objects[-(nBlocks * blockSize)];
+	nBlocks++;
+}
+
+// Return the IndexedObject at the position 'index' in the pool.
+//
+template <class IndexedObject>
+IndexedObject& IndexedPool<IndexedObject>::get(Uint32 index) const
+{
+	Uint32 blockIndex = index / blockSize;
+	assert(blockIndex < nBlocks);
+
+	return block[blockIndex][index];
+}
+
+// Return the reference of an unused object in the pool.
+//
+template <class IndexedObject>
+IndexedObject& IndexedPool<IndexedObject>::newObject()
+{
+	if (freeObjects != NULL) {
+		IndexedObject& newObject = *freeObjects;
+		freeObjects = newObject.next;
+		return newObject;
+	}
+	
+	Uint32 nextIndex = this->nextIndex++;
+	Uint32 blockIndex = nextIndex / blockSize;
+
+	while (blockIndex >= nBlocks)
+		allocateAnotherBlock();
+	
+	IndexedObject& newObject = block[blockIndex][nextIndex];
+	newObject.index = nextIndex;
+
+	return newObject;
+}
+
+// Return the address of the next unsused object in the given
+// indexed pool. The field index of the newly allocated object
+// will be initialized to the corresponding index of this object
+// in the pool.
+//
+template <class IndexedObject>
+void* operator new(size_t size, IndexedPool<IndexedObject>& pool)
+{
+	assert(size == sizeof(IndexedObject));
+	return (void *) &pool.newObject();
+}
+
+#endif // _INDEXED_POOL_H_

mozilla/ef/Compiler/RegisterAllocator/InterferenceGraph.h

@@ -0,0 +1,258 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _INTERFERENCE_GRAPH_H_
+#define _INTERFERENCE_GRAPH_H_
+
+#include "Fundamentals.h"
+#include "ControlGraph.h"
+#include "Primitives.h"
+#include "Instruction.h"
+#include "VirtualRegister.h"
+#include "RegisterPressure.h"
+#include "SparseSet.h"
+#include <string.h>
+
+struct InterferenceVector
+{
+	Uint32				count;
+	InterferenceVector*	next;
+	RegisterName*		neighbors;
+
+	InterferenceVector() : count(0), next(NULL) {}
+};
+
+class RegisterAllocator;
+
+template <class RegisterPressure>
+class InterferenceGraph
+{
+private:
+
+	RegisterAllocator&			registerAllocator;
+
+	RegisterPressure::Set*		interferences;
+	InterferenceVector**		vector;
+	Uint32*						offset;
+	Uint32 						rangeCount;
+
+private:
+
+	// No copy constructor.
+	InterferenceGraph(const InterferenceGraph&);
+	// No copy operator.
+	void operator = (const InterferenceGraph&);
+
+	// Check if reg is a member of the universe.
+	void checkMember(RegisterName name) {assert(name < rangeCount);}
+	// Return the edge index for the interference between name1 and name2.
+	Uint32 getEdgeIndex(RegisterName name1, RegisterName name2);
+
+public:
+	InterferenceGraph(RegisterAllocator& registerAllocator) : registerAllocator(registerAllocator) {}
+
+	// Calculate the interferences.
+	void build();
+	// Return true if reg1 and reg2 interfere.
+	bool interfere(RegisterName name1, RegisterName name2);
+	// Return the interference vector for the given register or NULL if there is none.
+	InterferenceVector* getInterferenceVector(RegisterName name) {return vector[name];}
+	// Set the interference between name1 and name2.
+	void setInterference(RegisterName name1, RegisterName name2);
+	// Set the interference vector for the given register.
+	void setInterferenceVector(RegisterName name, InterferenceVector* v) {vector[name] = v;}
+
+
+#ifdef DEBUG_LOG
+	// Print the interferences.
+	void printPretty(LogModuleObject log);
+#endif // DEBUG_LOG
+};
+
+template <class RegisterPressure>
+void InterferenceGraph<RegisterPressure>::build()
+{
+	Pool& pool = registerAllocator.pool;
+	Uint32 rangeCount = registerAllocator.rangeCount;
+	this->rangeCount = rangeCount;
+
+	// Initialize the structures.
+	//
+	offset = new(pool) Uint32[rangeCount + 1];
+	vector = new(pool) InterferenceVector*[rangeCount];
+	memset(vector, '\0', sizeof(InterferenceVector*) * rangeCount);
+
+	Uint32 o = 0;
+	offset[0] = 0;
+	for (Uint32 i = 1; i <= rangeCount; ++i) {
+		offset[i] = o;
+		o += i;
+	}
+	
+	interferences = new(pool) RegisterPressure::Set(pool, (rangeCount * rangeCount) / 2);
+
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	RegisterName* name2range = registerAllocator.name2range;
+	LivenessInfo<RegisterPressure> liveness = Liveness<RegisterPressure>::analysis(controlGraph, rangeCount, name2range);
+	registerAllocator.liveness = liveness;
+	SparseSet currentLive(pool, rangeCount);
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+		ControlNode& node = *nodes[n];
+		currentLive = liveness.liveOut[n];
+
+		InstructionList& instructions = node.getInstructions();
+		for (InstructionList::iterator i = instructions.end(); !instructions.done(i); i = instructions.retreat(i)) {
+			Instruction& instruction = instructions.get(i);
+
+			InstructionUse* useBegin = instruction.getInstructionUseBegin();
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			InstructionUse* usePtr;
+			InstructionDefine* defineBegin = instruction.getInstructionDefineBegin();
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			InstructionDefine* definePtr;
+
+			// Handle the copy instruction to avoid unnecessary interference between the 2 registers.
+			if ((instruction.getFlags() & ifCopy) != 0) {
+				assert(useBegin != useEnd && useBegin[0].isRegister());
+				currentLive.clear(name2range[useBegin[0].getRegisterName()]);
+			}
+
+			// Create the interferences.
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister()) {
+					RegisterName define = name2range[definePtr->getRegisterName()];
+
+					for (SparseSet::iterator e = currentLive.begin(); !currentLive.done(e); e = currentLive.advance(e)) {
+						RegisterName live = RegisterName(currentLive.get(e));
+
+						if ((live != define) && !interfere(live, define) && registerAllocator.canInterfere(live, define)) {
+
+							if (vector[define] == NULL)
+								vector[define] = new(pool) InterferenceVector();
+							vector[define]->count++;
+
+							if (vector[live] == NULL)
+								vector[live] = new(pool) InterferenceVector();
+							vector[live]->count++;
+
+							setInterference(live, define);
+						}
+					}
+				}
+
+			// Now update the liveness.
+			//
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister())
+					currentLive.clear(name2range[definePtr->getRegisterName()]);
+
+			for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister())
+					currentLive.set(name2range[usePtr->getRegisterName()]);
+		}
+	}
+
+	// Allocate the memory to store the interferences.
+	//
+	for (Uint32 e = 0; e < rangeCount; e++)
+		if (vector[e] != NULL) {
+			InterferenceVector& v = *vector[e];
+			v.neighbors = new(pool) RegisterName[v.count];
+			v.count = 0;
+		}
+
+	// Initialize the edges.
+	//
+	if (RegisterPressure::Set::isOrdered()) {
+		RegisterName name1 = RegisterName(0);
+
+		for (RegisterPressure::Set::iterator i = interferences->begin(); !interferences->done(i); i = interferences->advance(i)) {
+			Uint32 interferenceIndex = interferences->get(i);
+
+			while(interferenceIndex >= offset[name1 + 1])
+				name1 = RegisterName(name1 + 1);
+
+			assert((interferenceIndex >= offset[name1]) && (interferenceIndex < offset[name1 + 1]));
+
+			RegisterName name2 = RegisterName(interferenceIndex - offset[name1]);
+
+			assert(interfere(name1, name2));
+
+			InterferenceVector& vector1 = *vector[name1];
+			vector1.neighbors[vector1.count++] = name2;
+		
+			InterferenceVector& vector2 = *vector[name2];
+			vector2.neighbors[vector2.count++] = name1;
+		}
+	} else {
+		trespass("not Implemented"); // FIX: need one more pass to initialize the vectors.
+	}
+}
+
+template <class RegisterPressure>
+Uint32 InterferenceGraph<RegisterPressure>::getEdgeIndex(RegisterName name1, RegisterName name2)
+{
+	checkMember(name1); checkMember(name2);
+	assert(name1 != name2); // This is not possible.
+	return (name1 < name2) ? offset[name2] + name1 : offset[name1] + name2;
+}
+
+template <class RegisterPressure>
+void InterferenceGraph<RegisterPressure>::setInterference(RegisterName name1, RegisterName name2)
+{
+	interferences->set(getEdgeIndex(name1, name2));
+}
+
+template <class RegisterPressure>
+bool InterferenceGraph<RegisterPressure>::interfere(RegisterName name1, RegisterName name2)
+{
+	return interferences->test(getEdgeIndex(name1, name2));
+}
+
+#ifdef DEBUG_LOG
+template <class RegisterPressure>
+void InterferenceGraph<RegisterPressure>::printPretty(LogModuleObject log)
+{
+	UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("Interference Vectors:\n"));
+	for (Uint32 i = 1; i < rangeCount; i++) {
+		if (vector[i] != NULL) {
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\tvr%d: (", i));
+			for (InterferenceVector* v = vector[i]; v != NULL; v = v->next)
+				for (Uint32 j = 0; j < v->count; j++) {
+					UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("%d", v->neighbors[j]));
+					if (v->next != NULL || j != (v->count - 1))
+						UT_OBJECTLOG(log, PR_LOG_ALWAYS, (","));
+				}
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, (")\n"));
+		}
+	}
+	UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("Interference Matrix:\n"));
+	for (RegisterName name1 = RegisterName(1); name1 < rangeCount; name1 = RegisterName(name1 + 1)) {
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\t%d:\t", name1));
+		for (RegisterName name2 = RegisterName(1); name2 < rangeCount; name2 = RegisterName(name2 + 1))
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("%c", ((name1 != name2) && interfere(name1, name2)) ? '1' : '0'));
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\n"));
+	}
+}
+#endif // DEBUG_LOG
+
+#endif // _INTERFERENCE_GRAPH_H_

mozilla/ef/Compiler/RegisterAllocator/LiveRange.h

@@ -0,0 +1,87 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _LIVE_RANGE_H_
+#define _LIVE_RANGE_H_
+
+#include "Fundamentals.h"
+#include "ControlGraph.h"
+#include "ControlNodes.h"
+#include "Primitives.h"
+#include "Instruction.h"
+#include "RegisterAllocator.h"
+#include "RegisterAllocatorTools.h"
+
+template <class RegisterPressure>
+struct LiveRange
+{
+	static void build(RegisterAllocator& registerAllocator);
+};
+
+template <class RegisterPressure>
+void LiveRange<RegisterPressure>::build(RegisterAllocator& registerAllocator)
+{
+	// Intialize the lookup table.
+	//
+	Uint32 nameCount = registerAllocator.nameCount;
+	RegisterName* nameTable = new(registerAllocator.pool) RegisterName[2*nameCount];
+	RegisterName* rangeName = &nameTable[nameCount];
+
+	init(rangeName, nameCount);
+
+	// Walk the graph.
+	//
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	SparseSet destination(registerAllocator.pool, nameCount);
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+		InstructionList& phiNodes = nodes[n]->getPhiNodeInstructions();
+
+		destination.clear();
+		for (InstructionList::iterator i = phiNodes.begin(); !phiNodes.done(i); i = phiNodes.advance(i)) {
+			Instruction& phiNode = phiNodes.get(i);
+			assert(phiNode.getInstructionDefineBegin() != phiNode.getInstructionDefineEnd() && phiNode.getInstructionDefineBegin()[0].isRegister());
+			destination.set(findRoot(phiNode.getInstructionDefineBegin()[0].getRegisterName(), rangeName));
+		}
+
+		for (InstructionList::iterator p = phiNodes.begin(); !phiNodes.done(p); p = phiNodes.advance(p)) {
+			Instruction& phiNode = phiNodes.get(p);
+
+			assert(phiNode.getInstructionDefineBegin() != phiNode.getInstructionDefineEnd() && phiNode.getInstructionDefineBegin()[0].isRegister());
+			RegisterName destinationName = phiNode.getInstructionDefineBegin()[0].getRegisterName();
+			RegisterName destinationRoot = findRoot(destinationName, rangeName);
+
+			InstructionUse* useEnd = phiNode.getInstructionUseEnd();
+			for (InstructionUse* usePtr = phiNode.getInstructionUseBegin(); usePtr < useEnd; usePtr++) {
+				assert(usePtr->isRegister());
+				RegisterName sourceName = usePtr->getRegisterName();
+				RegisterName sourceRoot = findRoot(sourceName, rangeName);
+
+				if (sourceRoot != destinationRoot && !destination.test(sourceRoot))
+					rangeName[sourceRoot] = destinationRoot;
+			}
+		}
+	}
+
+	registerAllocator.rangeCount = compress(registerAllocator.name2range, rangeName, nameCount, nameCount);
+}
+
+#endif // _LIVE_RANGE_H_

mozilla/ef/Compiler/RegisterAllocator/LiveRangeGraph.h

@@ -0,0 +1,163 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _LIVE_RANGE_GRAPH_
+#define _LIVE_RANGE_GRAPH_
+
+#include "Fundamentals.h"
+#include "Pool.h"
+#include "ControlGraph.h"
+#include "ControlNodes.h"
+#include "Instruction.h"
+#include "RegisterTypes.h"
+
+class RegisterAllocator;
+
+template <class RegisterPressure>
+class LiveRangeGraph
+{
+private:
+
+	RegisterAllocator&		registerAllocator;
+
+	RegisterPressure::Set*	edges;
+	Uint32					rangeCount;
+
+public:
+	//
+	//
+	LiveRangeGraph(RegisterAllocator& registerAllocator) : registerAllocator(registerAllocator) {}
+
+	//
+	//
+	void build();
+
+	//
+	//
+	void addEdge(RegisterName name1, RegisterName name2);
+
+	//
+	//
+	bool haveEdge(RegisterName name1, RegisterName name2);
+
+#ifdef DEBUG_LOG
+	//
+	//
+	void printPretty(LogModuleObject log);
+#endif // DEBUG_LOG
+};
+
+template <class RegisterPressure>
+void LiveRangeGraph<RegisterPressure>::build()
+{
+	Pool& pool = registerAllocator.pool;
+	Uint32 rangeCount = registerAllocator.rangeCount;
+	this->rangeCount = rangeCount;
+
+	edges = new(pool) RegisterPressure::Set(pool, rangeCount * rangeCount);
+
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	RegisterName* name2range = registerAllocator.name2range;
+	LivenessInfo<RegisterPressure>& liveness = registerAllocator.liveness;
+	SparseSet currentLive(pool, rangeCount);
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+		ControlNode& node = *nodes[n];
+		currentLive = liveness.liveOut[n];
+
+		InstructionList& instructions = node.getInstructions();
+		for (InstructionList::iterator i = instructions.end(); !instructions.done(i); i = instructions.retreat(i)) {
+			Instruction& instruction = instructions.get(i);
+
+			InstructionUse* useBegin = instruction.getInstructionUseBegin();
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			InstructionUse* usePtr;
+			InstructionDefine* defineBegin = instruction.getInstructionDefineBegin();
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			InstructionDefine* definePtr;
+
+			if ((instruction.getFlags() & ifCopy) != 0) {
+				assert(useBegin != useEnd && useBegin[0].isRegister());
+				currentLive.clear(name2range[useBegin[0].getRegisterName()]);
+			}
+
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister()) {
+					RegisterName define = name2range[definePtr->getRegisterName()];
+
+					for (SparseSet::iterator l = currentLive.begin(); !currentLive.done(l); l = currentLive.advance(l)) {
+						RegisterName live = RegisterName(currentLive.get(l));
+						if (define != live && registerAllocator.canInterfere(define, live))
+							addEdge(define, live);
+					}
+				}
+
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister())
+					currentLive.clear(name2range[definePtr->getRegisterName()]);
+
+			for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister())
+					currentLive.set(name2range[usePtr->getRegisterName()]);
+
+			for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister()) {
+					RegisterName use = name2range[usePtr->getRegisterName()];
+
+					for (SparseSet::iterator l = currentLive.begin(); !currentLive.done(l); l = currentLive.advance(l)) {
+						RegisterName live = RegisterName(currentLive.get(l));
+						if (use != live && registerAllocator.canInterfere(use, live))
+							addEdge(use, live);
+					}
+				}
+		}
+	}
+}
+
+template <class RegisterPressure>
+void LiveRangeGraph<RegisterPressure>::addEdge(RegisterName name1, RegisterName name2)
+{
+	assert(name1 != name2);
+	edges->set(name1 * rangeCount + name2);
+}
+
+template <class RegisterPressure>
+bool LiveRangeGraph<RegisterPressure>::haveEdge(RegisterName name1, RegisterName name2)
+{
+	assert(name1 != name2);
+	return edges->test(name1 * rangeCount + name2);
+}
+
+#ifdef DEBUG_LOG
+template <class RegisterPressure>
+void LiveRangeGraph<RegisterPressure>::printPretty(LogModuleObject log)
+{
+	UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("Live ranges graph:\n"));
+	for (RegisterName name1 = RegisterName(1); name1 < rangeCount; name1 = RegisterName(name1 + 1)) {
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\t%d:\t", name1));
+		for (RegisterName name2 = RegisterName(1); name2 < rangeCount; name2 = RegisterName(name2 + 1))
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("%c", ((name1 != name2) && haveEdge(name1, name2)) ? '1' : '0'));
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\n"));
+	}
+}
+#endif // DEBUG_LOG
+
+#endif // _LIVE_RANGE_GRAPH_

mozilla/ef/Compiler/RegisterAllocator/Liveness.cpp

@@ -0,0 +1,21 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include "Liveness.h"
+

mozilla/ef/Compiler/RegisterAllocator/Liveness.h

@@ -0,0 +1,301 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _LIVENESS_H_
+#define _LIVENESS_H_
+
+#include "Fundamentals.h"
+#include "ControlGraph.h"
+#include "ControlNodes.h"
+#include "Instruction.h"
+#include "RegisterTypes.h"
+
+// ----------------------------------------------------------------------------
+// LivenessInfo -
+
+template <class RegisterPressure>
+struct LivenessInfo
+{
+	RegisterPressure::Set*	liveIn;
+	RegisterPressure::Set*	liveOut;
+	DEBUG_LOG_ONLY(Uint32	size);
+
+#ifdef DEBUG_LOG
+	void printPretty(LogModuleObject log);
+#endif // DEBUG_LOG
+};
+
+// ----------------------------------------------------------------------------
+// Liveness
+//
+// The liveness is defined by the following data-flow equations:
+//
+//		LiveIn(n) = LocalLive(n) U (LiveOut(n) - Killed(n)).
+//		LiveOut(n) = U LiveIn(s) (s a successor of n).
+//
+//	where LocalLive(n) is the set of used registers in the block n, Killed(n)
+//  is the set of defined registers in the block n, LiveIn(n) is the set of
+//  live registers at the begining of the block n and LiveOut(n) is the set
+//  of live registers at the end of the block n.
+//
+//
+// We will compute the liveness analysis in two stages:
+//
+//	1- Build LocalLive(n) (wich is an approximation of LiveIn(n)) and Killed(n) 
+//     for each block n.
+//  2- Perform a backward data-flow analysis to propagate the liveness information
+//     through the entire control-flow graph.
+//
+
+template <class RegisterPressure>
+struct Liveness
+{
+	static LivenessInfo<RegisterPressure> analysis(ControlGraph& controlGraph, Uint32 rangeCount, const RegisterName* name2range);
+	static LivenessInfo<RegisterPressure> analysis(ControlGraph& controlGraph, Uint32 nameCount);
+};
+
+template <class RegisterPressure>
+LivenessInfo<RegisterPressure> Liveness<RegisterPressure>::analysis(ControlGraph& controlGraph, Uint32 rangeCount, const RegisterName* name2range)
+{
+	Pool& pool = controlGraph.pool;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	// Allocate the temporary sets.
+	RegisterPressure::Set* killed = new(pool) RegisterPressure::Set[nNodes](pool, rangeCount);
+	
+	// Allocate the globals sets.
+	RegisterPressure::Set* liveIn = new(pool) RegisterPressure::Set[nNodes](pool, rangeCount);
+	RegisterPressure::Set* liveOut = new(pool) RegisterPressure::Set[nNodes](pool, rangeCount);
+
+	// First stage of the liveness analysis: Compute the sets LocalLive(stored in LiveIn) and Killed.
+	//
+	for (Uint32 n = 0; n < (nNodes - 1); n++) {
+		ControlNode& node = *nodes[n];
+
+		RegisterPressure::Set& currentLocalLive = liveIn[n];
+		RegisterPressure::Set& currentKilled = killed[n];
+		
+		// Find the instructions contributions to the sets LocalLive and Killed.
+		//
+		InstructionList& instructions = node.getInstructions();
+		for (InstructionList::iterator i = instructions.begin(); !instructions.done(i); i = instructions.advance(i)) {
+			Instruction& instruction = instructions.get(i);
+
+			// If a VirtualRegister is 'used' before being 'defined' then we add it to set LocalLive.
+
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister()) {
+					Uint32 index = name2range[usePtr->getRegisterName()];
+
+					if (!currentKilled.test(index))
+						currentLocalLive.set(index);
+				}
+
+			// If a Virtualregister is 'defined' then we add it to the set Killed.
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			for (InstructionDefine* definePtr = instruction.getInstructionDefineBegin(); definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister())
+					currentKilled.set(name2range[definePtr->getRegisterName()]);
+		}
+	}
+
+	// Second stage of the liveness analysis: We propagate the LiveIn & LiveOut through the entire 
+	// control-flow graph.
+	//
+	RegisterPressure::Set temp(pool, rangeCount);
+
+	bool changed;
+	do {
+		changed = false;
+
+		// For all nodes is this graph except the endNode.
+		for (Int32 n = (nNodes - 2); n >= 0; n--) {
+			ControlNode& node = *nodes[n];
+
+			RegisterPressure::Set& currentLiveIn = liveIn[n];
+			RegisterPressure::Set& currentLiveOut = liveOut[n];
+
+			// Compute temp = Union of LiveIn(s) (s a successor of this node) | usedByPhiNodes(n).
+			// temp will be the new LiveOut(n).
+			Uint32 nSuccessors = node.nSuccessors();
+			if (nSuccessors != 0) {
+				temp = liveIn[node.nthSuccessor(0).getTarget().dfsNum];
+				for (Uint32 s = 1; s < nSuccessors; s++)
+					temp |= liveIn[node.nthSuccessor(s).getTarget().dfsNum];
+			} else 
+				temp.clear();
+
+			// If temp and LiveOut(n) differ then set LiveOut(n) = temp and recalculate the
+			// new LiveIn(n).
+			if (currentLiveOut != temp) {
+				currentLiveOut = temp;
+				temp -= killed[n]; // FIX: could be optimized with one call to unionDiff !
+				temp |= currentLiveIn;
+			
+				if (currentLiveIn != temp) {
+					currentLiveIn = temp;
+					changed = true;
+				}
+			}
+		}
+	} while(changed);
+
+	LivenessInfo<RegisterPressure> liveness;
+	liveness.liveIn = liveIn;
+	liveness.liveOut = liveOut;
+	DEBUG_LOG_ONLY(liveness.size = nNodes);
+	return liveness;
+}
+
+template <class RegisterPressure>
+LivenessInfo<RegisterPressure> Liveness<RegisterPressure>::analysis(ControlGraph& controlGraph, Uint32 nameCount)
+{
+	Pool& pool = controlGraph.pool;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	// Allocate the temporary sets.
+	RegisterPressure::Set* killed = new(pool) RegisterPressure::Set[nNodes](pool, nameCount);
+	RegisterPressure::Set* usedByPhiNodes = NULL;
+	
+	// Allocate the globals sets.
+	RegisterPressure::Set* liveIn = new(pool) RegisterPressure::Set[nNodes](pool, nameCount);
+	RegisterPressure::Set* liveOut = new(pool) RegisterPressure::Set[nNodes](pool, nameCount);
+
+	// First stage of the liveness analysis: Compute the sets LocalLive(stored in LiveIn) and Killed.
+	//
+	for (Uint32 n = 0; n < (nNodes - 1); n++) {
+		ControlNode& node = *nodes[n];
+
+		RegisterPressure::Set& currentLocalLive = liveIn[n];
+		RegisterPressure::Set& currentKilled = killed[n];
+		
+		InstructionList& phiNodes = node.getPhiNodeInstructions();
+
+		if ((usedByPhiNodes == NULL) && !phiNodes.empty())
+			usedByPhiNodes = new(pool) RegisterPressure::Set[nNodes](pool, nameCount);
+
+		for (InstructionList::iterator p = phiNodes.begin(); !phiNodes.done(p); p = phiNodes.advance(p)) {
+			Instruction& phiNode = phiNodes.get(p);
+
+			InstructionDefine& define = phiNode.getInstructionDefineBegin()[0];
+			currentKilled.set(define.getRegisterName());
+
+			typedef DoublyLinkedList<ControlEdge> ControlEdgeList;
+			const ControlEdgeList& predecessors = node.getPredecessors();
+			ControlEdgeList::iterator p = predecessors.begin();
+			InstructionUse* useEnd = phiNode.getInstructionUseEnd();
+			for (InstructionUse* usePtr = phiNode.getInstructionUseBegin(); usePtr < useEnd; usePtr++, p = predecessors.advance(p))
+				if (usePtr->isRegister())
+					usedByPhiNodes[predecessors.get(p).getSource().dfsNum].set(usePtr->getRegisterName());
+		}
+
+		// Find the instructions contributions to the sets LocalLive and Killed.
+		//
+		InstructionList& instructions = node.getInstructions();
+		for (InstructionList::iterator i = instructions.begin(); !instructions.done(i); i = instructions.advance(i)) {
+			Instruction& instruction = instructions.get(i);
+
+			// If a VirtualRegister is 'used' before being 'defined' then we add it to set LocalLive.
+
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister()) {
+					Uint32 index = usePtr->getRegisterName();
+
+					if (!currentKilled.test(index))
+						currentLocalLive.set(index);
+				}
+
+			// If a Virtualregister is 'defined' then we add it to the set Killed.
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			for (InstructionDefine* definePtr = instruction.getInstructionDefineBegin(); definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister())
+					currentKilled.set(definePtr->getRegisterName());
+		}
+	}
+
+	// Second stage of the liveness analysis: We propagate the LiveIn & LiveOut through the entire 
+	// control-flow graph.
+	//
+	RegisterPressure::Set temp(pool, nameCount);
+
+	bool changed;
+	do {
+		changed = false;
+
+		// For all nodes is this graph except the endNode.
+		for (Int32 n = (nNodes - 2); n >= 0; n--) {
+			ControlNode& node = *nodes[n];
+
+			RegisterPressure::Set& currentLiveIn = liveIn[n];
+			RegisterPressure::Set& currentLiveOut = liveOut[n];
+
+			// Compute temp = Union of LiveIn(s) (s a successor of this node) | usedByPhiNodes(n).
+			// temp will be the new LiveOut(n).
+			Uint32 nSuccessors = node.nSuccessors();
+			if (nSuccessors != 0) {
+				temp = liveIn[node.nthSuccessor(0).getTarget().dfsNum];
+				for (Uint32 s = 1; s < nSuccessors; s++)
+					temp |= liveIn[node.nthSuccessor(s).getTarget().dfsNum];
+			} else 
+				temp.clear();
+
+			// Insert the phiNodes contribution.
+			if (usedByPhiNodes != NULL)
+				temp |= usedByPhiNodes[n];
+
+			// If temp and LiveOut(n) differ then set LiveOut(n) = temp and recalculate the
+			// new LiveIn(n).
+			if (currentLiveOut != temp) {
+				currentLiveOut = temp;
+				temp -= killed[n]; // FIX: could be optimized with one call to unionDiff !
+				temp |= currentLiveIn;
+			
+				if (currentLiveIn != temp) {
+					currentLiveIn = temp;
+					changed = true;
+				}
+			}
+		}
+	} while(changed);
+
+	LivenessInfo<RegisterPressure> liveness;
+	liveness.liveIn = liveIn;
+	liveness.liveOut = liveOut;
+	DEBUG_LOG_ONLY(liveness.size = nNodes);
+	return liveness;
+}
+
+#ifdef DEBUG_LOG
+template <class RegisterPressure>
+void LivenessInfo<RegisterPressure>::printPretty(LogModuleObject log)
+{
+	for (Uint32 n = 0; n < size; n++) {
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("Node N%d:\n\tliveIn = ", n));
+		liveIn[n].printPretty(log);
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\tliveOut = "));
+		liveOut[n].printPretty(log);
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\n"));
+	}
+}
+#endif // DEBUG_LOG
+
+#endif // _LIVENESS_H_

mozilla/ef/Compiler/RegisterAllocator/Makefile

@@ -0,0 +1,40 @@
+#! gmake
+
+DEPTH			= ../..
+
+MODULE_NAME		= RegisterAllocator
+
+include $(DEPTH)/config/config.mk
+
+INCLUDES		+=										\
+	-I$(DEPTH)/Utilities/General						\
+	-I$(DEPTH)/Utilities/zlib							\
+	-I$(DEPTH)/Runtime/ClassReader						\
+	-I$(DEPTH)/Runtime/NativeMethods					\
+	-I$(DEPTH)/Runtime/System							\
+	-I$(DEPTH)/Runtime/ClassInfo						\
+	-I$(DEPTH)/Runtime/FileReader						\
+	-I$(DEPTH)/Compiler/PrimitiveGraph					\
+	-I$(DEPTH)/Compiler/FrontEnd						\
+	-I$(DEPTH)/Compiler/Optimizer						\
+	-I$(DEPTH)/Compiler/CodeGenerator					\
+	-I$(DEPTH)/Compiler/CodeGenerator/md				\
+	-I$(DEPTH)/Compiler/CodeGenerator/md/$(CPU_ARCH)	\
+	-I$(DEPTH)/Compiler/RegisterAllocator				\
+	-I$(DEPTH)/Driver/StandAloneJava					\
+	-I$(DEPTH)/Debugger									\
+	$(NULL)
+
+CXXSRCS 		=										\
+	RegisterAllocator.cpp								\
+	RegisterAllocatorTools.cpp							\
+	DominatorGraph.cpp									\
+	VirtualRegister.cpp									\
+	BitSet.cpp											\
+	SparseSet.cpp										\
+	$(NULL)
+
+
+include $(DEPTH)/config/rules.mk
+
+libs:: $(MODULE)

mozilla/ef/Compiler/RegisterAllocator/PhiNodeRemover.h

@@ -0,0 +1,392 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _PHI_NODE_REMOVER_H_
+#define _PHI_NODE_REMOVER_H_
+
+#include "Fundamentals.h"
+#include "Pool.h"
+#include "ControlGraph.h"
+#include "DominatorGraph.h"
+#include "VirtualRegister.h"
+#include "RegisterPressure.h"
+#include "Liveness.h"
+#include "Instruction.h"
+#include "InstructionEmitter.h"
+#include "SparseSet.h"
+#include <string.h>
+
+//------------------------------------------------------------------------------
+// RegisterNameNode -
+
+struct RegisterNameNode 
+{
+	RegisterNameNode*	next;
+	RegisterName		newName;
+	Uint32				nextPushed;
+};
+
+//------------------------------------------------------------------------------
+// CopyData -
+
+struct CopyData
+{
+	RegisterName		source;
+	RegisterClassKind	classKind;
+	Uint32				useCount;
+	bool				isLiveOut;
+	RegisterName		sourceNameToUse;
+	RegisterName		temporaryName;
+	RegisterNameNode*	newName;
+};
+
+//------------------------------------------------------------------------------
+// PhiNodeRemover<RegisterPressure> -
+
+template <class RegisterPressure>
+struct PhiNodeRemover
+{
+	// Replace the phi nodes by copy instructions.
+	static void replacePhiNodes(ControlGraph& controlGraph, VirtualRegisterManager& vrManager, InstructionEmitter& emitter);
+};
+
+// Split some of the critical edges and return true if there are still some
+// in the graph after that.
+//
+static bool splitCriticalEdges(ControlGraph& /*cg*/)
+{
+	// FIX: not implemented.
+	return true;
+}
+
+inline void pushName(Pool& pool, RegisterNameNode** stack, SparseSet& pushed, Uint32* nodeListPointer, RegisterName oldName, RegisterName newName)
+{
+	RegisterNameNode& newNode = *new(pool) RegisterNameNode();
+
+	if (pushed.test(oldName))
+		(*stack)->newName = newName;
+	else {
+		newNode.newName = newName;
+		newNode.nextPushed = *nodeListPointer;
+		*nodeListPointer = oldName;
+		newNode.next = *stack;
+		*stack = &newNode;
+		pushed.set(oldName);
+	}
+}
+
+template <class RegisterPressure>
+void PhiNodeRemover<RegisterPressure>::replacePhiNodes(ControlGraph& controlGraph, VirtualRegisterManager& vrManager, InstructionEmitter& emitter)
+{
+	Pool& pool = controlGraph.pool;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	// Initialize the local variables.
+	//
+
+	// When we insert the copies we will also need to create new VirtualRegisters for
+	// the insertion of temporaries. The maximum number of temporary register will not
+	// exceed the number of phiNodes in the primitive graph.
+	Uint32 nameCount = vrManager.getSize();
+	Uint32 maxNameCount = nameCount;
+	for (Uint32 n = 0; n < nNodes; n++)
+		maxNameCount += nodes[n]->getPhiNodes().length();
+
+	// If the CFG contains some critical edges (backward edge which source has more than one
+	// outgoing edge and destination has more than one incomimg edge) then we need the liveness
+	// information to be able to insert temporary copies.
+	RegisterPressure::Set* liveOut = NULL;
+	if (splitCriticalEdges(controlGraph))
+		liveOut = Liveness<LowRegisterPressure>::analysis(controlGraph, nameCount).liveOut;
+
+	DominatorGraph dGraph(controlGraph);
+
+	SparseSet pushed(pool, maxNameCount);
+	SparseSet destinationList(pool, maxNameCount);
+	SparseSet workList(pool, maxNameCount);
+
+	CopyData* copyStats = new(pool) CopyData[maxNameCount];
+	memset(copyStats, '\0', maxNameCount*sizeof(CopyData));
+
+	struct NodeStack {
+		Uint32* next;
+		Uint32* limit;
+		Uint32 pushedList;
+	};
+
+	// Allocate the node stack and initialize the node stack pointer.
+	NodeStack* nodeStack = new(pool) NodeStack[nNodes + 1];
+	NodeStack* nodeStackPtr = nodeStack;
+
+	// We start by the begin node. 
+	Uint32 startNode = 0;
+	Uint32* next = &startNode;
+	Uint32* limit = &startNode + 1;
+
+	while (true) {
+
+		if (next == limit) {
+			// If there are no more node in the sibling, we have to pop the current
+			// frame from the stack and update the copyStats of the pushed nodes.
+			//
+			if (nodeStackPtr == nodeStack)
+				// We are at the bottom of the stack and there are no more nodes
+				// to look at. We are done !
+				break;
+
+			--nodeStackPtr;
+			// We are done with all the children of this node in the dominator tree.
+			// We need to update the copy information of all the new names pushed
+			// during the walk over this node.
+			Uint32 pushedList = nodeStackPtr->pushedList;
+			while (pushedList != 0) {
+				Uint32 nextName = copyStats[pushedList].newName->nextPushed;
+				copyStats[pushedList].newName = copyStats[pushedList].newName->next;
+				pushedList = nextName;
+			}
+
+			// restore the previous frame.
+			next = nodeStackPtr->next;
+			limit = nodeStackPtr->limit;
+		} else {
+			Uint32 currentNode = *next++;
+			Uint32 pushedList = 0;
+
+
+			// Initialize the sets.
+			pushed.clear();
+			destinationList.clear();
+
+			// STEP1:
+			//  Walk the instruction list and to replace all the instruction uses with their new name. 
+			//  If the instruction is a phi node and its defined register is alive at the end of this 
+			//  block then we push the defined register into the stack.
+			//
+			ControlNode& node = *nodes[currentNode];
+			RegisterPressure::Set* currentLiveOut = (liveOut != NULL) ? &liveOut[currentNode] : (RegisterPressure::Set*) 0;
+
+			InstructionList& phiNodes = node.getPhiNodeInstructions();
+			for (InstructionList::iterator p = phiNodes.begin(); !phiNodes.done(p); p = phiNodes.advance(p)) {
+				Instruction& phiNode = phiNodes.get(p);
+
+				InstructionUse* useEnd = phiNode.getInstructionUseEnd();
+				for (InstructionUse* usePtr = phiNode.getInstructionUseBegin(); usePtr < useEnd; usePtr++) {
+					assert(usePtr->isRegister());
+					RegisterName name = usePtr->getRegisterName();
+
+					if (copyStats[name].newName != NULL && copyStats[name].newName->newName != name)
+						usePtr->setRegisterName(copyStats[name].newName->newName);
+				}
+
+				if (currentLiveOut != NULL) {
+					// This is a phi node and we have to push its defined name if it is live
+					// at the end of the node. We only need to do this if the CFG has critical edges.
+					assert(phiNode.getInstructionDefineBegin() != phiNode.getInstructionDefineEnd() && phiNode.getInstructionDefineBegin()[0].isRegister());
+					RegisterName name = phiNode.getInstructionDefineBegin()[0].getRegisterName();
+
+					if (currentLiveOut->test(name))
+						pushName(pool, &(copyStats[name].newName), pushed, &pushedList, name, name);
+				}
+				
+			}
+
+			InstructionList& instructions = node.getInstructions();
+			for (InstructionList::iterator i = instructions.begin(); !instructions.done(i); i = instructions.advance(i)) {
+				Instruction& instruction = instructions.get(i);
+
+				InstructionUse* useEnd = instruction.getInstructionUseEnd();
+				for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+					if (usePtr->isRegister()) {
+						RegisterName name = usePtr->getRegisterName();
+
+						if (copyStats[name].newName != NULL && copyStats[name].newName->newName != name)
+							usePtr->setRegisterName(copyStats[name].newName->newName);
+					}
+			}
+
+			// STEP2:
+			//  Look at this node's successors' phiNodes. We keep track of the number of time
+			//  a VR will be used by another copy instruction and insert each definition into the 
+			//  destinationList. This is the only pass over this node's successors as we will
+			//  get all the information we need in the CopyData structures.
+			//
+			ControlEdge* successorEdgeEnd = node.getSuccessorsEnd();
+			for (ControlEdge* successorEdgePtr = node.getSuccessorsBegin(); successorEdgePtr < successorEdgeEnd; successorEdgePtr++) {
+				Uint32 useIndex = successorEdgePtr->getIndex();
+				ControlNode& successor = successorEdgePtr->getTarget();
+
+				// Look at its phi nodes. The phi nodes are at the top of the instruction list. We exit
+				// as soon as we find an instruction which is not a phi node
+				InstructionList& phiNodes = successor.getPhiNodeInstructions();
+				for (InstructionList::iterator p = phiNodes.begin(); !phiNodes.done(p); p = phiNodes.advance(p)) {
+					Instruction& phiNode = phiNodes.get(p);
+					
+					assert((phiNode.getInstructionUseBegin() + useIndex) < phiNode.getInstructionUseEnd());
+					assert(phiNode.getInstructionDefineBegin() != phiNode.getInstructionDefineEnd());
+
+					InstructionUse& source = phiNode.getInstructionUseBegin()[useIndex];
+					InstructionDefine& destination = phiNode.getInstructionDefineBegin()[0];
+
+					assert(source.isRegister() && destination.isRegister());
+
+					RegisterName sourceName = source.getRegisterName();
+					RegisterName destinationName = destination.getRegisterName();
+
+					// Get the correct name for the source.
+					if (copyStats[sourceName].newName != NULL)
+						sourceName = copyStats[sourceName].newName->newName;
+
+					// Update the CopyData structures.
+					if ((sourceName != rnInvalid) && (sourceName != destinationName)) {
+						copyStats[destinationName].source = sourceName;
+						copyStats[destinationName].classKind = destination.getRegisterClass();
+						copyStats[destinationName].isLiveOut = (currentLiveOut != NULL) ? currentLiveOut->test(destinationName) : false;
+						copyStats[destinationName].sourceNameToUse = destinationName;
+						copyStats[sourceName].sourceNameToUse = sourceName;
+						copyStats[sourceName].useCount++;
+						destinationList.set(destinationName);
+					}
+				}
+			}
+
+			// STEP3:
+			//  Insert into the worklist only the destination registers that will be not used in 
+			//  another copy instruction in this block.
+			//
+			assert(workList.getSize() == 0);
+			for (SparseSet::iterator d = destinationList.begin(); !destinationList.done(d); d = destinationList.advance(d)) {
+				Uint32 dest = destinationList.get(d);
+				if (copyStats[dest].useCount == 0)
+					workList.set(dest);
+			}
+
+			// STEP4:
+			//  Insert the copy instructions.
+			//
+			Uint32 destinationListSize = destinationList.getSize();
+			InstructionList::iterator endOfTheNode = instructions.end();
+
+			// Find the right place to insert the copy instructions.
+			if (destinationListSize != 0)
+				while (instructions.get(endOfTheNode).getFlags() & ifControl)
+					endOfTheNode = instructions.retreat(endOfTheNode);
+
+			while (destinationListSize != 0) {
+				while(workList.getSize()) {
+					RegisterName destinationName = RegisterName(workList.getOne());
+					RegisterName sourceName = copyStats[destinationName].source;
+
+					workList.clear(destinationName);
+					if (copyStats[destinationName].isLiveOut && !copyStats[destinationName].temporaryName) {
+						// Lost copy problem.
+						copyStats[destinationName].isLiveOut = false;
+
+						RegisterName sourceName = destinationName;
+						RegisterClassKind classKind = copyStats[sourceName].classKind;
+						RegisterName destinationName = getName(vrManager.newVirtualRegister(classKind));
+						assert(destinationName < maxNameCount);
+
+						copyStats[destinationName].classKind = classKind;
+						copyStats[sourceName].useCount = 0;
+				
+						// We need to insert a copy to a temporary register to keep the
+						// source register valid at the end of the node defining it.
+						// This copy will be inserted right after the phi node defining it.
+						RegisterName from = copyStats[sourceName].sourceNameToUse;
+						Instruction* definingPhiNode = vrManager.getVirtualRegister(from).getDefiningInstruction();
+						assert(definingPhiNode && (definingPhiNode->getFlags() & ifPhiNode) != 0);
+
+						RegisterID fromID = buildRegisterID(from, classKind);
+						RegisterID toID = buildRegisterID(destinationName, classKind);
+						Instruction& copy = emitter.newCopy(*definingPhiNode->getPrimitive(), fromID, toID);
+						vrManager.getVirtualRegister(destinationName).setDefiningInstruction(copy);
+						definingPhiNode->getPrimitive()->getContainer()->getInstructions().addFirst(copy);
+
+						copyStats[sourceName].temporaryName = destinationName;
+						copyStats[sourceName].sourceNameToUse = destinationName;
+						pushName(pool, &(copyStats[sourceName].newName), pushed, &pushedList, sourceName, destinationName);
+					}
+
+					// Insert the copy instruction at the end of the current node.
+					RegisterName from = copyStats[sourceName].sourceNameToUse;
+
+					RegisterClassKind classKind = copyStats[destinationName].classKind;
+					RegisterID fromID = buildRegisterID(from, classKind);
+					RegisterID toID = buildRegisterID(destinationName, classKind);
+					Instruction& copy = emitter.newCopy(*vrManager.getVirtualRegister(from).getDefiningInstruction()->getPrimitive(), fromID, toID);
+					instructions.insertAfter(copy, endOfTheNode);
+					endOfTheNode = instructions.advance(endOfTheNode);
+
+					copyStats[sourceName].useCount = 0;
+					if (destinationList.test(sourceName) && copyStats[sourceName].isLiveOut)
+						pushName(pool, &(copyStats[sourceName].newName), pushed, &pushedList, sourceName, destinationName);
+					copyStats[sourceName].isLiveOut = false;
+					copyStats[sourceName].sourceNameToUse = destinationName;
+
+					if (destinationList.test(sourceName))
+						workList.set(sourceName);
+					destinationList.clear(destinationName);
+				}
+
+				destinationListSize = destinationList.getSize();
+				if (destinationListSize != 0) {
+					RegisterName sourceName = RegisterName(destinationList.getOne());
+					RegisterName destinationName;
+
+					if (!copyStats[sourceName].temporaryName) {
+						// Cycle problem.
+						RegisterClassKind classKind = copyStats[sourceName].classKind;
+						destinationName = getName(vrManager.newVirtualRegister(classKind));
+						assert(destinationName < maxNameCount);
+				
+						copyStats[destinationName].classKind = classKind;
+						copyStats[sourceName].temporaryName = destinationName;
+
+						// Insert the copy instruction at the end of the current node.
+						RegisterName from = copyStats[sourceName].sourceNameToUse;
+
+						RegisterID fromID = buildRegisterID(from, classKind);
+						RegisterID toID = buildRegisterID(destinationName, classKind);
+						Instruction& copy = emitter.newCopy(*vrManager.getVirtualRegister(from).getDefiningInstruction()->getPrimitive(), fromID, toID);
+						vrManager.getVirtualRegister(destinationName).setDefiningInstruction(copy);
+						instructions.insertAfter(copy, endOfTheNode);
+						endOfTheNode = instructions.advance(endOfTheNode);
+					} else 
+						destinationName = copyStats[sourceName].temporaryName;
+
+					copyStats[sourceName].useCount = 0;
+					copyStats[sourceName].isLiveOut = false;
+					copyStats[sourceName].sourceNameToUse = destinationName;
+					pushName(pool, &(copyStats[sourceName].newName), pushed, &pushedList, sourceName, destinationName);
+
+					workList.set(sourceName);
+				}
+			}
+
+			nodeStackPtr->pushedList = pushedList;
+			nodeStackPtr->next = next;
+			nodeStackPtr->limit = limit;
+			++nodeStackPtr;
+			next = dGraph.getSuccessorsBegin(currentNode);
+			limit = dGraph.getSuccessorsEnd(currentNode);
+		}
+	}
+}
+
+#endif // _PHI_NODE_REMOVER_H_

mozilla/ef/Compiler/RegisterAllocator/RegisterAllocator.cpp

@@ -0,0 +1,155 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include "LogModule.h"
+#include "RegisterAllocator.h"
+#include "RegisterPressure.h"
+#include "RegisterAllocatorTools.h"
+#include "PhiNodeRemover.h"
+#include "LiveRange.h"
+#include "Liveness.h"
+#include "InterferenceGraph.h"
+#include "LiveRangeGraph.h"
+#include "Coalescing.h"
+#include "Spilling.h"
+#include "Coloring.h"
+#include "Splits.h"
+
+class Pool;
+class ControlGraph;
+class VirtualRegisterManager;
+class InstructionEmitter;
+
+UT_DEFINE_LOG_MODULE(RegAlloc);
+
+void RegisterAllocator::allocateRegisters(Pool& pool, ControlGraph& controlGraph, VirtualRegisterManager& vrManager, InstructionEmitter& emitter)
+{
+	// Insert the phi node instructions. We want to do this to have a single defined register per instruction.
+	// If we keep the PhiNode (as a DataNode) and a PhiNode is of DoubleWordKind then we have to execute
+	// some special code for the high word annotation.
+	//
+	RegisterAllocatorTools::insertPhiNodeInstructions(controlGraph, emitter);
+
+	// Perform some tests on the instruction graph.
+	//
+	DEBUG_ONLY(RegisterAllocatorTools::testTheInstructionGraph(controlGraph, vrManager));
+
+	// Replace the phi node instructions by their equivalent copy instructions.
+	//
+	PhiNodeRemover<LowRegisterPressure>::replacePhiNodes(controlGraph, vrManager, emitter);
+
+	// Do the register allocation.
+	//
+	RegisterAllocator registerAllocator(pool, controlGraph, vrManager, emitter);
+	registerAllocator.doGraphColoring();
+}
+
+void RegisterAllocator::doGraphColoring()
+{
+	// Initialize the liverange map.
+	//
+	initLiveRanges();
+
+	// Build the live ranges. We do this to compress the number of RegisterNames 
+	// used in the insterference graph.
+	//
+	LiveRange<LowRegisterPressure>::build(*this);
+
+	// Remove unnecessary copies.
+	//
+	RegisterAllocatorTools::removeUnnecessaryCopies(*this);
+
+	for (Uint8 loop = 0; loop < 10; loop++) {
+
+		UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("********* RegisterAllocator loop %d *********\n", loop));
+
+		while(true) {
+			// Build the interference graph.
+			//
+			iGraph.build();
+
+			// Coalesce the copy instructions.
+			//
+			if (!Coalescing<LowRegisterPressure>::coalesce(*this))
+				break;
+		}
+
+		// Print the interference graph.
+		//
+		DEBUG_LOG_ONLY(iGraph.printPretty(UT_LOG_MODULE(RegAlloc)));
+
+		// Calculate the spill costs.
+		//
+		Spilling<LowRegisterPressure>::calculateSpillCosts(*this);
+		DEBUG_LOG_ONLY(RegisterAllocatorTools::printSpillCosts(*this));
+
+		// Calculate the split costs.
+		//
+		Splits<LowRegisterPressure>::calculateSplitCosts(*this);
+		DEBUG_LOG_ONLY(RegisterAllocatorTools::printSplitCosts(*this));
+
+		// Build the live range graph.
+		//
+		lGraph.build();
+		DEBUG_LOG_ONLY(lGraph.printPretty(UT_LOG_MODULE(RegAlloc)));
+
+		// Color the graph. If it succeeds then we're done with the
+		// register allocation.
+		//
+		if (Coloring<LowRegisterPressure>::color(*this)) {
+			// Write the final colors in the instruction graph.
+			//
+			Coloring<LowRegisterPressure>::finalColoring(*this);
+
+			UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("********** RegisterAllocator  done **********\n"));
+			DEBUG_LOG_ONLY(RegisterAllocatorTools::printInstructions(*this));
+
+			return;
+		}
+
+		// We need to spill some registers.
+		//
+		Spilling<LowRegisterPressure>::insertSpillCode(*this);
+
+		// Insert the split instructions.
+		//
+		Splits<LowRegisterPressure>::insertSplitCode(*this);
+
+		// Update the live ranges.
+		// 
+		// FIX
+	}
+
+#ifdef DEBUG_LOG
+	RegisterAllocatorTools::updateInstructionGraph(*this);
+	RegisterAllocatorTools::printInstructions(*this);
+#endif
+	fprintf(stderr, "!!! Coloring failed after 10 loops !!!\n");
+	abort();
+}
+
+void RegisterAllocator::initLiveRanges()
+{
+	Uint32 count = this->nameCount;
+	RegisterName* name2range = new(pool) RegisterName[nameCount];
+	for (RegisterName r = RegisterName(1); r < count; r = RegisterName(r + 1))
+		name2range[r] = r;
+	this->name2range = name2range;
+	rangeCount = count;
+}

mozilla/ef/Compiler/RegisterAllocator/RegisterAllocator.h

@@ -0,0 +1,88 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _REGISTER_ALLOCATOR_H_
+#define _REGISTER_ALLOCATOR_H_
+
+class Pool;
+class ControlGraph;
+class InstructionEmitter;
+struct SpillCost;
+struct SplitCost;
+
+#include "Liveness.h"
+#include "VirtualRegister.h"
+#include "RegisterPressure.h" // This should included by Backend.cpp
+#include "InterferenceGraph.h"
+#include "LiveRangeGraph.h"
+
+//template <class RegisterPressure>
+class RegisterAllocator
+{
+public:
+
+	Pool&									pool;			//
+	ControlGraph&							controlGraph;	//
+	VirtualRegisterManager&					vrManager;		//
+	InstructionEmitter&						emitter;		//
+
+	RegisterName*							name2range;		//
+	RegisterName*							color;			//
+	SpillCost*								spillCost;		//
+	SparseSet*								willSpill;		//
+	SplitCost*								splitCost;		//
+	NameLinkedList**						splitAround;	//
+	InterferenceGraph<LowRegisterPressure>	iGraph;			//
+	LiveRangeGraph<LowRegisterPressure>		lGraph;			//
+	LivenessInfo<LowRegisterPressure>		liveness;		//
+	Uint32									nameCount;		//
+	Uint32									rangeCount;		//
+	bool									splitFound;		//
+
+private:
+
+	//
+	//
+	void doGraphColoring();
+
+public:
+
+	//
+	//
+	inline RegisterAllocator(Pool& pool, ControlGraph& controlGraph, VirtualRegisterManager& vrManager, InstructionEmitter& emitter);
+
+	//
+	//
+	bool canInterfere(RegisterName /*name1*/, RegisterName /*name2*/) const {return true;}
+
+	//
+	//
+	void initLiveRanges();
+
+	//
+	//
+	static void allocateRegisters(Pool& pool, ControlGraph& controlGraph, VirtualRegisterManager& vrManager, InstructionEmitter& emitter);
+};
+
+//
+//
+inline RegisterAllocator::RegisterAllocator(Pool& pool, ControlGraph& controlGraph, VirtualRegisterManager& vrManager, InstructionEmitter& emitter)
+	: pool(pool), controlGraph(controlGraph), vrManager(vrManager), emitter(emitter), iGraph(*this), lGraph(*this), nameCount(vrManager.getSize()) {}
+
+#endif // _REGISTER_ALLOCATOR_H_
+

mozilla/ef/Compiler/RegisterAllocator/RegisterAllocatorTools.cpp

@@ -0,0 +1,355 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include "LogModule.h"
+#include "RegisterAllocatorTools.h"
+#include "Pool.h"
+#include "ControlGraph.h"
+#include "ControlNodes.h"
+#include "Primitives.h"
+#include "InstructionEmitter.h"
+#include "Instruction.h"
+#include "RegisterAllocator.h"
+#include "Spilling.h"
+#include "Splits.h"
+#include "BitSet.h"
+
+UT_EXTERN_LOG_MODULE(RegAlloc);
+
+#ifdef DEBUG
+void RegisterAllocatorTools::testTheInstructionGraph(ControlGraph& controlGraph, VirtualRegisterManager& vrManager)
+{
+	// Test the declared VirtualRegisters. The register allocator tries to condense the register universe.
+	// Any gap in the VirtualRegister names will be a loss of efficiency !!!!
+
+	Uint32 nameCount = vrManager.getSize();
+	BitSet registerSeen(controlGraph.pool, nameCount);
+
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+
+		InstructionList& instructions = nodes[n]->getInstructions();
+		for (InstructionList::iterator i = instructions.begin(); !instructions.done(i); i = instructions.advance(i)) {
+			Instruction& instruction = instructions.get(i);
+
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister())
+					registerSeen.set(usePtr->getRegisterName());
+
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			for (InstructionDefine* definePtr = instruction.getInstructionDefineBegin(); definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister())
+					registerSeen.set(definePtr->getRegisterName());
+		}
+
+		InstructionList& phiNodes = nodes[n]->getPhiNodeInstructions();
+		for (InstructionList::iterator p = phiNodes.begin(); !phiNodes.done(p); p = phiNodes.advance(p)) {
+			Instruction& instruction = phiNodes.get(p);
+
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister())
+					registerSeen.set(usePtr->getRegisterName());
+
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			for (InstructionDefine* definePtr = instruction.getInstructionDefineBegin(); definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister())
+					registerSeen.set(definePtr->getRegisterName());
+		}
+	}
+
+	bool renameRegisters = false;
+	for (BitSet::iterator i = registerSeen.nextZero(0); !registerSeen.done(i); i = registerSeen.nextZero(i)) {
+		renameRegisters = true;
+		fprintf(stderr, 
+				"WARNING: The VirtualRegister vr%d has been allocated during CodeGeneration but\n"
+				"         is never used nor defined by any instruction in the instruction graph\n"
+				"                                  PLEASE FIX                                  \n",
+				i);
+	}
+	if (renameRegisters) {
+		Instruction** definingInstruction = new Instruction*[nameCount];
+		memset(definingInstruction, '\0', nameCount * sizeof(Instruction*));
+		RegisterName* newName = new RegisterName[nameCount];
+		memset(newName, '\0', nameCount * sizeof(RegisterName));
+		RegisterName nextName = RegisterName(1);
+
+		for (Uint32 n = 0; n < nNodes; n++) {
+
+			InstructionList& instructions = nodes[n]->getInstructions();
+			for (InstructionList::iterator i = instructions.begin(); !instructions.done(i); i = instructions.advance(i)) {
+				Instruction& instruction = instructions.get(i);
+
+				InstructionUse* useEnd = instruction.getInstructionUseEnd();
+				for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+					if (usePtr->isRegister()) {
+						RegisterName name = usePtr->getRegisterName();
+						if (newName[name] == rnInvalid) {
+							newName[name] = nextName;
+							definingInstruction[nextName] = vrManager.getVirtualRegister(name).getDefiningInstruction();
+							nextName = RegisterName(nextName + 1);
+						}
+						usePtr->setRegisterName(newName[name]);
+					}
+
+				InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+				for (InstructionDefine* definePtr = instruction.getInstructionDefineBegin(); definePtr < defineEnd; definePtr++)
+					if (definePtr->isRegister()) {
+						RegisterName name = definePtr->getRegisterName();
+						if (newName[name] == rnInvalid) {
+							newName[name] = nextName;
+							definingInstruction[nextName] = vrManager.getVirtualRegister(name).getDefiningInstruction();
+							nextName = RegisterName(nextName + 1);
+						}
+						definePtr->setRegisterName(newName[name]);
+					}
+			}
+
+			InstructionList& phiNodes = nodes[n]->getPhiNodeInstructions();
+			for (InstructionList::iterator p = phiNodes.begin(); !phiNodes.done(p); p = phiNodes.advance(p)) {
+				Instruction& instruction = phiNodes.get(p);
+
+				InstructionUse* useEnd = instruction.getInstructionUseEnd();
+				for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+					if (usePtr->isRegister()) {
+						RegisterName name = usePtr->getRegisterName();
+						if (newName[name] == rnInvalid) {
+							newName[name] = nextName;
+							definingInstruction[nextName] = vrManager.getVirtualRegister(name).getDefiningInstruction();
+							nextName = RegisterName(nextName + 1);
+						}
+						usePtr->setRegisterName(newName[name]);
+					}
+
+				InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+				for (InstructionDefine* definePtr = instruction.getInstructionDefineBegin(); definePtr < defineEnd; definePtr++)
+					if (definePtr->isRegister()) {
+						RegisterName name = definePtr->getRegisterName();
+						if (newName[name] == rnInvalid) {
+							newName[name] = nextName;
+							definingInstruction[nextName] = vrManager.getVirtualRegister(name).getDefiningInstruction();
+							nextName = RegisterName(nextName + 1);
+						}
+						definePtr->setRegisterName(newName[name]);
+					}
+			}
+		}
+		
+		vrManager.setSize(nextName);
+
+		for (RegisterName r = RegisterName(1); r < nextName; r = RegisterName(r + 1))
+			vrManager.getVirtualRegister(r).definingInstruction = definingInstruction[r];
+
+		UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("RegisterMap:\n"));
+		for (Uint32 i = 1; i < nameCount; i++)
+			if (newName[i] != 0)
+				UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\tvr%d becomes vr%d.\n", i, newName[i]));
+			else
+				UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\tvr%d is dead.\n", i));
+
+
+		delete newName;
+		delete definingInstruction;
+	}
+
+}
+#endif // DEBUG
+
+void RegisterAllocatorTools::removeUnnecessaryCopies(RegisterAllocator& registerAllocator)
+{
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+	RegisterName* name2range = registerAllocator.name2range;
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+		InstructionList& instructions = nodes[n]->getInstructions();
+		for (InstructionList::iterator i = instructions.begin(); !instructions.done(i);) {
+			Instruction& instruction = instructions.get(i);
+			i = instructions.advance(i);
+
+			if (instruction.getFlags() & ifCopy) {
+				assert(instruction.getInstructionUseBegin() != instruction.getInstructionUseEnd() && instruction.getInstructionUseBegin()[0].isRegister());
+				assert(instruction.getInstructionDefineBegin() != instruction.getInstructionDefineEnd() && instruction.getInstructionDefineBegin()[0].isRegister());
+				
+				RegisterName source = name2range[instruction.getInstructionUseBegin()[0].getRegisterName()];
+				RegisterName destination = name2range[instruction.getInstructionDefineBegin()[0].getRegisterName()];
+
+				if (source == destination)
+					instruction.remove();
+			}
+		}
+	}
+}
+
+
+void RegisterAllocatorTools::updateInstructionGraph(RegisterAllocator& registerAllocator)
+{
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+	RegisterName* name2range = registerAllocator.name2range;
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+		InstructionList& instructions = nodes[n]->getInstructions();
+		for (InstructionList::iterator i = instructions.begin(); !instructions.done(i); i = instructions.advance(i)) {
+			Instruction& instruction = instructions.get(i);
+
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister())
+					usePtr->setRegisterName(name2range[usePtr->getRegisterName()]);
+
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			for (InstructionDefine* definePtr = instruction.getInstructionDefineBegin(); definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister())
+					definePtr->setRegisterName(name2range[definePtr->getRegisterName()]);
+		}
+
+		InstructionList& phiNodes = nodes[n]->getPhiNodeInstructions();
+		for (InstructionList::iterator p = phiNodes.begin(); !phiNodes.done(p); p = phiNodes.advance(p)) {
+			Instruction& instruction = phiNodes.get(p);
+
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister())
+					usePtr->setRegisterName(name2range[usePtr->getRegisterName()]);
+
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			for (InstructionDefine* definePtr = instruction.getInstructionDefineBegin(); definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister())
+					definePtr->setRegisterName(name2range[definePtr->getRegisterName()]);
+		}
+	}
+}
+
+
+void RegisterAllocatorTools::insertPhiNodeInstructions(ControlGraph& controlGraph, InstructionEmitter& emitter)
+{
+	Pool& pool = controlGraph.pool;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+	
+	for (Uint32 n = 0; n < nNodes; n++) {
+		ControlNode& node = *nodes[n];
+		DoublyLinkedList<PhiNode>& phiNodes = node.getPhiNodes();
+
+		if (!phiNodes.empty()) {
+
+			// Set the index of the incoming edges.
+			Uint32 index = 0;
+			const DoublyLinkedList<ControlEdge>& predecessors = node.getPredecessors();
+			for (DoublyLinkedList<ControlEdge>::iterator p = predecessors.begin(); !predecessors.done(p); p = predecessors.advance(p))
+				predecessors.get(p).setIndex(index++);
+
+			// Insert the phi node instruction in the instruction list.
+			for (DoublyLinkedList<PhiNode>::iterator i = phiNodes.begin(); !phiNodes.done(i); i = phiNodes.advance(i)) {
+				PhiNode& phiNode = phiNodes.get(i);
+				ValueKind kind = phiNode.getKind();
+
+				if (!isStorableKind(kind))
+					continue;
+
+				RegisterClassKind classKind = rckGeneral; // FIX: get class kind from phi node kind.
+				Uint32 nInputs = phiNode.nInputs();
+
+				PhiNodeInstruction& phiNodeInstruction = *new(pool) PhiNodeInstruction(&phiNode, pool, nInputs);
+
+				emitter.defineProducer(phiNode, phiNodeInstruction, 0, classKind, drLow);
+				for (Uint32 whichInput = 0; whichInput < nInputs; whichInput++)
+					emitter.useProducer(phiNode.nthInputVariable(whichInput), phiNodeInstruction, whichInput, classKind, drLow);
+
+				node.addPhiNodeInstruction(phiNodeInstruction);
+
+				if (isDoublewordKind(kind)) {
+					PhiNodeInstruction& phiNodeInstruction = *new(pool) PhiNodeInstruction(&phiNode, pool, nInputs);
+
+					emitter.defineProducer(phiNode, phiNodeInstruction, 0, classKind, drHigh);
+					for (Uint32 whichInput = 0; whichInput < nInputs; whichInput++)
+						emitter.useProducer(phiNode.nthInputVariable(whichInput), phiNodeInstruction, whichInput, classKind, drHigh);
+
+					node.addPhiNodeInstruction(phiNodeInstruction);
+				}
+			}
+		}
+	}
+}
+
+#ifdef DEBUG_LOG
+
+void RegisterAllocatorTools::printSpillCosts(RegisterAllocator& registerAllocator)
+{
+	LogModuleObject log = UT_LOG_MODULE(RegAlloc);
+	Uint32 rangeCount = registerAllocator.rangeCount;
+	SpillCost* cost = registerAllocator.spillCost;
+
+	UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("Spill costs:\n"));
+	for (Uint32 i = 1; i < rangeCount; i++) {
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\trange %d : ", i));
+		if (cost[i].infinite)
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("infinite\n"));
+		else
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("%f\n", cost[i].cost));
+	}
+}
+
+void RegisterAllocatorTools::printSplitCosts(RegisterAllocator& registerAllocator)
+{
+	LogModuleObject log = UT_LOG_MODULE(RegAlloc);
+	Uint32 rangeCount = registerAllocator.rangeCount;
+	SplitCost* cost = registerAllocator.splitCost;
+
+	UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("Split costs:\n"));
+	for (Uint32 i = 1; i < rangeCount; i++) {
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\trange %d : loads = %f stores = %f\n", i, cost[i].loads, cost[i].stores));
+	}
+}
+
+void RegisterAllocatorTools::printInstructions(RegisterAllocator& registerAllocator)
+{
+	LogModuleObject log = UT_LOG_MODULE(RegAlloc);
+	ControlNode** nodes = registerAllocator.controlGraph.dfsList;
+	Uint32 nNodes = registerAllocator.controlGraph.nNodes;
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("N%d:\n", n));
+
+		InstructionList& phiNodes = nodes[n]->getPhiNodeInstructions();
+		InstructionList& instructions = nodes[n]->getInstructions();
+
+		if (!phiNodes.empty()) {
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, (" PhiNodes:\n", n));
+			for(InstructionList::iterator i = phiNodes.begin(); !phiNodes.done(i); i = phiNodes.advance(i)) {
+				phiNodes.get(i).printPretty(log);
+				UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\n"));
+			}
+			if (!instructions.empty())
+				UT_OBJECTLOG(log, PR_LOG_ALWAYS, (" Instructions:\n", n));
+		}
+
+		for(InstructionList::iterator i = instructions.begin(); !instructions.done(i); i = instructions.advance(i)) {
+			instructions.get(i).printPretty(log);
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\n"));
+		}
+	}
+}
+#endif // DEBUG_LOG

mozilla/ef/Compiler/RegisterAllocator/RegisterAllocatorTools.h

@@ -0,0 +1,117 @@
+//	-*- mode:C++; tab-width:4; truncate-lines:t -*-
+//
+//           CONFIDENTIAL AND PROPRIETARY SOURCE CODE OF
+//              NETSCAPE COMMUNICATIONS CORPORATION
+// Copyright © 1996, 1997 Netscape Communications Corporation.  All Rights
+// Reserved.  Use of this Source Code is subject to the terms of the
+// applicable license agreement from Netscape Communications Corporation.
+// The copyright notice(s) in this Source Code does not indicate actual or
+// intended publication of this Source Code.
+//
+// $Id: RegisterAllocatorTools.h,v 1.1.2.1 1999-03-02 16:12:05 fur%netscape.com Exp $
+//
+
+#ifndef _REGISTER_ALLOCATOR_TOOLS_H_
+#define _REGISTER_ALLOCATOR_TOOLS_H_
+
+#include "LogModule.h"
+#include "RegisterTypes.h"
+#include <string.h>
+
+class RegisterAllocator;
+class ControlGraph;
+class InstructionEmitter;
+class VirtualRegisterManager;
+
+struct RegisterAllocatorTools
+{
+	//
+	//
+	static void insertPhiNodeInstructions(ControlGraph& controlGraph, InstructionEmitter& emitter);
+
+	//
+	//
+	static void updateInstructionGraph(RegisterAllocator& registerAllocator);
+
+	//
+	//
+	static void removeUnnecessaryCopies(RegisterAllocator& registerAllocator);
+
+#ifdef DEBUG
+	//
+	//
+	static void testTheInstructionGraph(ControlGraph& controlGraph, VirtualRegisterManager& vrManager);
+#endif // DEBUG
+
+#ifdef DEBUG_LOG
+	//
+	//
+	static void printInstructions(RegisterAllocator& registerAllocator);
+
+	//
+	//
+	static void printSpillCosts(RegisterAllocator& registerAllocator);
+
+	//
+	//
+	static void printSplitCosts(RegisterAllocator& registerAllocator);
+#endif // DEBUG_LOG
+};
+
+//
+// FIX: this should go in a class (LookupTable ?)
+//
+
+inline RegisterName findRoot(RegisterName name, RegisterName* table)
+{
+	RegisterName* stack = table;
+	RegisterName* stackPtr = stack;
+
+	RegisterName newName;
+	while((newName = table[name]) != name) {
+		*--stackPtr = name;
+		name = newName;
+	}
+
+	while (stackPtr != stack)
+		table[*stackPtr++] = name;
+
+	return name;
+}
+
+inline void init(RegisterName* table, Uint32 nameCount)
+{
+	for (RegisterName r = RegisterName(0); r < nameCount; r = RegisterName(r + 1))
+		table[r] = r;
+}
+
+inline Uint32 compress(RegisterName* name2range, RegisterName* table, Uint32 nameCount, Uint32 tableSize)
+{
+	RegisterName* liveRange = new RegisterName[tableSize];
+	memset(liveRange, '\0', tableSize * sizeof(RegisterName));
+
+	// Update the lookup table.
+	for (RegisterName r = RegisterName(1); r < tableSize; r = RegisterName(r + 1))
+		findRoot(r, table);
+
+	// Count the liveranges.
+	Uint32 liveRangeCount = 1;
+	for (RegisterName s = RegisterName(1); s < tableSize; s = RegisterName(s + 1))
+		if (table[s] == s)
+			liveRange[s] = RegisterName(liveRangeCount++);
+
+	for (RegisterName t = RegisterName(1); t < nameCount; t = RegisterName(t + 1))
+		name2range[t] = liveRange[table[name2range[t]]];
+
+	return liveRangeCount;
+}
+
+inline double doLog10(Uint32 power)
+{
+	double log = 1.0;
+	while (power--)
+		log *= 10.0;
+	return log;
+}
+
+#endif // _REGISTER_ALLOCATOR_TOOLS_H_

mozilla/ef/Compiler/RegisterAllocator/RegisterAssigner.h

@@ -0,0 +1,38 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _REGISTER_ASSIGNER_H_
+#define _REGISTER_ASSIGNER_H_
+
+#include "Fundamentals.h"
+#include "VirtualRegister.h"
+
+class FastBitMatrix;
+
+class RegisterAssigner
+{
+protected:
+  VirtualRegisterManager& vRegManager;
+  
+public:
+  RegisterAssigner(VirtualRegisterManager& vrMan) : vRegManager(vrMan) {}
+  
+  virtual bool assignRegisters(FastBitMatrix& interferenceMatrix) = 0;
+};
+
+#endif /* _REGISTER_ASSIGNER_H_ */

mozilla/ef/Compiler/RegisterAllocator/RegisterClass.h

@@ -0,0 +1,25 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _REGISTER_CLASS_H_
+#define _REGISTER_CLASS_H_
+
+#include "Fundamentals.h"
+#include "RegisterTypes.h"
+
+#endif // _REGISTER_CLASS_H_

mozilla/ef/Compiler/RegisterAllocator/RegisterPressure.h

@@ -0,0 +1,37 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _REGISTER_PRESSURE_H_
+#define _REGISTER_PRESSURE_H_
+
+#include "BitSet.h"
+#include "HashSet.h"
+
+struct LowRegisterPressure
+{
+	typedef BitSet Set;
+	static const bool setIsOrdered = true;
+};
+
+struct HighRegisterPressure
+{
+	typedef HashSet Set;
+	static const bool setIsOrdered = false;
+};
+
+#endif // _REGISTER_PRESSURE_H_

mozilla/ef/Compiler/RegisterAllocator/RegisterTypes.h

@@ -0,0 +1,104 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _REGISTER_TYPES_H_
+#define _REGISTER_TYPES_H_
+
+#include "Fundamentals.h"
+
+//------------------------------------------------------------------------------
+// RegisterName -
+//
+
+enum RegisterName {
+	rnInvalid = 0,
+};
+
+//------------------------------------------------------------------------------
+// RegisterClassKind -
+//
+
+enum RegisterClassKind {
+	rckInvalid = 0,
+	rckGeneral,
+	rckStackSlot,
+
+	nRegisterClassKind
+};
+
+//------------------------------------------------------------------------------
+// RegisterID -
+//
+
+enum RegisterID {
+	invalidID = 0
+};
+
+//------------------------------------------------------------------------------
+// RegisterKind -
+//
+
+enum RegisterKind {
+	rkCallerSave = 0,
+	rkCalleeSave,
+};
+
+struct NameLinkedList {
+	RegisterName name;
+	NameLinkedList* next;
+};
+
+#ifdef DEBUG
+
+const registerNameMask = 		0x03ffffff;
+const coloredRegisterMask = 	0x04000000;
+const machineRegisterMask = 	0x08000000;
+const registerClassMask = 		0xf0000000;
+
+const registerNameShift = 		0;
+const coloredRegisterShift = 	26;
+const machineRegisterShift = 	27;
+const registerClassShift = 		28;
+
+#else // DEBUG
+
+const registerNameMask = 		0x0fffffff;
+const registerClassMask = 		0xf0000000;
+
+const registerNameShift = 		0;
+const registerClassShift = 		28;
+
+#endif // DEBUG
+
+
+inline RegisterClassKind getClass(RegisterID registerID) {return RegisterClassKind((registerID & registerClassMask) >> registerClassShift);}
+inline RegisterName getName(RegisterID registerID) {return RegisterName((registerID & registerNameMask) >> registerNameShift);}
+inline void setClass(RegisterID& registerID, RegisterClassKind classKind) {registerID = RegisterID((registerID & ~registerClassMask) | ((classKind << registerClassShift) & registerClassMask));}
+inline void setName(RegisterID& registerID, RegisterName name) {assert((name & ~registerNameMask) == 0); registerID = RegisterID((registerID & ~registerNameMask) | ((name << registerNameShift) & registerNameMask));}
+inline RegisterID buildRegisterID(RegisterName name, RegisterClassKind classKind) {return RegisterID(((classKind << registerClassShift) & registerClassMask) | ((name << registerNameShift) & registerNameMask));}
+
+#ifdef DEBUG
+
+inline bool isMachineRegister(RegisterID rid) {return (rid & machineRegisterMask) != 0;}
+inline void setMachineRegister(RegisterID& rid) {rid = RegisterID(rid | machineRegisterMask);}
+inline bool isColoredRegister(RegisterID rid) {return (rid & coloredRegisterMask) != 0;}
+inline void setColoredRegister(RegisterID& rid) {rid = RegisterID(rid | coloredRegisterMask);}
+
+#endif // DEBUG
+
+#endif // _REGISTER_TYPES_H_

mozilla/ef/Compiler/RegisterAllocator/SSATools.cpp

@@ -0,0 +1,32 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include "SSATools.h"
+#include "ControlGraph.h"
+#include "VirtualRegister.h"
+#include "Liveness.h"
+
+void replacePhiNodes(ControlGraph& controlGraph, VirtualRegisterManager& vrManager)
+{
+	if (!controlGraph.hasBackEdges)
+		return;
+
+	Liveness liveness(controlGraph.pool);
+	liveness.buildLivenessAnalysis(controlGraph, vrManager);
+}

mozilla/ef/Compiler/RegisterAllocator/SSATools.h

@@ -0,0 +1,29 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _SSA_TOOLS_H_
+#define _SSA_TOOLS_H_
+
+#include "Fundamentals.h"
+
+class ControlGraph;
+class VirtualRegisterManager;
+
+extern void replacePhiNodes(ControlGraph& controlGraph, VirtualRegisterManager& vrManager);
+
+#endif // _SSA_TOOLS_H_

mozilla/ef/Compiler/RegisterAllocator/SparseSet.cpp

@@ -0,0 +1,37 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include "SparseSet.h"
+#include "BitSet.h"
+#include "Pool.h"
+
+#ifdef DEBUG_LOG
+// Print the set.
+//
+void SparseSet::printPretty(LogModuleObject log)
+{
+	Pool pool;
+	BitSet set(pool, universeSize);
+
+	for (Uint32 i = 0; i < count; i++)
+	   set.set(node[i].element);
+
+	set.printPretty(log);
+}
+#endif // DEBUG_LOG

mozilla/ef/Compiler/RegisterAllocator/SparseSet.h

@@ -0,0 +1,168 @@
+//	-*- mode:C++; tab-width:4; truncate-lines:t -*-
+//
+//           CONFIDENTIAL AND PROPRIETARY SOURCE CODE OF
+//              NETSCAPE COMMUNICATIONS CORPORATION
+// Copyright © 1996, 1997 Netscape Communications Corporation.  All Rights
+// Reserved.  Use of this Source Code is subject to the terms of the
+// applicable license agreement from Netscape Communications Corporation.
+// The copyright notice(s) in this Source Code does not indicate actual or
+// intended publication of this Source Code.
+//
+// $Id: SparseSet.h,v 1.1.2.1 1999-03-02 16:12:07 fur%netscape.com Exp $
+//
+
+#ifndef _SPARSE_SET_H_
+#define _SPARSE_SET_H_
+
+#include "Fundamentals.h"
+#include "Pool.h"
+#include "LogModule.h"
+#include "BitSet.h"
+
+class SparseSet
+{
+private:
+
+	struct Node {
+		Uint32		element;
+		Uint32		stackIndex;
+	};
+
+	Node*			node;
+	Uint32			count;
+	Uint32			universeSize;
+
+private:
+
+	// No copy constructor.
+	SparseSet(const SparseSet&);
+
+	// Check if the given set's universe is of the same size than this universe.
+	void checkUniverseCompatibility(const SparseSet& set) const {assert(set.universeSize == universeSize);}
+	// Check if pos is valid for this set's universe.
+	void checkMember(Int32 pos) const {assert(pos >=0 && Uint32(pos) < universeSize);}
+
+public:
+
+	SparseSet(Pool& pool, Uint32 universeSize) : universeSize(universeSize) {node = new(pool) Node[universeSize]; clear();}
+
+	// Clear the sparse set.
+	void clear() {count = 0;}
+	// Clear the element at index.
+	inline void clear(Uint32 index);
+	// Set the element at index.
+	inline void set(Uint32 index);
+	// Return true if the element at index is set.
+	inline bool test(Uint32 index) const;
+	// Union with the given sparse set.
+	inline void or(const SparseSet& set);
+	// Intersection with the given sparse set.
+	inline void and(const SparseSet& set);
+	// Difference with the given sparse set.
+	inline void difference(const SparseSet& set);
+	// Copy set.
+	inline SparseSet& operator = (const SparseSet& set);
+	inline SparseSet& operator = (const BitSet& set);
+	// Return true if the sparse sets are identical.
+	friend bool operator == (const SparseSet& set1, const SparseSet& set2);
+	// Return true if the sparse sets are different.
+	friend bool operator != (const SparseSet& set1, const SparseSet& set2);
+
+	// Logical operators.
+	SparseSet& operator |= (const SparseSet& set) {or(set); return *this;}
+	SparseSet& operator &= (const SparseSet& set) {and(set); return *this;}
+	SparseSet& operator -= (const SparseSet& set) {difference(set); return *this;}
+
+	// Iterator to conform with the set API.
+	typedef Int32 iterator;
+	// Return the iterator for the first element of this set.
+	iterator begin() const {return count - 1;}
+	// Return the next iterator.
+	iterator advance(iterator pos) const {return --pos;}
+	// Return true if the iterator is at the end of the set.
+	bool done(iterator pos) const {return pos < 0;}
+	// Return the element for the given iterator;
+	Uint32 get(iterator pos) const {return node[pos].element;}
+	// Return one element of this set.
+	Uint32 getOne() const {assert(count > 0); return node[0].element;}
+	// Return the size of this set.
+	Uint32 getSize() const {return count;}
+
+#ifdef DEBUG_LOG
+	// Print the set.
+	void printPretty(LogModuleObject log);
+#endif // DEBUG_LOG
+};
+
+inline void SparseSet::clear(Uint32 element)
+{
+	checkMember(element);
+	Uint32 count = this->count;
+	Node* node = this->node;
+
+	Uint32 stackIndex = node[element].stackIndex;
+
+	if ((stackIndex < count) && (node[stackIndex].element == element)) {
+		Uint32 stackTop = node[count - 1].element;
+
+		node[stackIndex].element = stackTop;
+		node[stackTop].stackIndex = stackIndex;
+		this->count = count - 1;
+	}
+}
+
+inline void SparseSet::set(Uint32 element)
+{
+	checkMember(element);
+  	Uint32 count = this->count;
+	Node* node = this->node;
+
+	Uint32 stackIndex = node[element].stackIndex;
+
+	if ((stackIndex >= count) || (node[stackIndex].element != element)) {
+		node[count].element = element;
+		node[element].stackIndex = count;
+		this->count = count + 1;
+	}
+}
+
+inline bool SparseSet::test(Uint32 element) const
+{
+	checkMember(element);
+	Node* node = this->node;
+
+	Uint32 stackIndex = node[element].stackIndex;
+	return ((stackIndex < count) && (node[stackIndex].element == element));
+}
+
+inline SparseSet& SparseSet::operator = (const SparseSet& set)
+{
+	checkUniverseCompatibility(set);
+	Uint32 sourceCount = set.getSize();
+	Node* node = this->node;
+
+	memcpy(node, set.node, sourceCount * sizeof(Node));
+
+	for (Uint32 i = 0; i < sourceCount; i++) {
+		Uint32 element = node[i].element;
+		node[element].stackIndex = i;
+	}
+
+	count = sourceCount;
+
+	return *this;
+}
+
+
+inline SparseSet& SparseSet::operator = (const BitSet& set)
+{
+	// FIX: there's room for optimization here.
+	assert(universeSize == set.getSize());
+
+	clear();
+	for (Int32 i = set.firstOne(); i != -1; i = set.nextOne(i))
+		this->set(i);
+	return *this;
+}
+
+#endif // _SPARSE_SET_H_

mozilla/ef/Compiler/RegisterAllocator/Spilling.cpp

@@ -0,0 +1,270 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef NEW_LAURENTM_CODE
+#define INCLUDE_EMITTER
+#include "CpuInfo.h"
+#include "Fundamentals.h"
+#include "ControlNodes.h"
+#include "Instruction.h"
+#include "InstructionEmitter.h"
+#include "Spilling.h"
+
+
+void Spilling::
+insertSpillCode(ControlNode** dfsList, Uint32 nNodes)
+{
+  PRUint32 nVirtualRegisters = vRegManager.count();
+  FastBitSet currentLive(vRegManager.pool, nVirtualRegisters);
+  FastBitSet usedInThisInstruction(vRegManager.pool, nVirtualRegisters);
+  RegisterFifo grNeedLoad(nVirtualRegisters);
+  RegisterFifo fpNeedLoad(nVirtualRegisters);
+
+  for (PRInt32 n = nNodes - 1; n >= 0; n--)
+	{
+	  PR_ASSERT(grNeedLoad.empty() & fpNeedLoad.empty());
+	  ControlNode& node = *dfsList[n];
+
+	  currentLive = node.liveAtEnd;
+
+	  PRUint32 nGeneralAlive = 0;
+	  PRUint32 nFloatingPointAlive = 0;
+
+	  // Get the number of registers alive at the end of this node.
+	  for (PRInt32 j = currentLive.firstOne(); j != -1; j = currentLive.nextOne(j))
+		{
+		  VirtualRegister& vReg = vRegManager.getVirtualRegister(j);
+		  if (vReg.spillInfo.willSpill)
+			{
+			  currentLive.clear(j);
+			}
+		  else
+			{
+			  switch (vReg.getClass())
+				{
+				case vrcInteger:
+				  nGeneralAlive++;
+				  break;
+				case vrcFloatingPoint:
+				case vrcFixedPoint:
+				  nFloatingPointAlive++;
+				  break;
+				default:
+				  break;
+				}
+			}
+		}
+	  
+//		  if(node.dfsNum == 8) printf("\n________Begin Node %d________\n", node.dfsNum);
+
+		InstructionList& instructions = node.getInstructions();
+	  for (InstructionList::iterator i = instructions.end(); !instructions.done(i); i = instructions.retreat(i))
+		{
+		  Instruction&       instruction = instructions.get(i);
+		  InstructionUse*    useBegin    = instruction.getInstructionUseBegin();
+		  InstructionUse*    useEnd      = instruction.getInstructionUseEnd();
+		  InstructionUse*    usePtr;
+		  InstructionDefine* defBegin    = instruction.getInstructionDefineBegin();
+		  InstructionDefine* defEnd      = instruction.getInstructionDefineEnd();
+		  InstructionDefine* defPtr;
+
+//		if(node.dfsNum == 8)  { printf("\n");
+//		instruction.printPretty(stdout);
+//		printf("\n"); }
+
+		  // Handle definitions
+		  for (defPtr = defBegin; defPtr < defEnd; defPtr++)
+			if (defPtr->isVirtualRegister())
+			  {
+				VirtualRegister& vReg = defPtr->getVirtualRegister();
+				currentLive.clear(vReg.getRegisterIndex());
+				switch (vReg.getClass())
+				  {
+				  case vrcInteger:
+					nGeneralAlive--;
+					break;
+				  case vrcFloatingPoint:
+				  case vrcFixedPoint:
+					nFloatingPointAlive--;
+					break;
+				  default:
+					break;
+				  }
+			  }
+
+		  // Check for deaths
+		  for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+			if (usePtr->isVirtualRegister())
+			  {
+				VirtualRegister& vReg = usePtr->getVirtualRegister();
+				if (!currentLive.test(vReg.getRegisterIndex()))
+				  // This is the last use of this register.
+				  {
+					currentLive.set(vReg.getRegisterIndex());
+					switch (vReg.getClass())
+					  {
+					  case vrcInteger:
+						nGeneralAlive++;
+						while (/*(nGeneralAlive > NUMBER_OF_GREGISTERS) &&*/ !grNeedLoad.empty())
+						  {
+							PRUint32 toLoad = grNeedLoad.get();
+							currentLive.clear(toLoad);
+							nGeneralAlive--;
+							
+							VirtualRegister& nReg = vRegManager.getVirtualRegister(toLoad);
+							Instruction& lastUsingInstruction = *nReg.spillInfo.lastUsingInstruction;
+							emitter.emitLoadAfter(*lastUsingInstruction.getPrimitive(), lastUsingInstruction.getLinks().prev,
+												  nReg.getAlias(), *nReg.equivalentRegister[vrcStackSlot]);
+							nReg.releaseSelf();
+						  }
+						break;
+					  case vrcFloatingPoint:
+					  case vrcFixedPoint:
+						nFloatingPointAlive++;
+						while (/*(nFloatingPointAlive > NUMBER_OF_FPREGISTERS) &&*/ !fpNeedLoad.empty())
+						  {
+							PRUint32 toLoad = fpNeedLoad.get();
+							currentLive.clear(toLoad);
+							nFloatingPointAlive--;
+							
+							VirtualRegister& nReg = vRegManager.getVirtualRegister(toLoad);
+							Instruction& lastUsingInstruction = *nReg.spillInfo.lastUsingInstruction;
+							emitter.emitLoadAfter(*lastUsingInstruction.getPrimitive(), lastUsingInstruction.getLinks().prev,
+												  nReg.getAlias(), *nReg.equivalentRegister[vrcStackSlot]);
+							nReg.releaseSelf();
+						  }
+						break;
+					  default:
+						break;
+					  }
+				  }
+			  }
+
+		  // Handle uses
+		  for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+			if (usePtr->isVirtualRegister())
+			  {
+				VirtualRegister& vReg = usePtr->getVirtualRegister();
+				PRUint32 registerIndex = vReg.getRegisterIndex();
+
+				if (vReg.spillInfo.willSpill) {
+#if defined(GENERATE_FOR_X86)
+				  if (!instruction.switchUseToSpill((usePtr - useBegin), *vReg.equivalentRegister[vrcStackSlot]))
+#endif
+					{
+					  switch (vReg.getClass())
+						{
+						case vrcInteger:
+						  if (!grNeedLoad.test(registerIndex))
+							{
+							  grNeedLoad.put(registerIndex);
+							  VirtualRegister& alias = vRegManager.newVirtualRegister(vrcInteger);
+							  if (vReg.isPreColored())
+								  alias.preColorRegister(vReg.getPreColor());
+							  /* if (vReg.hasSpecialInterference) {
+								  alias.specialInterference.sizeTo(NUMBER_OF_REGISTERS);
+								  alias.specialInterference = vReg.specialInterference;
+								  alias.hasSpecialInterference = true;
+							  } */
+							  vReg.setAlias(alias);
+							  vReg.retainSelf();
+							}
+						  break;
+						case vrcFloatingPoint:
+						case vrcFixedPoint:
+						  if (!fpNeedLoad.test(registerIndex))
+							{
+							  fpNeedLoad.put(registerIndex);
+							  VirtualRegister& alias = vRegManager.newVirtualRegister(vReg.getClass());
+							  if (vReg.isPreColored())
+								  alias.preColorRegister(vReg.getPreColor());
+							  /*if (vReg.hasSpecialInterference) {
+								  alias.specialInterference.sizeTo(NUMBER_OF_REGISTERS);
+								  alias.specialInterference = vReg.specialInterference;
+								  alias.hasSpecialInterference = true;
+							  } */
+							  vReg.setAlias(alias);
+							  vReg.retainSelf();
+							}
+						  break;
+						default:
+						  break;
+						}
+					  usePtr->getVirtualRegisterPtr().initialize(vReg.getAlias());
+					  usedInThisInstruction.set(registerIndex);
+					  vReg.spillInfo.lastUsingInstruction = &instruction;
+					}
+				  currentLive.clear(registerIndex);
+				} else { // will not spill
+				  currentLive.set(registerIndex);
+				}
+			  }
+		  
+		  // Handle definitions
+		  for (defPtr = defBegin; defPtr < defEnd; defPtr++)
+			if (defPtr->isVirtualRegister())
+			  {
+				VirtualRegister& vReg = defPtr->getVirtualRegister();
+				
+				if (vReg.spillInfo.willSpill)
+#if defined(GENERATE_FOR_X86)
+				  if (!instruction.switchDefineToSpill((defPtr - defBegin), *vReg.equivalentRegister[vrcStackSlot]))
+#endif
+					{
+					  if (usedInThisInstruction.test(vReg.getRegisterIndex()))
+						// this virtualRegister was used in this instruction and is also defined. We need to move 
+						// this virtual register to its alias first and then save it to memory.
+						{
+						  emitter.emitStoreAfter(*instruction.getPrimitive(), &instruction.getLinks(), 
+												 vReg.getAlias(), *vReg.equivalentRegister[vrcStackSlot]);
+						  defPtr->getVirtualRegisterPtr().initialize(vReg.getAlias());
+						}
+					  else
+						{
+						  emitter.emitStoreAfter(*instruction.getPrimitive(), &instruction.getLinks(), 
+												 vReg, *vReg.equivalentRegister[vrcStackSlot]);
+						}
+					}
+			  }
+		}
+	  while (!grNeedLoad.empty())
+		{
+		  PRUint32 nl = grNeedLoad.get();
+		  VirtualRegister& nlReg = vRegManager.getVirtualRegister(nl);
+		  Instruction& lastUse = *nlReg.spillInfo.lastUsingInstruction;
+		  
+		  emitter.emitLoadAfter(*lastUse.getPrimitive(), lastUse.getLinks().prev, 
+								nlReg.getAlias(), *nlReg.equivalentRegister[vrcStackSlot]);
+		  nlReg.releaseSelf();
+		}
+	  while (!fpNeedLoad.empty())
+		{
+		  PRUint32 nl = fpNeedLoad.get();
+		  VirtualRegister& nlReg = vRegManager.getVirtualRegister(nl);
+		  Instruction& lastUse = *nlReg.spillInfo.lastUsingInstruction;
+
+		  emitter.emitLoadAfter(*lastUse.getPrimitive(), lastUse.getLinks().prev, 
+								nlReg.getAlias(), *nlReg.equivalentRegister[vrcStackSlot]);
+		  nlReg.releaseSelf();
+		}
+
+//	  if(node.dfsNum == 8) printf("\n________End Node %d________\n", node.dfsNum);
+
+	}
+}
+#endif

mozilla/ef/Compiler/RegisterAllocator/Spilling.h

@@ -0,0 +1,269 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _SPILLING_H_
+#define _SPILLING_H_
+
+#include "Fundamentals.h"
+#include <string.h>
+#include "RegisterAllocator.h"
+#include "RegisterAllocatorTools.h"
+#include "ControlGraph.h"
+#include "ControlNodes.h"
+#include "Instruction.h"
+#include "SparseSet.h"
+
+template <class RegisterPressure>
+class Spilling
+{
+private:
+	static void insertStoreAfter(Instruction& instruction, RegisterName name);
+	static void insertLoadBefore(Instruction& instruction, RegisterName name);
+
+public:
+	static void calculateSpillCosts(RegisterAllocator& registerAllocator);
+	static void insertSpillCode(RegisterAllocator& registerAllocator);
+};
+
+struct SpillCost
+{
+	double loads;
+	double stores;
+	double copies;
+	double cost;
+	bool infinite;
+};
+
+template <class RegisterPressure>
+void Spilling<RegisterPressure>::insertSpillCode(RegisterAllocator& registerAllocator)
+{
+	Uint32 rangeCount = registerAllocator.rangeCount;
+	RegisterName* name2range = registerAllocator.name2range;
+
+	Pool& pool = registerAllocator.pool;
+	SparseSet currentLive(pool, rangeCount);
+	SparseSet needLoad(pool, rangeCount);
+	SparseSet mustSpill(pool, rangeCount);
+	SparseSet& willSpill = *registerAllocator.willSpill;
+	
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	RegisterPressure::Set* liveOut = registerAllocator.liveness.liveOut;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+
+		needLoad.clear();
+		currentLive = liveOut[n];
+		mustSpill = currentLive;
+
+		InstructionList& instructions = nodes[n]->getInstructions();
+		for (InstructionList::iterator i = instructions.end(); !instructions.done(i);) {
+			Instruction& instruction = instructions.get(i);
+			i = instructions.retreat(i);
+
+			InstructionUse* useBegin = instruction.getInstructionUseBegin();
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			InstructionUse* usePtr;
+			InstructionDefine* defineBegin = instruction.getInstructionDefineBegin();
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			InstructionDefine* definePtr;
+
+			bool foundLiveDefine = false;
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++) 
+				if (definePtr->isRegister()) {
+					if (currentLive.test(name2range[definePtr->getRegisterName()])) {
+						foundLiveDefine = true;
+						break;
+					}
+				} else {
+					foundLiveDefine = true;
+					break;
+				}
+			if (defineBegin != defineEnd && !foundLiveDefine) {
+				fprintf(stderr, "!!! Removed instruction because it was only defining unused registers !!!\n");
+				instruction.remove();
+			}
+
+ 			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++) 
+				if (definePtr->isRegister()) {
+					RegisterName range = name2range[definePtr->getRegisterName()];
+#ifdef DEBUG
+					if (needLoad.test(range))
+						if (!mustSpill.test(range) && registerAllocator.spillCost[range].infinite && willSpill.test(range)) {
+							fprintf(stderr, "Tried to spill a register with infinite spill cost\n");
+							abort();
+						}
+#endif // DEBUG
+					if (willSpill.test(range))
+						insertStoreAfter(instruction, range);
+
+					needLoad.clear(range);
+				}
+
+			if (instruction.getFlags() & ifCopy)
+				for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+					if (usePtr->isRegister()) {
+						RegisterName range = name2range[usePtr->getRegisterName()];
+						if (!currentLive.test(range))
+							for (SparseSet::iterator r = needLoad.begin(); !needLoad.done(r); r = needLoad.advance(r)) {
+								RegisterName load = RegisterName(needLoad.get(r));
+								if (willSpill.test(load))
+									insertLoadBefore(instruction, load);
+								mustSpill.set(load);
+							}
+						needLoad.clear();
+					}
+
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++) 
+				if (definePtr->isRegister())
+					currentLive.clear(name2range[definePtr->getRegisterName()]);
+
+
+			for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister()) {
+					RegisterName range = name2range[usePtr->getRegisterName()];
+					currentLive.set(range);
+					needLoad.set(range);
+				}
+		}
+
+		for (SparseSet::iterator l = needLoad.begin(); !needLoad.done(l); l = needLoad.advance(l)) {
+			RegisterName load = RegisterName(needLoad.get(l));
+			if (willSpill.test(load))
+				insertLoadBefore(instructions.first(), load);
+		}		
+	}
+}
+
+template <class RegisterPressure>
+void Spilling<RegisterPressure>::insertLoadBefore(Instruction& /*instruction*/, RegisterName name)
+{
+	fprintf(stdout, "will insert load for range %d\n", name);
+}
+
+template <class RegisterPressure>
+void Spilling<RegisterPressure>::insertStoreAfter(Instruction& /*instruction*/, RegisterName name)
+{
+	fprintf(stdout, "will insert store for range %d\n", name);
+}
+
+template <class RegisterPressure>
+void Spilling<RegisterPressure>::calculateSpillCosts(RegisterAllocator& registerAllocator)
+{
+	Uint32 rangeCount = registerAllocator.rangeCount;
+	RegisterName* name2range = registerAllocator.name2range;
+
+	Pool& pool = registerAllocator.pool;
+	SparseSet live(pool, rangeCount);
+	SparseSet needLoad(pool, rangeCount);
+	SparseSet mustSpill(pool, rangeCount);
+
+	SparseSet alreadyStored(pool, rangeCount); // FIX: should get this from previous spilling.
+
+	SpillCost* cost = new SpillCost[rangeCount];
+	memset(cost, '\0', rangeCount * sizeof(SpillCost));
+
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	RegisterPressure::Set* liveOut = registerAllocator.liveness.liveOut;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+		ControlNode& node = *nodes[n];
+
+		double weight = doLog10(node.loopDepth);
+
+		needLoad.clear();
+		live = liveOut[n];
+		mustSpill = live;
+
+		InstructionList& instructions = nodes[n]->getInstructions();
+		for (InstructionList::iterator i = instructions.end(); !instructions.done(i); i = instructions.retreat(i)) {
+			Instruction& instruction = instructions.get(i);
+
+			InstructionUse* useBegin = instruction.getInstructionUseBegin();
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			InstructionUse* usePtr;
+			InstructionDefine* defineBegin = instruction.getInstructionDefineBegin();
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			InstructionDefine* definePtr;
+
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++) 
+				if (definePtr->isRegister()) {
+					RegisterName range = name2range[definePtr->getRegisterName()];
+
+					if (needLoad.test(range))
+						if (!mustSpill.test(range))
+							cost[range].infinite = true;
+
+					if ((false /* !rematerializable(range) */ || !needLoad.test(range)) && !alreadyStored.test(range))
+						cost[range].stores += weight;
+
+					needLoad.clear(range);
+				}
+
+			if (instruction.getFlags() & ifCopy)
+				for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+					if (usePtr->isRegister())
+						if (!live.test(name2range[usePtr->getRegisterName()])) {
+							for (SparseSet::iterator l = needLoad.begin(); !needLoad.done(l); l = needLoad.advance(l)) {
+								Uint32 range = needLoad.get(l);
+								cost[range].loads += weight;
+								mustSpill.set(range);
+							}
+							needLoad.clear();
+						}
+
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++) 
+				if (definePtr->isRegister())
+					live.clear(name2range[definePtr->getRegisterName()]);
+
+			for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister()) {
+					RegisterName range = name2range[usePtr->getRegisterName()];
+
+					live.set(range);
+					needLoad.set(range);
+				}
+
+			if (instruction.getFlags() & ifCopy) {
+				assert(useBegin != useEnd && useBegin[0].isRegister());
+				assert(defineBegin != defineEnd && defineBegin[0].isRegister());
+
+				RegisterName source = name2range[useBegin[0].getRegisterName()];
+				RegisterName destination = name2range[defineBegin[0].getRegisterName()];
+
+				cost[source].copies += weight;
+				cost[destination].copies += weight;
+			}			
+		}
+
+		for (SparseSet::iterator s = needLoad.begin(); !needLoad.done(s); s = needLoad.advance(s))
+			cost[needLoad.get(s)].loads += weight;
+	}
+	
+	for (Uint32 r = 0; r < rangeCount; r++) {
+		SpillCost& c = cost[r];
+		c.cost = 2 * (c.loads + c.stores) - c.copies;
+	}
+
+	registerAllocator.spillCost = cost;
+}
+
+#endif // _SPILLING_H_

mozilla/ef/Compiler/RegisterAllocator/Splits.h

@@ -0,0 +1,239 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _SPLITS_H_
+#define _SPLITS_H_
+
+#include "Fundamentals.h"
+#include <string.h>
+#include "Pool.h"
+#include "ControlGraph.h"
+#include "ControlNodes.h"
+#include "Instruction.h"
+#include "RegisterAllocator.h"
+#include "RegisterAllocatorTools.h"
+
+UT_EXTERN_LOG_MODULE(RegAlloc);
+
+template <class RegisterPressure>
+struct Splits
+{
+	static void calculateSplitCosts(RegisterAllocator& registerAllocator);
+	static bool findSplit(RegisterAllocator& registerAllocator, RegisterName* color, RegisterName range);
+	static void insertSplitCode(RegisterAllocator& registerAllocator);
+};
+
+struct SplitCost
+{
+	double loads;
+	double stores;
+};
+
+template <class RegisterPressure>
+void Splits<RegisterPressure>::insertSplitCode(RegisterAllocator& /*registerAllocator*/)
+{
+	// FIX
+}
+
+template <class RegisterPressure>
+bool Splits<RegisterPressure>::findSplit(RegisterAllocator& registerAllocator, RegisterName* color, RegisterName range)
+{
+	Pool& pool = registerAllocator.pool;
+	NameLinkedList** neighborsWithColor = new(pool) NameLinkedList*[6]; // FIX
+	memset(neighborsWithColor, '\0', 6 * sizeof(NameLinkedList*));
+
+	InterferenceGraph<RegisterPressure>& iGraph = registerAllocator.iGraph;
+
+	for (InterferenceVector* vector = iGraph.getInterferenceVector(range); vector != NULL; vector = vector->next)
+		for (Int32 i = vector->count - 1; i >=0; --i) {
+			RegisterName neighbor = vector->neighbors[i];
+			RegisterName c = color[neighbor];
+
+			if (c < 6) { // FIX
+				NameLinkedList* node = new(pool) NameLinkedList();
+				node->name = neighbor;
+				node->next = neighborsWithColor[c];
+				neighborsWithColor[c] = node;
+			}
+		}
+
+	bool splitAroundName = true;
+
+	LiveRangeGraph<RegisterPressure>& lGraph = registerAllocator.lGraph;
+	RegisterName bestColor = RegisterName(6); // FIX
+	double bestCost = registerAllocator.spillCost[range].cost;
+	SplitCost* splitCost = registerAllocator.splitCost;
+
+	for (RegisterName i = RegisterName(0); i < 6; i = RegisterName(i + 1)) { // FIX
+
+		double splitAroundNameCost = 0.0;
+		bool canSplitAroundName = true;
+
+		SplitCost& sCost = splitCost[range];
+		double addedCost = 2.0 * (sCost.stores + sCost.loads);
+
+		for (NameLinkedList* node = neighborsWithColor[i]; node != NULL; node = node->next) {
+			RegisterName neighbor = node->name;
+			if (lGraph.haveEdge(neighbor, range)) {
+				canSplitAroundName = false;
+				break;
+			} else
+				splitAroundNameCost += addedCost;
+		}
+		if (canSplitAroundName && splitAroundNameCost < bestCost) {
+			bestCost = splitAroundNameCost;
+			bestColor = i;
+			splitAroundName = true;
+		}
+
+		double splitAroundColorCost = 0.0;
+		bool canSplitAroundColor = true;
+
+		for (NameLinkedList* node = neighborsWithColor[i]; node != NULL; node = node->next) {
+			RegisterName neighbor = node->name;
+			if (lGraph.haveEdge(range, neighbor)) {
+				canSplitAroundColor = false;
+				break;
+			} else {
+				SplitCost& sCost = splitCost[neighbor];
+				double addedCost = 2.0 * (sCost.stores + sCost.loads);
+				splitAroundColorCost += addedCost;
+			}
+		}
+		if (canSplitAroundColor && splitAroundColorCost < bestCost) {
+			bestCost = splitAroundColorCost;
+			bestColor = i;
+			splitAroundName = false;
+		}
+ 	}
+	if (bestColor < RegisterName(6)) {
+		color[range] = bestColor;
+		registerAllocator.splitFound = true;
+
+		NameLinkedList** splitAround = registerAllocator.splitAround;
+
+		if (splitAroundName)
+			for (NameLinkedList* node = neighborsWithColor[bestColor]; node != NULL; node = node->next) {
+				NameLinkedList* newNode = new(pool) NameLinkedList();
+				newNode->name = node->name;
+				newNode->next = splitAround[range];
+				splitAround[range] = newNode;
+			}
+		else
+			for (NameLinkedList* node = neighborsWithColor[bestColor]; node != NULL; node = node->next) {
+				NameLinkedList* newNode = new(pool) NameLinkedList();
+				RegisterName neighbor = node->name;
+				newNode->name = range;
+				newNode->next = splitAround[neighbor];
+				splitAround[neighbor] = newNode;
+			}
+
+		trespass("Found a split");
+		return true;
+	}
+
+	return false;
+}
+
+template <class RegisterPressure>
+void Splits<RegisterPressure>::calculateSplitCosts(RegisterAllocator& registerAllocator)
+{
+	Pool& pool = registerAllocator.pool;
+	Uint32 rangeCount = registerAllocator.rangeCount;
+	RegisterName* name2range = registerAllocator.name2range;
+
+	SplitCost* splitCost = new(pool) SplitCost[rangeCount];
+	memset(splitCost, '\0', rangeCount * sizeof(SplitCost));
+
+	SparseSet live(pool, rangeCount);
+	RegisterPressure::Set* liveIn = registerAllocator.liveness.liveIn;
+	RegisterPressure::Set* liveOut = registerAllocator.liveness.liveOut;
+
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+		ControlNode& node = *nodes[n];
+		double weight = doLog10(node.loopDepth);
+
+		live = liveOut[n];
+
+		ControlEdge* successorsEnd = node.getSuccessorsEnd();
+		for (ControlEdge* successorsPtr = node.getSuccessorsBegin(); successorsPtr < successorsEnd; successorsPtr++) {
+			ControlNode& successor = successorsPtr->getTarget();
+
+			if (successor.getControlKind() != ckEnd) {
+				RegisterPressure::Set& successorLiveIn = liveIn[successor.dfsNum];
+
+				for (SparseSet::iterator i = live.begin(); !live.done(i); i = live.advance(i)) {
+					RegisterName name = RegisterName(live.get(i));
+					if (!successorLiveIn.test(name))
+						splitCost[name].loads += doLog10(successor.loopDepth);
+				}
+			}
+		}
+
+		InstructionList& instructions = node.getInstructions();
+		for (InstructionList::iterator i = instructions.end(); !instructions.done(i); i = instructions.retreat(i)) {
+			Instruction& instruction = instructions.get(i);
+
+			InstructionUse* useBegin = instruction.getInstructionUseBegin();
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			InstructionUse* usePtr;
+			InstructionDefine* defineBegin = instruction.getInstructionDefineBegin();
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			InstructionDefine* definePtr;
+
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++) 
+				if (definePtr->isRegister())
+					splitCost[name2range[definePtr->getRegisterName()]].stores += weight;
+
+			for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister()) {
+					RegisterName range = name2range[usePtr->getRegisterName()];
+					if (!live.test(range)) {
+						if (&instruction != &instructions.last())
+							splitCost[range].loads += weight;
+						else {
+							ControlEdge* successorsEnd = node.getSuccessorsEnd();
+							for (ControlEdge* successorsPtr = node.getSuccessorsBegin(); successorsPtr < successorsEnd; successorsPtr++)
+								splitCost[range].loads += doLog10(successorsPtr->getTarget().loopDepth);
+						}
+					}
+				}
+
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++) 
+				if (definePtr->isRegister())
+					live.clear(name2range[definePtr->getRegisterName()]);
+
+			for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister())
+					live.set(name2range[usePtr->getRegisterName()]);
+		}
+	}
+
+	NameLinkedList** splitAround = new(pool) NameLinkedList*[rangeCount];
+	memset(splitAround, '\0', rangeCount * sizeof(NameLinkedList*));
+	registerAllocator.splitAround = splitAround;
+
+	registerAllocator.splitCost = splitCost;
+	registerAllocator.splitFound = false;
+}
+
+#endif // _SPLITS_H_

mozilla/ef/Compiler/RegisterAllocator/Timer.cpp

@@ -0,0 +1,186 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include "HashTable.h"
+#include "Timer.h"
+#include "Pool.h"
+
+static Pool pool;											// Pool for the Timer class.
+static HashTable<TimerEntry*> timerEntries(pool);			// Timers hashtable.
+
+const nTimersInABlock = 128;								// Number of timers in a block.
+static PRTime *timers = new(pool) PRTime[nTimersInABlock];	// A block of timers.
+static Uint8 nextTimer = 0;									// nextAvailableTimer.
+
+//
+// Calibrate the call to PR_Now().
+//
+static PRTime calibrate()
+{
+	PRTime t = PR_Now();
+	PRTime& a = *new(pool) PRTime();
+
+	// Call 10 times the PR_Now() function.
+	a = PR_Now(); a = PR_Now(); a = PR_Now(); a = PR_Now(); a = PR_Now(); a = PR_Now(); 
+	a = PR_Now(); a = PR_Now(); a = PR_Now(); a = PR_Now(); a = PR_Now(); a = PR_Now(); 
+	t = (PR_Now() - t + 9) / 10;
+
+	return t;
+}
+
+static PRTime adjust = calibrate();
+
+//
+// Return the named timer..
+//
+TimerEntry& Timer::getTimerEntry(const char* name)
+{
+	if (!timerEntries.exists(name)) {
+		TimerEntry* newEntry = new(pool) TimerEntry();
+		newEntry->accumulator = 0;
+		newEntry->running = false;
+		timerEntries.add(name, newEntry);
+	}
+
+	return *timerEntries[name];
+}
+
+//
+// Return a reference to a new timer.
+//
+PRTime& Timer::getNewTimer()
+{
+	if (nextTimer >= nTimersInABlock) {
+		timers = new(pool) PRTime[nTimersInABlock];
+		nextTimer = 0;
+	}
+	return timers[nextTimer++];
+}
+
+static Uint32 timersAreFrozen = 0;
+
+//
+// Start the named timer.
+//
+void Timer::start(const char* name)
+{
+	if (timersAreFrozen)
+		return;
+
+	freezeTimers();
+
+	TimerEntry& timer = getTimerEntry(name);
+	PR_ASSERT(!timer.running);
+
+	timer.accumulator = 0;
+	timer.running = true;
+	timer.done = false;
+
+	unfreezeTimers();
+}
+
+//
+// Stop the named timer.
+//
+void Timer::stop(const char* name)
+{
+	if (timersAreFrozen)
+		return;
+
+	freezeTimers();
+
+	TimerEntry& timer = getTimerEntry(name);
+	PR_ASSERT(timer.running);
+	timer.running = false;
+	timer.done = true;
+
+	unfreezeTimers();
+}
+
+//
+// Freeze all the running timers.
+//
+void Timer::freezeTimers()
+{
+	PRTime when = PR_Now() - adjust;
+
+	if (timersAreFrozen == 0) {
+		Vector<TimerEntry*> entries = timerEntries;
+		Uint32 count = entries.size();
+
+		for (Uint32 i = 0; i < count; i++) {
+			TimerEntry& entry = *entries[i];
+			if (entry.running) {
+				entry.accumulator += (when - *entry.startTime);
+			}
+		}
+	}
+	timersAreFrozen++;
+}
+ 
+//
+// Unfreeze all the running timers.
+//
+void Timer::unfreezeTimers()
+{
+	PR_ASSERT(timersAreFrozen != 0);
+	timersAreFrozen--;
+
+	if (timersAreFrozen == 0) {
+		Vector<TimerEntry *> entries = timerEntries;
+		Uint32 count = entries.size();
+		
+		PRTime& newStart = getNewTimer();
+		
+		for (Uint32 i = 0; i < count; i++) {
+			TimerEntry& entry = *entries[i];
+			if (entry.running) {
+				entry.startTime = &newStart;
+			}
+		}
+		
+		newStart = PR_Now();
+	}
+}
+
+//
+// Print the named timer in the file f.
+//
+void Timer::print(FILE* f, const char *name)
+{
+	if (timersAreFrozen)
+		return;
+
+	freezeTimers();
+
+	TimerEntry& timer = getTimerEntry(name);
+  
+	PR_ASSERT(timer.done);
+	PRTime elapsed = timer.accumulator;
+
+	if (elapsed >> 32) {
+		fprintf(f, "[timer %s out of range]\n", name);
+	} else {
+		fprintf(f, "[%dus in %s]\n", Uint32(elapsed), name);
+	}
+	fflush(f);
+
+	unfreezeTimers();
+}
+

mozilla/ef/Compiler/RegisterAllocator/Timer.h

@@ -0,0 +1,80 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _TIMER_H_
+#define _TIMER_H_
+
+#include "Fundamentals.h"
+#include "HashTable.h"
+#include "prtime.h"
+
+//
+// Naming convention:
+//  As the class Timer contains only static methods, the timer's name should start with the 
+//  module name. Otherwise starting 2 timers with the same name will assert.
+//
+
+#ifndef NO_TIMER
+
+struct TimerEntry
+{
+	PRTime *startTime;					// Current time when we start the timer.
+	PRTime accumulator;					// Time spent in this timer.
+	bool running;						// True if the timer is running.
+	bool done;							// True if the timer was running and was stopped. 
+};
+
+class Timer
+{
+private:
+
+	// Return the named timer.
+	static TimerEntry& getTimerEntry(const char* name);
+	// Return a reference to a new Timer.
+	static PRTime& getNewTimer();
+
+public:
+
+	// Start the timer.
+	static void start(const char* name);
+	// Stop the timer.
+	static void stop(const char* name);
+	// Freeze all the running timers.
+	static void freezeTimers();
+	// Unfreeze all the running timers.
+	static void unfreezeTimers();
+	// Print the timer.
+	static void print(FILE* f, const char *name);
+};
+
+inline void startTimer(const char* name) 		{Timer::start(name);}
+inline void stopTimer(const char* name) 		{Timer::stop(name); Timer::print(stdout, name);}
+#define START_TIMER_SAFE						Timer::freezeTimers();
+#define END_TIMER_SAFE							Timer::unfreezeTimers();
+#define TIMER_SAFE(x)							START_TIMER_SAFE x; END_TIMER_SAFE
+
+#else /* NO_TIMER */
+
+inline void startTimer(const char* /*name*/) 	{} 
+inline void stopTimer(const char* /*name*/) 	{} 
+#define START_TIMER_SAFE
+#define END_TIMER_SAFE
+#define TIMER_SAFE(x)							x;
+
+#endif /* NO_TIMER */
+#endif /* _TIMER_H_ */

mozilla/ef/Compiler/RegisterAllocator/VirtualRegister.cpp

@@ -0,0 +1,40 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include "VirtualRegister.h"
+#include "Instruction.h"
+
+//------------------------------------------------------------------------------
+// VirtualRegister -
+
+#ifdef MANUAL_TEMPLATES
+template class IndexedPool<VirtualRegister>;
+#endif
+
+// Set the defining instruction.
+//
+void VirtualRegister::setDefiningInstruction(Instruction& instruction)
+{
+	if (definingInstruction != NULL) {
+		if ((instruction.getFlags() & ifCopy) && (definingInstruction->getFlags() & ifPhiNode))
+			return;
+	}
+	definingInstruction = &instruction;
+}
+

mozilla/ef/Compiler/RegisterAllocator/VirtualRegister.h

@@ -0,0 +1,116 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _VIRTUAL_REGISTER_H_
+#define _VIRTUAL_REGISTER_H_
+
+#include "Fundamentals.h"
+#include "IndexedPool.h"
+#include <string.h>
+
+#include "RegisterTypes.h"
+#include "RegisterClass.h"
+
+
+//------------------------------------------------------------------------------
+// VirtualRegister - 24b
+
+class Instruction;
+
+class VirtualRegister : public IndexedObject<VirtualRegister>
+{
+public:
+
+	Instruction*					definingInstruction;	// Instruction defining this VR.
+
+	// Initialize a VR of the given classKind.
+	VirtualRegister(RegisterClassKind /*classKind*/) : definingInstruction(NULL) {}
+
+	// Return the defining instruction for this VR.
+	Instruction* getDefiningInstruction() const {return definingInstruction;}
+	// Set the defining instruction.
+	void setDefiningInstruction(Instruction& insn);
+};
+
+// Return true if the VirtualRegisters are equals. The only way 2 VRs can be equal is if
+// they have the same index. If they have the same index then they are at the same
+// address in the indexed pool.
+//
+inline bool operator == (const VirtualRegister& regA, const VirtualRegister& regB) {return &regA == &regB;}
+
+//------------------------------------------------------------------------------
+// VirtualRegisterManager -
+
+struct PreColoredRegister
+{
+	RegisterID id;
+	RegisterName color;
+};
+
+class VirtualRegisterManager
+{
+private:
+
+	IndexedPool<VirtualRegister> registerPool;
+	PreColoredRegister machineRegister[6];
+
+public:
+	VirtualRegisterManager()
+		{
+			for (Uint32 i = 0; i < 6; i++)
+				machineRegister[i].id = invalidID;
+		}
+
+	// Return the VirtualRegister at the given index.
+	VirtualRegister& getVirtualRegister(RegisterName name) const {return registerPool.get(name);}
+
+	// Return a new VirtualRegister.
+	RegisterID newVirtualRegister(RegisterClassKind classKind)
+		{
+			VirtualRegister& vReg = *new(registerPool) VirtualRegister(classKind);
+			RegisterID rid;
+
+			setName(rid, RegisterName(vReg.getIndex()));
+			setClass(rid, classKind);
+			return rid;
+		}
+
+	RegisterID newMachineRegister(RegisterName name, RegisterClassKind classKind)
+		{
+			RegisterID rid = machineRegister[name].id;
+
+			if (rid == invalidID) {
+				rid = newVirtualRegister(classKind);
+				DEBUG_ONLY(setMachineRegister(rid));
+				machineRegister[name].id = rid;
+				machineRegister[name].color = name;
+			}
+
+			return rid;
+		}
+
+	PreColoredRegister* getMachineRegistersBegin() const {return (PreColoredRegister*) machineRegister;} // FIX
+	PreColoredRegister* getMachineRegistersEnd() const {return (PreColoredRegister*) &machineRegister[6];} // FIX
+
+	// Return the VirtualRegister universe size.
+	Uint32 getSize() {return registerPool.getSize();}
+
+	void setSize(Uint32 size) {registerPool.setSize(size);}
+};
+
+#endif // _VIRTUAL_REGISTER_H_

mozilla/tools/tinderbox/INSTALL

@@ -1,26 +0,0 @@
-
-To install a fresh tinderbox:
-
-1) Checkout the latest copy of the tinderbox scripts
-	cd /builds/cvs; cvs -z3 co mozilla/tools/tinderbox
-
-2) Change to the location that you wish to run the tinderbox from.
-	cd /builds/tinderbox
-
-3) Create links from the cvs directory to your build directory
-	ln -s /builds/cvs/mozilla/tools/tinderbox/*.pl .
-	
-4) Create your tinderbox config file
-	perl ./build-seamonkey.pl --example-config > tinder-config.pl
-
-5) Create your mozconfig build file in the current dir
-	mozilla -remote http://webtools.mozilla.org/build/config.cgi
-
-6) Customize your tinderbox configuration
-	vi tinder-config.pl
-
-7) Test your tinderbox configuration on the test tree
-	perl ./build-seamonkey.pl --depend -t MozillaTest
-
-8) Once you are satisfied with the results run your tinderbox
-	perl ./build-seamonkey.pl --depend

mozilla/tools/tinderbox/README

@@ -1,74 +0,0 @@
-mozilla/tools/tinderbox
-===================
-
-This directory is for the scripts associated with the client-side of
-tinderbox (scripts to checkout, build, and report the status of the tree
-to a tinderbox server).
-
-
-Table of Contents
-=================
-
-* README 
-   This file.
-
-* build-seamonkey.pl
-   A perl script to drive the client side of tinderbox (unix variants).
-   usage:
-      build-seamonkey.pl [--clobber | --depend] [-t TreeName] [--testonly] [--once]
-
-* bloatdiff.pl
-    Script used to process leak data in the logs.
-
-* build-seamonkey-util.pl
-    Core unix tinderbox stuff.
-
-* post-mozilla-sample.pl
-    Example of post-build test script
-
-* tinder-defaults.pl
-    Default script variables.
-
-* gettime.pl
-    Wrapper to get hires time, if available.
-
-* tinderbox
-    Wrapper script to start unix builds.
-
-* install-links
-    Create links to a tinderbox install directory.
-
-
-Tinderbox example for SeaMonkey build
-=====================================
-
-Here is an example of how to set up a "SeaMonkey" tinderbox
-build of mozilla.
-
-  # Create tinderbox source files in mozilla,
-  # then SeaMonkey directory where mozilla tree will live.
-  cvs co mozilla/tools/tinderbox
-  mkdir SeaMonkey
-  cd SeaMonkey; ../mozilla/tools/tinderbox/install-links
-
-  #
-  # Create tinder-config.pl file in SeaMonkey directory.  
-  # Copy one from an existing build, or create a sample one and edit it:
-  #
-  ./build-seamonkey.pl --example-config > tinder-config.pl
-
-  #
-  # mozconfig.  If you have configure options, add them to a
-  # file named "mozconfig" in the SeaMonkey directory.
-  # Again, you can copy one from a build, or create one.
-  # For a default stock build, this file is not needed or
-  # can be blank.
-  #
-
-  # Start the tinderbox!  From the SeaMonkey directory:
-  ./tinderbox depend start
-
-  # You can watch the build run the first time with:
-  tail -f <objdir>/<logname>
-
-

mozilla/tools/tinderbox/bloatdiff.pl

@@ -1,332 +0,0 @@
-#!/usr/bin/perl -w
-
-#
-# Munges the output from 
-#   XPCOM_MEM_BLOAT_LOG=1; mozilla-bin -f bloaturls.txt
-# so that it does some summary and stats stuff.
-#
-# To show leak test results for a set of changes, do something like this:
-#
-#   XPCOM_MEM_BLOAT_LOG=1
-#   mozilla -f bloaturls.txt > a.out
-#     **make change**
-#   mozilla -f bloaturls.txt > b.out
-#   bloatdiff.pl a.out b.out
-#
-
-$OLDFILE = $ARGV[0];
-$NEWFILE = $ARGV[1];
-$LABEL   = $ARGV[2];
-
-sub processFile {
-    my ($filename, $map, $prevMap) = @_;
-    open(FH, $filename);
-    while (<FH>) {
-        if (m{
-              ^\s*(\d+)\s          # Line number
-              ([\w:]+)\s+          # Name
-              (-?\d+)\s+           # Size
-              (-?\d+)\s+           # Leaked
-              (-?\d+)\s+           # Objects Total
-              (-?\d+)\s+           # Objects Rem
-              \(\s*(-?[\d.]+)\s+   # Objects Mean
-                 \+/-\s+
-              ([\w.]+)\)\s+        # Objects StdDev
-              (-?\d+)\s+           # Reference Total
-              (-?\d+)\s+           # Reference Rem
-              \(\s*(-?[\d.]+)\s+   # Reference Mean
-                 \+/-\s+
-              ([\w\.]+)\)          # Reference StdDev
-             }x) {
-          $$map{$2} = { name => $2,
-                        size => $3,
-                        leaked => $4,
-                        objTotal => $5,
-                        objRem => $6,
-                        objMean => $7,
-                        objStdDev => $8,
-                        refTotal => $9,
-                        refRem => $10,
-                        refMean => $11,
-                        refStdDev => $12,
-                        bloat => $3 * $5 # size * objTotal
-                      };
-        } else {
-#            print "failed to parse: $_\n";
-        }
-    }
-    close(FH);
-}
-
-%oldMap = ();
-processFile($OLDFILE, \%oldMap);
-
-%newMap = ();
-processFile($NEWFILE, \%newMap);
-
-################################################################################
-
-$inf = 9999999.99;
-
-sub getLeaksDelta {
-    my ($key) = @_;
-    my $oldLeaks = $oldMap{$key}{leaked} || 0;
-    my $newLeaks = $newMap{$key}{leaked};
-    my $percentLeaks = 0;
-    if ($oldLeaks == 0) {
-        if ($newLeaks != 0) {
-            # there weren't any leaks before, but now there are!
-            $percentLeaks = $inf;
-        }
-    }
-    else {
-        $percentLeaks = ($newLeaks - $oldLeaks) / $oldLeaks * 100;
-    }
-    # else we had no record of this class before
-    return ($newLeaks - $oldLeaks, $percentLeaks);
-}
-    
-################################################################################
-
-sub getBloatDelta {
-    my ($key) = @_;
-    my $newBloat = $newMap{$key}{bloat};
-    my $percentBloat = 0;
-    my $oldSize = $oldMap{$key}{size} || 0;
-    my $oldTotal = $oldMap{$key}{objTotal} || 0;
-    my $oldBloat = $oldTotal * $oldSize;
-    if ($oldBloat == 0) {
-        if ($newBloat != 0) {
-            # this class wasn't used before, but now it is
-            $percentBloat = $inf;
-        }
-    }
-    else {
-        $percentBloat = ($newBloat - $oldBloat) / $oldBloat * 100;
-    }
-    # else we had no record of this class before
-    return ($newBloat - $oldBloat, $percentBloat);
-}
-
-################################################################################
-
-foreach $key (keys %newMap) {
-    my ($newLeaks, $percentLeaks) = getLeaksDelta($key);
-    my ($newBloat, $percentBloat) = getBloatDelta($key);
-    $newMap{$key}{leakDelta} = $newLeaks;
-    $newMap{$key}{leakPercent} = $percentLeaks;
-    $newMap{$key}{bloatDelta} = $newBloat;
-    $newMap{$key}{bloatPercent} = $percentBloat;
-}
-
-################################################################################
-
-# Print a value of bytes out in a reasonable
-# KB, MB, or GB form.  Copied from build-seamonkey-util.pl, sorry.  -mcafee
-sub PrintSize($) {
-
-    # print a number with 3 significant figures
-    sub PrintNum($) {
-        my ($num) = @_;
-        my $rv;
-        if ($num < 1) {
-            $rv = sprintf "%.3f", ($num);
-        } elsif ($num < 10) {
-            $rv = sprintf "%.2f", ($num);
-        } elsif ($num < 100) {
-            $rv = sprintf "%.1f", ($num);
-        } else {
-            $rv = sprintf "%d", ($num);
-        }
-    }
-
-    my ($size) = @_;
-    my $rv;
-    if ($size > 1000000000) {
-        $rv = PrintNum($size / 1000000000.0) . "G";
-    } elsif ($size > 1000000) {
-        $rv = PrintNum($size / 1000000.0) . "M";
-    } elsif ($size > 1000) {
-        $rv = PrintNum($size / 1000.0) . "K";
-    } else {
-        $rv = PrintNum($size);
-    }
-}
-
-
-print "Bloat/Leak Delta Report\n";
-print "--------------------------------------------------------------------------------------\n";
-print "Current file:  $NEWFILE\n";
-print "Previous file: $OLDFILE\n";
-print "----------------------------------------------leaks------leaks%------bloat------bloat%\n";
-printf "%-40s %10s %10.2f%% %10s %10.2f%%\n",
-       ("TOTAL",
-        $newMap{"TOTAL"}{leaked}, $newMap{"TOTAL"}{leakPercent},
-        $newMap{"TOTAL"}{bloat}, $newMap{"TOTAL"}{bloatPercent});
-
-################################################################################
-
-sub percentStr {
-    my ($p) = @_;
-    if ($p == $inf) {
-        return "-";
-    }
-    else {
-        return sprintf "%10.2f%%", $p;
-    }
-}
-
-# NEW LEAKS
-@keys = sort { $newMap{$b}{leakPercent} <=> $newMap{$a}{leakPercent} } keys %newMap;
-my $needsHeading = 1;
-my $total = 0;
-foreach $key (@keys) {
-    my $percentLeaks = $newMap{$key}{leakPercent};
-    my $leaks = $newMap{$key}{leaked};
-    if ($percentLeaks > 0 && $key !~ /TOTAL/) {
-        if ($needsHeading) {
-            printf "--NEW-LEAKS-----------------------------------leaks------leaks%%-----------------------\n";
-            $needsHeading = 0;
-        }
-        printf "%-40s %10s %10s\n", ($key, $leaks, percentStr($percentLeaks));
-        $total += $leaks;
-    }
-}
-if (!$needsHeading) {
-    printf "%-40s %10s\n", ("TOTAL", $total);
-}
-
-# FIXED LEAKS
-@keys = sort { $newMap{$b}{leakPercent} <=> $newMap{$a}{leakPercent} } keys %newMap;
-$needsHeading = 1;
-$total = 0;
-foreach $key (@keys) {
-    my $percentLeaks = $newMap{$key}{leakPercent};
-    my $leaks = $newMap{$key}{leaked};
-    if ($percentLeaks < 0 && $key !~ /TOTAL/) {
-        if ($needsHeading) {
-            printf "--FIXED-LEAKS---------------------------------leaks------leaks%%-----------------------\n";
-            $needsHeading = 0;
-        }
-        printf "%-40s %10s %10s\n", ($key, $leaks, percentStr($percentLeaks));
-        $total += $leaks;
-    }
-}
-if (!$needsHeading) {
-    printf "%-40s %10s\n", ("TOTAL", $total);
-}
-
-# NEW BLOAT
-@keys = sort { $newMap{$b}{bloatPercent} <=> $newMap{$a}{bloatPercent} } keys %newMap;
-$needsHeading = 1;
-$total = 0;
-foreach $key (@keys) {
-    my $percentBloat = $newMap{$key}{bloatPercent};
-    my $bloat = $newMap{$key}{bloat};
-    if ($percentBloat > 0  && $key !~ /TOTAL/) {
-        if ($needsHeading) {
-            printf "--NEW-BLOAT-----------------------------------bloat------bloat%%-----------------------\n";
-            $needsHeading = 0;
-        }
-        printf "%-40s %10s %10s\n", ($key, $bloat, percentStr($percentBloat));
-        $total += $bloat;
-    }
-}
-if (!$needsHeading) {
-    printf "%-40s %10s\n", ("TOTAL", $total);
-}
-
-# ALL LEAKS
-@keys = sort { $newMap{$b}{leaked} <=> $newMap{$a}{leaked} } keys %newMap;
-$needsHeading = 1;
-$total = 0;
-foreach $key (@keys) {
-    my $leaks = $newMap{$key}{leaked};
-    my $percentLeaks = $newMap{$key}{leakPercent};
-    if ($leaks > 0) {
-        if ($needsHeading) {
-            printf "--ALL-LEAKS-----------------------------------leaks------leaks%%-----------------------\n";
-            $needsHeading = 0;
-        }
-        printf "%-40s %10s %10s\n", ($key, $leaks, percentStr($percentLeaks));
-        if ($key !~ /TOTAL/) {
-            $total += $leaks;
-        }
-    }
-}
-if (!$needsHeading) {
-#    printf "%-40s %10s\n", ("TOTAL", $total);
-}
-
-# ALL BLOAT
-@keys = sort { $newMap{$b}{bloat} <=> $newMap{$a}{bloat} } keys %newMap;
-$needsHeading = 1;
-$total = 0;
-foreach $key (@keys) {
-    my $bloat = $newMap{$key}{bloat};
-    my $percentBloat = $newMap{$key}{bloatPercent};
-    if ($bloat > 0) {
-        if ($needsHeading) {
-            printf "--ALL-BLOAT-----------------------------------bloat------bloat%%-----------------------\n";
-            $needsHeading = 0;
-        }
-        printf "%-40s %10s %10s\n", ($key, $bloat, percentStr($percentBloat));
-        if ($key !~ /TOTAL/) {
-            $total += $bloat;
-        }
-    }
-}
-if (!$needsHeading) {
-#    printf "%-40s %10s\n", ("TOTAL", $total);
-}
-
-# NEW CLASSES
-@keys = sort { $newMap{$b}{bloatDelta} <=> $newMap{$a}{bloatDelta} } keys %newMap;
-$needsHeading = 1;
-my $ltotal = 0;
-my $btotal = 0;
-foreach $key (@keys) {
-    my $leaks = $newMap{$key}{leaked};
-    my $bloat = $newMap{$key}{bloat};
-    my $percentBloat = $newMap{$key}{bloatPercent};
-    if ($percentBloat == $inf && $key !~ /TOTAL/) {
-        if ($needsHeading) {
-            printf "--CLASSES-NOT-REPORTED-LAST-TIME--------------leaks------bloat------------------------\n";
-            $needsHeading = 0;
-        }
-        printf "%-40s %10s %10s\n", ($key, $leaks, $bloat);
-        if ($key !~ /TOTAL/) {
-            $ltotal += $leaks;
-            $btotal += $bloat;
-        }
-    }
-}
-if (!$needsHeading) {
-    printf "%-40s %10s %10s\n", ("TOTAL", $ltotal, $btotal);
-}
-
-# OLD CLASSES
-@keys = sort { ($oldMap{$b}{bloat} || 0) <=> ($oldMap{$a}{bloat} || 0) } keys %oldMap;
-$needsHeading = 1;
-$ltotal = 0;
-$btotal = 0;
-foreach $key (@keys) {
-    if (!defined($newMap{$key})) {
-        my $leaks = $oldMap{$key}{leaked};
-        my $bloat = $oldMap{$key}{bloat};
-        if ($needsHeading) {
-            printf "--CLASSES-THAT-WENT-AWAY----------------------leaks------bloat------------------------\n";
-            $needsHeading = 0;
-        }
-        printf "%-40s %10s %10s\n", ($key, $leaks, $bloat);
-        if ($key !~ /TOTAL/) {
-            $ltotal += $leaks;
-            $btotal += $bloat;
-        }
-    }
-}
-if (!$needsHeading) {
-    printf "%-40s %10s %10s\n", ("TOTAL", $ltotal, $btotal);
-}
-
-print "--------------------------------------------------------------------------------------\n";

mozilla/tools/tinderbox/build-camino.pl

@@ -1,488 +0,0 @@
-#!/usr/bin/perl
-# -*- Mode: perl; indent-tabs-mode: nil -*-
-#
-
-#
-# This script gets called after a full mozilla build & test.
-# Use this to build and test an embedded or commercial branding of Mozilla.
-#
-# ./build-seamonkey-utils.pl will call PostMozilla::main() after
-# a successful build and testing of mozilla.  This package can report
-# status via the $TinderUtils::build_status variable.  Yeah this is a hack,
-# but it works for now.  Feel free to improve this mechanism to properly
-# return values & stuff.  -mcafee
-#
-# Things to do:
-#   * Get pull by branch working
-#
-#
-use strict;
-use File::Path;     # for rmtree();
-
-package PostMozilla;
-
-sub checkout {
-  my ($mozilla_build_dir) = @_;
-
-  # chdir to build directory
-  chdir "$mozilla_build_dir";
-
-  # Next, do the checkout:
-  print "Settings::CVS = $Settings::CVS\n";
-  my $status = TinderUtils::run_shell_command("$Settings::CVS checkout mozilla/camino");
-
-  # hack in the camino prefs, if needed
-
-  return $status;
-}
-
-
-sub ReadHeapDumpToHash($$)
-{
-  my($dumpfile, $hashref) = @_;
-
-  local(*DUMP_FILE);
-  open(DUMP_FILE, "< $dumpfile") || die "Can't open heap output file $dumpfile\n";
-
-  my $section = 0;
-  my $zone = "";
-  my $default_zone_bytes = 0;
-  
-  while (<DUMP_FILE>)
-  {
-    my($line) = $_;
-    chomp($line);
-
-    if ($line =~ /^\#/ || $line =~ /^\s*$/ || $line =~ /------------------------/) {    # ignore comments and empty lines
-      next;
-    }
-    
-    # use the 'All zones' lines as section markers
-    if ($line =~ /^All zones:/) {
-      $section ++; 
-      next;
-    }
-    
-    if ($section == 2) # we're in the detailed section
-    {
-      if ($line =~ /^Zone ([^_]+).+\((\d+).+\)/)
-      {
-        $zone = $1;
-        if ($zone eq "DefaultMallocZone") {
-          $default_zone_bytes = $2;
-        }
-        TinderUtils::print_log("  $line\n");
-        next;
-      }
-      
-      if ($zone eq "DefaultMallocZone")
-      {
-        if ($line =~ /(\w+)\s*=\s*(\d+)\s*\((\d+).+\)/)
-        {
-          my(%entry_hash) = ("count", $2,
-                             "bytes", $3);
-          $hashref->{$1} = \%entry_hash;
-        }
-        elsif ($line =~ /^<not.+>\s*=\s*(\d+)\s*\((\d+).+\)/)
-        {
-          my(%entry_hash) = ("count", $1,
-                             "bytes", $2);
-          $hashref->{"malloc_block"} = \%entry_hash;
-        }
-      }
-    }
-  }
- 
-  close(DUMP_FILE);
-  
-  return $default_zone_bytes;
-}
-
-sub DumpHash($)
-{
-  my($hashref) = @_;
-  
-  print "Dumping values\n";
-  
-  my($key);
-  foreach $key (keys %{$hashref})
-  {
-    my($value) = $hashref->{$key};
-    print "Class $key count $value->{'count'} bytes $value->{'bytes'}\n";
-  }
-}
-
-sub ClassEntriesEqual($$)
-{
-  my($hashone, $hashtwo) = @_;
-  
-  return ($hashone->{"count"} == $hashtwo->{"count"}) and ($hashone->{"bytes"} == $hashtwo->{"bytes"})
-}
-
-
-sub DumpHashDiffs($$)
-{
-  my($beforehash, $afterhash) = @_;
-    
-  my($name_width) = 50;
-  my($print_format) = "%10s %-${name_width}s %8d %8d\n";
-
-  TinderUtils::print_log(sprintf "%10s %-${name_width}s %8s %8s\n", "", "Class", "Count", "Bytes");
-  TinderUtils::print_log("--------------------------------------------------------------------------------\n");
-  
-  my($key);
-  foreach $key (keys %{$beforehash})
-  {
-    my($beforevalue) = $beforehash->{$key};
-
-    if (exists $afterhash->{$key})
-    {
-      my($aftervalue) = $afterhash->{$key};
-      if (!ClassEntriesEqual($beforevalue, $aftervalue))
-      {
-        my($count_change) = $aftervalue->{"count"} - $beforevalue->{"count"};
-        my($bytes_change) = $aftervalue->{"bytes"} - $beforevalue->{"bytes"};
-        
-        if ($bytes_change > 0) {
-          TinderUtils::print_log(sprintf $print_format, "Leaked", $key, $count_change, $bytes_change);
-        } else {
-          TinderUtils::print_log(sprintf $print_format, "Freed", $key, $count_change, $bytes_change);
-        }
-      }
-    }
-    else
-    {
-      #$before_only{$key} = $beforevalue;
-      TinderUtils::print_log(sprintf $print_format, "Freed", $key, $beforevalue->{'count'}, $beforevalue->{'bytes'});
-    }
-  }
-
-  # now look for things only in the after cache
-  foreach $key (keys %{$afterhash})
-  {
-    my($value) = $afterhash->{$key};
-
-    if (!exists $beforehash->{$key})
-    {
-      #$after_only{$key} = $value;
-      TinderUtils::print_log(sprintf $print_format, "Leaked", $key, $value->{'count'}, $value->{'bytes'});
-    }
-  }
- 
-  TinderUtils::print_log("--------------------------------------------------------------------------------\n");
-
-}
-
-
-sub ParseHeapOutput($$)
-{
-  my($beforedump, $afterdump) = @_;
-  
-  TinderUtils::print_log("Before window open:\n");
-  my %before_data;
-  my $before_heap = ReadHeapDumpToHash($beforedump, \%before_data);
-  
-  TinderUtils::print_log("After window open and close:\n");
-  my %after_data;
-  my $after_heap = ReadHeapDumpToHash($afterdump, \%after_data);
-
-#  DumpHash(\%before_data);
-#  DumpHash(\%after_data);
-
-  TinderUtils::print_log("Open/close window leaks:\n");
-  DumpHashDiffs(\%before_data, \%after_data);
-
-  my $heap_diff = $after_heap - $before_heap;
-  TinderUtils::print_log("TinderboxPrint:<acronym title=\"Per-window leaks\">Lw:".TinderUtils::PrintSize($heap_diff, 3)."B</acronym>\n");
-}
-
-
-sub CaminoWindowLeaksTest($$$$$)
-{
-  my ($test_name, $build_dir, $binary, $args, $timeout_secs) = @_;
-
-  my($status) = 'success';
-
-  my $beforefile = "/tmp/nav_before_heap.dat";
-  my $afterfile  = "/tmp/nav_after_heap.dat";
-
-  my $run_test = 1;   # useful for testing parsing code
-  if ($run_test)
-  {
-    my $close_window_script =<<END_SCRIPT;
-tell application "Camino"
-  delay 5
-  close the first window
-end tell
-END_SCRIPT
-    
-    my $new_window_script =<<END_SCRIPT;
-tell application "Camino"
-  Get URL "about:blank"
-  delay 20
-  close the first window
-end tell
-END_SCRIPT
-  
-    TinderUtils::print_log("Window leak test\n");
-  
-    my $binary_basename = File::Basename::basename($binary);
-    my $binary_dir = File::Basename::dirname($binary);
-    my $binary_log = "$build_dir/$test_name.log";
-    my $cmd = $binary_basename;
-      
-    my $pid = TinderUtils::fork_and_log($build_dir, $binary_dir, $cmd, $binary_log);
-  
-    # close the existing window 
-    system("echo '$close_window_script' | osascript");
-    # open and close few window to get to a stable point
-    system("echo '$new_window_script' | osascript");
-  
-    # dump before data
-    system("heap $pid > $beforefile");
-  
-    # run the test
-    system("echo '$new_window_script' | osascript");
-  
-    # dump after data
-    system("heap $pid > $afterfile");
-    
-    my $result = TinderUtils::wait_for_pid($pid, $timeout_secs);
-  }
-  
-  ParseHeapOutput($beforefile, $afterfile);
-
-  return $status;
-}
-
-
-sub main {
-  my ($mozilla_build_dir) = @_;
-
-  TinderUtils::print_log("Starting camino build.\n");
-
-  # Tell camino to unbuffer stdio, otherwise when we kill the child process
-  # stdout & stderr won't get flushed.
-  $ENV{MOZ_UNBUFFERED_STDIO} = 1;
-
-  # Pending a config file, stuff things here.
-  my $post_status = 'success';  # Success until we report a failure.
-  my $status = 0;  # 0 = success
-
-  # Control tests from here, sorry no config file yet.
-  my $camino_alive_test              = 1;
-  my $camino_test8_test              = 1;
-  my $camino_layout_performance_test = 1;
-  my $camino_startup_test            = 1;
-  my $camino_window_leaks_test       = 0;
-
-  my $safari_layout_performance_test  = 0;
-
-  my $camino_clean_profile = 1;
-
-  # Build flags
-  my $camino_build_static = 0;
-  my $camino_build_opt    = 1;
-
-  my $camino_dir = "$mozilla_build_dir/mozilla/camino";
-  my $embedding_dir = "$mozilla_build_dir/mozilla/embedding/config";
-  my $camino_binary = "Camino";
-
-  unless ($Settings::TestOnly) {
-    # Checkout/update the camino code.
-    $status = checkout($mozilla_build_dir);
-    TinderUtils::print_log("Status from checkout: $status\n");
-    if ($status != 0) {
-      $post_status = 'busted';
-    }
-    
-    # Build camino if we passed the checkout command.
-    if ($post_status ne 'busted') {
-
-      #
-      # Build embedding/config.
-      #
-      
-      chdir $embedding_dir;
-      
-      if ($status == 0) {
-        $status = TinderUtils::run_shell_command("make");
-        TinderUtils::print_log("Status from make: $status\n");
-      }
-      
-      #
-      # Build camino.
-      #
-      
-      chdir $camino_dir;
-      
-      if ($status == 0) {
-        TinderUtils::print_log("Deleting binary...\n");
-        TinderUtils::DeleteBinary("$camino_dir/build/Camino.app/Contents/MacOS/$camino_binary");
-          
-        # Always do a clean build; gecko dependencies don't work correctly
-        # for Camino.
-          
-        TinderUtils::print_log("Clobbering camino...\n");
-        TinderUtils::run_shell_command("make clean");
-          
-        $status = TinderUtils::run_shell_command("make");
-        TinderUtils::print_log("Status from pbxbuild: $status\n");
-      }
-
-      TinderUtils::print_log("Testing build status...\n");
-      if ($status != 0) {
-        TinderUtils::print_log("busted, pbxbuild status non-zero\n");
-        $post_status = 'busted';
-      } elsif (not TinderUtils::BinaryExists("$camino_dir/build/Camino.app/Contents/MacOS/$camino_binary")) {
-        TinderUtils::print_log("Error: binary not found: $camino_dir/build/Camino.app/Contents/MacOS/$camino_binary\n");
-        $post_status = 'busted';
-      } else {
-        $post_status = 'success';
-      }
-    }  
-  }
-
-  #
-  # Tests...
-  #
-
-  # Clean profile out, if set.
-  # Assume Camino always uses ~/Library/Application Support/Chimera/Profiles/default for now.
-  if ($camino_clean_profile) {
-    # Warning: workaround camino bug, delete whole Camino dir.
-    my $chim_profile_dir = "$ENV{HOME}/Library/Application Support/Chimera";
-    #my $chim_profile_dir = "$ENV{HOME}/Library/Application Support/Chimera/Profiles/default";
-
-    TinderUtils::print_log("Deleting $chim_profile_dir...\n");
-    print "Deleting $chim_profile_dir...\n";
-    File::Path::rmtree([$chim_profile_dir], 0, 0);
-
-    if (-e "$chim_profile_dir") {
-      TinderUtils::print_log("Error: rmtree('$chim_profile_dir') failed\n");
-    }
-      
-    # Re-create profile.  We have no -CreateProfile, so we instead
-    # run the AliveTest first.
-  }
-
-  # AliveTest for camino, about:blank
-  if ($camino_alive_test and $post_status eq 'success') {
-
-    $post_status = TinderUtils::AliveTest("CaminoAliveTest",
-                                          "$camino_dir/build/Camino.app/Contents/MacOS",
-                                          ["Camino", "-url", "about:blank"],
-                                          45);
-  }
-
-  # Find the prefs file, remember we have the secret/random salt dir,
-  # e.g. /Users/cltbld/Library/Application Support/Chimera/Profiles/default/dyrs1ar8.slt/prefs.js
-  # so File::Path::find will find the prefs.js file.
-  #
-  my $pref_file = "prefs.js";
-  my $start_dir = "/Users/cltbld/Library/Application Support/Chimera/Profiles/default";
-  my $found = undef;
-  my $sub = sub {$pref_file = $File::Find::name, $found++ if $pref_file eq $_};
-
-  File::Find::find($sub, $start_dir);  # Find prefs.js, write this to $pref_file.
-
-  # Set up performance prefs.
-  if ($pref_file and ($camino_layout_performance_test or 1)) {
-
-      # Some tests need browser.dom.window.dump.enabled set to true, so
-      # that JS dump() will work in optimized builds.
-      if (system("\\grep -s browser.dom.window.dump.enabled $pref_file > /dev/null")) {
-	  TinderUtils::print_log("Setting browser.dom.window.dump.enabled\n");
-	  open PREFS, ">>$pref_file" or die "can't open $pref_file ($?)\n";
-	  print PREFS "user_pref(\"browser.dom.window.dump.enabled\", true);\n";
-	  close PREFS;
-        } else {
-            TinderUtils::print_log("Already set browser.dom.window.dump.enabled\n");
-        }
-
-      # Set security prefs to allow us to close our own window,
-      # pageloader test (and possibly other tests) needs this on.
-      if (system("\\grep -s dom.allow_scripts_to_close_windows $pref_file > /dev/null")) {
-          TinderUtils::print_log("Setting dom.allow_scripts_to_close_windows to true.\n");
-          open PREFS, ">>$pref_file" or die "can't open $pref_file ($?)\n";
-          print PREFS "user_pref(\"dom.allow_scripts_to_close_windows\", true);\n";
-          close PREFS;
-      } else {
-          TinderUtils::print_log("Already set dom.allow_scripts_to_close_windows\n");
-      }
-
-
-  }
-
-  # LayoutTest8
-  # resource:///res/samples/test8.html
-  if ($camino_test8_test and $post_status eq 'success') {
-
-      if(0) {
-          open STDOUT, ">/tmp/foo";
-          open STDERR, ">&/tmp/foo";
-          select STDOUT; $| = 1;  # make STDOUT unbuffered
-          select STDERR; $| = 1;  # make STDERR unbuffered
-          print STDERR "hello, world\n";
-          chdir("$camino_dir/build/Camino.app/Contents/MacOS");
-          exec "./Camino -url \"http://lxr.mozilla.org/seamonkey/source/webshell/tests/viewer/samples/test8.html\"";
-          #exec "foo";
-      } else {
-          $post_status = TinderUtils::AliveTest("CaminoLayoutTest8Test",
-                                                "$camino_dir/build/Camino.app/Contents/MacOS",
-                                                ["Camino", "-url", "http://lxr.mozilla.org/seamonkey/source/webshell/tests/viewer/samples/test8.html"],
-                                                20);
-      }
-  }
-  
-  # Pageload test.
-  if ($camino_layout_performance_test and $post_status eq 'success') {
-
-      $post_status = 
-        TinderUtils::LayoutPerformanceTest("CaminoLayoutPerformanceTest",
-                                           "$camino_dir/build/Camino.app/Contents/MacOS",
-                                           ["Camino", "-url"]);
-
-  }
-
-
-  # Pageload test -- Safari.
-  if ($safari_layout_performance_test) {
-      
-      TinderUtils::run_system_cmd("/Applications/Utilities/Safari.app/Contents/MacOS/Safari-wrap.pl http://$Settings::pageload_server/page-loader/loader.pl?delay=1000%26nocache=0%26maxcyc=4%26timeout=$Settings::LayoutPerformanceTestPageTimeout%26auto=1", 30);
-        
-        # This is a hack.
-        TinderUtils::run_system_cmd("sync; sleep 400", 405);
-
-        TinderUtils::run_system_cmd("/Applications/Utilities/Safari.app/Contents/MacOS/Safari-wrap.pl quit", 30);
-      
-        TinderUtils::print_log "TinderboxPrint:" .
-            "<a title=\"Avg of the median per url pageload time\" href=\"http://$Settings::results_server/graph/query.cgi?testname=pageload&tbox=" . ::hostname() . "-aux&autoscale=1&days=7&avg=1\">~Tp" . "</a>\n";
-        
-  }
-
-  # Startup test.
-  if ($camino_startup_test and $post_status eq 'success') {
-      $post_status =
-        TinderUtils::StartupPerformanceTest("CaminoStartupPerformanceTest",
-                                            "Camino",
-                                            "$camino_dir/build/Camino.app/Contents/MacOS",
-                                            ["-url"],
-                                            "file:$camino_dir/../../../startup-test.html");      
-  }
-  
-  if ($camino_window_leaks_test and $post_status eq 'success') {
-        $post_status = CaminoWindowLeaksTest("CaminoWindowLeakTest",
-                                              "$camino_dir/build/Camino.app/Contents/MacOS/",
-                                              "./Camino",
-                                              "-url \"http://www.mozilla.org\"",
-                                              20);
-
-  }
-  
-  # Pass our status back to calling script.
-  return $post_status;
-}
-
-# Need to end with a true value, (since we're using "require").
-1;

mozilla/tools/tinderbox/build-galeon.pl

@@ -1,148 +0,0 @@
-#!/usr/bin/perl
-#
-
-#
-# This script gets called after a full mozilla build & test.
-# Use this to build and test an embedded or commercial branding of Mozilla.
-#
-# ./build-seamonkey-utils.pl will call PostMozilla::main() after
-# a successful build and testing of mozilla.  This package can report
-# status via the $TinderUtils::build_status variable.  Yeah this is a hack,
-# but it works for now.  Feel free to improve this mechanism to properly
-# return values & stuff.  -mcafee
-#
-# Things to do:
-#   * Get pull by branch working
-#
-#
-use strict;
-
-package PostMozilla;
-
-sub checkout {
-  my ($mozilla_build_dir) = @_;
-
-  # chdir to build directory
-  chdir "$mozilla_build_dir";
-
-  # Hack to get around po/ChangeLog cvs conflict bug in gettext lib.
-  my $status = TinderUtils::run_shell_command("\\rm -f galeon/po/ChangeLog");
-
-  # Checkout galeon source.  First set up cvsroot:
-  # Both of these as of 10/2001 are kinda flakey:
-  #   $ENV{CVSROOT} = ":pserver:anonymous\@anoncvs.gnome.org:/cvs/gnome";
-  #   $ENV{CVSROOT} = ":pserver:anonymous@cvs.galeon.sourceforge.net:/cvsroot/galeon";
-  #
-  # Asked for direct cvs access and got it:
-  $ENV{CVSROOT} = ":pserver:mcafee\@cvs.gnome.org:/cvs/gnome";
-
-  # Next, actually do the checkout:
-  my $status = TinderUtils::run_shell_command("$Settings::CVS checkout galeon");
-
-  # hack in the galeon prefs, if needed
-
-  return $status;
-}
-
-
-sub main {
-  my ($mozilla_build_dir) = @_;
-
-  TinderUtils::print_log "Post-Mozilla build goes here.\n";
-
-  # Pending a config file, stuff things here.
-  my $post_status = 'success';  # Success until we report a failure.
-  my $status = 0;  # 0 = success
-  my $galeon_alive_test = 1;
-  my $galeon_test8_test = 1;
-  my $galeon_dir = "$mozilla_build_dir/galeon";
-  my $galeon_binary = "galeon-bin";
-
-  # Checkout/update the galeon code.
-  $status = checkout($mozilla_build_dir);
-  TinderUtils::print_log "Status from checkout: $status\n";
-  if ($status != 0) {
-  	$post_status = 'busted';
-  }
-
-  # Build galeon if we passed the checkout command.
-  if ($post_status ne 'busted') {
-    # Build galeon.
-    
-    chdir $galeon_dir;
-    
-    # Make sure we have a configure
-    unless (-e "configure" and $post_status ne 'busted') {
-      $status = TinderUtils::run_shell_command("./autogen.sh");
-      TinderUtils::print_log "Status from autogen: $status\n";
-    }
-    
-    # Not sure how to only do this when we need to.
-    # Force a configure for now.
-    if ($status == 0) {
-      TinderUtils::print_log "configuring...\n";
-      $status = TinderUtils::run_shell_command("./configure --sysconfdir=/etc --with-mozilla-libs=$mozilla_build_dir/mozilla/dist/bin --with-mozilla-includes=$mozilla_build_dir/mozilla/dist/include --with-nspr-includes=$mozilla_build_dir/mozilla/dist/include/nspr --with-mozilla-home=$mozilla_build_dir/mozilla/dist/bin");
-      TinderUtils::print_log "Status from configure: $status\n";
-    }
-    
-    if ($status == 0) {
-      TinderUtils::print_log "Deleting, gmake...\n";
-      TinderUtils::DeleteBinary("$galeon_dir/src/$galeon_binary");
-      
-      my $foo = Cwd::getcwd();
-      TinderUtils::print_log "cwd = $foo\n";
-      $status = TinderUtils::run_shell_command("gmake");
-      TinderUtils::print_log "Status from gmake: $status\n";
-    }
-    
-    TinderUtils::print_log "Testing build status...\n";
-    if ($status != 0) {
-      TinderUtils::print_log "busted, gmake status non-zero\n";
-      $post_status = 'busted';
-    } elsif (not TinderUtils::BinaryExists("$galeon_dir/src/$galeon_binary")) {
-      TinderUtils::print_log "Error: binary not found: $galeon_dir/src/$galeon_binary\n";
-      $post_status = 'busted';
-    } else {
-      $post_status = 'success';
-    }
-  }
-  
-  #
-  # Need a way to bypass initial setup dialog stuff, or
-  # we'll need to manually run this by hand the first time.
-  #
-  # Also, have to set crash_recovery=0 in ~/.gnome/galeon to avoid
-  # getting the crash dialog after the alive test times out.
-  #
-  
-  # Test galeon, about:blank
-  if ($galeon_alive_test and $post_status eq 'success') {
-    $post_status = TinderUtils::AliveTest("GaleonAliveTest",
-					  "$galeon_dir/src",
-					  ["galeon", "about:blank"],
-					  45);
-  }
-  
-  # Test galeon, test8
-  if ($galeon_test8_test and $post_status eq 'success') {
-    $post_status = TinderUtils::AliveTest("GaleonTest8Test",
-					  "$galeon_dir/src",
-					  ["galeon", "resource:///res/samples/test8.html"],
-					  45);
-  }
-  
-  # Startup test
-  if ($galeon_startup_test and $post_status eq 'success') {
-    TinderUtils::StartupPerformanceTest("GaleonStartupPerformanceTest",
-					"galeon",
-					"$galeon_dir/src",
-					["", "$galeon_dir/src/../../../startup-test.html"]);     
-    
-  }
-
-  # Pass our status back to calling script.
-  return $post_status;
-}
-
-# Need to end with a true value, (since we're using "require").
-1;

mozilla/tools/tinderbox/build-seamonkey-win32.pl

@@ -1,338 +0,0 @@
-
-#!d:/nstools/bin/perl5
-
-use Cwd;
-
-$build_depend=1;      #depend or clobber
-$build_tree = '';
-$build_tag = '';
-$build_name = '';
-$build_continue = 0;
-$build_sleep=10;
-$no32 = 0;
-$original_path = $ENV{'PATH'};
-$early_exit = 1;
-$doawt11 = 0;
-
-$do_clobber = '';
-$client_param = '';
-
-&parse_args;
-
-if( $build_test ){
-    $build_sleep=1;
-}
-
-$dirname = ($build_depend?'dep':'clob');
-
-
-$logfile = "${dirname}.log";
-
-if( $build_depend ){
-    $clobber_str = 'depend';
-}     
-else {
-    $clobber_str = 'clobber_all';
-}
-
-
-mkdir("$dirname", 0777);
-chdir("$dirname") || die "couldn't cd to $dirname";
-
-$start_dir = cwd;
-$start_dir =~ s/\//\\/ ;
-$last_time = 0;
-
-print "starting dir is: $start_dir\n";
-
-while( $early_exit ){
-    chdir("$start_dir");
-    if( time - $last_time < (60 * $build_sleep) ){
-        $sleep_time = (60 * $build_sleep) - (time - $last_time);
-        print "\n\nSleeping $sleep_time seconds ...\n";
-        sleep( $sleep_time );
-    }
-    $last_time = time;
-
-    $start_time = time;
-    $start_time = adjust_start_time($start_time);
-    $start_time_str = `unix_date +"%m/%d/%Y %H:%M"`;
-    chop($start_time_str);
-# call setup_env here in the loop, to update MOZ_DATE with each pass.
-# setup_env uses start_time_str for MOZ_DATE.
-    &setup_env;
-
-    $cur_dir = cwd;
-    $cur_dir =~ s/\//\\/ ;
-
-    if( $cur_dir ne $start_dir ){
-        print "startdir: $start_dir, curdir $cur_dir\n";
-        die "curdir != startdir";
-    }
-
-    if ($build_test) {
-        $early_exit = 0;        # stops this while loop after one pass.
-    }
-
-# strip_conf fails to strip any variables from the real environemnt
-#    &strip_config;
-    &do_build(1,$do_clobber);
-#    &restore_config;
-
-}
-
-sub setup32 {
-    local ($awt) = @_;
-
-    $ENV{"MOZ_BITS"}  = '32';
-    $ENV{"WINOS"}  = 'WINNT';
-    $ENV{"STANDALONE_IMAGE_LIB"} = '1';
-    $ENV{"MODULAR_NETLIB"} = '1';
-    $ENV{"OS_TARGET"} = 'WIN95';
-    $ENV{"PATH"}      = $original_path;
-    $ENV{"_MSC_VER"}      = '1200';
-    $moz_src          = $ENV{'MOZ_SRC'} = $start_dir;
-    $build_name       = 'Win32 VC6.0' . ($build_depend?'Depend':'Clobber');
-    $do_clobber       = $clobber_str;
-    $logname          = "win32.log";
-}
-
-
-sub do_build {
-    local ($pull, $do_clobber) = @_;
-    
-    print "pull = $pull, do_clobber = $do_clobber\n";
-    &start_build;
-
-    print "opening log file ${logname}\n";
-    open( LOG, ">${logname}" ) || print "can't open $logname\n";
-    print LOG "current dir is: $cur_dir\n";
-
-    &print_env;
-    $build_status = 0;
-    if( $pull ){
-        if ( $build_tag eq '' ){
-#           print LOG   "cvs -d %MOZ_CVSROOT% co -A mozilla/config 2>&1 |\n";
-#           open( PULL, "cvs -d %MOZ_CVSROOT% co -A mozilla/config 2>&1 |") || print "couldn't execute cvs\n";;
-            print LOG   "cvs -d $moz_cvsroot co -A mozilla/client.mak 2>&1 |\n";
-            open( PULL, "cvs -d $moz_cvsroot co -A mozilla/client.mak 2>&1 |") || print "couldn't execute cvs\n";;
-        } else{
-            print LOG   "cvs -d $moz_cvsroot co -A -r $build_tag mozilla/config 2>&1 |\n";
-            open( PULL, "cvs -d $moz_cvsroot co -A -r $build_tag mozilla/config 2>&1 |") || print "couldn't execute cvs\n";;
-            print LOG   "cvs -d $moz_cvsroot co -A -r $build_tag mozilla/client.mak 2>&1 |\n";
-            open( PULL, "cvs -d $moz_cvsroot co -A -r $build_tag mozilla/client.mak 2>&1 |") || print "couldn't execute cvs\n";;
-        }
-
-        # tee the output
-        while( <PULL> ){
-            print $_;
-            print LOG $_;
-        }
-        close( PULL );
-     
-        $build_status = $?;
-    }
-
-    chdir("$moz_src/mozilla") || die "couldn't chdir to '$moz_src/mozilla'";
-
-#    if( $do_clobber ne '' ){
-#        print LOG   "nmake -f client.mak $do_clobber |\n";
-#        print "nmake -f client.mak $do_clobber |\n";
-#        open( CLOBBER, "nmake -f client.mak $do_clobber 2>&1 |") || print "couldn't execute nmake\n";;
-
-        # tee the output
-#        while( <CLOBBER> ){
-#            print $_;
-#            print LOG $_;
-#        }
-#        close( CLOBBER );
-#    }
-
-
-    if (!$pull) {
-      $client_param = $do_clobber . ' build_all';
-    }
-    else {
-      $client_param = 'pull_all ' . $do_clobber . ' build_all';
-    }
-    
-    print LOG "nmake  -f client.mak $client_param 2>&1 |\n";
-    open( BUILD, "nmake -f client.mak $client_param 2>&1 |");
-
-    # tee the output
-    while( <BUILD> ){
-        print $_;
-        print LOG $_;
-    }
-    close( BUILD );
-    $build_status |= $?;
-    $build_status_str = ( $build_status ? 'busted' : 'success' );
-
-    print LOG "\n";
-    print LOG "tinderbox: tree: $build_tree\n";
-    print LOG "tinderbox: builddate: $start_time\n";
-    print LOG "tinderbox: status: $build_status_str\n";
-    print LOG "tinderbox: build: $build_name\n";
-    print LOG "tinderbox: errorparser: windows\n";
-    print LOG "tinderbox: buildfamily: windows\n";
-
-    close( LOG );
-    chdir("$start_dir");
-    system( "$nstools\\bin\\blat ${logname} -t tinderbox-daemon\@cvs-mirror.mozilla.org" );
-
- # we should save at least one log back
-    system("copy ${logname} last-${logname}");
-}
-
-sub cvs_time {
-    local( $ret_time );
-
-    ($sec,$minute,$hour,$mday,$mon,$year) = localtime( $_[0] );
-    $mon++; # month is 0 based.
-
-    sprintf("%02d/%02d/%04d %02d:%02d:00",
-        $mon,$mday,$year,$hour,$minute );
-}
-
-
-sub start_build {
-    open( LOG, ">logfile" );
-    print LOG "\n";
-    print LOG "tinderbox: tree: $build_tree\n";
-    print LOG "tinderbox: builddate: $start_time\n";
-    print LOG "tinderbox: status: building\n";
-    print LOG "tinderbox: build: $build_name\n";
-    print LOG "tinderbox: errorparser: windows\n";
-    print LOG "tinderbox: buildfamily: windows\n";
-    print LOG "\n";
-    close( LOG );
-    system("$nstools\\bin\\blat logfile -t tinderbox-daemon\@cvs-mirror.mozilla.org" );
-}
-
-sub parse_args {
-    local($i);
-
-    if( @ARGV == 0 ){
-        &usage;
-    }
-    $i = 0;
-    while( $i < @ARGV ){
-        if( $ARGV[$i] eq '--depend' ){
-            $build_depend = 1;
-        }
-        elsif ( $ARGV[$i] eq '--clobber' ){
-            $build_depend = 0;
-        }
-        elsif ( $ARGV[$i] eq '--continue' ){
-            $build_continue = 1;
-        }
-        elsif ( $ARGV[$i] eq '--test' ){
-            $build_test = 1;
-        }
-        elsif ( $ARGV[$i] eq '-tag' ){
-            $i++;
-            $build_tag = $ARGV[$i];
-            if( $build_tag eq '' || $build_tag eq '-t'){
-                &usage;
-            }
-                }
-        elsif ( $ARGV[$i] eq '-t' ){
-            $i++;
-            $build_tree = $ARGV[$i];
-            if( $build_tree eq '' ){
-                &usage;
-            }
-        }
-        $i++;
-    }
-    if( $build_tree eq '' ){
-        &usage;
-    }
-}
-
-sub usage {
-    die "usage: buildit.pl [--depend | --clobber] [--continue] [--test] [-tag TAGNAME] -t TREENAME\n";
-}
-
-sub setup_env {
-    local($p);
-
-#    $ENV{"MOZ_DEBUG"} = '1';
-    $ENV{"MOZ_MFC"} = '1';
-    $ENV{"CVSROOT"} = ':pserver:cltbld%netscape.com@cvs.mozilla.org:/cvsroot';
-    $moz_cvsroot = $ENV{"CVSROOT"};
-#    $ENV{"MOZ_EDITOR"} = '1';
-    $ENV{"VERBOSE"} = '1';
-    $ENV{"NGLAYOUT_PLUGINS"} = '1';
-    $nstools = $ENV{"MOZ_TOOLS"};
-    if( $nstools eq '' ){
-        print "warning: environment variable MOZ_TOOLS not set\n";
-        $ENV{"MOZ_TOOLS"} = 'C:\nstools';
-        $nstools = $ENV{"MOZ_TOOLS"};
-        print "using MOZ_TOOLS = $nstools \n";
-
-    }
-#    $msdev = $ENV{"MOZ_MSDEV"} = 'c:\msdev';
-#    if( $msdev eq '' ){
-#        die "error: environment variable MOZ_MSDEV not set\n";
-#    }
-#    $msvc = $ENV{"MOZ_MSVC"} = 'c:\msvc';
-#    if( $msvc eq '' ){
-#        die "error: environment variable MOZ_VC not set\n";
-#    }
-    if ( $build_tag ne '' ) {
-        $ENV{"MOZ_BRANCH"} = $build_tag;
-    }
-    $moz_src = $ENV{"MOZ_SRC"} = $start_dir;
-#    $ENV{"INCLUDE"}='c:\devstudio\vc\lib;C:\DevStudio\VC\INCLUDE;C:\DevStudio\VC\MFC\INCLUDE;C:\DevStudio\VC\lib;C:\DevStudio\VC\ATL\INCLUDE';
-#    $ENV{"LIB"}='C:\DevStudio\VC\MFC\LIB;C:\DevStudio\VC\lib';
-#    $ENV{"PATH"}='C:\DevStudio\SharedIDE\BIN;C:\DevStudio\VC\bin;C:\DevStudio\VC\lib;C:\DevStudio\VC\BIN\WINNT;.;%MOZ_TOOLS%\perl5\bin;C:\WINNT\system32;C:\WINNT;c:\usr\local\bin;%MOZ_TOOLS%\bin';
-##
-## We should pull by date to avoid mid-checkin disasters
-##
-    $ENV{"MOZ_DATE"} = $start_time_str;
-    
-    &setup32
-}
-
-sub print_env {
-    local( $k, $v);
-    print LOG "\nEnvironment\n";
-    print     "\nEnvironment\n";
-    for $k (sort keys %ENV){
-        $v = $ENV{$k};
-        print LOG "   $k=$v\n";
-        print     "   $k=$v\n";
-    }
-    print LOG "\n";
-    print     "\n";
-    system 'set';
-}
-
-sub strip_config {
-        $save_compname=$ENV{"COMPUTERNAME"};
-        $save_userdomain=$ENV{"USERDOMAIN"};
-        $save_username=$ENV{"USERNAME"};
-        $save_userprofile=$ENV{"USERPROFILE"};
-}
-
-sub restore_config {
-        $ENV{"COMPUTERNAME"}=$save_compname;
-        $ENV{"USERDOMAIN"}=$save_userdomain;
-        $ENV{"USERNAME"}=$save_username;
-        $ENV{"MSDevDir"}=$save_userprofile;
-        &print_env;
-}
-
-sub adjust_start_time {
-    # Allows the start time to match up with the update times of a mirror.
-    my ($start_time) = @_;
-
-    # Since we are not pulling for cvs-mirror anymore, just round times
-    # to 1 minute intervals to make them nice and even.
-    my $cycle = 1 * 60; # Updates every 1 minutes.
-    my $begin = 0 * 60; # Starts 0 minutes after the hour.
-    my $lag = 0 * 60; # Takes 0 minute to update.
-    return int(($start_time - $begin - $lag) / $cycle) * $cycle + $begin;
-}
-

mozilla/tools/tinderbox/build-seamonkey.pl

@@ -1,36 +0,0 @@
-#!/usr/bin/perl -w
-
-require 5.003;
-
-# This script has split some functions off into a util
-# script so they can be re-used by other scripts.
-require "build-seamonkey-util.pl";
-
-use strict;
-
-# "use strict" complains if we do not define these.
-# They are not initialized here. The default values are after "__END__".
-$TreeSpecific::name = $TreeSpecific::checkout_target = $TreeSpecific::checkout_clobber_target = $::Version = undef;
-
-$::Version = '$Revision: 1.100 $ ';
-
-{    
-    TinderUtils::Setup();
-    tree_specific_overides();
-    TinderUtils::Build();
-}
-
-# End of main
-#======================================================================
-
-
-
-sub tree_specific_overides {
-
-	$TreeSpecific::name = 'mozilla';
-	$TreeSpecific::checkout_target = '';
-	$TreeSpecific::checkout_clobber_target = "checkout realclean build";
-	
-}
-
-    

mozilla/tools/tinderbox/examples/mozconfig

@@ -1,18 +0,0 @@
-# Turning on security
-#
-ac_add_options --enable-crypto
-#
-# Add all extensions
-#
-ac_add_options --enable-extensions=all
-#
-# Optimized
-#
-ac_add_options --enable-optimize
-ac_add_options --disable-debug
-#
-# Bloat stats/optimized needs these:
-#
-#ac_add_options --enable-logrefcnt
-#ac_add_options --enable-perf-metrics
-#

mozilla/tools/tinderbox/examples/tinder-config.pl

@@ -1,38 +0,0 @@
-#- tinder-config.pl - Tinderbox configuration file.
-#-    Uncomment the variables you need to set.
-#-    The default values are the same as the commented variables
-
-#- PLEASE FILL THIS IN WITH YOUR PROPER EMAIL ADDRESS
-$BuildAdministrator = 'mcafee@mocha.com';
-
-#- You'll need to change these to suit your machine's needs
-$DisplayServer = ':0.0'; # costarica:0.0
-
-#- Until you get the script working. When it works,
-#- change to the tree you're actually building
-$BuildTree  = 'MozillaTest';
-#$BuildTree  = 'SeaMonkey';
-
-$AliveTest                = 1;
-$ViewerTest               = 0;
-$BloatTest                = 0;
-$BloatTest2               = 0;
-$DomToTextConversionTest  = 0;
-$EmbedTest                = 0;
-$MailNewsTest             = 0;
-$LayoutPerformanceTest    = 0;
-$StartupPerformanceTest   = 0;
-
-$MozProfileName = "default";
-$BloatTestTimeout  = 240;    # seconds
-$LayoutPerformanceTestTimeout  = 1400;    # seconds
-$StartupPerformanceTestTimeout = 60;      # seconds
-
-# Testing...
-# $TestOnly = 1;
-# $ObjDir = 'obj-i686-unknown-linux-gnu';
-
-$UserComment = "Sample tinder-config.pl, changeme!";
-
-# Need to end with a true value
-1;

mozilla/tools/tinderbox/examples/tinder-config.pl.branch

@@ -1,63 +0,0 @@
-#- tinder-config.pl - Tinderbox configuration file.
-#-    Uncomment the variables you need to set.
-#-    The default values are the same as the commented variables.
-
-#- PLEASE FILL THIS IN WITH YOUR PROPER EMAIL ADDRESS
-$BuildAdministrator = "mcafee\@netscape.com";
-
-#- You'll need to change these to suit your machine's needs
-$DisplayServer = 'costarica.mcom.com:0.0';
-
-#- Default values of command-line opts
-#-
-$BuildDepend       = 1;      # Depend or Clobber
-$ReportStatus      = 1;      # Send results to server, or not
-$ReportFinalStatus = 1;      # Finer control over $ReportStatus.
-$UseTimeStamp      = 0;      # Use the CVS 'pull-by-timestamp' option, or not
-#$BuildOnce         = 0;      # Build once, don't send results to server
-#$RunTest           = 1;      # Run the smoke tests on successful build, or not
-#$TestOnly          = 0;      # Only run tests, don't pull/build
-
-# Tests
-$AliveTest = 1;
-$ViewerTest = 1;
-$BloatTest = 1;
-$DomToTextConversionTest = 1;
-$MailNewsTest = 0;
-#$MozConfigFileName = 'mozconfig';
-#$MozProfileName = 'default';
-$BloatTestTimeout	= 240;
-$DomTestTimeout		= 45;
-
-#- Set these to what makes sense for your system
-$Make          = 'gmake';       # Must be GNU make
-#$MakeOverrides = '';
-$mail          = '/bin/mail';
-$CVS           = 'cvs -q';
-$CVSCO         = 'checkout -P';
-
-#- Set these proper values for your tinderbox server
-$Tinderbox_server = 'tinderbox-daemon@tinderbox.mozilla.org';
-
-#-
-#- The rest should not need to be changed
-#-
-
-#- Minimum wait period from start of build to start of next build in minutes.
-#$BuildSleep = 10;
-
-#- Until you get the script working. When it works,
-#- change to the tree you're actually building
-$BuildTree  = 'SeaMonkey-Branch'; 
-
-#$BuildName = '';
-$BuildTag = 'MOZILLA_0_9_1_BRANCH';
-#$BuildConfigDir = 'mozilla/config';
-#$Topsrcdir = 'mozilla';
-#$BinaryName = 'mozilla-bin';
-#$ShellOverride = ''; # Only used if the default shell is too stupid
-#$ConfigureArgs = '';
-#$ConfigureEnvArgs = '';
-#$Compiler = 'gcc';
-#$NSPRArgs = '';
-#$ShellOverride = '';

mozilla/tools/tinderbox/gettime.pl

@@ -1,73 +0,0 @@
-#!/usr/bin/perl
-#
-# Use high resolution routines if installed (on win32 or linux), using
-# eval as try/catch block around import of modules. Otherwise, just use 'time()'.
-#
-# 'Win32::API'  <http://www.activestate.com/PPMPackages/zips/5xx-builds-only/Win32-API.zip>
-# 'Time::HiRes' <http://search.cpan.org/search?dist=Time-HiRes> 
-#   (also: http://rpmfind.net/linux/rpm2html/search.php?query=perl-Time-HiRes)
-#
-package Time::PossiblyHiRes;
-
-use strict;
-
-#use Time::HiRes qw(gettimeofday);
-
-my $getLocalTime;                      # for win32
-my $lpSystemTime = pack("SSSSSSSS");   # for win32
-my $timesub;                           # code ref
-
-# returns 12 char string "'s'x9.'m'x3" which is milliseconds since epoch, 
-# although resolution may vary depending on OS and installed packages
-
-sub getTime () {
-
-    return &$timesub 
-	if $timesub;
-
-    $timesub = sub { time() . "000"; }; # default
-
-    return &$timesub 
-	if $^O eq "MacOS"; # don't know a better way on Mac
-
-    if ($^O eq "MSWin32") {
-	eval "use Win32::API;";
-	$timesub = sub { 
-	    # pass pointer to struct, void return 
-	    $getLocalTime = 
-		eval "new Win32::API('kernel32', 'GetLocalTime', [qw{P}], qw{V});"
-		    unless $getLocalTime;
-	    $getLocalTime->Call($lpSystemTime);
-	    my @t = unpack("SSSSSSSS", $lpSystemTime);
-	    sprintf("%9s%03s", time(), pop @t);
-	} if !$@;
-    } 
-
-    # ass-u-me if not mac/win32, then we're on a unix flavour
-    else {
-	eval "use Time::HiRes qw(gettimeofday);";
-	$timesub = sub { 
-	    my @t = gettimeofday();
-	    $t[0]*1000 + int($t[1]/1000);	    
-	} if !$@;
-    }
-
-    return &$timesub;
-
-} 
-
-#
-#
-# Test script to compare with low-res time:
-#
-# require "gettime.pl";
-#
-# use POSIX qw(strftime);
-#
-# print "hires  time = " . Time::PossiblyHiRes::getTime() . "\n";
-# print "lowres time = " . time()    . "\n";
-#
-
-
-# end package
-1;

mozilla/tools/tinderbox/install-links

@@ -1,14 +0,0 @@
-#! /bin/csh -f
-
-#
-# Create links to install tinderbox stuff.
-#
-
-ln -s ../mozilla/tools/tinderbox/tinderbox
-ln -s ../mozilla/tools/tinderbox/build-seamonkey.pl
-ln -s ../mozilla/tools/tinderbox/build-seamonkey-util.pl
-ln -s ../mozilla/tools/tinderbox/gettime.pl
-ln -s ../mozilla/tools/tinderbox/bloatdiff.pl
-ln -s ../mozilla/tools/tinderbox/tinder-defaults.pl
-ln -s ../mozilla/tools/tinderbox/reportdata.pl
-

mozilla/tools/tinderbox/multi-tinderbox.pl

@@ -1,75 +0,0 @@
-#!/usr/bin/perl
-# vim:sw=4:et:ts=4:ai:
-
-use strict;
-
-sub PrintUsage() {
-    die <<END_USAGE
-    usage: $0 [options]
-Options:
-  --example-config       Instead of running, print an example
-                           'multi-config.pl' to help get started.
-END_USAGE
-}
-
-sub PrintExample() {
-    print <<END_EXAMPLE
-# multi-config.pl
-\$BuildSleep = 10;                       # minutes
-\$Tinderboxes = [ { tree => "SeaMonkey", args => "--depend --mozconfig mozconfig" }, { tree => "SeaMonkey-Branch", args => "--depend --mozconfig mozconfig" } ];
-END_EXAMPLE
-    ;
-    exit;
-}
-
-sub HandleArgs() {
-    return if ($#ARGV == -1);
-    PrintUsage() if ($#ARGV != 0 || $ARGV[0] ne "--example-config");
-    PrintExample();
-}
-
-sub LoadConfig() {
-    if (-r 'multi-config.pl') {
-        no strict 'vars';
-
-        open CONFIG, 'multi-config.pl' or
-            print "can't open multi-config.pl, $?\n";
-
-        while (<CONFIG>) {
-            package Settings;
-            eval;
-        }
-
-        close CONFIG;
-    } else {
-        warn "Error: Need tinderbox config file, multi-config.pl\n";
-        exit;
-    }
-}
-
-
-sub Run() {
-    my $start_time = 0;
-    while (1) {
-        # $BuildSleep is the minimum amount of time a build is allowed to take.
-        # It prevents sending too many messages to the tinderbox server when
-        # something is broken.
-        my $sleep_time = ($Settings::BuildSleep * 60) - (time() - $start_time);
-        if ($sleep_time > 0) {
-            print "\n\nSleeping $sleep_time seconds ...\n";
-            sleep $sleep_time;
-        }
-        $start_time = time();
-
-        foreach my $treeentry (@{$Settings::Tinderboxes}) {
-            chdir($treeentry->{tree}) or
-                die "Tree $treeentry->{tree} does not exist";
-            system("./build-seamonkey.pl --once $treeentry->{args}");
-            chdir("..");
-        }
-    }
-}
-
-HandleArgs();
-LoadConfig();
-Run();

mozilla/tools/tinderbox/post-mozilla-linux-release.pl

@@ -1,179 +0,0 @@
-#!/usr/bin/perl
-#
-
-#
-# This script gets called after a full mozilla build & test.
-# Use this to build and test an embedded or commercial branding of Mozilla.
-#
-# Edit, and rename this file to post-mozilla.pl to activate.
-# ./build-seamonkey-utils.pl will call PostMozilla::main() after
-# a successful build and testing of mozilla.  This package can report
-# status via the $TinderUtils::build_status variable.  Yeah this is a hack,
-# but it works for now.  Feel free to improve this mechanism to properly
-# return values & stuff.  -mcafee
-#
-# Contributors: 
-# leaf@mozilla.org - release processing/packaging/uploading
-
-# Assumptions:
-#  no objdir 
-#  ssh-agent running or empty passphrase RSA key
-#  
-
-use strict;
-
-package PostMozilla;
-
-sub print_log {
-    my ($text) = @_;
-    print LOG $text;
-    print $text;
-}
-
-# Cache builds in a dated directory if:
-#  * The hour of the day is $Settings::build_hour or higher 
-#    (set in tinder-config.pl)
-#    -and-
-#  * the "last-built" file indicates a day before today's date
-#
-sub cacheit {
-  my ($c_hour, $c_yday, $target_hour, $last_build_day) = @_;
-  TinderUtils::print_log "current hour = $c_hour\n";
-  TinderUtils::print_log "target hour = $target_hour\n";
-  TinderUtils::print_log "current julian day = $c_yday\n";
-  TinderUtils::print_log "last build julian day = $last_build_day\n";
-  if (($c_hour > $target_hour) && 
-      (($last_build_day < $c_yday) || ($c_yday == 0))) {
-        return 1;
-      } else {
-	return 0;
-      }
-}
-
-
-
-sub returnStatus{
-  # build-anvil-util.pl expects an array, if no package is uploaded,
-  # a single-element array with 'busted', 'testfailed', or 'success' works.
-  my ($logtext, @status) = @_;
-  TinderUtils::print_log "$logtext\n";
-  return @status;
-}
-
-sub pushit {
-  my ($ssh_server,$upload_path,$upload_target) = @_;
-  # need to convert the path in case we're using activestate perl
-  # check for platform
-  #my $upload_target_dos = `cygpath -w $upload_target`;
-  #chop($upload_target_dos);
-
-  unless ( -e $upload_target) {
-    TinderUtils::print_log "No $upload_target to upload\n";
-    return 0;
-  }
-
-#for leaf
-  TinderUtils::run_shell_command "ssh -1 -i /home/leaf/.ssh/cltbld/.ssh/identity -l cltbld $ssh_server mkdir -p $upload_path";
-  TinderUtils::run_shell_command "scp -i /home/leaf/.ssh/cltbld/.ssh/identity -oProtocol=1 -r $upload_target cltbld\@$ssh_server:$upload_path";
-  TinderUtils::run_shell_command "ssh -1 -i /home/leaf/.ssh/cltbld/.ssh/identity -l cltbld $ssh_server chmod -R 755 $upload_path/$upload_target";
-
-# for cltbld
-  #TinderUtils::run_shell_command "ssh -1 -l cltbld $ssh_server mkdir -p $upload_path";
-  #TinderUtils::run_shell_command "scp -oProtocol=1 $upload_target cltbld\@$ssh_server:$upload_path";
-  #TinderUtils::run_shell_command "ssh -1 -l cltbld $ssh_server chmod -R 755 $upload_path";
-  return 1;
-}
-
-sub process_talkback {
-# this is where we
-# * generate a master.ini
-# * upload symbol-files
-# * shove talkback files into dist for packaging.
-# 
-
-}
-
-sub make_packages {
-  my ($build_dir, $build_date) = @_;
-  my $save_dir  = `pwd`;
-
-#DEBUG_LEAF
-    print_log "current directory is $save_dir\n";
-    print_log "cd to $build_dir/$Settings::Topsrcdir/xpinstall\n";
-#end DEBUG_LEAF
-
-  chdir "$build_dir/$Settings::Topsrcdir/xpinstall";
-  $ENV{"INSTALLER_URL"} = "http://ftp.mozilla.org/pub/mozilla.org/pub/mozilla/tinderbox-builds/$build_date";
-  system "make installer";
-#  if ($DEBUG_LEAF) {
-    print_log "post |make installer|\n";
-# DEBUG_LEAF
-  chdir $save_dir;
-
-}
-
-sub push_to_stage {
-  my ($build_dir, $build_date) = @_;
-  my $save_dir = `pwd`;
-  chdir "$build_dir/$Settings::Topsrcdir/installer";
-  mkdir $build_date;
-  system "cp sea/* $build_date"; 
-  system "cp stub/* $build_date";
-  system "cp -r raw/xpi $build_date/linux-xpi";
-  pushit ("stage.mozilla.org", "/home/ftp/pub/mozilla/tinderbox-builds", $build_date);
-  chdir $save_dir;
-
-}
-
-sub pad_digit {
-  my ($digit) = @_;
-  if ($digit < 10) { return "0" . $digit };
-  return $digit;
-}
-
-sub main {
-  # Get build directory from caller.
-  my ($mozilla_build_dir) = @_;
- 
-  #
-  # (0: $sec, 1: $min, 2: $hour, 3: $mday, 4: $mon, 5: $year, 
-  #  6: $wday, 7: $yday, 8: $isdst)
-  my ($hour, $mday, $mon, $year, $yday) = (localtime (time)) [2,3,4,5,7];
-  $year = $year + 1900;
-  $mon = $mon + 1;
-  $hour = pad_digit ($hour);
-  $mday = pad_digit ($mday);
-  $mon = pad_digit ($mon);
-  my $build_date = "$year-$mon-$mday-$hour";
-  #
-  my $last_build_day = -1;
-  if ( -e "$mozilla_build_dir/last-built"){
-    ($last_build_day) = (localtime((stat "$mozilla_build_dir/last-built")[9]))[7];
-  }
-  
-  print_log "build dir is $mozilla_build_dir \n";
-  TinderUtils::print_log "Post-Mozilla build goes here.\n";
-
-  # someday, we'll have talkback
-  #process_talkback;
-  
-  make_packages ($mozilla_build_dir, $build_date);
-  if (cacheit($hour, $yday, "8", $last_build_day)) { 
-    push_to_stage ($mozilla_build_dir, $build_date);
-    unlink "$mozilla_build_dir/last-built";
-    open BLAH, ">$mozilla_build_dir/last-built"; 
-    close BLAH;
-  }
-
-  # Report some kind of status to parent script.
-  #
-  #	 {'busted', 'testfailed', 'success'}
-  #
-
-  # Report a fake success, for example's sake.
-  # Eventually return an array 
-  &returnStatus (('success'));
-}
-
-# Need to end with a true value, (since we're using "require").
-1;

mozilla/tools/tinderbox/post-mozilla-sample.pl

@@ -1,46 +0,0 @@
-#!/usr/bin/perl
-#
-
-#
-# This script gets called after a full mozilla build & test.
-# Use this to build and test an embedded or commercial branding of Mozilla.
-#
-# Edit, and rename this file to post-mozilla.pl to activate.
-# ./build-seamonkey-utils.pl will call PostMozilla::main() after
-# a successful build and testing of mozilla.  This package can report
-# status via the $TinderUtils::build_status variable.  Yeah this is a hack,
-# but it works for now.  Feel free to improve this mechanism to properly
-# return values & stuff.  -mcafee
-#
-
-use strict;
-
-package PostMozilla;
-
-
-sub main {
-  # Get build directory from caller.
-  my ($mozilla_build_dir) = @_;
- 
-  
-  TinderUtils::print_log "Post-Mozilla build goes here.\n";
-
-  #
-  # Build script goes here.
-  #
-
-  # Report some kind of status to parent script.
-  #
-  #	 {'busted', 'testfailed', 'success'}
-  #
-
-  # Report a fake success, for example's sake.
-  # we return a list because sometimes we pass back a status *and*
-  # a url to a binary location, e.g.:
-  # return ('success', 'http://upload.host.org/path/to/binary');
-  # tinderbox processes the binary url and links to it in the log.
-  return ('success');
-}
-
-# Need to end with a true value, (since we're using "require").
-1;

mozilla/tools/tinderbox/qatest.pl

@@ -1,362 +0,0 @@
-#!/usr/bin/perl -w
-# -*- Mode: perl; indent-tabs-mode: nil -*-
-#
-###################################################################
-# Report Summary Generator for ARMS v2.0 by Vladimir Ermakov	
-###################################################################
-# This file parses through a results file and generates a
-# test summary giving the following info:
-#	  # of tcs passed
-#	  # of tcs failed
-#	  # of tcs died
-#	  % of pass and fail
-#	  List of testcases that failed.
-#	  Separates the results into suites with a convinient quick link
-#		 at the top of the page
-###################################################################
-# Questions Coments go to vladimire@netscape.com
-###################################################################
-
-sub PrintUsage {
-  die <<END_USAGE
-  usage: $0 <filename> ["express"]
-END_USAGE
-}
-
-if ($#ARGV < 0) {
-  PrintUsage();
-}
-
-my $DATAFILE = $ARGV[0];
-my $MODE;     
-
-if($#ARGV > 0) {
-  $MODE = $ARGV[1];
-} else {
-  $MODE = "";
-}
-
-my $express  = 0;
-
-if($MODE eq "express") {
-  $express = 1;
-}
-
-my $ngdir	= "http://geckoqa.mcom.com/ngdriver/"; #$input->url(-base=>1) . "/ngdriver/";
-my $ngsuites = $ngdir . "suites/";
-my $conffile = "ngdriver.conf";
-my $HTMLreport = "";
-
-unless ($express) {
-  print "Content-type: text/html\n\n";
-}
-
-&generateResults;
-
-$File{'SuiteList'} = \@suiteArray;
-
-&generateHTML;
-
-$File{'Project'} = "Buffy";
-
-print $HTMLreport;
-
-sub generateResults
-  {
-	if (!open(INFILE,$DATAFILE)) {
-	  print "DATAFILE = $DATAFILE\n";
-	  print "<H3> Cannot open $?, $!</H3>\n";
-	  return -1;
-	}
-
-	$File{'tcsPass'} = 0;
-	$File{'tcsFail'} = 0;
-	$File{'tcsDied'} = 0;
-	$File{'tcsTotal'} = 0;
-
-	$line = <INFILE>;
-	while ($line) {
-      my %Suite = ();
-
-      my @diedArray = ();
-      $Suite{'DiedList'} = \@diedArray;
-      my @testArray = ();
-      $Suite{'FailedList'} = \@testArray; 
-
-      # Skip to first anchor.
-      while (!($line =~ /<A NAME=".*?">/i) && $line) {
-        $line = <INFILE>;       # Go to next line.
-      }
-
-      # First anchor.
-      $line =~ /<A NAME="(.*?)"><H1>(.*?)<\/H1>/i;
-
-
-      my $name = $1;
-      my $title =$2;
-
-      $Suite{'Name'} = $name; 
-      $Suite{'Title'} = $title;
-
-      $Suite{'tcsPass'} = 0;
-      $Suite{'tcsFail'} = 0;
-      $Suite{'tcsDied'} = 0;
-      $Suite{'tcsTotal'} = 0;
-
-      do
-		{
-          while ($line && !($line =~ /<TC>/i) && !($line =~ /<A name=".*?">/i)) {
-            $line = <INFILE>;
-          }
-
-          if ($line && ($line =~ /<A name=\"(.*?)\">/i) && ($1 eq $Suite{'Name'})) {
-            $line = <INFILE>;  
-          }
-
-          # TC = test case.
-          if ($line && ($line =~ /<TC>/i)) {
-            while ($line && !($line =~ /<ENDTC>/i)) { 
-              $line1 = <INFILE>; 
-              if ($line1 =~ /<TC>/i) {
-                print "<H1>SOMETHING WRONG!</H1><BR>"; next; next;
-              }
-              $line .= $line1;
-            }
-
-            my ($tfName, $tcStat);
-            my @lines = split /<->/, $line;
-            $tfName = $lines[1];
-            $tcStat = $lines[3];
-			
-            # D=died, P=pass, F=failure
-            if ($tcStat eq 'D') {
-              $Suite{'tcsDied'} += 1;
-              push(@diedArray,$line);
-            }
-            if ($tcStat eq 'P') {
-              $Suite{'tcsPass'} += 1;
-              $Suite{'tcsTotal'} += 1;
-            }
-            if ($tcStat eq 'F') {
-              push(@testArray,$line);
-              $Suite{'tcsFail'} += 1;
-              $Suite{'tcsTotal'} += 1;
-            }
-            $line = <INFILE>;
-          }
-		} while ($line && !($line =~ /<A NAME=".*?">/i) && $line);
-
-      $File{'tcsPass'} += $Suite{'tcsPass'};
-      $File{'tcsFail'} += $Suite{'tcsFail'};
-      $File{'tcsTotal'} += $Suite{'tcsTotal'};
-      $File{'tcsDied'} += $Suite{'tcsDied'};
-      push(@suiteArray,\%Suite);
-	}
-	close INFILE;
-	1;
-  }
-
-sub generateHTML
-  {
-    my $prjExtension;
-    my %extList;
-
-    my $os = `uname -s`;        # Cheap OS id for now
-
-    my %Matrices;
-    
-    # Hard-coded from ngdriver.conf, I didn't want extra files in tree.
-    
-    $extList{"mb"}  = "http://cemicrobrowser.web.aol.com/bugReportDetail.php?RID=%";
-    $extList{"bs"}  = "http://bugscape.nscp.aoltw.net/show_bug.cgi?id=%";
-    $extList{"bz"}  = "http://bugzilla.mozilla.org/show_bug.cgi?id=%";
-    $extList{"bzx"} = "http://bugzilla.mozilla.org/show_bug.cgi?id=%";
-      
-    $prjExtension = "bz";       # Buffy hard-coded here.
-      
-    $Matricies{"dom-core"} = "http://geckoqa.mcom.com/browser/standards/dom1/tcmatrix/index.html";
-    $Matricies{"dom-html"} = "http://geckoqa.mcom.com/browser/standards/dom1/tcmatrix/index.html";
-    $Matricies{"domevents"} = "http://geckoqa.mcom.com/browser/standards/dom1/tcmatrix/index.html";
-    $Matricies{"javascript"} = "http://geckoqa.mcom.com/browser/standards/javascript/tcmatrix/index.html";
-    $Matricies{"forms"} = "http://geckoqa.mcom.com/browser/standards/form_submission/tcmatrix/index.html";
-    $Matricies{"formsec"} = "http://geckoqa.mcom.com/browser/standards/form_submission/tcmatrix/index.html";
-
-    unless ($express) {
-    $HTMLreport .= <<END_PRINT;
-		<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-		<html>
-			<head>
-			  <title>Test Result Summary on $File{'Platform'}</title>
-			  <meta http-equiv="content-type" content="text/html; charset=ISO-8859-1">
-			</head>
-
-		<body>
-		  <center><u><font color="#990000"><h3>AUTOMATED TEST RESULTS</h3></font></u></center><br>						   
-		  <center>			   
-		   <table border="0" cols="3" width="90%">
-			<tbody>
-			 <tr align="Left" valign="CENTER">
-			   <td width="250" valign="Middle"><b>OS: </b><font color="#990000">$os</script></font></td>
-			 </tr>
-			</tbody>			 
-		   </table>
-		  </center>							
-		<hr>		 
- <h3><u>The Following Test Suites Were Run:</u></h3>
-<UL>
-END_PRINT
-    
-      for (my $var = 0;$File{'SuiteList'}->[$var]->{'Name'};$var++) {
-        if (my $href = $Matrices{$File{'SuiteList'}->[$var]->{'Name'}}) {
-          $HTMLreport .= "<li><a href=\"$href\">$File{'SuiteList'}->[$var]->{'Title'}</a></li>\n";
-        } else {
-          $HTMLreport .= "<li><a href=\"$ngsuites$File{'SuiteList'}->[$var]->{'Name'}\">$File{'SuiteList'}->[$var]->{'Title'}</a></li>\n";
-        }
-      }
-    
-    $HTMLreport .= <<END_PRINT;
-	</UL>
-
-	<h3><u>Test Result Summary:</u></h3>
-END_PRINT
-    } # !express
-
-
-    $HTMLreport .= <<END_PRINT;
-<table border=2 cellspacing=0>
-<tr valign=top bgcolor=#CCCCCC>
-<td bgcolor=#999999>&nbsp;</td>
-<td>Passed</td>
-<td>Failed</td>
-<td>Total</td>
-<td>Died</td>
-<td>% Passed</td>
-<td>% Failed</td>
-</tr>
-END_PRINT
-
-    for (my $var = 0;$File{'SuiteList'}->[$var]->{'Name'};$var++) {
-      $curSuite = $File{'SuiteList'}->[$var];
-
-      $HTMLreport .= "<tr valign=top>\n";
-      if($express) {
-        $HTMLreport .= "<td>$curSuite->{'Title'}</td>\n";
-      } else {
-        $HTMLreport .= "<td bgcolor=#cccccc><a href=\"#$curSuite->{'Name'}\">$curSuite->{'Title'}</a></td>\n";
-      }
-      $HTMLreport .= "<td>$File{'SuiteList'}->[$var]->{'tcsPass'}</td>\n";
-      $HTMLreport .= "<td>$File{'SuiteList'}->[$var]->{'tcsFail'}</td>\n";
-      $HTMLreport .= "<td>$File{'SuiteList'}->[$var]->{'tcsTotal'}</td>\n";
-      $HTMLreport .= "<td>${@{$File{'SuiteList'}}[$var]}{'tcsDied'}</td>\n";
-
-      my $pctPass = $File{'SuiteList'}->[$var]->{'tcsPass'} / $File{'SuiteList'}->[$var]->{'tcsTotal'};
-      $pctPass = int($pctPass*10000)/100;
-	
-      $HTMLreport .= "<td>$pctPass</td>\n";
-
-      my $pctFail = $File{'SuiteList'}->[$var]->{'tcsFail'} / $File{'SuiteList'}->[$var]->{'tcsTotal'};
-      $pctFail = int($pctFail*10000)/100;
-	
-      $HTMLreport .= "<td>$pctFail</td>\n";
-      $HTMLreport .= "</tr>\n";
-    }
-
-    $HTMLreport .= <<END_PRINT; 
-<tr valign=top bgcolor=#FFFFCC>
-<td>Total:</td>
-<td>$File{'tcsPass'}</td>
-<td>$File{'tcsFail'}</td>
-<td>$File{'tcsTotal'}</td>
-<td>$File{'tcsDied'}</td>
-END_PRINT
-	my $pctPass = $File{'tcsPass'} / $File{'tcsTotal'};
-	$pctPass = int($pctPass*10000)/100;
-	my $pctFail = $File{'tcsFail'} / $File{'tcsTotal'};
-	$pctFail = int($pctFail*10000)/100;
-
-	$HTMLreport .= <<END_PRINT; 
-<td>$pctPass</td>
-<td>$pctFail</td>
-</tr>
-</table>
-END_PRINT
-
-    unless ($express) {
-    $HTMLreport .= <<END_PRINT;
-<h3>Failed Testcases:</h3>
-END_PRINT
-
-    my $curSuite;
-    for (my $var=0;$File{'SuiteList'}->[$var]->{'Name'};$var++) {
-      $curSuite = $File{'SuiteList'}->[$var];
-
-      $HTMLreport .= <<END_PRINT;
-	<hr>
-	<h2>
-	<a NAME="$curSuite->{'Name'}"></a><u><font color="#666600">$curSuite->{'Title'}</font></u></h2>
-	<b><u>Died:</u></b>
-	<table>
-END_PRINT
-
-      for (my $dcnt = 0;$curFile = $File{'SuiteList'}->[$var]->{'DiedList'}->[$dcnt];$dcnt++) {
-		($none,$fName) = split(/<->/,$curFile);
-		$HTMLreport .= "<tr><td style=\"color: red;\"><A href='$ngsuites$curSuite->{'Name'}/$fName' target=\"new\">$fName</A></td></tr>\n";
-      }
-
-      $HTMLreport .= "</table><BR>\n";
-      $HTMLreport .= "<b><u>Failures:</u></b><br>";
-      $HTMLreport .= "<table BORDER CELLSPACING=0><TR>\n";
-
-      for ($fcnt = 0;$curFile = $File{'SuiteList'}->[$var]->{'FailedList'}->[$fcnt];$fcnt++) {
-		($none,$fName,$fDesc,$fStat,$fBug,$fExpected,$fActual) = split(/<->/,$curFile);
-		$HTMLreport.= "<TR><TD><A href=\"$ngsuites$curSuite->{'Name'}/$fName\" target=\"_new\">$fName</A></TD><TD>";
-
-		# Quiet perl warnings about unused variables.
-		my $tmp; $tmp = $fStat; $tmp = $fActual; $tmp = $fExpected;
-
-		#
-		# TEMPRORAY DISABLED.
-		#
-		my @bugList = split(/[\s+]|,/,$fBug);
-		my $bug = "";
-		my $index = 0; 
-
-		while ($bugList[$index]) {
-          if ($bugList[$index] =~ /(\d+)$prjExtension/i) {
-            $bugList[$index] =~ s/(\d+)($prjExtension)/makelink($1,$extList{$2})/ige; 
-            $bug .= $bugList[$index];
-          }
- 
-          $index++;
-		}
-		$HTMLreport.= "$bug</TD><TD>$fDesc</TD></TR>\n";
-
-        #		 $fBug =~ s/(\d+)($prjExtension)/makelink($1,$extList{$2})/ige; 
-        #		 $HTMLreport.= "$fBug</TD><TD>$fDesc</TD></TR>\n";
-
-      }
-      $HTMLreport .= "</table>\n";
-    }
-	
-    $HTMLreport .= <<END_PRINT;
-	</BODY>
-	</HTML>
-END_PRINT
-  } # !express
-
-    1;
-  }
-
-sub makelink
-  {
-	$bugNum = $_[0];
-	$bugLnk = $_[1];
-
-	
-	$bugLnk =~ s/%/$bugNum/ig;
-	$bugLnk = "<A href=\"$bugLnk\">$bugNum</A>";
-
-	return $bugLnk;
-  }
-
-1;

mozilla/tools/tinderbox/report-http-status.pl

@@ -1,165 +0,0 @@
-#!/usr/bin/perl
-# -*- Mode: perl; indent-tabs-mode: nil -*-
-
-#
-# Graph tree-open status, via tbox graph server.
-#
-
-
-# Location of this file.  Make sure that hand-runs and crontab-runs
-# of this script read/write the same data.
-my $script_dir = "/builds/tinderbox/mozilla/tools/tinderbox";
-
-my $graph_server = "coffee";
-
-# Send data to graph server via HTTP.
-require "$script_dir/reportdata.pl";
-
-use Sys::Hostname;  # for ::hostname()
-
-sub PrintUsage {
-    die <<END_USAGE
-Usage:
-
-  $0 <ip or hostname>
-
-END_USAGE
-}
-
-
-# Return true if httpd server is up.
-sub is_http_alive() {
-  my $url = "http://$ARGV[0]";
-
-  my $rv = 0; # Assume false.
-
-  my $res = 
-    eval q{
-           use LWP::UserAgent;
-           use HTTP::Request;
-           my $ua  = LWP::UserAgent->new;
-           $ua->timeout(10); # seconds
-           
-           my $req = HTTP::Request->new(GET => $url);
-           my $res = $ua->request($req);
-           return $res;
-          };
-  if ($@) {
-    warn "GET Failed: $@";
-    #print "GET Failed.\n";
-  } else {
-    # Debug.
-    #print "GET Succeeded: \n";
-    #print "status:\n", $res->status_line, "\n";
-    #print "content:\n",  $res->content, "\n";
-    #print "GET Succeeded.\n";
-
-    # This will be non-zero if http get went through ok.
-    if($res->content) {
-      $rv = 1;  
-    } else {
-      $rv = 0;
-    }
-  }
-
-  return $rv;
-}
-
-
-
-# main
-{
-  my $alive_time = 0;  # Hours http has been up.
-  my $alive = 0;
-  my $timefile = "$script_dir/http_alive_timefiles/$ARGV[0]";
-
-
-  # make sure directory exists
-  unless (-d $timefile) {
-    mkdir "$script_dir/http_alive_timefiles";
-  }
-
-  PrintUsage() if $#ARGV == -1;
-
-  $alive = is_http_alive();
-  
-  if ($alive) {
-    print "$ARGV[0] is alive\n";
-
-    #
-    # Record alive time.
-    #
-
-    # Was zero before, report zero here, write out the
-    # time for next cycle.
-    if (not (-e "$timefile")) {
-      print "no timefile found.\n";
-      open TIMEFILE, ">$timefile";
-      print TIMEFILE time();
-      close TIMEFILE;
-    } else {
-      # Timefile found, compute difference and report that number.
-      print "found timefile: $timefile!\n";     
-    
-      my $time_http_started = 0;
-      my $now = 0;
-  
-      open TIMEFILE, "$timefile";
-      while (<TIMEFILE>) {
-        chomp;
-        $time_http_started = $_;
-      }
-      close TIMEFILE;
-      print "time_http_started = $time_http_started\n";
-      
-      $now = time();
-      print "now = $now\n";
-
-      # Report time in hours.
-      $alive_time = ($now - $time_http_started)/3600;
-      print "alive_time (hours) = $alive_time\n";
-
-      # Clamp time to 20 hours so we don't get huge spikes for
-      # extended open times (weekends)
-      if ($alive_time > 20.0) {
-        $alive_time = 20.0;
-      }
-      
-    }
-    
-  } else {
-    print "$ARGV[0] is not responding.\n";
-
-    # Delete timefile if there is one.
-    if (-e "$timefile") {
-      unlink("$timefile");
-    }
-  }
-
-  # Shorten some machine names.
-  my $short_name = "$ARGV[0]";
-  $short_name =~ s/.websys.aol.com//g;
-
-  ReportData::send_results_to_server($graph_server,
-                                     "$alive_time",
-                                     ::hostname(),
-                                     "http_alive", 
-                                     "$ARGV[0]");
-
-  my $status = "";
-  if($alive) {
-    $status = "success";
-  } else {
-    $status = "busted";
-  }
-
-  # Hard-coded for now.
-  my $graph_url = "http://$graph_server/graph/query.cgi?tbox=$ARGV[0]&testname=http_alive&autoscale=&size=&days=7&units=hours&ltype=&points=&avg=&showpoint=";
-
-  ReportData::send_tbox_packet("tinderbox-daemon\@warp.mcom.com",
-                               "Talkback",
-                               $status,
-                               "TinderboxPrint:<a title=\"Hours httpd:80 has been alive.\" href=\"$graph_url\">Ta</a>",
-                               "$ARGV[0]",
-                               "$short_name HTTP Alive Test");
-}

mozilla/tools/tinderbox/report-tree-status.pl

@@ -1,160 +0,0 @@
-#!/usr/bin/perl
-# -*- Mode: perl; indent-tabs-mode: nil -*-
-
-#
-# Graph tree-open status, via tbox graph server.
-#
-
-# Location of this file.  Make sure that hand-runs and crontab-runs
-# of this script read/write the same data.
-my $script_dir = "/builds/tinderbox/mozilla/tools/tinderbox";  
-
-# Send data to graph server via HTTP.
-require "$script_dir/reportdata.pl";
-
-use Sys::Hostname;  # for ::hostname()
-
-my $sheriff_string;
-
-sub is_tree_open {
-  my $tbox_url = "http://tinderbox.mozilla.org/showbuilds.cgi?tree=SeaMonkey";
-
-  # Dump tbox page source into a file.
-  print "HTTP...";
-  system ("wget", "-q", "-O", "$script_dir/tbox.source", $tbox_url);
-  print "done\n";
-
-  my $rv = 0;
-
-  $sheriff_string = "";
-
-  # Scan file, looking for line that starts with <a NAME="open">
-  open TBOX_FILE, "$script_dir/tbox.source";
-  while (<TBOX_FILE>) {
-    # Scan for open string
-    if(/^<a NAME="open">/) {
-      # look for "open" string
-      if (/open<\/font>$/) {
-        print "open\n";
-        $rv = 1;
-      } else {
-        print "closed\n";
-        $rv = 0;
-      }
-    }
-
-    # Scan for sheriff string & save it off for HTTP submit later.
-    if(/^<br><a NAME="sheriff"><\/a>/) {
-      chomp;
-      $sheriff_string = $_;
-
-      # Strip out content to save space.
-
-      # Strip out permanent content.
-      $sheriff_string =~ s/^<br><a NAME="sheriff"><\/a>//;
-      
-      # Crude attempt at reducing the random html that shows up here.
-      # Order is important, pick off easy tags, then make it legal cgi,
-      # then shorten it up.
-      $sheriff_string =~ s/<[pP]>//g;
-      $sheriff_string =~ s/\015//g;   # ^M
-      $sheriff_string =~ s/<br>//g;
-      $sheriff_string =~ s/<\/a>//g;
-      $sheriff_string =~ s/<//g;
-      $sheriff_string =~ s/>//g;
-      $sheriff_string =~ s/"/ /g;
-      $sheriff_string =~ s/\///g;
-      $sheriff_string =~ s/\\//g;
-      $sheriff_string =~ s/#/[lb]/g;
-      $sheriff_string =~ s/mailto://g;
-      $sheriff_string =~ s/[aA][iI][mM]://g;
-      $sheriff_string =~ s/[iI][rR][cC]://g;
-      $sheriff_string =~ s/a href//g;
-      $sheriff_string =~ s/[sS]heriff//g;
-      $sheriff_string =~ s/[mM]onday//g;
-      $sheriff_string =~ s/[tT]uesday//g;
-      $sheriff_string =~ s/[wW]ednesday//g;
-      $sheriff_string =~ s/[tT]hursday//g;
-      $sheriff_string =~ s/[fF]riday//g;
-      $sheriff_string =~ s/[wW]eekend//g;
-      $sheriff_string =~ s/^[tT]he //g;
-      $sheriff_string =~ s/\/a//g;
-      $sheriff_string =~ s/netscape.com/nscp/g;
-      $sheriff_string =~ s/mozilla.org/moz/g;
-      $sheriff_string =~ s/ is / /g;
-      $sheriff_string =~ s/ for / /g;
-      $sheriff_string =~ s/ on / /g;
-      $sheriff_string =~ s/ in / /g;
-      $sheriff_string =~ s/ = / /g;
-      $sheriff_string =~ s/ - / /g;
-
-      $sheriff_string = substr($sheriff_string,0,60);
-      print "sheriff string = $sheriff_string\n";
-    }
-  }
-  close TBOX_FILE;
-
-  # Clean up.
-  unlink("$script_dir/tbox.source");
-
-  return $rv;
-}
-
-
-# main
-{
-  my $time_since_open = 0;
-  my $timefile = "$script_dir/treeopen_timefile";
-
-  # Get tree status.
-  if(is_tree_open()) {
-
-    # Record tree open time if not set.
-    if (not (-e "$timefile")) {
-      open TIMEFILE, ">$timefile";
-      print TIMEFILE time();
-      close TIMEFILE;
-    } else {
-      # Timefile found, compute difference and report that number.
-      print "found timefile: $timefile!\n";     
-      
-      my $time_tree_opened = 0;
-      my $now = 0;
-  
-      open TIMEFILE, "$timefile";
-      while (<TIMEFILE>) {
-        chomp;
-        $time_tree_opened = $_;
-      }
-      close TIMEFILE;
-      print "time_tree_opened = $time_tree_opened\n";
-      
-      $now = time();
-      print "now = $now\n";
-
-      # Report time in hours.
-      $time_since_open = ($now - $time_tree_opened)/3600;
-      print "time_since_open (hours) = $time_since_open\n";
-
-      # Clamp time to 20 hours so we don't get huge spikes for
-      # extended open times (weekends)
-      if($time_since_open > 20.0) {
-        $time_since_open = 20.0;
-      }
-      
-    }
-    
-  } else {
-    # tree is closed, leave tree_open_time at zero.
-
-    # Delete timefile if there is one.
-    if (-e "$timefile") {
-      unlink("$timefile");
-    }
-  }
-
-  ReportData::send_results_to_server("tegu.mozilla.org", 
-                                     "$time_since_open",
-                                     "$sheriff_string",
-                                     "treeopen", ::hostname());
-}

mozilla/tools/tinderbox/reportdata.pl

@@ -1,84 +0,0 @@
-#!/usr/bin/perl
-# -*- Mode: perl; indent-tabs-mode: nil -*-
-
-
-#
-# Utils used by tests to send data to graph server, or tinderbox.
-#
-
-require 5.003;
-
-use strict;
-
-$::Version = '$Revision: 1.3 $ ';
-
-package ReportData;
-
-# Send data to graph cgi via HTTP.
-sub send_results_to_server {
-    my ($server, $value, $data, $testname, $tbox) = @_;
-
-    my $tmpurl = "http://$server/graph/collect.cgi";
-    $tmpurl .= "?value=$value&data=$data&testname=$testname&tbox=$tbox";
-
-    print "send_results_to_server(): \n";
-    print "tmpurl = $tmpurl\n";
-
-    # libwww-perl has process control problems on windows,
-    # spawn wget instead.
-    if ($Settings::OS =~ /^WIN/) {
-        system ("wget", "-o", "/dev/null", $tmpurl);
-        print "send_results_to_server() succeeded.\n";
-    } else {
-        my $res = eval q{
-            use LWP::UserAgent;
-            use HTTP::Request;
-            my $ua  = LWP::UserAgent->new;
-            $ua->timeout(10); # seconds
-            my $req = HTTP::Request->new(GET => $tmpurl);
-            my $res = $ua->request($req);
-            return $res;
-        };
-        if ($@) {
-            warn "Failed to submit startup results: $@";
-            print "send_results_to_server() failed.\n";
-        } else {
-            print "Results submitted to server: \n",
-            $res->status_line, "\n", $res->content, "\n";
-            print "send_results_to_server() succeeded.\n";
-        }
-    }
-}
-
-# Fake a tinderbox message.
-sub send_tbox_packet {
-  my ($server_email, $tree, $status,
-      $log, $machine, $build_name) = @_;
-
-  my $foo;
-
-  my $now = time();
-
-  $foo .= <<END_PRINT;
-tinderbox: tree: $tree
-tinderbox: builddate: $now
-tinderbox: status: $status
-tinderbox: build: $build_name
-tinderbox: errorparser: unix
-tinderbox: buildfamily: unix
-tinderbox: END
-END_PRINT
-
-$foo .= $log;
-
-  print "foo = \n$foo\n";
-
-  open MSG, ">msg.$machine";
-  print MSG $foo;
-  close MSG;
-
-  system "/bin/mail  $server_email " . "< msg.$machine";
-
-
-  unlink "msg.$machine";
-}

mozilla/tools/tinderbox/tinder-defaults.pl

@@ -1,170 +0,0 @@
-#- PLEASE FILL THIS IN WITH YOUR PROPER EMAIL ADDRESS
-#$BuildAdministrator = "$ENV{USER}\@$ENV{HOST}";
-$BuildAdministrator = ($ENV{USER} || "cltbld") . "\@" . ($ENV{HOST} || "dhcp");
-
-#- You'll need to change these to suit your machine's needs
-$DisplayServer = ':0.0';
-
-#- Default values of command-line opts
-#-
-$BuildDepend       = 1;      # Depend or Clobber
-$BuildDebug        = 0;      # Debug or Opt (Darwin)
-$ReportStatus      = 1;      # Send results to server, or not
-$ReportFinalStatus = 1;      # Finer control over $ReportStatus.
-$UseTimeStamp      = 1;      # Use the CVS 'pull-by-timestamp' option, or not
-$BuildOnce         = 0;      # Build once, don't send results to server
-$TestOnly          = 0;      # Only run tests, don't pull/build
-$BuildEmbed        = 0;      # After building seamonkey, go build embed app.
-$SkipMozilla       = 0;      # Use to debug post-mozilla.pl scripts.
-
-# Tests
-$CleanProfile             = 0;
-$ResetHomeDirForTests     = 1;
-$ProductName              = "Mozilla";
-
-$RunMozillaTests          = 1;  # Allow turning off of all tests if needed.
-$RegxpcomTest             = 1;
-$AliveTest                = 1;
-$JavaTest                 = 0;
-$ViewerTest               = 0;
-$BloatTest                = 0;  # warren memory bloat test
-$BloatTest2               = 0;  # dbaron memory bloat test, require tracemalloc
-$DomToTextConversionTest  = 0;  
-$XpcomGlueTest            = 0;
-$CodesizeTest             = 0;  # Z,  require mozilla/tools/codesighs
-$EmbedCodesizeTest        = 0;  # mZ, require mozilla/tools/codesigns
-$MailBloatTest            = 0;
-$EmbedTest                = 0;  # Assumes you wanted $BuildEmbed=1
-$LayoutPerformanceTest    = 0;  # Tp
-$QATest                   = 0;  
-$XULWindowOpenTest        = 0;  # Txul
-$StartupPerformanceTest   = 0;  # Ts
-
-# Release Build options
-# requires an appropriate post-mozilla.pl
-$ReleaseBuild             = 0;  # Make a release build?
-$package_creation_path    = "mozilla/xpinstall/packager";
-$package_location         = "mozilla/dist/install";  
-$ftp_path = "/home/ftp/pub/mozilla/tinderbox-builds";
-$url_path = "http://ftp.mozilla.org/pub/mozilla.org/mozilla/tinderbox-builds";
-$build_hour               = "8";
-$ssh_server               = "stage.mozilla.org";
-$ssh_user                 = "cltbld";
-
-# end Release Build options
-
-$TestsPhoneHome           = 0;  # Should test report back to server?
-$results_server           = "axolotl.mozilla.org"; # was tegu
-$pageload_server          = "spider";  # localhost
-
-#
-# Timeouts, values are in seconds.
-#
-
-$CreateProfileTimeout             = 45;
-$RegxpcomTestTimeout              = 15;
-
-$AliveTestTimeout                 = 45;
-$ViewerTestTimeout                = 45;
-$EmbedTestTimeout                 = 45;
-$BloatTestTimeout                 = 120;   # seconds
-$MailBloatTestTimeout             = 120;   # seconds
-$JavaTestTimeout                  = 45;
-$DomTestTimeout	                  = 45;    # seconds
-$XpcomGlueTestTimeout             = 15;
-$CodesizeTestTimeout              = 900;     # seconds
-$CodesizeTestType                 = "auto";  # {"auto"|"base"}
-$LayoutPerformanceTestTimeout     = 1200;  # entire test, seconds
-$QATestTimeout                    = 1200;   # entire test, seconds
-$LayoutPerformanceTestPageTimeout = 30000; # each page, ms
-$StartupPerformanceTestTimeout    = 60;    # seconds
-$XULWindowOpenTestTimeout	      = 150;   # seconds
-
-
-$MozConfigFileName = 'mozconfig';
-
-$UseMozillaProfile = 1;
-$MozProfileName = 'default';
-
-#- Set these to what makes sense for your system
-$Make          = 'gmake';       # Must be GNU make
-$MakeOverrides = '';
-$mail          = '/bin/mail';
-$CVS           = 'cvs -q';
-$CVSCO         = 'checkout -P';
-
-# win32 usually doesn't have /bin/mail
-$blat           = 'c:/nstools/bin/blat';
-$use_blat       = 0;
-
-# Set moz_cvsroot to something like:
-# :pserver:$ENV{USER}%netscape.com\@cvs.mozilla.org:/cvsroot
-# :pserver:anonymous\@cvs-mirror.mozilla.org:/cvsroot
-#
-# Note that win32 may not need \@, depends on ' or ".
-# :pserver:$ENV{USER}%netscape.com@cvs.mozilla.org:/cvsroot
-
-$moz_cvsroot   = $ENV{CVSROOT};
-
-#- Set these proper values for your tinderbox server
-$Tinderbox_server = 'tinderbox-daemon@tinderbox.mozilla.org';
-
-# Allow for non-client builds, e.g. camino.
-$moz_client_mk = 'client.mk';
-
-# Allow for non-client builds, e.g. camino.
-$moz_client_mk = 'client.mk';
-
-#- Set if you want to build in a separate object tree
-$ObjDir = '';
-
-# Extra build name, if needed.
-$BuildNameExtra = '';
-
-# User comment, eg. ip address for dhcp builds.
-# ex: $UserComment = "ip = 208.12.36.108";
-$UserComment = 0;
-
-#-
-#- The rest should not need to be changed
-#-
-
-#- Minimum wait period from start of build to start of next build in minutes.
-$BuildSleep = 10;
-
-#- Until you get the script working. When it works,
-#- change to the tree you're actually building
-$BuildTree  = 'MozillaTest';
-
-$BuildName = '';
-$BuildTag = '';
-$BuildConfigDir = 'mozilla/config';
-$Topsrcdir = 'mozilla';
-
-$BinaryName = 'mozilla-bin';
-
-#
-# For embedding app, use:
-$EmbedBinaryName = 'TestGtkEmbed';
-$EmbedDistDir    = 'dist/bin'
-
-
-$ShellOverride = ''; # Only used if the default shell is too stupid
-$ConfigureArgs = '';
-$ConfigureEnvArgs = '';
-$Compiler = 'gcc';
-$NSPRArgs = '';
-$ShellOverride = '';
-
-# allow override of timezone value (for win32 POSIX::strftime)
-$Timezone = '';
-
-# Reboot the OS at the end of build-and-test cycle. This is primarily
-# intended for Win9x, which can't last more than a few cycles before
-# locking up (and testing would be suspect even after a couple of cycles).
-# Right now, there is only code to force the reboot for Win9x, so even
-# setting this to 1, will not have an effect on other platforms. Setting
-# up win9x to automatically logon and begin running tinderbox is left 
-# as an exercise to the reader. 
-$RebootSystem = 0;
-

mozilla/tools/tinderbox/tinderbox

@@ -1,118 +0,0 @@
-#!/bin/sh
-#
-# 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 Mozilla Communicator.
-#
-# The Initial Developer of the Original Code is Chris McAfee.
-# Portions created by Chris McAfee are
-# Copyright (C) The Mozilla Organization.
-# All Rights Reserved.
-#
-# Contributor(s): Chris McAfee <mcafee@netscape.com>
-#
-
-#
-# Tinderbox control script.
-#
-# Assumes that at most two tinderboxes are running
-# simultaneously, depend and clobber.
-#
-# Assumes that if mozconfig exists, use it. Format:
-#   mk_add_options MOZ_MAKE_FLAGS=j8
-#   ac_add_options --disable-debug
-#   ac_add_options --enable-optimize
-#
-
-
-tinderbox_usage() {
-  echo "Usage: tinderbox [depend|clobber|multi] {start|stop|status|restart}"
-  exit 1
-}
-
-if [ $# != 2 ]; then
-  echo "Wrong number of arguments."
-  tinderbox_usage
-fi
-
-build_type="$1"
-build_action="$2"
-
-# Depend or clobber build?
-if [ "$build_type" != "depend" -a \
-     "$build_type" != "clobber" -a \
-     "$build_type" != "multi" ]; then
-    echo "Unknown option: $1"
-    tinderbox_usage
-fi
-
-# See how we were called.
-case "$build_action" in
-  start)
-    if test -f $build_type.pid; then
-      echo "$build_type build already running with PID "`cat $build_type.pid`
-    else
-      echo "Starting $build_type tinderbox..."
-
-	  # Say if we found post-mozilla.pl
-	  if test -f post-mozilla.pl; then
-	    echo "Found post-mozilla.pl"
-	  fi
-
-	  # Grab and use mozconfig if it exists.
-      if test "$build_type" = "multi"; then
-        nohup ./multi-tinderbox.pl &
-      elif test -f mozconfig; then
-        echo "Found mozconfig..."
-        nohup ./build-seamonkey.pl --$build_type --mozconfig mozconfig &
-      elif test -f .mozconfig; then
-        echo "Found .mozconfig..."
-        nohup ./build-seamonkey.pl --$build_type --mozconfig .mozconfig &
-      else
-        nohup ./build-seamonkey.pl --$build_type &
-      fi
-	  # Write out PID so we can shut things down later.
-	  # This needs to be right after the ./build-seamonkey.pl call to
-	  # get the right PID.
-      echo "PID $!"
-      echo $! > $build_type.pid
-	  \rm -f nohup.out
-    fi
-    ;;
-  stop)
-    if test -f $build_type.pid; then
-      pid=`cat $build_type.pid`
-      echo "Shutting down $build_type tinderbox, PID = $pid"
-      kill $pid
-      \rm $build_type.pid
-    else
-      echo "$build_type is not running."
-    fi
-    echo
-    ;;
-  status)
-    if test -f $build_type.pid; then
-      echo "$build_type build is running with PID of "`cat $build_type.pid`
-    else
-      echo "$build_type build is not running."
-    fi
-    ;;
-  restart)
-    echo "Restarting $build_type tinderbox:"
-    $0 $build_type stop
-    $0 $build_type start
-    ;;
-  *)
-    tinderbox_usage
-    exit 1
-esac
-
-exit 0