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/extensions/sql/Makefile.in

@@ -1,19 +0,0 @@
-DEPTH		= ../..
-topsrcdir	= @top_srcdir@
-srcdir		= @srcdir@
-VPATH		= @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-DIRS            = \
-		base \
-		pgsql \
-		build
-
-ifdef ENABLE_TESTS
-DIRS		+= \
-		sqltest \
-		tests
-endif
-
-include $(topsrcdir)/config/rules.mk

mozilla/extensions/sql/base/Makefile.in

@@ -1,11 +0,0 @@
-DEPTH           = ../../..
-topsrcdir       = @top_srcdir@
-srcdir          = @srcdir@
-VPATH           = @srcdir@
-
-DIRS            = \
-		public \
-		src \
-		resources
-
-include $(topsrcdir)/config/rules.mk

mozilla/extensions/sql/base/public/Makefile.in

@@ -1,19 +0,0 @@
-DEPTH		= ../../../..
-topsrcdir	= @top_srcdir@
-srcdir		= @srcdir@
-VPATH		= @srcdir@
-
-MODULE		= sql
-
-XPIDLSRCS	= \
-		mozISqlConnection.idl \
-		mozISqlRequest.idl \
-		mozISqlDataSource.idl \
-		mozISqlInputStream.idl \
-		mozISqlRequestObserver.idl \
-		mozISqlResult.idl \
-		mozISqlResultEnumerator.idl \
-		mozISqlService.idl \
-		$(NULL)
-
-include $(topsrcdir)/config/rules.mk

mozilla/extensions/sql/base/public/mozISqlConnection.idl

@@ -1,124 +0,0 @@
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla Public License Version
- * 1.1 (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- * http://www.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 2001
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *   Jan Varga <varga@utcru.sk>
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#include "nsISupports.idl"
-
-interface mozISqlResult;
-interface mozISqlRequest;
-interface mozISqlRequestObserver;
-
-/**
- * @status UNDER_REVIEW
- */
-
-[scriptable, uuid(f16397a4-1ecb-4e08-84f8-27750c04b779)]
-interface mozISqlConnection : nsISupports
-{
-
-  readonly attribute AString serverVersion;
-
-  /**
-   * The most recent error message.
-   */
-  readonly attribute AString errorMessage;
-
-  /**
-   * The ID of the most recently added record.
-   */
-  readonly attribute long lastID;
-
-  /**
-   * Set up the connection.
-   *
-   * @param aHost       The host name.
-   * @param aPort       The port at which the host is listening.
-   * @param aDatabase   The real database name to connect to.
-   * @param aUsername   The username to connect as.
-   * @param aPassword   The password to use in authentification phase.   
-   */
-  void init(in AString aHost,
-            in long aPort,
-            in AString aDatabase,
-            in AString aUsername,
-            in AString aPassword);
-
-  /**
-   * Execute the query synchronously and return database result.
-   *
-   * @param aQuery      The query to execute.
-   */
-  mozISqlResult executeQuery(in AString aQuery);
-
-  /**
-   * Execute the update synchronously and return number of updated rows.
-   *
-   * @param aUpdate     The update to execute.
-   */
-  long executeUpdate(in AString aUpdate);
-
-  mozISqlRequest asyncExecuteQuery(in AString aQuery,
-                                   in nsISupports aContext,
-                                   in mozISqlRequestObserver aObserver);
-
-  mozISqlRequest asyncExecuteUpdate(in AString aQuery,
-                                    in nsISUpports aContext,
-                                    in mozISqlRequestObserver aObserver);
-
-  /**
-   * Begin transaction.
-   */
-  void beginTransaction();
-
-  /**
-   * Commit transaction.
-   */
-  void commitTransaction();
-
-  /**
-   * Rollback transaction.
-   */
-  void rollbackTransaction();
-
-  /**
-   * Get primary keys.
-   *
-   * @param aSchema     The schema.
-   * @param aTable      The table name.
-   */
-  mozISqlResult getPrimaryKeys(in AString aSchema, in AString aTable);
-
-};

mozilla/extensions/sql/base/public/mozISqlDataSource.idl

@@ -1,65 +0,0 @@
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla Public License Version
- * 1.1 (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- * http://www.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 2001
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *   Jan Varga <varga@utcru.sk>
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#include "nsISupports.idl"
-
-interface nsIRDFResource;
-
-/**
- * @status UNDER_REVIEW
- */
-
-[scriptable, uuid(3c0a954f-b595-46a4-932c-3660f55e2e10)]
-interface mozISqlDataSource : nsISupports
-{
-
-  /**
-   * Retrieve the RDF resource associated with the specified row.
-   *
-   * @param aRowIndex   The row index.
-   */
-
-  nsIRDFResource getResourceAtIndex(in long aRowIndex);
-
-  /**
-   * Retrieve the index associated with specified RDF resource.
-   *
-   * @param aResource   The resource.
-   */
-  long getIndexOfResource(in nsIRDFResource aResource);
-
-};

mozilla/extensions/sql/base/public/mozISqlInputStream.idl

@@ -1,52 +0,0 @@
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla Public License Version
- * 1.1 (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- * http://www.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 2001
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *   Jan Varga <varga@utcru.sk>
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#include "nsISupports.idl"
-
-/**
- * @status UNDER_DEVELOPMENT
- */
-
-[scriptable, uuid(555f2485-ba82-4c5c-9dd2-d801104dc09e)]
-interface mozISqlInputStream : nsISupports
-{
-
-  AString getColumnHeader(in long aColumnIndex);
-
-  void setColumnHeader(in long aColumnIndex, in AString aLabel);
-
-};

mozilla/extensions/sql/base/public/mozISqlRequest.idl

@@ -1,77 +0,0 @@
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla Public License Version
- * 1.1 (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- * http://www.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 2001
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *   Jan Varga <varga@utcru.sk>
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#include "nsISupports.idl"
-
-interface mozISqlConnection;
-interface mozISqlRequestObserver;
-interface mozISqlResult;
-
-/**
- * @status UNDER_REVIEW
- */
-
-[scriptable, uuid(f67cb817-5e07-49ff-aacc-5c80585c5031)]
-interface mozISqlRequest : nsISupports
-{
-  readonly attribute AString errorMessage;
-
-  readonly attribute mozISqlResult result;
-
-  readonly attribute long affectedRows;
-
-  readonly attribute long lastID;
-
-
-  readonly attribute AString query;
-
-  readonly attribute nsISupports ctxt;
-
-  readonly attribute mozISqlRequestObserver observer;
-
-
-  const long STATUS_NONE        = 0;
-  const long STATUS_EXECUTED    = 1;
-  const long STATUS_COMPLETE    = 2;
-  const long STATUS_ERROR       = 3;
-  const long STATUS_CANCELLED   = 4;
-  
-  readonly attribute long status;
-  
-  void cancel();
-
-};

mozilla/extensions/sql/base/public/mozISqlRequestObserver.idl

@@ -1,56 +0,0 @@
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla Public License Version
- * 1.1 (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- * http://www.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 2001
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *   Jan Varga <varga@utcru.sk>
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#include "nsISupports.idl"
-
-interface mozISqlRequest;
-
-/**
- * @status UNDER_REVIEW
- */
-
-[scriptable, uuid(9e950bc0-e252-41ef-ac6f-3e3c4acd9dd8)]
-interface mozISqlRequestObserver : nsISupports
-{
-
-  void onStartRequest(in mozISqlRequest aRequest,
-                      in nsISupports aContext);
-
-  void onStopRequest(in mozISqlRequest aRequest,
-                     in nsISupports aContext);
-
-};

mozilla/extensions/sql/base/public/mozISqlResult.idl

@@ -1,87 +0,0 @@
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla Public License Version
- * 1.1 (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- * http://www.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 2001
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *   Jan Varga <varga@utcru.sk>
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#include "nsISupports.idl"
-
-interface mozISqlConnection;
-interface mozISqlResultEnumerator;
-interface mozISqlInputStream;
-
-/**
- * @status UNDER_DEVELOPMENT
- */
-
-[scriptable, uuid(08c220b0-7140-456a-89e9-c94609a7392d)]
-interface mozISqlResult : nsISupports
-{
-
-  readonly attribute mozISqlConnection connection;
-
-  readonly attribute AString query;
-
-  readonly attribute AString tableName;
-
-  readonly attribute long rowCount;
-
-  readonly attribute long columnCount;
-
-  AString getColumnName(in long aColumnIndex);
-
-  long getColumnIndex(in AString aColumnName);
-
-  const long TYPE_STRING        = 1;
-  const long TYPE_INT           = 2;
-  const long TYPE_FLOAT         = 3;
-  const long TYPE_DECIMAL       = 4;
-  const long TYPE_DATE	        = 5;
-  const long TYPE_TIME	        = 6;
-  const long TYPE_DATETIME      = 7;
-  const long TYPE_BOOL	        = 8;
-  
-  long getColumnType(in long aColumnIndex);
-
-  AString getColumnTypeAsString(in long aColumnIndex);
-
-  long getColumnDisplaySize(in long aColumnIndex);
-
-  mozISqlResultEnumerator enumerate();
-
-  mozISqlInputStream open();
-
-  void reload();
-
-};

mozilla/extensions/sql/base/public/mozISqlResultEnumerator.idl

@@ -1,126 +0,0 @@
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla Public License Version
- * 1.1 (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- * http://www.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 2001
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *   Jan Varga <varga@utcru.sk>
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#include "nsISupports.idl"
-
-interface nsIVariant;
-
-/**
- * @status UNDER_DEVELOPMENT
- */
-
-[scriptable, uuid(dcc0d29e-2b44-460e-b39f-89121ff8b963)]
-interface mozISqlResultEnumerator : nsISupports
-{
-
-  readonly attribute AString errorMessage;
-
-  boolean next();
-
-  boolean previous();
-
-  void beforeFirst();
-
-  void first();
-
-  void last();
-
-  void relative(in long aRows);
-
-  void absolute(in long aRowIndex);
-
-
-  boolean isNull(in long aColumnIndex);
-
-  nsIVariant getVariant(in long aColumnIndex);
-
-  AString getString(in long aColumnIndex);
-
-  long getInt(in long aColumnIndex);
-
-  float getFloat(in long aColumnIndex);
-
-  float getDecimal(in long aColumnIndex);
-
-  long long getDate(in long aColumnIndex);
-
-  boolean getBool(in long aColumnIndex);
-
-
-  void setNull(in long aColumnIndex);
-
-  void setDefault(in long aColumnIndex);
-
-  void copy(in long aColumnIndex);
-
-  void setVariant(in long aColumnIndex, in nsIVariant aValue);
-
-  void setString(in long aColumnIndex, in AString aValue);
-
-  void setInt(in long aColumnIndex, in long aValue);
-
-  void setFloat(in long aColumnIndex, in float aValue);
-
-  void setDecimal(in long aColumnIndex, in float aValue);
-
-  void setDate(in long aColumnIndex, in long long aValue);
-
-  void setBool(in long aColumnIndex, in boolean aValue);
-
-
-  void setNullValues();
-
-  void setDefaultValues();
-
-  void copyValues();
-
-
-  boolean canInsert();
-
-  boolean canUpdate();
-
-  boolean canDelete();
-
-  long insertRow();
-  
-  long updateRow();
-
-  long deleteRow();
-
-  readonly attribute AString currentCondition;
-
-};

mozilla/extensions/sql/base/public/mozISqlService.idl

@@ -1,81 +0,0 @@
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla Public License Version
- * 1.1 (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- * http://www.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 2001
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *   Jan Varga <varga@utcru.sk>
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#include "nsISupports.idl"
-
-interface mozISqlConnection;
-
-/**
- * @status UNDER_DEVELOPMENT
- */
-
-[scriptable, uuid(1ceb35b7-daa8-4ce4-ac67-125fb17cb019)]
-interface mozISqlService : nsISupports
-{
-
-  readonly attribute AString errorMessage;
-
-  void addAlias(in ACString aURI,
-                in AString aName,
-                in AString aType,
-                in AString aHostname,
-                in long aPort,
-                in AString aDatabase);
-
-  boolean hasAlias(in ACString aURI);
-
-  void getAlias(in ACString aURI,
-                out AString aName,
-                out AString aType,
-                out AString aHostname,
-                out long aPort,
-                out AString aDatabase);
-
-  void updateAlias(in ACString aURI,
-                   in AString aName,
-                   in AString aType,
-                   in AString aHostname,
-                   in long aPort,
-                   in AString aDatabase);
-
-  void removeAlias(in ACString aURI);
-
-  mozISqlConnection getConnection(in ACString aURI);
-
-  mozISqlConnection getNewConnection(in ACString aURI);
-
-};

mozilla/extensions/sql/base/resources/Makefile.in

@@ -1,6 +0,0 @@
-DEPTH		= ../../../..
-topsrcdir	= @top_srcdir@
-srcdir		= @srcdir@
-VPATH		= @srcdir@
-
-include $(topsrcdir)/config/rules.mk

mozilla/extensions/sql/base/resources/content/aliasDialog.js

@@ -1,39 +0,0 @@
-var sqlService = null;
-
-var name;
-var type;
-var hostname;
-var port;
-var database;
-
-function init() {
-  sqlService = Components.classes["@mozilla.org/sql/service;1"]
-              .getService(Components.interfaces.mozISqlService);
-
-  name = document.getElementById("name");
-  type = document.getElementById("type");
-  hostname = document.getElementById("hostname");
-  port = document.getElementById("port");
-  database = document.getElementById("database");
-
-  if (window.arguments) {
-    // get original values
-    var uri = window.arguments[0];
-    sqlService.getAlias(uri, name, type, hostname, port, database);
-  }
-}
-
-function onAccept() {
-  if (window.arguments) {
-    // update an existing alias
-    var uri = window.arguments[0];
-    sqlService.updateAlias(uri, name.value, type.value, hostname.value,
-                           port.value, database.value);
-  }
-  else {
-    // add a new database
-    var uri = "urn:aliases:" + name.value;
-    sqlService.addAlias(uri, name.value, type.value, hostname.value,
-                        port.value, database.value);
-  }
-}

mozilla/extensions/sql/base/resources/content/aliasDialog.xul

@@ -1,46 +0,0 @@
-<?xml version="1.0"?>
-
-<?xml-stylesheet href="chrome://communicator/skin/" type="text/css"?>
-
-<!DOCTYPE dialog SYSTEM "chrome://sql/locale/aliasDialog.dtd">
-
-<dialog id="aliasDialog"
-  xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
-  title="&window.title;"
-  width="250" height="180"
-  buttons="accept,cancel" buttonpack="center"
-  ondialogaccept="return onAccept(event);"
-  onload="init()">
-
-  <script type="application/x-javascript" src="aliasDialog.js"/>
-
-  <grid flex="1">
-    <columns>
-      <column/>
-      <column flex="1"/>
-    </columns>
-    <rows>
-      <row>
-        <label value="&name.label;"/>
-        <textbox id="name"/>
-      </row>
-      <row>
-        <label value="&type.label;"/>
-        <textbox id="type"/>
-      </row>
-      <row>
-        <label value="&hostname.label;"/>
-        <textbox id="hostname"/>
-      </row>
-      <row>
-        <label value="&port.label;"/>
-        <textbox id="port"/>
-      </row>
-      <row>
-        <label value="&database.label;"/>
-        <textbox id="database"/>
-      </row>
-    </rows>
-  </grid>
-
-</dialog>

mozilla/extensions/sql/base/resources/content/contents.rdf

@@ -1,21 +0,0 @@
-<?xml version="1.0"?>
-<RDF:RDF xmlns:RDF="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-         xmlns:chrome="http://www.mozilla.org/rdf/chrome#">
-
-  <!-- list all the packages being supplied by this jar -->
-  <RDF:Seq about="urn:mozilla:package:root">
-    <RDF:li resource="urn:mozilla:package:sql"/>
-  </RDF:Seq>
-
-  <!-- package information -->
-  <RDF:Description about="urn:mozilla:package:sql"
-        chrome:displayName="SQL support"
-        chrome:author="mozilla.org"
-	chrome:authorURL="http://www.mozilla.org/projects/sql/index.html"
-        chrome:name="sql"
-        chrome:extension="true"
-	chrome:settingsURL="chrome://sql/content/sqlSettings.xul"
-	chrome:description="Allow applications to directly connect to SQL databases.">
-  </RDF:Description>
-
-</RDF:RDF>

mozilla/extensions/sql/base/resources/content/sqlSettings.js

@@ -1,36 +0,0 @@
-var sqlService = null;
-
-function getSqlService() {
-  if (! sqlService)
-    sqlService = Components.classes["@mozilla.org/sql/service;1"]
-                 .getService(Components.interfaces.mozISqlService);
-  return sqlService;
-}
-
-function getSelectedAlias() {
-  var tree = document.getElementById("aliasesTree");
-  return tree.builderView.getResourceAtIndex(tree.currentIndex).Value;
-}
-
-function updateButtons() {
-  var tree = document.getElementById("aliasesTree");
-  const buttons = ["updateButton", "removeButton"];
-  for (i = 0; i < buttons.length; i++)
-    document.getElementById(buttons[i]).disabled = tree.currentIndex < 0;
-}
-
-function addAlias() {
-  window.openDialog("aliasDialog.xul", "addAlias", "chrome,modal=yes,resizable=no,centerscreen");
-}
-
-function updateAlias() {
-  var alias = getSelectedAlias();
-  window.openDialog("aliasDialog.xul", "updateDatabase", "chrome,modal=yes,resizable=no,centerscreen", alias);
-}
-
-function removeAlias() {
-  var sqlService = getSqlService();
-  var alias = getSelectedAlias();
-  sqlService.removeAlias(alias);  
-  updateButtons();
-}

mozilla/extensions/sql/base/resources/content/sqlSettings.xul

@@ -1,55 +0,0 @@
-<?xml version="1.0"?>
-
-<?xml-stylesheet href="chrome://global/skin/" type="text/css"?>
-
-<!DOCTYPE dialog SYSTEM "chrome://sql/locale/sqlSettings.dtd">
-
-<dialog xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
-        title="&header.label;"
-        width="450" height="350">
-
-  <script type="application/x-javascript" src="sqlSettings.js"/>
-
-  <groupbox flex="1">
-    <caption label="&aliases.label;"/>
-    <hbox flex="1">
-      <tree id="aliasesTree" flex="1"
-            seltype="single"
-            datasources="rdf:sql" ref="SQL:AliasesRoot" flags="dont-build-content"
-            onselect="updateButtons()">
-        <treecols>
-          <treecol id="nameCol" flex="1" label="&nameCol.label;"
-                   sort="rdf:http://www.mozilla.org/SQL-rdf#name"
-                   sortActive="true" sortDirection="ascending"/>
-          <treecol id="typeCol" flex="1" label="&typeCol.label;"
-                   sort="rdf:http://www.mozilla.org/SQL-rdf#type"/>
-          <treecol id="hostnameCol" flex="1" label="&hostnameCol.label;"
-                   sort="rdf:http://www.mozilla.org/SQL-rdf#hostname"/>
-          <treecol id="portCol" flex="1" label="&portCol.label;"
-                   sort="rdf:http://www.mozilla.org/SQL-rdf#port"/>
-          <treecol id="databaseCol" flex="1" label="&databaseCol.label;"
-                   sort="rdf:http://www.mozilla.org/SQL-rdf#database"/>
-        </treecols>
-        <template>
-          <treechildren>
-            <treeitem uri="rdf:*">
-              <treerow>
-                <treecell label="rdf:http://www.mozilla.org/SQL-rdf#name"/>
-                <treecell label="rdf:http://www.mozilla.org/SQL-rdf#type"/>
-                <treecell label="rdf:http://www.mozilla.org/SQL-rdf#hostname"/>
-                <treecell label="rdf:http://www.mozilla.org/SQL-rdf#port"/>
-                <treecell label="rdf:http://www.mozilla.org/SQL-rdf#database"/>
-              </treerow>
-            </treeitem>
-          </treechildren>
-        </template>
-      </tree>
-      <vbox>
-        <button id="addButton" label="&add.label;" oncommand="addAlias()"/>
-        <button id="updateButton" label="&update.label;" disabled="true" oncommand="updateAlias()"/>
-        <button id="removeButton" label="&remove.label;" disabled="true" oncommand="removeAlias()"/>
-      </vbox>
-    </hbox>
-  </groupbox>
-
-</dialog>

mozilla/extensions/sql/base/resources/jar.mn

@@ -1,9 +0,0 @@
-sql.jar:
-    content/sql/contents.rdf				(content/contents.rdf)
-    content/sql/sqlSettings.xul				(content/sqlSettings.xul)
-    content/sql/sqlSettings.js				(content/sqlSettings.js)
-    content/sql/aliasDialog.xul				(content/aliasDialog.xul)
-    content/sql/aliasDialog.js				(content/aliasDialog.js)
-    locale/en-US/sql/contents.rdf			(locale/en-US/contents.rdf)
-    locale/en-US/sql/sqlSettings.dtd			(locale/en-US/sqlSettings.dtd)
-    locale/en-US/sql/aliasDialog.dtd			(locale/en-US/aliasDialog.dtd)

mozilla/extensions/sql/base/resources/locale/en-US/aliasDialog.dtd

@@ -1,7 +0,0 @@
-<!ENTITY window.title "Alias">
-
-<!ENTITY name.label "Name:">
-<!ENTITY type.label "Type:">
-<!ENTITY hostname.label "Hostname:">
-<!ENTITY port.label "Port:">
-<!ENTITY database.label "Database:">

mozilla/extensions/sql/base/resources/locale/en-US/contents.rdf

@@ -1,23 +0,0 @@
-<?xml version="1.0"?>
-<RDF:RDF xmlns:RDF="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-         xmlns:chrome="http://www.mozilla.org/rdf/chrome#">
-
-  <!-- list all the locales being supplied by this package -->
-  <RDF:Seq about="urn:mozilla:locale:root">
-    <RDF:li resource="urn:mozilla:locale:en-US"/>
-  </RDF:Seq>
-
-  <!-- locale information -->
-  <RDF:Description about="urn:mozilla:locale:en-US"
-        chrome:displayName="English(US)"
-        chrome:author="mozilla.org"
-        chrome:name="en-US"
-        chrome:previewURL="http://www.mozilla.org/locales/en-US.gif">
-    <chrome:packages>
-      <RDF:Seq about="urn:mozilla:locale:en-US:packages">
-        <RDF:li resource="urn:mozilla:locale:en-US:sql"/>
-      </RDF:Seq>
-    </chrome:packages>
-  </RDF:Description>
-
-</RDF:RDF>

mozilla/extensions/sql/base/resources/locale/en-US/sqlSettings.dtd

@@ -1,12 +0,0 @@
-<!ENTITY header.label "SQL support">
-
-<!ENTITY aliases.label "Aliases">
-<!ENTITY nameCol.label "Name">
-<!ENTITY typeCol.label "Type">
-<!ENTITY hostnameCol.label "Hostname">
-<!ENTITY portCol.label "Port">
-<!ENTITY databaseCol.label "Database">
-
-<!ENTITY add.label "Add alias">
-<!ENTITY update.label "Update alias">
-<!ENTITY remove.label "Remove alias">

mozilla/extensions/sql/base/src/Makefile.in

@@ -1,33 +0,0 @@
-DEPTH		= ../../../..
-topsrcdir	= @top_srcdir@
-srcdir		= @srcdir@
-VPATH		= @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-MODULE		= sql
-LIBRARY_NAME	= sqlbase_s
-REQUIRES	= xpcom \
-		  string \
-		  unicharutil \
-		  locale \
-		  necko \
-		  rdf \
-		  windowwatcher \
-		  $(NULL)
-
-CPPSRCS		= \
-		  mozSqlConnection.cpp \
-		  mozSqlRequest.cpp \
-		  mozSqlResult.cpp \
-		  mozSqlService.cpp
-
-EXPORTS		= \
-		  mozSqlConnection.h \
-		  mozSqlRequest.h \
-		  mozSqlResult.h \
-		  mozSqlService.h
-
-FORCE_STATIC_LIB=1
-
-include $(topsrcdir)/config/rules.mk

mozilla/extensions/sql/base/src/mozSqlConnection.cpp

@@ -1,237 +0,0 @@
-#include "nsIProxyObjectManager.h"
-#include "mozSqlRequest.h"
-#include "mozSqlConnection.h"
-
-mozSqlConnection::mozSqlConnection()
-  : mLock(nsnull),
-    mCondVar(nsnull),
-    mThread(nsnull),
-    mShutdown(PR_FALSE),
-    mWaiting(PR_FALSE)
-{
-  NS_INIT_ISUPPORTS();
-  mExecLock = PR_NewLock();
-}
-
-mozSqlConnection::~mozSqlConnection()
-{
-  mRequests.Clear();
-
-  if (mCondVar)
-    PR_DestroyCondVar(mCondVar);
-  PR_DestroyLock(mExecLock);
-  if (mLock)
-    PR_DestroyLock(mLock);
-}
-
-// We require a special implementation of Release, which knows about
-// a circular strong reference
-NS_IMPL_THREADSAFE_ADDREF(mozSqlConnection)
-NS_IMPL_THREADSAFE_QUERY_INTERFACE3(mozSqlConnection,
-                                    mozISqlConnection,
-                                    nsIRunnable,
-				    nsISupportsWeakReference)
-NS_IMETHODIMP_(nsrefcnt)
-mozSqlConnection::Release()
-{
-  PR_AtomicDecrement((PRInt32*)&mRefCnt);
-  // Delete if the last reference is our strong circular reference.
-  if (mThread && mRefCnt == 1) {
-    PR_Lock(mLock);
-    mRequests.Clear();
-    mShutdown = PR_TRUE;
-    if (mWaiting)
-      PR_NotifyCondVar(mCondVar);
-    else
-      CancelExec();
-    PR_Unlock(mLock);
-    return 0;
-  }
-  else if (mRefCnt == 0) {
-    delete this;
-    return 0;
-  }
-  return mRefCnt;
-}
-
-NS_IMETHODIMP
-mozSqlConnection::GetServerVersion(nsAString& aServerVersion) 
-{
-  aServerVersion = mServerVersion;
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-mozSqlConnection::GetErrorMessage(nsAString& aErrorMessage) 
-{
-  aErrorMessage = mErrorMessage;
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-mozSqlConnection::GetLastID(PRInt32* aLastID) 
-{
-  *aLastID = mLastID;
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-mozSqlConnection::Init(const nsAString & aHost, PRInt32 aPort,
-                       const nsAString & aDatabase, const nsAString & aUsername,
-                       const nsAString & aPassword)
-{
-  // descendants have to implement this themselves
-  return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-NS_IMETHODIMP
-mozSqlConnection::ExecuteQuery(const nsAString& aQuery, mozISqlResult** _retval)
-{
-  PR_Lock(mExecLock);
-  nsresult rv = RealExec(aQuery, _retval, nsnull);
-  PR_Unlock(mExecLock);
-  return rv;
-}
-
-NS_IMETHODIMP
-mozSqlConnection::ExecuteUpdate(const nsAString& aUpdate, PRInt32* _retval)
-{
-  PR_Lock(mExecLock);
-  nsresult rv = RealExec(aUpdate, nsnull, _retval);
-  PR_Unlock(mExecLock);
-  return rv;
-}
-
-NS_IMETHODIMP
-mozSqlConnection::AsyncExecuteQuery(const nsAString& aQuery, nsISupports* aCtxt, 
-                                    mozISqlRequestObserver* aObserver,
-                                    mozISqlRequest **_retval)
-{
-  if (!mThread) {
-    mLock = PR_NewLock();
-    mCondVar = PR_NewCondVar(mLock);
-    NS_NewThread(getter_AddRefs(mThread), this, 0, PR_UNJOINABLE_THREAD);
-  }
-
-  mozSqlRequest* request = new mozSqlRequest(this);
-  if (! request)
-    return NS_ERROR_OUT_OF_MEMORY;
-
-  request->mIsQuery = PR_TRUE;
-  request->mQuery = aQuery;
-  request->mCtxt = aCtxt;
-
-  nsresult rv = NS_GetProxyForObject(NS_CURRENT_EVENTQ,
-                                     NS_GET_IID(mozISqlRequestObserver),
-                                     aObserver,
-                                     PROXY_SYNC | PROXY_ALWAYS,
-                                     getter_AddRefs(request->mObserver));
-  if (NS_FAILED(rv))
-    return rv;
-
-  PR_Lock(mLock);
-  mRequests.AppendObject(request);
-  if (mWaiting && mRequests.Count() == 1)
-    PR_NotifyCondVar(mCondVar);
-  PR_Unlock(mLock);
-
-  NS_ADDREF(*_retval = request);
-
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-mozSqlConnection::AsyncExecuteUpdate(const nsAString& aQuery, nsISupports* aCtxt, 
-                                     mozISqlRequestObserver* aObserver,
-                                     mozISqlRequest **_retval)
-{
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-mozSqlConnection::BeginTransaction()
-{
-  PRInt32 affectedRows;
-  return ExecuteUpdate(NS_LITERAL_STRING("begin"), &affectedRows);
-}
-
-NS_IMETHODIMP
-mozSqlConnection::CommitTransaction()
-{
-  PRInt32 affectedRows;
-  return ExecuteUpdate(NS_LITERAL_STRING("commit"), &affectedRows);
-}
-
-NS_IMETHODIMP
-mozSqlConnection::RollbackTransaction()
-{
-  PRInt32 affectedRows;
-  return ExecuteUpdate(NS_LITERAL_STRING("rollback"), &affectedRows);
-}
-
-NS_IMETHODIMP
-mozSqlConnection::GetPrimaryKeys(const nsAString& aSchema, const nsAString& aTable, mozISqlResult** _retval)
-{
-  // descendants have to implement this themselves
-  return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-NS_IMETHODIMP
-mozSqlConnection::Run()
-{
-  while(!mShutdown) {
-    PR_Lock(mLock);
-
-    while (mRequests.Count()) {
-      mCurrentRequest = mRequests[0];
-      mRequests.RemoveObjectAt(0);
-
-
-      mozSqlRequest* r = (mozSqlRequest*)mCurrentRequest.get();
-
-      r->mObserver->OnStartRequest(mCurrentRequest, r->mCtxt);
-
-      r->mStatus = mozISqlRequest::STATUS_EXECUTED;
-
-      PR_Unlock(mLock);
-
-      nsresult rv = ExecuteQuery(r->mQuery, getter_AddRefs(r->mResult));
-
-      PR_Lock(mLock);
-
-      if (NS_SUCCEEDED(rv))
-        r->mStatus = mozISqlRequest::STATUS_COMPLETE;
-      else {
-        r->mStatus = mozISqlRequest::STATUS_ERROR;
-	GetErrorMessage(r->mErrorMessage);
-      }
-        
-      r->mObserver->OnStopRequest(mCurrentRequest, r->mCtxt);
-
-      mCurrentRequest = nsnull;
-
-    }
-    
-    mWaiting = PR_TRUE;
-    PR_WaitCondVar(mCondVar, PR_INTERVAL_NO_TIMEOUT);
-    mWaiting = PR_FALSE;
-    PR_Unlock(mLock);
-  }
-
-  return NS_OK;
-}
-
-nsresult
-mozSqlConnection::CancelRequest(mozISqlRequest* aRequest)
-{
-  PR_Lock(mLock);
-  if (mCurrentRequest == aRequest)
-    CancelExec();
-  else {
-    if (mRequests.RemoveObject(aRequest))
-      ((mozSqlRequest*)aRequest)->mStatus = mozISqlRequest::STATUS_CANCELLED;
-  }
-  PR_Unlock(mLock);
-
-  return NS_OK;
-}

mozilla/extensions/sql/base/src/mozSqlConnection.h

@@ -1,53 +0,0 @@
-#ifndef mozSqlConnection_h
-#define mozSqlConnection_h                                                  
-
-#include "prcvar.h"
-#include "nsString.h"
-#include "nsCOMArray.h"
-#include "nsWeakReference.h"
-#include "nsIThread.h"
-#include "nsIRunnable.h"
-#include "mozISqlConnection.h"
-#include "mozISqlRequest.h"
-#include "mozISqlResult.h"
-
-class mozSqlConnection : public mozISqlConnection,
-                         public nsIRunnable,
-                         public nsSupportsWeakReference
-{
-  public:
-    mozSqlConnection();
-    virtual ~mozSqlConnection();
-
-    NS_DECL_ISUPPORTS
-
-    NS_DECL_MOZISQLCONNECTION
-
-    NS_DECL_NSIRUNNABLE
-
-    friend class mozSqlRequest;
-    friend class mozSqlResult;
-
-  protected:
-    virtual nsresult RealExec(const nsAString& aQuery,
-                              mozISqlResult** aResult, PRInt32* aAffectedRows) = 0;
-    virtual nsresult CancelExec() = 0;
-    virtual nsresult GetIDName(nsAString& aIDName) = 0;
-
-    nsresult CancelRequest(mozISqlRequest* aRequest);
-
-    nsString                    mServerVersion;
-    nsString                    mErrorMessage;
-    PRInt32                     mLastID;
-
-    PRLock*                     mLock;
-    PRCondVar*                  mCondVar;
-    PRLock*                     mExecLock;
-    nsCOMPtr<nsIThread>         mThread;
-    nsCOMArray<mozISqlRequest>  mRequests;
-    nsCOMPtr<mozISqlRequest>    mCurrentRequest;
-    PRBool                      mShutdown;
-    PRBool                      mWaiting;
-};
-
-#endif // mozSqlConnection_h

mozilla/extensions/sql/base/src/mozSqlRequest.cpp

@@ -1,86 +0,0 @@
-#include "mozSqlConnection.h"
-#include "mozSqlRequest.h"
-
-mozSqlRequest::mozSqlRequest(mozISqlConnection* aConnection)
-  : mAffectedRows(-1),
-    mIsQuery(PR_TRUE),
-    mStatus(mozISqlRequest::STATUS_NONE)
-{
-  NS_INIT_ISUPPORTS();
-  mConnection = do_GetWeakReference(aConnection);
-}
-
-mozSqlRequest::~mozSqlRequest()
-{
-}
-
-
-NS_IMPL_THREADSAFE_ISUPPORTS1(mozSqlRequest,
-                              mozISqlRequest);
-
-NS_IMETHODIMP
-mozSqlRequest::GetErrorMessage(nsAString & aErrorMessage)
-{
-  aErrorMessage = mErrorMessage;
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-mozSqlRequest::GetResult(mozISqlResult * *aResult)
-{
-  NS_IF_ADDREF(*aResult = mResult);
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-mozSqlRequest::GetAffectedRows(PRInt32 *aAffectedRows)
-{
-  *aAffectedRows = mAffectedRows;
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-mozSqlRequest::GetLastID(PRInt32* aLastID)
-{
-  *aLastID = mLastID;
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-mozSqlRequest::GetQuery(nsAString & aQuery)
-{
-  aQuery = mQuery;
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-mozSqlRequest::GetCtxt(nsISupports * *aCtxt)
-{
-  NS_IF_ADDREF(*aCtxt = mCtxt);
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-mozSqlRequest::GetObserver(mozISqlRequestObserver * *aObserver)
-{
-  NS_IF_ADDREF(*aObserver = mObserver);
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-mozSqlRequest::GetStatus(PRInt32 *aStatus)
-{
-  *aStatus = mStatus;
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-mozSqlRequest::Cancel()
-{
-  nsCOMPtr<mozISqlConnection> connection = do_QueryReferent(mConnection);
-  if (!connection)
-    return NS_ERROR_FAILURE;
-
-  mozISqlConnection* connectionRaw = connection.get();
-  return ((mozSqlConnection*)connectionRaw)->CancelRequest(this);
-}

mozilla/extensions/sql/base/src/mozSqlRequest.h

@@ -1,41 +0,0 @@
-#ifndef mozSqlRequest_h
-#define mozSqlRequest_h                                                  
-
-#include "nsString.h"
-#include "nsCOMPtr.h"
-#include "nsIWeakReference.h"
-#include "mozISqlConnection.h"
-#include "mozISqlResult.h"
-#include "mozISqlRequest.h"
-#include "mozISqlRequestObserver.h"
-
-class mozSqlRequest : public mozISqlRequest
-{
-  public:
-    mozSqlRequest(mozISqlConnection* aConnection);
-    virtual ~mozSqlRequest();
-
-    NS_DECL_ISUPPORTS
-
-    NS_DECL_MOZISQLREQUEST
-
-    friend class mozSqlConnection;
-
-  protected:
-    nsCOMPtr<nsIWeakReference>          mConnection;
-
-    nsString                            mErrorMessage;
-    nsCOMPtr<mozISqlResult>             mResult;
-    PRInt32                             mAffectedRows;
-    PRInt32                             mLastID;
-
-    PRBool                              mIsQuery;
-    nsString                            mQuery;
-    nsCOMPtr<nsISupports>               mCtxt;
-    nsCOMPtr<mozISqlRequestObserver>    mObserver;
-
-    PRInt32                             mStatus;
-
-};
-
-#endif // mozSqlRequest_h

mozilla/extensions/sql/base/src/mozSqlResult.h

@@ -1,367 +0,0 @@
-#ifndef mozSqlResult_h
-#define mozSqlResult_h                                                  
-
-#include "nsCRT.h"
-#include "nsFixedSizeAllocator.h"
-#include "nsVoidArray.h"
-#include "nsCOMArray.h"
-#include "nsHashtable.h"
-#include "nsCOMPtr.h"
-#include "nsWeakReference.h"
-#include "nsISimpleEnumerator.h"
-#include "nsIRDFService.h"
-#include "nsIRDFDataSource.h"
-#include "nsIRDFRemoteDataSource.h"
-#include "nsIDateTimeFormat.h"
-#include "nsIInputStream.h"
-#include "mozISqlConnection.h"
-#include "mozISqlDataSource.h"
-#include "mozISqlResult.h"
-#include "mozISqlResultEnumerator.h"
-#include "mozISqlInputStream.h"
-
-#define CELL_FLAG_NULL          0x80
-#define CELL_FLAG_DEFAULT       0x40
-#define CELL_FLAG_MASK          ~(CELL_FLAG_NULL | CELL_FLAG_DEFAULT)
-
-class ColumnInfo {
-  public:
-    static ColumnInfo*
-    Create(nsFixedSizeAllocator& aAllocator,
-           PRUnichar* aName,
-	   PRInt32 aType,
-	   PRInt32 aSize,
-	   PRInt32 aMod,
-           nsIRDFResource* aProperty) {
-      void* place = aAllocator.Alloc(sizeof(ColumnInfo));
-      return place ? ::new(place) ColumnInfo(aName, aType, aSize, aMod, aProperty) : nsnull;
-    }
-
-    static void
-    Destroy(nsFixedSizeAllocator& aAllocator, ColumnInfo* aColumnInfo) {
-      aColumnInfo->~ColumnInfo();
-      aAllocator.Free(aColumnInfo, sizeof(ColumnInfo));
-    }
-
-    ColumnInfo(PRUnichar* aName, PRInt32 aType, PRInt32 aSize, PRInt32 aMod, nsIRDFResource* aProperty)
-      : mName(aName),
-        mType(aType),
-        mSize(aSize),
-        mMod(aMod),
-	mProperty(aProperty) {
-      NS_IF_ADDREF(mProperty);
-    }
-
-    ~ColumnInfo() {
-      if (mName)
-        nsMemory::Free(mName);
-      NS_IF_RELEASE(mProperty);
-    }
-
-    PRUnichar*          mName;
-    PRInt32             mType;
-    PRInt32             mSize;
-    PRInt32             mMod;
-    nsIRDFResource*     mProperty;
-
-  private:
-    // Hide so that only Create() and Destroy() can be used to
-    // allocate and deallocate from the heap
-    static void* operator new(size_t) CPP_THROW_NEW { return 0; } 
-    static void operator delete(void*, size_t) {}
-};
-
-class Cell {
-  public:
-    static Cell*
-    Create(nsFixedSizeAllocator& aAllocator,
-           PRInt32 aType) {
-      void* place = aAllocator.Alloc(sizeof(Cell));
-      return place ? ::new(place) Cell(aType) : nsnull;
-    }
-
-    static Cell*
-    Create(nsFixedSizeAllocator& aAllocator,
-           PRInt32 aType,
-           Cell* aSrcCell) {
-      void* place = aAllocator.Alloc(sizeof(Cell));
-      if (! place)
-        return nsnull;
-      Cell* newCell = ::new(place) Cell(aType);
-      Copy(aSrcCell, newCell);
-      return newCell;
-    }
-
-    static void
-    Copy(Cell* aSrcCell, Cell* aDestCell) {
-      if (aSrcCell->IsNull())
-        aDestCell->SetNull(PR_TRUE);
-      else {
-        aDestCell->SetNull(PR_FALSE);
-        PRInt32 type = aSrcCell->GetType();
-        if (type == mozISqlResult::TYPE_STRING)
-          aDestCell->SetString(nsCRT::strdup(aSrcCell->mString));
-        else if (type == mozISqlResult::TYPE_INT)
-          aDestCell->mInt = aSrcCell->mInt;
-        else if (type == mozISqlResult::TYPE_FLOAT ||
-                 type == mozISqlResult::TYPE_DECIMAL)
-          aDestCell->mFloat = aSrcCell->mFloat;
-        else if (type == mozISqlResult::TYPE_DATE ||
-                 type == mozISqlResult::TYPE_TIME ||
-                 type == mozISqlResult::TYPE_DATETIME)
-          aDestCell->mDate = aSrcCell->mDate;
-        else if (type == mozISqlResult::TYPE_BOOL)
-          aDestCell->mBool = aSrcCell->mBool;
-      }
-    }
-
-    static void
-    Destroy(nsFixedSizeAllocator& aAllocator, Cell* aCell) {
-      aCell->~Cell();
-      aAllocator.Free(aCell, sizeof(Cell));
-    }
-
-    Cell(PRInt32 aType)
-      : mString(nsnull),
-        mType(aType | CELL_FLAG_NULL) {
-    }
-
-    ~Cell() {
-      if ((GetType() == mozISqlResult::TYPE_STRING) && mString) {
-        nsMemory::Free(mString);
-      }
-    }
-
-    void SetString(PRUnichar* aString) {
-     if (mString)
-        nsMemory::Free(mString);
-      mString = aString;
-    }
-
-    PRInt32 GetType() {
-      return mType & CELL_FLAG_MASK;
-    }
-
-    void SetNull(PRBool aNull) {
-      mType &= CELL_FLAG_MASK;
-      if (aNull)
-        mType |= CELL_FLAG_NULL;
-    }
-
-    void SetDefault(PRBool aDefault) {
-      mType &= CELL_FLAG_MASK;
-      if (aDefault)
-        mType |= CELL_FLAG_DEFAULT;
-    }
-
-    PRBool IsNull() {
-      return mType & CELL_FLAG_NULL;
-    }
-
-    PRBool IsDefault() {
-      return mType & CELL_FLAG_DEFAULT;
-    }
-
-    union {
-      PRUnichar*        mString;
-      PRInt32           mInt;
-      float             mFloat;
-      PRInt64           mDate;
-      PRBool            mBool;
-    };
-
-  private:
-    static void* operator new(size_t) CPP_THROW_NEW { return 0; } 
-    static void operator delete(void*, size_t) {}
-
-    PRInt8              mType;
-};
-
-class Row {
-  public:
-    static Row*
-    Create(nsFixedSizeAllocator& aAllocator,
-           nsIRDFResource* aSource,
-           nsVoidArray& aColumnInfo) {
-      void* place = aAllocator.Alloc(sizeof(Row));
-      if (! place)
-        return nsnull;
-      Row* newRow = ::new(place) Row(aSource, aColumnInfo.Count());
-      for (PRInt32 i = 0; i < aColumnInfo.Count(); i++) {
-        Cell* newCell = Cell::Create(aAllocator, ((ColumnInfo*)aColumnInfo[i])->mType);
-        newRow->mCells[i] = newCell;
-      }
-      return newRow;
-    }
-
-    static Row*
-    Create(nsFixedSizeAllocator& aAllocator,
-           nsIRDFResource* aSource,
-           nsVoidArray& aColumnInfo,
-           Row* aSrcRow) {
-      void* place = aAllocator.Alloc(sizeof(Row));
-      if (! place)
-        return nsnull;
-      Row* newRow = ::new(place) Row(aSource, aColumnInfo.Count());
-      for (PRInt32 i = 0; i < aColumnInfo.Count(); i++) {
-        Cell* srcCell = aSrcRow->mCells[i];
-        Cell* newCell = Cell::Create(aAllocator, ((ColumnInfo*)aColumnInfo[i])->mType, srcCell);
-        newRow->mCells[i] = newCell;
-      }
-      return newRow;
-    }
-
-    static void
-    Copy(PRInt32 aColumnCount, Row* aSrcRow, Row* aDestRow) {
-      for (PRInt32 i = 0; i < aColumnCount; i++) {
-        Cell* srcCell = aSrcRow->mCells[i];
-        Cell* destCell = aDestRow->mCells[i];
-        Cell::Copy(srcCell, destCell);
-      }
-    }
-
-    static void
-    Destroy(nsFixedSizeAllocator& aAllocator, PRInt32 aColumnCount, Row* aRow) {
-      for (PRInt32 i = 0; i < aColumnCount; i++)
-        Cell::Destroy(aAllocator, aRow->mCells[i]);
-      aRow->~Row();
-      aAllocator.Free(aRow, sizeof(*aRow));
-    }
-
-    Row(nsIRDFResource* aSource, PRInt32 aColumnCount)
-      : mSource(aSource)
-    {
-      NS_IF_ADDREF(mSource);
-      mCells = new Cell*[aColumnCount];
-    }
-
-    ~Row() {
-      delete[] mCells;
-      NS_IF_RELEASE(mSource);
-    }
-    
-    nsIRDFResource*     mSource;
-    Cell**              mCells;
-  private:
-    static void* operator new(size_t) CPP_THROW_NEW { return 0; } 
-    static void operator delete(void*, size_t) {}
-};
-
-class mozSqlResult : public mozISqlResult,
-                     public mozISqlDataSource,
-                     public nsIRDFDataSource,
-                     public nsIRDFRemoteDataSource
-{
-  public:
-    mozSqlResult(mozISqlConnection* aConnection,
-                 const nsAString& aQuery);
-    nsresult Init();
-    nsresult Rebuild();
-    virtual ~mozSqlResult();
-
-    NS_DECL_ISUPPORTS
-
-    NS_DECL_MOZISQLRESULT
-
-    NS_DECL_MOZISQLDATASOURCE
-
-    NS_DECL_NSIRDFDATASOURCE
-
-    NS_DECL_NSIRDFREMOTEDATASOURCE
-
-    friend class mozSqlResultEnumerator;
-    friend class mozSqlResultStream;
-
-  protected:
-    virtual nsresult BuildColumnInfo() = 0 ;
-    virtual nsresult BuildRows() = 0;
-    virtual void ClearNativeResult() = 0;
-
-    void ClearColumnInfo();
-    void ClearRows();
-
-    nsresult EnsureTableName();
-    nsresult EnsurePrimaryKeys();
-
-    void AppendValue(Cell* aCell, nsAutoString& aValues);
-    nsresult AppendKeys(Row* aRow, nsAutoString& aKeys);
-    nsresult GetValues(Row* aRow, mozISqlResult** aResult, PRBool aUseID);
-    nsresult CopyValues(mozISqlResult* aResult, Row* aRow);
-
-    virtual nsresult CanInsert(PRBool* _retval) = 0;
-    virtual nsresult CanUpdate(PRBool* _retval) = 0;
-    virtual nsresult CanDelete(PRBool* _retval) = 0;
-
-    nsresult InsertRow(Row* aSrcRow, PRInt32* _retval);
-    nsresult UpdateRow(PRInt32 aRowIndex, Row* aSrcRow, PRInt32* _retval);
-    nsresult DeleteRow(PRInt32 aRowIndex, PRInt32* _retval);
-    nsresult GetCondition(Row* aRow, nsAString& aCurrentCondition);
-
-    static PRInt32                      gRefCnt;
-    static nsIRDFService*               gRDFService;
-    static nsIDateTimeFormat*           gFormat;
-    static nsIRDFResource*              kSQL_ResultRoot;
-    static nsIRDFResource*              kNC_Child;
-    static nsIRDFLiteral*               kNullLiteral;
-    static nsIRDFLiteral*               kTrueLiteral;
-    static nsIRDFLiteral*               kFalseLiteral;
-
-    nsCOMPtr<mozISqlConnection>         mConnection;
-    nsString                            mErrorMessage;
-    nsString                            mQuery;
-    nsString                            mTableName;
-    nsFixedSizeAllocator                mAllocator;
-    nsAutoVoidArray                     mColumnInfo;
-    nsVoidArray                         mRows;
-    nsObjectHashtable                   mSources;
-    nsCOMArray<nsIRDFObserver>          mObservers;
-    nsCOMPtr<mozISqlResultEnumerator>   mPrimaryKeys;
-    PRInt32                             mCanInsert;
-    PRInt32                             mCanUpdate;
-    PRInt32                             mCanDelete;
-};
-
-class mozSqlResultEnumerator : public mozISqlResultEnumerator,
-                               public nsISimpleEnumerator
-{
-  public:
-    mozSqlResultEnumerator(mozSqlResult* aResult);
-    virtual ~mozSqlResultEnumerator();
-
-    NS_DECL_ISUPPORTS
-
-    NS_DECL_MOZISQLRESULTENUMERATOR
-
-    NS_DECL_NSISIMPLEENUMERATOR
-
-  private:
-    mozSqlResult*               mResult;
-    PRInt32                     mCurrentIndex;
-    Row*                        mCurrentRow;
-    Row*                        mBuffer;
-};
-
-class mozSqlResultStream : public mozISqlInputStream,
-                           public nsIInputStream
-{
-  public:
-    mozSqlResultStream(mozSqlResult* aResult);
-    virtual ~mozSqlResultStream();
-
-    NS_DECL_ISUPPORTS
-
-    NS_DECL_MOZISQLINPUTSTREAM
-
-    NS_DECL_NSIINPUTSTREAM
-
-  protected:
-    nsresult EnsureBuffer();
-
-  private:
-    mozSqlResult*               mResult;
-    char*                       mBuffer;
-    PRUint32                    mLength;
-    PRUint32                    mPosition;
-};
-
-#endif // mozSqlResult_h

mozilla/extensions/sql/base/src/mozSqlService.cpp

@@ -1,624 +0,0 @@
-#include "nsReadableUtils.h"
-#include "nsXPIDLString.h"
-#include "nsCRT.h"
-#include "nsIAtom.h"
-#include "nsISupportsUtils.h"
-#include "nsIServiceManager.h"
-#include "rdf.h"
-#include "nsRDFCID.h"
-#include "nsAppDirectoryServiceDefs.h"
-#include "nsNetUtil.h"
-#include "nsIRDFXMLSink.h"
-#include "nsIWindowWatcher.h"
-#include "nsIPrompt.h"
-#include "mozSqlService.h"
-#include "mozSqlConnection.h"
-
-#define SQL_NAMESPACE_URI "http://www.mozilla.org/SQL-rdf#"
-
-static NS_DEFINE_CID(kRDFServiceCID,            NS_RDFSERVICE_CID);
-static NS_DEFINE_CID(kRDFContainerUtilsCID,     NS_RDFCONTAINERUTILS_CID);
-
-nsIRDFService*          mozSqlService::gRDFService;
-nsIRDFContainerUtils*   mozSqlService::gRDFContainerUtils;
-
-nsIRDFResource*         mozSqlService::kSQL_AliasesRoot;
-nsIRDFResource*         mozSqlService::kSQL_Name;
-nsIRDFResource*         mozSqlService::kSQL_Type;
-nsIRDFResource*         mozSqlService::kSQL_Hostname;
-nsIRDFResource*         mozSqlService::kSQL_Port;
-nsIRDFResource*         mozSqlService::kSQL_Database;
-
-
-mozSqlService::mozSqlService()
-  : mConnectionCache(nsnull)
-{
-  NS_INIT_ISUPPORTS();
-}
-
-mozSqlService::~mozSqlService()
-{
-  gRDFService->UnregisterDataSource(this);
-
-  delete mConnectionCache;
-
-  NS_IF_RELEASE(kSQL_AliasesRoot);
-  NS_IF_RELEASE(kSQL_Name);
-  NS_IF_RELEASE(kSQL_Type);
-  NS_IF_RELEASE(kSQL_Hostname);
-  NS_IF_RELEASE(kSQL_Port);
-  NS_IF_RELEASE(kSQL_Database);
-
-  nsServiceManager::ReleaseService(kRDFContainerUtilsCID, gRDFContainerUtils);
-  gRDFContainerUtils = nsnull;
-
-  nsServiceManager::ReleaseService(kRDFServiceCID, gRDFService);
-  gRDFService = nsnull;
-}
-
-NS_IMPL_ISUPPORTS3(mozSqlService,
-                   mozISqlService,
-                   nsIRDFDataSource,
-                   nsIRDFRemoteDataSource);
-
-NS_IMETHODIMP
-mozSqlService::GetErrorMessage(nsAString& aErrorMessage)
-{
-  aErrorMessage = mErrorMessage;
-  return NS_OK;
-}
-
-nsresult
-mozSqlService::Init()
-{
-  nsresult rv;
-
-  rv = nsServiceManager::GetService(kRDFServiceCID, NS_GET_IID(nsIRDFService), 
-                                    (nsISupports**) &gRDFService);
-  if (NS_FAILED(rv)) return rv;
-
-  rv = nsServiceManager::GetService(kRDFContainerUtilsCID, NS_GET_IID(nsIRDFContainerUtils),
-                                    (nsISupports**) &gRDFContainerUtils);
-
-  if (NS_FAILED(rv)) return rv;
-
-  gRDFService->GetResource(NS_LITERAL_CSTRING("SQL:AliasesRoot"),
-                           &kSQL_AliasesRoot);
-  gRDFService->GetResource(NS_LITERAL_CSTRING(SQL_NAMESPACE_URI "name"),
-                           &kSQL_Name);
-  gRDFService->GetResource(NS_LITERAL_CSTRING(SQL_NAMESPACE_URI "type"),
-                           &kSQL_Type);
-  gRDFService->GetResource(NS_LITERAL_CSTRING(SQL_NAMESPACE_URI "hostname"),
-                           &kSQL_Hostname);
-  gRDFService->GetResource(NS_LITERAL_CSTRING(SQL_NAMESPACE_URI "port"),
-                           &kSQL_Port);
-  gRDFService->GetResource(NS_LITERAL_CSTRING(SQL_NAMESPACE_URI "database"),
-                           &kSQL_Database);
-
-  nsCOMPtr<nsIFile> file;
-  rv = NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR, getter_AddRefs(file));
-  if (NS_FAILED(rv)) return rv;
-  rv = file->AppendNative(NS_LITERAL_CSTRING("sql.rdf"));
-  if (NS_FAILED(rv)) return rv;
-
-  nsCAutoString sql;
-  NS_GetURLSpecFromFile(file, sql);
-
-  rv = gRDFService->GetDataSourceBlocking(sql.get(), getter_AddRefs(mInner));
-  if (NS_FAILED(rv)) return rv;
-  nsCOMPtr<nsIRDFXMLSink> sink = do_QueryInterface(mInner);
-  if (sink) {
-    nsCOMPtr<nsIAtom> prefix = getter_AddRefs(NS_NewAtom("SQL"));
-    sink->AddNameSpace(prefix, NS_ConvertASCIItoUCS2(SQL_NAMESPACE_URI));
-  }
-
-  return gRDFService->RegisterDataSource(this, PR_FALSE);
-}
-
-NS_IMETHODIMP
-mozSqlService::AddAlias(const nsACString& aURI,
-                        const nsAString& aName,
-                        const nsAString& aType,
-                        const nsAString& aHostname,
-                        PRInt32 aPort,
-                        const nsAString& aDatabase)
-{
-  nsCOMPtr<nsIRDFResource> resource;
-  gRDFService->GetResource(aURI, getter_AddRefs(resource));
-
-  nsCOMPtr<nsIRDFLiteral> rdfLiteral;
-  nsCOMPtr<nsIRDFInt> rdfInt;
-
-  gRDFService->GetLiteral(PromiseFlatString(aName).get(), getter_AddRefs(rdfLiteral));
-  mInner->Assert(resource, kSQL_Name, rdfLiteral, PR_TRUE);
-
-  gRDFService->GetLiteral(PromiseFlatString(aType).get(), getter_AddRefs(rdfLiteral));
-  mInner->Assert(resource, kSQL_Type, rdfLiteral, PR_TRUE);
-
-  gRDFService->GetLiteral(PromiseFlatString(aHostname).get(), getter_AddRefs(rdfLiteral));
-  mInner->Assert(resource, kSQL_Hostname, rdfLiteral, PR_TRUE);
-
-  gRDFService->GetIntLiteral(aPort, getter_AddRefs(rdfInt));
-  mInner->Assert(resource, kSQL_Port, rdfInt, PR_TRUE);
-
-  gRDFService->GetLiteral(PromiseFlatString(aDatabase).get(), getter_AddRefs(rdfLiteral));
-  mInner->Assert(resource, kSQL_Database, rdfLiteral, PR_TRUE);
-
-  nsresult rv = EnsureAliasesContainer();
-  if (NS_FAILED(rv))
-    return rv;
-  mAliasesContainer->AppendElement(resource);
-
-  Flush();
-
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-mozSqlService::HasAlias(const nsACString& aURI, PRBool* _retval)
-{
-  nsCOMPtr<nsIRDFResource> resource;
-  gRDFService->GetResource(aURI, getter_AddRefs(resource));
-
-  nsresult rv = EnsureAliasesContainer();
-  if (NS_FAILED(rv))
-    return rv;
-
-  PRInt32 aliasIndex;
-  mAliasesContainer->IndexOf(resource, &aliasIndex);
-
-  *_retval = aliasIndex != -1;
-
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-mozSqlService::GetAlias(const nsACString& aURI,
-                        nsAString& aName,
-                        nsAString& aType,
-                        nsAString& aHostname,
-                        PRInt32* aPort,
-                        nsAString& aDatabase)
-{
-  nsCOMPtr<nsIRDFResource> resource;
-  gRDFService->GetResource(aURI, getter_AddRefs(resource));
-
-  nsCOMPtr<nsIRDFNode> rdfNode;
-  nsCOMPtr<nsIRDFLiteral> rdfLiteral;
-  nsCOMPtr<nsIRDFInt> rdfInt;
-  const PRUnichar* value;
-  
-  mInner->GetTarget(resource, kSQL_Name, PR_TRUE, getter_AddRefs(rdfNode));
-  if (rdfNode) {
-    rdfLiteral = do_QueryInterface(rdfNode);
-    rdfLiteral->GetValueConst(&value);
-    aName.Assign(value);
-  }
-
-  mInner->GetTarget(resource, kSQL_Type, PR_TRUE, getter_AddRefs(rdfNode));
-  if (rdfNode) {
-    rdfLiteral = do_QueryInterface(rdfNode);
-    rdfLiteral->GetValueConst(&value);
-    aType.Assign(value);
-  }
-
-  mInner->GetTarget(resource, kSQL_Hostname, PR_TRUE, getter_AddRefs(rdfNode));
-  if (rdfNode) {
-    rdfLiteral = do_QueryInterface(rdfNode);
-    rdfLiteral->GetValueConst(&value);
-    aHostname.Assign(value);
-  }
-
-  mInner->GetTarget(resource, kSQL_Port, PR_TRUE, getter_AddRefs(rdfNode));
-  if (rdfNode) {
-    rdfInt = do_QueryInterface(rdfNode);
-    rdfInt->GetValue(aPort);
-  }
-
-  mInner->GetTarget(resource, kSQL_Database, PR_TRUE, getter_AddRefs(rdfNode));
-  if (rdfNode) {
-    rdfLiteral = do_QueryInterface(rdfNode);
-    rdfLiteral->GetValueConst(&value);
-    aDatabase.Assign(value);
-  }
-
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-mozSqlService::UpdateAlias(const nsACString& aURI,
-                           const nsAString& aName,
-                           const nsAString& aType,
-                           const nsAString& aHostname,
-                           PRInt32 aPort,
-                           const nsAString& aDatabase)
-{
-  nsCOMPtr<nsIRDFResource> resource;
-  gRDFService->GetResource(aURI, getter_AddRefs(resource));
-
-  nsCOMPtr<nsIRDFNode> rdfNode;
-  nsCOMPtr<nsIRDFLiteral> rdfLiteral;
-  nsCOMPtr<nsIRDFInt> rdfInt;
-
-  mInner->GetTarget(resource, kSQL_Name, PR_TRUE, getter_AddRefs(rdfNode));
-  gRDFService->GetLiteral(PromiseFlatString(aName).get(), getter_AddRefs(rdfLiteral));
-  mInner->Change(resource, kSQL_Name, rdfNode, rdfLiteral);
-
-  mInner->GetTarget(resource, kSQL_Type, PR_TRUE, getter_AddRefs(rdfNode));
-  gRDFService->GetLiteral(PromiseFlatString(aType).get(), getter_AddRefs(rdfLiteral));
-  mInner->Change(resource, kSQL_Type, rdfNode, rdfLiteral);
-
-  mInner->GetTarget(resource, kSQL_Hostname, PR_TRUE, getter_AddRefs(rdfNode));
-  gRDFService->GetLiteral(PromiseFlatString(aHostname).get(), getter_AddRefs(rdfLiteral));
-  mInner->Change(resource, kSQL_Hostname, rdfNode, rdfLiteral);
-
-  mInner->GetTarget(resource, kSQL_Port, PR_TRUE, getter_AddRefs(rdfNode));
-  gRDFService->GetIntLiteral(aPort, getter_AddRefs(rdfInt));
-  mInner->Change(resource, kSQL_Port, rdfNode, rdfInt);
-
-  mInner->GetTarget(resource, kSQL_Database, PR_TRUE, getter_AddRefs(rdfNode));
-  gRDFService->GetLiteral(PromiseFlatString(aDatabase).get(), getter_AddRefs(rdfLiteral));
-  mInner->Change(resource, kSQL_Database, rdfNode, rdfLiteral);
-
-  Flush();
-
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-mozSqlService::RemoveAlias(const nsACString &aURI)
-{
-  nsCOMPtr<nsIRDFResource> resource;
-  gRDFService->GetResource(aURI, getter_AddRefs(resource));
-
-  nsCOMPtr<nsIRDFNode> rdfNode;
-
-  mInner->GetTarget(resource, kSQL_Name, PR_TRUE, getter_AddRefs(rdfNode));
-  mInner->Unassert(resource, kSQL_Name, rdfNode);
-
-  mInner->GetTarget(resource, kSQL_Type, PR_TRUE, getter_AddRefs(rdfNode));
-  mInner->Unassert(resource, kSQL_Type, rdfNode);
-
-  mInner->GetTarget(resource, kSQL_Hostname, PR_TRUE, getter_AddRefs(rdfNode));
-  mInner->Unassert(resource, kSQL_Hostname, rdfNode);
-
-  mInner->GetTarget(resource, kSQL_Port, PR_TRUE, getter_AddRefs(rdfNode));
-  mInner->Unassert(resource, kSQL_Port, rdfNode);
-
-  mInner->GetTarget(resource, kSQL_Database, PR_TRUE, getter_AddRefs(rdfNode));
-  mInner->Unassert(resource, kSQL_Database, rdfNode);
-
-  nsresult rv = EnsureAliasesContainer();
-  if (NS_FAILED(rv))
-    return rv;
-  mAliasesContainer->RemoveElement(resource, PR_TRUE);
-
-  Flush();
-
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-mozSqlService::GetConnection(const nsACString &aURI, mozISqlConnection **_retval)
-{
-  nsCStringKey key(aURI);
-  nsCOMPtr<nsIWeakReference> weakRef;
-  nsCOMPtr<mozISqlConnection> conn;
-
-  if (mConnectionCache) {
-    weakRef = getter_AddRefs(NS_STATIC_CAST(nsIWeakReference*, mConnectionCache->Get(&key)));
-    if (weakRef) {
-      conn = do_QueryReferent(weakRef);
-      if (conn)
-        NS_ADDREF(*_retval = conn);
-    }
-  }
-
-  if (! *_retval) {
-    nsresult rv = GetNewConnection(aURI, getter_AddRefs(conn));
-    if (NS_FAILED(rv))
-      return rv;
-
-    weakRef = do_GetWeakReference(conn);
-
-    if (! mConnectionCache)
-      mConnectionCache = new nsSupportsHashtable(16);
-    mConnectionCache->Put(&key, weakRef);
-
-    NS_ADDREF(*_retval = conn);
-  }
-
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-mozSqlService::GetNewConnection(const nsACString &aURI, mozISqlConnection **_retval)
-{
-  PRBool hasAlias;
-  HasAlias(aURI, &hasAlias);
-  if (!hasAlias)
-    return NS_ERROR_FAILURE;
-
-  nsresult rv;
-
-  nsAutoString name;
-  nsAutoString type;
-  nsAutoString hostname;
-  PRInt32 port;
-  nsAutoString database;
-  GetAlias(aURI, name, type, hostname, &port, database);
-
-  nsCAutoString contractID(
-    NS_LITERAL_CSTRING("@mozilla.org/sql/connection;1?type=") +
-    NS_ConvertUCS2toUTF8(type));
-
-  nsCOMPtr<mozISqlConnection> conn = do_CreateInstance(contractID.get());
-  if (! conn)
-    return NS_ERROR_FAILURE;
-
-  nsCOMPtr<nsIWindowWatcher> watcher(do_GetService(NS_WINDOWWATCHER_CONTRACTID));
-  nsCOMPtr<nsIPrompt> prompter;
-  watcher->GetNewPrompter(0, getter_AddRefs(prompter));
-
-  PRBool retval;
-  do {
-    nsXPIDLString username;
-    nsXPIDLString password;
-    prompter->PromptUsernameAndPassword(
-      nsnull, // in wstring dialogTitle
-      nsnull, // in wstring text
-      getter_Copies(username),
-      getter_Copies(password),
-      nsnull, // in wstring checkMsg
-      nsnull, // inout boolean checkValue
-      &retval
-    );
-
-    if (retval) {
-      rv = conn->Init(hostname, port, database, username, password);
-      if (NS_FAILED(rv)) {
-        conn->GetErrorMessage(mErrorMessage);
-        prompter->Alert(nsnull, mErrorMessage.get());
-      }
-    }
-  } while(retval && NS_FAILED(rv));
-
-  NS_IF_ADDREF(*_retval = conn);
-
-  return rv;
-}
-
-NS_IMETHODIMP
-mozSqlService::GetURI(char** aURI)
-{
-  if (!aURI)
-    return NS_ERROR_NULL_POINTER;
-  
-  *aURI = nsCRT::strdup("rdf:sql");
-  if (!(*aURI))
-    return NS_ERROR_OUT_OF_MEMORY;
-  
-  return NS_OK;
-}
-
-NS_IMETHODIMP 
-mozSqlService::GetSource(nsIRDFResource* aProperty,
-                         nsIRDFNode* aTarget,
-                         PRBool aTruthValue,
-                         nsIRDFResource** aSource) 
-{
-  return mInner->GetSource(aProperty, aTarget, aTruthValue, aSource);
-}
-   
-NS_IMETHODIMP
-mozSqlService::GetSources(nsIRDFResource* aProperty,
-                          nsIRDFNode* aTarget,
-                          PRBool aTruthValue,
-                          nsISimpleEnumerator** aSources) {
-  return mInner->GetSources(aProperty, aTarget, aTruthValue, aSources);
-}
-   
-NS_IMETHODIMP
-mozSqlService::GetTarget(nsIRDFResource* aSource,
-                         nsIRDFResource* aProperty,
-                         PRBool aTruthValue,
-                         nsIRDFNode** aTarget) {
-  return mInner->GetTarget(aSource, aProperty, aTruthValue, aTarget);
-}
-   
-NS_IMETHODIMP
-mozSqlService::GetTargets(nsIRDFResource* aSource,
-                          nsIRDFResource* aProperty,
-                          PRBool aTruthValue,
-                          nsISimpleEnumerator** aTargets) {
-  return mInner->GetTargets(aSource, aProperty, aTruthValue, aTargets);
-}
-   
-NS_IMETHODIMP 
-mozSqlService::Assert(nsIRDFResource* aSource,
-                      nsIRDFResource* aProperty,
-                      nsIRDFNode* aTarget,
-                      PRBool aTruthValue) 
-{
-  return mInner->Assert(aSource, aProperty, aTarget, aTruthValue);
-}
-   
-NS_IMETHODIMP 
-mozSqlService::Unassert(nsIRDFResource* aSource,
-                        nsIRDFResource* aProperty,
-                        nsIRDFNode* aTarget) 
-{
-  return mInner->Unassert(aSource, aProperty, aTarget);
-}
-   
-NS_IMETHODIMP 
-mozSqlService::Change(nsIRDFResource* aSource,
-                      nsIRDFResource* aProperty,
-                      nsIRDFNode* aOldTarget,
-                      nsIRDFNode* aNewTarget) 
-{
-  return mInner->Change(aSource, aProperty, aOldTarget, aNewTarget);
-}
-   
-NS_IMETHODIMP 
-mozSqlService::Move(nsIRDFResource* aOldSource,
-                    nsIRDFResource* aNewSource,
-                    nsIRDFResource* aProperty,
-                    nsIRDFNode* aTarget) 
-{
-  return mInner->Move(aOldSource, aNewSource, aProperty, aTarget);
-}
-   
-NS_IMETHODIMP 
-mozSqlService::HasAssertion(nsIRDFResource* aSource,
-                            nsIRDFResource* aProperty,
-                            nsIRDFNode* aTarget,
-                            PRBool aTruthValue,
-                            PRBool* hasAssertion) 
-{
-  return mInner->HasAssertion(aSource, aProperty, aTarget, aTruthValue, hasAssertion);
-}
-   
-NS_IMETHODIMP 
-mozSqlService::AddObserver(nsIRDFObserver* aObserver) 
-{
-  return mInner->AddObserver(aObserver);
-}
-   
-NS_IMETHODIMP 
-mozSqlService::RemoveObserver(nsIRDFObserver* aObserver) 
-{
-  return mInner->RemoveObserver(aObserver);
-}
-   
-NS_IMETHODIMP 
-mozSqlService::HasArcIn(nsIRDFNode* aNode,
-                       nsIRDFResource* aArc,
-                       PRBool* _retval) 
-{
-  return mInner->HasArcIn(aNode, aArc, _retval);
-}
-
-NS_IMETHODIMP 
-mozSqlService::HasArcOut(nsIRDFResource* aSource,
-                         nsIRDFResource* aArc,
-                         PRBool* _retval) 
-{
-  return mInner->HasArcOut(aSource, aArc, _retval);
-}
-
-NS_IMETHODIMP 
-mozSqlService::ArcLabelsIn(nsIRDFNode* aNode,
-                           nsISimpleEnumerator** aLabels) 
-{
-  return mInner->ArcLabelsIn(aNode, aLabels);
-}
-
-NS_IMETHODIMP 
-mozSqlService::ArcLabelsOut(nsIRDFResource* aSource,
-                            nsISimpleEnumerator** aLabels) 
-{
-  return mInner->ArcLabelsIn(aSource, aLabels);
-}
-
-NS_IMETHODIMP 
-mozSqlService::GetAllResources(nsISimpleEnumerator** aResult) 
-{
-  return mInner->GetAllResources(aResult);
-}
-
-NS_IMETHODIMP 
-mozSqlService::GetAllCmds(nsIRDFResource* aSource,
-                          nsISimpleEnumerator** aCommands) 
-{
-  return mInner->GetAllCmds(aSource, aCommands);
-}
-
-NS_IMETHODIMP 
-mozSqlService::IsCommandEnabled(nsISupportsArray* aSources,
-                                nsIRDFResource* aCommand,
-                                nsISupportsArray* aArguments,
-                                PRBool* aResult) 
-{
-  return mInner->IsCommandEnabled(aSources, aCommand, aArguments, aResult);
-}
-
-NS_IMETHODIMP 
-mozSqlService::DoCommand(nsISupportsArray* aSources,
-                         nsIRDFResource* aCommand,
-                         nsISupportsArray* aArguments) 
-{
-  return mInner->DoCommand(aSources, aCommand, aArguments);
-}
-
-NS_IMETHODIMP 
-mozSqlService::BeginUpdateBatch()
-{
-  return mInner->BeginUpdateBatch();
-}
-
-NS_IMETHODIMP 
-mozSqlService::EndUpdateBatch()
-{
-  return mInner->EndUpdateBatch();
-}
-
-
-// nsIRDFRemoteDataSource
-NS_IMETHODIMP
-mozSqlService::GetLoaded(PRBool* aResult)
-{
-  nsCOMPtr<nsIRDFRemoteDataSource> remote(do_QueryInterface(mInner));
-  return remote->GetLoaded(aResult);
-}
-
-NS_IMETHODIMP
-mozSqlService::Init(const char* aURI)
-{
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-mozSqlService::Refresh(PRBool aBlocking)
-{
-  nsCOMPtr<nsIRDFRemoteDataSource> remote(do_QueryInterface(mInner));
-  return remote->Refresh(aBlocking);
-}
-
-NS_IMETHODIMP
-mozSqlService::Flush()
-{
-  nsCOMPtr<nsIRDFRemoteDataSource> remote(do_QueryInterface(mInner));
-  return remote->Flush();
-}
-
-NS_IMETHODIMP
-mozSqlService::FlushTo(const char *aURI)
-{
-  nsCOMPtr<nsIRDFRemoteDataSource> remote(do_QueryInterface(mInner));
-  return remote->FlushTo(aURI);
-}
-
-
-nsresult
-mozSqlService::EnsureAliasesContainer()
-{
-  if (! mAliasesContainer) {
-    PRBool isContainer;
-    nsresult rv = gRDFContainerUtils->IsContainer(mInner, kSQL_AliasesRoot, &isContainer);
-    if (NS_FAILED(rv)) return rv;
-
-    if (!isContainer) {
-      rv = gRDFContainerUtils->MakeSeq(mInner, kSQL_AliasesRoot, getter_AddRefs(mAliasesContainer));
-      if (NS_FAILED(rv)) return rv;
-    }
-    else {
-      mAliasesContainer = do_CreateInstance(NS_RDF_CONTRACTID "/container;1", &rv);
-      if (NS_FAILED(rv)) return rv;
-      rv = mAliasesContainer->Init(mInner, kSQL_AliasesRoot);
-      if (NS_FAILED(rv)) return rv;
-    }
-  }
-
-  return NS_OK;
-}

mozilla/extensions/sql/base/src/mozSqlService.h

@@ -1,52 +0,0 @@
-#ifndef mozSqlService_h
-#define mozSqlService_h
-
-#include "nsHashtable.h"
-#include "nsIRDFDataSource.h"
-#include "nsIRDFRemoteDataSource.h"
-#include "nsIRDFService.h"
-#include "nsIRDFContainerUtils.h"
-#include "mozISqlService.h"
-
-#define MOZ_SQLSERVICE_CLASSNAME "SQL service"
-#define MOZ_SQLSERVICE_CID \
-{0x1ceb35b7, 0xdaa8, 0x4ce4, {0xac, 0x67, 0x12, 0x5f, 0xb1, 0x7c, 0xb0, 0x19}}
-#define MOZ_SQLSERVICE_CONTRACTID "@mozilla.org/sql/service;1"
-#define MOZ_SQLDATASOURCE_CONTRACTID "@mozilla.org/rdf/datasource;1?name=sql"
-
-class mozSqlService : public mozISqlService,
-                      public nsIRDFDataSource,
-                      public nsIRDFRemoteDataSource
-{
-  public:
-    mozSqlService();
-    virtual ~mozSqlService();
-    nsresult Init();
-
-    NS_DECL_ISUPPORTS
-    NS_DECL_MOZISQLSERVICE
-    NS_DECL_NSIRDFDATASOURCE
-    NS_DECL_NSIRDFREMOTEDATASOURCE
-
-  protected:
-    nsresult EnsureAliasesContainer();
-
-  private:
-    static nsIRDFService*               gRDFService;
-    static nsIRDFContainerUtils*        gRDFContainerUtils;
-
-    static nsIRDFResource*              kSQL_AliasesRoot;
-    static nsIRDFResource*              kSQL_Name;
-    static nsIRDFResource*              kSQL_Type;
-    static nsIRDFResource*              kSQL_Hostname;
-    static nsIRDFResource*              kSQL_Port;
-    static nsIRDFResource*              kSQL_Database;
-	
-    nsString                            mErrorMessage;
-    nsCOMPtr<nsIRDFDataSource>          mInner;
-    nsCOMPtr<nsIRDFContainer>           mAliasesContainer;
-    nsSupportsHashtable*                mConnectionCache;
-
-};
-
-#endif /* mozSqlService_h */

mozilla/extensions/sql/build/Makefile.in

@@ -1,21 +0,0 @@
-DEPTH           = ../../..
-topsrcdir       = @top_srcdir@
-srcdir          = @srcdir@
-VPATH           = @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-DIRS            = \
-		src
-
-include $(topsrcdir)/config/rules.mk
-
-XPI_FILE = sql-$(shell date +%Y%m%d)-$(OS_ARCH).xpi
-
-xpi:
-	zip -j $(DIST)/$(XPI_FILE) $(srcdir)/install.js
-	cd $(DIST); zip -r $(XPI_FILE) \
-	bin/components/sql.xpt \
-	bin/components/sqlpgsql.xpt \
-	bin/components/$(LIB_PREFIX)sql$(DLL_SUFFIX) \
-	bin/chrome/sql.jar

mozilla/extensions/sql/build/install.js

@@ -1,58 +0,0 @@
-// this function verifies disk space in kilobytes
-function verifyDiskSpace(dirPath, spaceRequired)
-{
-  var spaceAvailable;
-
-  // Get the available disk space on the given path
-  spaceAvailable = fileGetDiskSpaceAvailable(dirPath);
-
-  // Convert the available disk space into kilobytes
-  spaceAvailable = parseInt(spaceAvailable / 1024);
-
-  // do the verification
-  if(spaceAvailable < spaceRequired)
-  {
-    logComment("Insufficient disk space: " + dirPath);
-    logComment("  required : " + spaceRequired + " K");
-    logComment("  available: " + spaceAvailable + " K");
-    return(false);
-  }
-
-  return(true);
-}
-
-var srDest = 200;
-
-var err = initInstall("SQL Support", "SQL", "0.1"); 
-logComment("initInstall: " + err);
-
-var fProgram = getFolder("Program");
-logComment("fProgram: " + fProgram);
-
-if (verifyDiskSpace(fProgram, srDest))
-{
-  err = addDirectory("Program", "0.1", "bin", fProgram, "", true);
-
-  logComment("addDirectory() returned: " + err);
-
-  var chromeFolder = getFolder("Chrome", "sql.jar");
-  registerChrome(CONTENT | DELAYED_CHROME, chromeFolder, "content/sql/");
-  registerChrome(LOCALE | DELAYED_CHROME, chromeFolder, "locale/en-US/sql/");
-
-  err = getLastError();
-  if (err == ACCESS_DENIED) {
-    alert("Unable to write to program directory " + fProgram + ".\n You will need to restart the browser with administrator/root privileges to install this software. After installing as root (or administrator), you will need to restart the browser one more time to register the installed software.\n After the second restart, you can go back to running the browser without privileges!");
-    cancelInstall(err);
-    logComment("cancelInstall() due to error: " + err);
-  }
-  else if (err != SUCCESS) {
-    cancelInstall(err);
-    logComment("cancelInstall() due to error: " + err);
-  }
-  else {
-    performInstall(); 
-    logComment("performInstall() returned: " + err);
-  }
-}
-else
-  cancelInstall(INSUFFICIENT_DISK_SPACE);

mozilla/extensions/sql/build/src/Makefile.in

@@ -1,40 +0,0 @@
-DEPTH			= ../../../..
-topsrcdir		= @top_srcdir@
-srcdir			= @srcdir@
-VPATH			= @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-MODULE			= sql
-MODULE_NAME    		= sqlModule
-LIBRARY_NAME		= sql
-SHORT_LIBNAME		= sql
-EXPORT_LIBRARY  	= 1
-IS_COMPONENT		= 1
-REQUIRES		= xpcom \
-		  	  string \
-		  	  rdf \
-			  $(NULL)
-
-CPPSRCS			= \
-  		  	  mozSqlModule.cpp
-
-SHARED_LIBRARY_LIBS	= \
-		 	  $(DIST)/lib/$(LIB_PREFIX)sqlbase_s.$(LIB_SUFFIX)
-
-EXTRA_DSO_LDOPTS	= \
-			  $(MOZ_COMPONENT_LIBS) \
-			  $(MOZ_UNICHARUTIL_LIBS) \
-    			  $(NULL)
-
-ifdef MOZ_ENABLE_PGSQL
-DEFINES             	+= -DMOZ_ENABLE_PGSQL
-SHARED_LIBRARY_LIBS 	+= $(DIST)/lib/$(LIB_PREFIX)sqlpgsql_s.$(LIB_SUFFIX)
-EXTRA_DSO_LDOPTS    	+= -L$(MOZ_PGSQL_LIBS) -lpq
-endif
-
-include $(topsrcdir)/config/rules.mk
-
-ifdef MOZ_ENABLE_PGSQL
-INCLUDES		+= -I$(MOZ_PGSQL_INCLUDES)
-endif

mozilla/extensions/sql/build/src/mozSqlModule.cpp

@@ -1,33 +0,0 @@
-#include "nsIGenericFactory.h"
-#include "mozSqlService.h"
-#ifdef MOZ_ENABLE_PGSQL
-#include "mozSqlConnectionPgsql.h"
-#endif
-
-NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(mozSqlService, Init)
-#ifdef MOZ_ENABLE_PGSQL
-NS_GENERIC_FACTORY_CONSTRUCTOR(mozSqlConnectionPgsql)
-#endif
-
-static nsModuleComponentInfo components[] =
-{
-  { MOZ_SQLSERVICE_CLASSNAME,
-    MOZ_SQLSERVICE_CID,
-    MOZ_SQLSERVICE_CONTRACTID,
-    mozSqlServiceConstructor
-  },
-  { MOZ_SQLSERVICE_CLASSNAME,
-    MOZ_SQLSERVICE_CID,
-    MOZ_SQLDATASOURCE_CONTRACTID,
-    mozSqlServiceConstructor
-  },
-#ifdef MOZ_ENABLE_PGSQL
-  { MOZ_SQLCONNECTIONPGSQL_CLASSNAME,
-    MOZ_SQLCONNECTIONPGSQL_CID,
-    MOZ_SQLCONNECTIONPGSQL_CONTRACTID,
-    mozSqlConnectionPgsqlConstructor
-  }
-#endif
-};
-
-NS_IMPL_NSGETMODULE("sql", components)

mozilla/extensions/sql/pgsql/Makefile.in

@@ -1,10 +0,0 @@
-DEPTH           = ../../..
-topsrcdir       = @top_srcdir@
-srcdir          = @srcdir@
-VPATH           = @srcdir@
-
-DIRS            = \
-		  public \
-		  src
-
-include $(topsrcdir)/config/rules.mk

mozilla/extensions/sql/pgsql/public/Makefile.in

@@ -1,14 +0,0 @@
-DEPTH		= ../../../..
-topsrcdir	= @top_srcdir@
-srcdir		= @srcdir@
-VPATH		= @srcdir@
-
-MODULE		= sql
-XPIDL_MODULE	= sqlpgsql
-
-XPIDLSRCS	= \
-		mozISqlConnectionPgsql.idl \
-		mozISqlResultPgsql.idl \
-		$(NULL)
-
-include $(topsrcdir)/config/rules.mk

mozilla/extensions/sql/pgsql/public/mozISqlConnectionPgsql.idl

@@ -1,8 +0,0 @@
-#include "nsISupports.idl"
-
-[scriptable, uuid(0cf1eefe-611d-48fa-ae27-0a6f40d6a33e)]
-
-interface mozISqlConnectionPgsql : nsISupports
-{
-
-};

mozilla/extensions/sql/pgsql/public/mozISqlResultPgsql.idl

@@ -1,8 +0,0 @@
-#include "nsISupports.idl"
-
-[scriptable, uuid(f6573169-286d-4a20-8253-9abb07bdba29)]
-
-interface mozISqlResultPgsql : nsISupports
-{
-
-};

mozilla/extensions/sql/pgsql/src/Makefile.in

@@ -1,28 +0,0 @@
-DEPTH		= ../../../..
-topsrcdir	= @top_srcdir@
-srcdir		= @srcdir@
-VPATH		= @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-MODULE		= sql
-LIBRARY_NAME	= sqlpgsql_s
-REQUIRES	= xpcom \
-		  string \
-		  locale \
-		  rdf \
-		  $(NULL)
-
-CPPSRCS		= \
-		mozSqlConnectionPgsql.cpp \
-		mozSqlResultPgsql.cpp
-
-EXPORTS		= \
-		mozSqlConnectionPgsql.h \
-		mozSqlResultPgsql.h
-
-FORCE_STATIC_LIB=1
-
-include $(topsrcdir)/config/rules.mk
-
-INCLUDES	+= -I$(MOZ_PGSQL_INCLUDES)

mozilla/extensions/sql/pgsql/src/mozSqlConnectionPgsql.cpp

@@ -1,240 +0,0 @@
-#include "prprf.h"
-#include "mozSqlConnectionPgsql.h"
-#include "mozSqlResultPgsql.h"
-
-mozSqlConnectionPgsql::mozSqlConnectionPgsql()
-  : mConnection(nsnull)
-{
-}
-
-mozSqlConnectionPgsql::~mozSqlConnectionPgsql()
-{
-  if (mConnection)
-    PQfinish(mConnection);
-}
-
-NS_IMPL_ADDREF_INHERITED(mozSqlConnectionPgsql, mozSqlConnection)
-NS_IMPL_RELEASE_INHERITED(mozSqlConnectionPgsql, mozSqlConnection)
-
-// QueryInterface
-NS_INTERFACE_MAP_BEGIN(mozSqlConnectionPgsql)
-  NS_INTERFACE_MAP_ENTRY(mozISqlConnectionPgsql)
-NS_INTERFACE_MAP_END_INHERITING(mozSqlConnection)
-
-NS_IMETHODIMP
-mozSqlConnectionPgsql::Init(const nsAString & aHost, PRInt32 aPort,
-                            const nsAString & aDatabase, const nsAString & aUsername,
-                            const nsAString & aPassword)
-{
-  if (mConnection)
-    return NS_OK;
-
-  if (aPort == -1)
-    aPort = 5432;
-  char port[11];
-  char options[] = "";
-  char tty[] = "";
-  PR_snprintf(port, 11, "%d", aPort);
-
-  mConnection = PQsetdbLogin(NS_ConvertUCS2toUTF8(aHost).get(),
-                             port, options, tty,
-                             NS_ConvertUCS2toUTF8(aDatabase).get(),
-                             NS_ConvertUCS2toUTF8(aUsername).get(),
-                             NS_ConvertUCS2toUTF8(aPassword).get());
-
-  return Setup();
-}
-
-NS_IMETHODIMP
-mozSqlConnectionPgsql::GetPrimaryKeys(const nsAString& aSchema, const nsAString& aTable, mozISqlResult** _retval)
-{
-  nsAutoString select;
-  nsAutoString from;
-  nsAutoString where;
-  if (mVersion >= SERVER_VERSION(7,3,0)) {
-    select = NS_LITERAL_STRING("SELECT n.nspname AS TABLE_SCHEM, ");
-    from = NS_LITERAL_STRING(" FROM pg_catalog.pg_namespace n, pg_catalog.pg_class ct, pg_catalog.pg_class ci, pg_catalog.pg_attribute a, pg_catalog.pg_index i");
-    where = NS_LITERAL_STRING(" AND ct.relnamespace = n.oid ");
-    if (!aSchema.IsEmpty()) {
-      where.Append(NS_LITERAL_STRING(" AND n.nspname = '") + aSchema);
-      where.Append(PRUnichar('\''));
-    }
-  }
-  else {
-    select = NS_LITERAL_STRING("SELECT NULL AS TABLE_SCHEM, ");
-    from = NS_LITERAL_STRING(" FROM pg_class ct, pg_class ci, pg_attribute a, pg_index i ");
-  }
-
-  if (!aTable.IsEmpty()) {
-    where.Append(NS_LITERAL_STRING(" AND ct.relname = '") + aTable);
-    where.Append(PRUnichar('\''));
-  }
-
-  NS_NAMED_LITERAL_STRING(select2, " ct.relname AS TABLE_NAME, a.attname AS COLUMN_NAME, a.attnum AS KEY_SEQ, ci.relname AS PK_NAME ");
-  NS_NAMED_LITERAL_STRING(where2, " WHERE ct.oid=i.indrelid AND ci.oid=i.indexrelid AND a.attrelid=ci.oid AND i.indisprimary ");
-  NS_NAMED_LITERAL_STRING(order2, " ORDER BY table_name, pk_name, key_seq");
-
-  return RealExec(select + select2 + from + where2 + where + order2, _retval, nsnull);
-}
-
-nsresult
-mozSqlConnectionPgsql::Setup()
-{
-  if (PQstatus(mConnection) == CONNECTION_BAD) {
-    mErrorMessage.Assign(NS_ConvertUTF8toUCS2(PQerrorMessage(mConnection)));
-    mConnection = nsnull;
-    return NS_ERROR_FAILURE;
-  }
-
-  PQsetClientEncoding(mConnection, "UNICODE");
-
-/*
-  PGresult* result = PQexec(mConnection, "SET DATESTYLE TO US");
-  PRInt32 stat = PQresultStatus(result);
-  if (stat != PGRES_COMMAND_OK) {
-    mErrorMessage.Assign(NS_ConvertUTF8toUCS2(PQresultErrorMessage(result)));
-    PQfinish(mConnection);
-    mConnection = nsnull;
-    return NS_ERROR_FAILURE;
-  }
-*/
-
-  PGresult* result = PQexec(mConnection, "select version()");
-  PRInt32 stat = PQresultStatus(result);
-  if (stat != PGRES_TUPLES_OK) {
-    mErrorMessage.Assign(NS_ConvertUTF8toUCS2(PQresultErrorMessage(result)));
-    return NS_ERROR_FAILURE;
-  }
-  char* version = PQgetvalue(result, 0, 0);
-  NS_ConvertUTF8toUCS2 buffer(version);
-  nsAString::const_iterator start, end, iter;
-  buffer.BeginReading(iter);
-  buffer.EndReading(end);
-  while (iter != end && !nsCRT::IsAsciiSpace(*iter))
-    ++iter;
-  while (iter != end && nsCRT::IsAsciiSpace(*iter))
-    ++iter;
-  start = iter;
-  while (iter != end && !nsCRT::IsAsciiSpace(*iter))
-    ++iter;
-  mServerVersion = Substring(start,iter);
-
-  PRInt32 numbers[3] = {0,0,0};
-  mServerVersion.BeginReading(iter);
-  mServerVersion.EndReading(end);
-  for (PRInt32 i = 0; i < 3; i++) {
-    start = iter;
-    while (iter != end && *iter != PRUnichar('.'))
-      ++iter;
-    nsAutoString v(Substring(start,iter));
-    PRInt32 err;
-    numbers[i] = v.ToInteger(&err);
-    while (iter != end && *iter == PRUnichar('.'))
-      ++iter;
-  }
-  mVersion = SERVER_VERSION(numbers[0], numbers[1], numbers[2]);
-
-  return NS_OK;
-}
-
-nsresult
-mozSqlConnectionPgsql::RealExec(const nsAString& aQuery,
-                                mozISqlResult** aResult, PRInt32* aAffectedRows)
-{
-  if (! mConnection)
-    return NS_ERROR_NOT_INITIALIZED;
-
-  PGresult* r;
-  r = PQexec(mConnection, NS_ConvertUCS2toUTF8(aQuery).get());
-  PRInt32 stat = PQresultStatus(r);
-
-  if (PQstatus(mConnection) == CONNECTION_BAD) {
-    PQreset(mConnection);
-    nsresult rv = Setup();
-    if (NS_FAILED(rv))
-      return rv;
-    r = PQexec(mConnection, NS_ConvertUCS2toUTF8(aQuery).get());
-    stat = PQresultStatus(r);
-  }
-
-  if (stat == PGRES_TUPLES_OK) {
-    if (!aResult)
-      return NS_ERROR_NULL_POINTER;
-
-    static char select1[] = "select t.oid, case when t.typbasetype = 0 then t.typname else (select t2.typname from pg_type t2 where t2.oid=t.typbasetype) end as typname from pg_type t where t.oid in (";
-    static char select2[] = "select oid, typname from pg_type where oid in (";
-    char* select;
-    if (mVersion >= SERVER_VERSION(7,3,0))
-      select = select1;
-    else
-      select = select2;
-    PRInt32 columnCount = PQnfields(r);
-    char* query = (char*)malloc(strlen(select) + columnCount * 11 + 2);
-    strcpy(query, select);
-    for (PRInt32 i = 0; i < columnCount; i++) {
-      PRInt32 oid = PQftype(r, i);
-      char oidStr[11];
-      if (i)
-        sprintf(oidStr, ",%d", oid);
-      else
-        sprintf(oidStr, "%d", oid);
-      strcat(query, oidStr);
-    }
-    strcat(query, ")");
-    PGresult* types = PQexec(mConnection, query);
-    free(query);
-    stat = PQresultStatus(types);
-    if (stat != PGRES_TUPLES_OK) {
-      mErrorMessage.Assign(NS_ConvertUTF8toUCS2(PQresultErrorMessage(types)));
-      return NS_ERROR_FAILURE;
-    }
-
-    if (*aResult) {
-      ((mozSqlResultPgsql*)*aResult)->SetResult(r, types);
-      nsresult rv = ((mozSqlResult*)*aResult)->Rebuild();
-      if (NS_FAILED(rv))
-        return rv;
-      NS_ADDREF(*aResult);
-    }
-    else {
-      mozSqlResult* result = new mozSqlResultPgsql(this, aQuery);
-      if (! result)
-        return NS_ERROR_OUT_OF_MEMORY;
-      ((mozSqlResultPgsql*)result)->SetResult(r, types);
-      nsresult rv = result->Init();
-      if (NS_FAILED(rv))
-        return rv;
-      NS_ADDREF(*aResult = result);
-    }
-  }
-  else if (stat == PGRES_COMMAND_OK) {
-    if (!aAffectedRows)
-      return NS_ERROR_NULL_POINTER;
-    PR_sscanf(PQcmdTuples(r), "%d", aAffectedRows);
-    mLastID = PQoidValue(r);
-  }
-  else {
-    mErrorMessage.Assign(NS_ConvertUTF8toUCS2(PQresultErrorMessage(r)));
-    return NS_ERROR_FAILURE;
-  }
-
-  return NS_OK;
-}
-
-nsresult
-mozSqlConnectionPgsql::CancelExec()
-{
-  if (!PQrequestCancel(mConnection)) {
-    mErrorMessage.Assign(NS_ConvertUTF8toUCS2(PQerrorMessage(mConnection)));
-    return NS_ERROR_FAILURE;
-  }
-
-  return NS_OK;
-}
-
-nsresult
-mozSqlConnectionPgsql::GetIDName(nsAString& aIDName)
-{
-  aIDName = NS_LITERAL_STRING("OID");
-  return NS_OK;
-}

mozilla/extensions/sql/pgsql/src/mozSqlConnectionPgsql.h

@@ -1,47 +0,0 @@
-#ifndef mozSqlConnectionPgsql_h
-#define mozSqlConnectionPgsql_h                                                  
-
-#include "libpq-fe.h"
-#include "mozSqlConnection.h"
-#include "mozISqlConnectionPgsql.h"
-
-#define MOZ_SQLCONNECTIONPGSQL_CLASSNAME "PosgreSQL SQL Connection"
-#define MOZ_SQLCONNECTIONPGSQL_CID \
-{0x0cf1eefe, 0x611d, 0x48fa, {0xae, 0x27, 0x0a, 0x6f, 0x40, 0xd6, 0xa3, 0x3e }}
-#define MOZ_SQLCONNECTIONPGSQL_CONTRACTID "@mozilla.org/sql/connection;1?type=pgsql"
-
-#define SERVER_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))
-
-class mozSqlConnectionPgsql : public mozSqlConnection,
-                              public mozISqlConnectionPgsql
-{
-  public:
-    mozSqlConnectionPgsql();
-    virtual ~mozSqlConnectionPgsql();
-
-    NS_DECL_ISUPPORTS
-
-    NS_IMETHOD Init(const nsAString& aHost, PRInt32 aPort,
-                    const nsAString& aDatabase, const nsAString& aUsername,
-		    const nsAString& aPassword);
-
-    NS_IMETHOD GetPrimaryKeys(const nsAString& aSchema, const nsAString& aTable, mozISqlResult** _retval);
-
-    NS_DECL_MOZISQLCONNECTIONPGSQL
-
-  protected:
-    nsresult Setup();
-
-    virtual nsresult RealExec(const nsAString& aQuery,
-                              mozISqlResult** aResult, PRInt32* aAffectedRows);
-
-    virtual nsresult CancelExec();
-
-    virtual nsresult GetIDName(nsAString& aIDName);
-
-  private:
-    PGconn*             mConnection;
-    PRInt32             mVersion;
-};
-
-#endif // mozSqlConnectionPgsql_h

mozilla/extensions/sql/pgsql/src/mozSqlResultPgsql.cpp

@@ -1,235 +0,0 @@
-
-#include "prprf.h"
-#include "nsReadableUtils.h"
-#include "mozSqlResultPgsql.h"
-
-mozSqlResultPgsql::mozSqlResultPgsql(mozISqlConnection* aConnection,
-                                     const nsAString& aQuery)
-  : mozSqlResult(aConnection, aQuery),
-    mResult(nsnull),
-    mTypes(nsnull)
-{
-}
-
-void
-mozSqlResultPgsql::SetResult(PGresult* aResult,
-                             PGresult* aTypes)
-{
-  mResult = aResult;
-  mTypes = aTypes;
-}
-
-mozSqlResultPgsql::~mozSqlResultPgsql()
-{
-  ClearNativeResult();
-}
-
-NS_IMPL_ADDREF_INHERITED(mozSqlResultPgsql, mozSqlResult)
-NS_IMPL_RELEASE_INHERITED(mozSqlResultPgsql, mozSqlResult)
-
-// QueryInterface
-NS_INTERFACE_MAP_BEGIN(mozSqlResultPgsql)
-  NS_INTERFACE_MAP_ENTRY(mozISqlResultPgsql)
-NS_INTERFACE_MAP_END_INHERITING(mozSqlResult)
-
-PRInt32
-mozSqlResultPgsql::GetColType(PRInt32 aColumnIndex)
-{
-  PRInt32 oid = PQftype(mResult, aColumnIndex);
-
-  for (PRInt32 i = 0; i < PQntuples(mTypes); i++) {
-    char* value = PQgetvalue(mTypes, i, 0);
-    PRInt32 o;
-    PR_sscanf(value, "%d", &o);
-    if (o == oid) {
-      char* type = PQgetvalue(mTypes, i, 1);
-      if (! strcmp(type, "int2"))
-        return mozISqlResult::TYPE_INT;
-      else if (! strcmp(type, "int4"))
-        return mozISqlResult::TYPE_INT;
-      else if (! strcmp(type, "float4"))
-        return mozISqlResult::TYPE_STRING;
-      else if (! strcmp(type, "numeric"))
-        return mozISqlResult::TYPE_STRING;
-      else if (! strcmp(type, "date"))
-        return mozISqlResult::TYPE_STRING;
-      else if (! strcmp(type, "time"))
-        return mozISqlResult::TYPE_STRING;
-      else if (! strcmp(type, "timestamp"))
-        return mozISqlResult::TYPE_STRING;
-      else if (! strcmp(type, "bool"))
-        return mozISqlResult::TYPE_BOOL;
-      else
-        return mozISqlResult::TYPE_STRING;
-    }
-  }
-
-  return mozISqlResult::TYPE_STRING;
-}
-
-nsresult
-mozSqlResultPgsql::BuildColumnInfo()
-{
-  for (PRInt32 i = 0; i < PQnfields(mResult); i++) {
-    char* n = PQfname(mResult, i);
-    PRUnichar* name = ToNewUnicode(NS_ConvertUTF8toUCS2(n));
-    PRInt32 type = GetColType(i);
-    PRInt32 size = PQfsize(mResult, i);
-    PRInt32 mod = PQfmod(mResult, i);
-
-    nsCAutoString uri(NS_LITERAL_CSTRING("http://www.mozilla.org/SQL-rdf#"));
-    uri.Append(n);
-    nsCOMPtr<nsIRDFResource> property;
-    gRDFService->GetResource(uri, getter_AddRefs(property));
-
-    ColumnInfo* columnInfo = ColumnInfo::Create(mAllocator, name, type, size, mod, property);
-    mColumnInfo.AppendElement(columnInfo); 
-  }
-
-  return NS_OK;
-}
-
-nsresult
-mozSqlResultPgsql::BuildRows()
-{
-  for(PRInt32 i = 0; i < PQntuples(mResult); i++) {
-    nsCOMPtr<nsIRDFResource> resource;
-    nsresult rv = gRDFService->GetAnonymousResource(getter_AddRefs(resource));
-    if (NS_FAILED(rv)) return rv;
-
-    Row* row = Row::Create(mAllocator, resource, mColumnInfo);
-
-    for (PRInt32 j = 0; j < mColumnInfo.Count(); j++) {
-      if (! PQgetisnull(mResult, i, j)) {
-        char* value = PQgetvalue(mResult, i, j);
-        Cell* cell = row->mCells[j];
-        cell->SetNull(PR_FALSE);
-        PRInt32 type = cell->GetType();
-        if (type == mozISqlResult::TYPE_STRING)
-          cell->SetString(ToNewUnicode(NS_ConvertUTF8toUCS2(value)));
-        else if (type == mozISqlResult::TYPE_INT)
-          PR_sscanf(value, "%d", &cell->mInt);
-        else if (type == mozISqlResult::TYPE_FLOAT)
-          PR_sscanf(value, "%f", &cell->mFloat);
-        else if (type == mozISqlResult::TYPE_DECIMAL)
-          PR_sscanf(value, "%f", &cell->mFloat);
-        else if (type == mozISqlResult::TYPE_DATE ||
-                 type == mozISqlResult::TYPE_TIME ||
-                 type == mozISqlResult::TYPE_DATETIME)
-          PR_ParseTimeString(value, PR_FALSE, &cell->mDate);
-        else if (type == mozISqlResult::TYPE_BOOL)
-          cell->mBool = !strcmp(value, "t");
-      }
-    }
-
-    mRows.AppendElement(row);
-    nsVoidKey key(resource);
-    mSources.Put(&key, row);
-  }
-
-  return NS_OK;
-}
-
-void
-mozSqlResultPgsql::ClearNativeResult()
-{
-  if (mResult) {
-    PQclear(mResult);
-    mResult = nsnull;
-  }
-  if (mTypes) {
-    PQclear(mTypes);
-    mTypes = nsnull;
-  }
-}
-
-nsresult
-mozSqlResultPgsql::EnsureTablePrivileges()
-{
-  nsresult rv = EnsureTableName();
-  if (NS_FAILED(rv))
-    return rv;
-
-  NS_NAMED_LITERAL_STRING(select, "select ");
-  NS_NAMED_LITERAL_STRING(func, "has_table_privilege(SESSION_USER, '");
-  NS_NAMED_LITERAL_STRING(comma, ", ");
-  NS_NAMED_LITERAL_STRING(ins, "', 'INSERT')");
-  NS_NAMED_LITERAL_STRING(upd, "', 'UPDATE')");
-  NS_NAMED_LITERAL_STRING(del, "','DELETE')");
-
-  nsCOMPtr<mozISqlResult> result;
-  rv = mConnection->ExecuteQuery(
-    select + func + mTableName + ins +
-    comma + func + mTableName + upd +
-    comma + func + mTableName + del,
-    getter_AddRefs(result));
-  if (NS_FAILED(rv)) {
-    mConnection->GetErrorMessage(mErrorMessage);
-    return rv;
-  }
-
-  nsCOMPtr<mozISqlResultEnumerator> enumerator;
-  rv = result->Enumerate(getter_AddRefs(enumerator));
-  if (NS_FAILED(rv))
-    return rv;
-
-  rv = enumerator->First();
-  if (NS_FAILED(rv))
-    return rv;
-
-  rv = enumerator->GetBool(0, &mCanInsert);
-  if (NS_FAILED(rv))
-    return rv;
-  rv = enumerator->GetBool(1, &mCanUpdate);
-  if (NS_FAILED(rv))
-    return rv;
-  return enumerator->GetBool(2, &mCanDelete);
-}
-
-nsresult
-mozSqlResultPgsql::CanInsert(PRBool* _retval)
-{
-  if (mCanInsert >= 0) {
-    *_retval = mCanInsert;
-    return NS_OK;
-  }
-
-  nsresult rv = EnsureTablePrivileges();
-  if (NS_FAILED(rv))
-    return rv;
-  *_retval = mCanInsert;
-
-  return NS_OK;
-}
-
-nsresult
-mozSqlResultPgsql::CanUpdate(PRBool* _retval)
-{
-  if (mCanUpdate >= 0) {
-    *_retval = mCanUpdate;
-    return NS_OK;
-  }
-
-  nsresult rv = EnsureTablePrivileges();
-  if (NS_FAILED(rv))
-    return rv;
-  *_retval = mCanUpdate;
-
-  return NS_OK;
-}
-
-nsresult
-mozSqlResultPgsql::CanDelete(PRBool* _retval)
-{
-  if (mCanDelete >= 0) {
-    *_retval = mCanDelete;
-    return NS_OK;
-  }
-
-  nsresult rv = EnsureTablePrivileges();
-  if (NS_FAILED(rv))
-    return rv;
-  *_retval = mCanDelete;
-
-  return NS_OK;
-}

mozilla/extensions/sql/pgsql/src/mozSqlResultPgsql.h

@@ -1,39 +0,0 @@
-#ifndef mozSqlResultPgsql_h
-#define mozSqlResultPgsql_h                                                  
-
-#include "libpq-fe.h"
-#include "mozSqlResult.h"
-#include "mozISqlResultPgsql.h"
-
-class mozSqlResultPgsql : public mozSqlResult,
-                          public mozISqlResultPgsql
-{
-  public:
-    mozSqlResultPgsql(mozISqlConnection* aConnection,
-                      const nsAString& aQuery);
-    void SetResult(PGresult* aResult,
-                   PGresult* aTypes);
-    virtual ~mozSqlResultPgsql();
-
-    NS_DECL_ISUPPORTS
-
-    NS_DECL_MOZISQLRESULTPGSQL 
-
-  protected:
-    PRInt32 GetColType(PRInt32 aColumnIndex);
-
-    virtual nsresult BuildColumnInfo();
-    virtual nsresult BuildRows();
-    virtual void ClearNativeResult();
-
-    nsresult EnsureTablePrivileges();
-    virtual nsresult CanInsert(PRBool* _retval);
-    virtual nsresult CanUpdate(PRBool* _retval);
-    virtual nsresult CanDelete(PRBool* _retval);
-
-  private:
-    PGresult*   mResult;
-    PGresult*   mTypes;
-};
-
-#endif // mozSqlResultPgsql_h

mozilla/extensions/sql/sqltest/Makefile.in

@@ -1,15 +0,0 @@
-DEPTH		= ../../..
-topsrcdir	= @top_srcdir@
-srcdir		= @srcdir@
-VPATH		= @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-include $(topsrcdir)/config/rules.mk
-
-XPI_FILE = sqltest-$(shell date +%Y%m%d).xpi
-
-xpi:
-	zip -j $(DIST)/$(XPI_FILE) $(srcdir)/install.js
-	cd $(DIST); zip -r $(XPI_FILE) \
-	bin/chrome/sqltest.jar

mozilla/extensions/sql/sqltest/contents.rdf

@@ -1,17 +0,0 @@
-<?xml version="1.0"?>
-<RDF:RDF xmlns:RDF="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-         xmlns:chrome="http://www.mozilla.org/rdf/chrome#">
-
-  <!-- list all the packages being supplied by this jar -->
-  <RDF:Seq about="urn:mozilla:package:root">
-    <RDF:li resource="urn:mozilla:package:sqltest"/>
-  </RDF:Seq>
-
-  <!-- package information -->
-  <RDF:Description about="urn:mozilla:package:sqltest"
-        chrome:displayName="SQL test"
-        chrome:author="mozilla.org"
-        chrome:name="sqltest">
-  </RDF:Description>
-
-</RDF:RDF>

mozilla/extensions/sql/sqltest/install.js

@@ -1,57 +0,0 @@
-// this function verifies disk space in kilobytes
-function verifyDiskSpace(dirPath, spaceRequired)
-{
-  var spaceAvailable;
-
-  // Get the available disk space on the given path
-  spaceAvailable = fileGetDiskSpaceAvailable(dirPath);
-
-  // Convert the available disk space into kilobytes
-  spaceAvailable = parseInt(spaceAvailable / 1024);
-
-  // do the verification
-  if(spaceAvailable < spaceRequired)
-  {
-    logComment("Insufficient disk space: " + dirPath);
-    logComment("  required : " + spaceRequired + " K");
-    logComment("  available: " + spaceAvailable + " K");
-    return(false);
-  }
-
-  return(true);
-}
-
-var srDest = 100;
-
-var err = initInstall("SQL test", "SQLTEST", "0.1"); 
-logComment("initInstall: " + err);
-
-var fProgram = getFolder("Program");
-logComment("fProgram: " + fProgram);
-
-if (verifyDiskSpace(fProgram, srDest))
-{
-  err = addDirectory("Program", "0.1", "bin", fProgram, "", true);
-
-  logComment("addDirectory() returned: " + err);
-
-  var chromeFolder = getFolder("Chrome", "sqltest.jar");
-  registerChrome(CONTENT | DELAYED_CHROME, chromeFolder, "content/sqltest/");
-
-  err = getLastError();
-  if (err == ACCESS_DENIED) {
-    alert("Unable to write to program directory " + fProgram + ".\n You will need to restart the browser with administrator/root privileges to install this software. After installing as root (or administrator), you will need to restart the browser one more time to register the installed software.\n After the second restart, you can go back to running the browser without privileges!");
-    cancelInstall(err);
-    logComment("cancelInstall() due to error: " + err);
-  }
-  else if (err != SUCCESS) {
-    cancelInstall(err);
-    logComment("cancelInstall() due to error: " + err);
-  }
-  else {
-    performInstall(); 
-    logComment("performInstall() returned: " + err);
-  }
-}
-else
-  cancelInstall(INSUFFICIENT_DISK_SPACE);

mozilla/extensions/sql/sqltest/jar.mn

@@ -1,7 +0,0 @@
-sqltest.jar:
-    content/sqltest/contents.rdf			(contents.rdf)
-    content/sqltest/sqltest.xul				(sqltest.xul)
-    content/sqltest/sqltest.js				(sqltest.js)
-    content/sqltest/sqltest.css				(sqltest.css)
-    content/sqltest/sqltestDialog.xul			(sqltestDialog.xul)
-    content/sqltest/sqltestDialog.js			(sqltestDialog.js)

mozilla/extensions/sql/sqltest/sqltest.css

@@ -1,8 +0,0 @@
-treechildren:-moz-tree-cell {
-  border-right: 1px solid ThreeDFace;
-  border-bottom: 1px solid ThreeDFace;
-}
-
-.spacer {
-  height: 10px;
-}

mozilla/extensions/sql/sqltest/sqltest.js

@@ -1,126 +0,0 @@
-const alias = "urn:aliases:sqltest";
-const complete = Components.interfaces.mozISqlRequest.STATUS_COMPLETE;
-
-var connection;
-var result;
-
-var startupObserver = {
-  onStartRequest: function(request, ctxt) {
-  },
-  onStopRequest: function(request, ctxt) {
-    if (request.status == complete) {
-      result = request.result;
-      var ds = result.QueryInterface(Components.interfaces.nsIRDFDataSource);
-
-      var menulist = document.getElementById("statesMenulist");
-      menulist.database.AddDataSource(ds);
-      menulist.builder.rebuild();
-      menulist.selectedIndex = 0;
-
-      var tree = document.getElementById("statesTree");
-      tree.database.AddDataSource(ds);
-      tree.builder.rebuild();
-    }
-    else {
-      alert(request.errorMessage);
-    }
-  }
-};
-
-var observer = {
-  onStartRequest: function(request, ctxt) {
-  },
-  
-  onStopRequest: function(request, ctxt) {
-    if (request.status == complete) {
-      var element = document.getElementById("asyncStateName");
-      if (request.result.rowCount) {
-        var enumerator = request.result.enumerate();
-        enumerator.first();
-        element.value = enumerator.getVariant(0);
-      }
-      else {
-        element.value = "Not found";
-      }
-    }
-    else {
-      alert(request.errorMessage);
-    }
-  }
-};
-
-function init() {
-  var service = Components.classes["@mozilla.org/sql/service;1"]
-                .getService(Components.interfaces.mozISqlService);
-
-  if (!service.hasAlias(alias)) {
-    alert("The alias for the sqltest was not defined.");
-    return;
-  }
-
-  try {
-    connection = service.getConnection(alias);
-  }
-  catch (ex) {
-    alert(service.errorMessage);
-    return;
-  }
-
-  var query = "select code, name from states";
-  var request = connection.asyncExecuteQuery(query, null, startupObserver);
-}
-
-function syncFindState() {
-  var code = document.getElementById("syncStateCode").value
-  var query = "select name from states where code = '" + code + "'";
-  try {
-    var result = connection.executeQuery(query);
-    var element = document.getElementById("syncStateName");
-    if (result.rowCount) {
-      var enumerator = result.enumerate();
-      enumerator.first();
-      element.value = enumerator.getVariant(0);
-    }
-    else {
-      element.value = "Not found";
-    }
-  }
-  catch (ex) {
-    alert(connection.errorMessage);
-  }
-}
-
-function asyncFindState() {
-  var code = document.getElementById("asyncStateCode").value;
-  var query = "select name from states where code = '" + code + "'";
-  var request = connection.asyncExecuteQuery(query, null, observer);
-}
-
-function getSelectedRowIndex() {
-  var tree = document.getElementById("statesTree");
-  var currentIndex = tree.currentIndex;
-  var resource = tree.builderView.getResourceAtIndex(currentIndex);
-  var datasource = result.QueryInterface(Components.interfaces.mozISqlDataSource);
-  return datasource.getIndexOfResource(resource);
-}
-
-function doInsert() {
-  window.openDialog("sqltestDialog.xul", "testDialog", "chrome,modal=yes,resizable=no", result);
-}
-
-function doUpdate() {
-  var rowIndex = this.getSelectedRowIndex();
-  window.openDialog("sqltestDialog.xul", "testDialog", "chrome,modal=yes,resizable=no", result, rowIndex);
-}
-
-function doDelete() {
-  var rowIndex = this.getSelectedRowIndex();
-  var enumerator = result.enumerate();
-  enumerator.absolute(rowIndex);
-  try {
-    enumerator.deleteRow();
-  }
-  catch(ex) {
-    alert(enumerator.errorMessage);
-  }
-}

mozilla/extensions/sql/sqltest/sqltest.xul

@@ -1,118 +0,0 @@
-<?xml version="1.0"?>
-
-<?xml-stylesheet href="chrome://global/skin/" type="text/css"?>
-<?xml-stylesheet href="sqltest.css" type="text/css"?>
-
-<window xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
-        orient="vertical"
-        width="640" height="480"
-        title="SQL test"
-        onload="init()">
-
-  <script type="application/x-javascript" src="sqltest.js"/>
-
-  <popupset>
-    <popup id="editContextMenu">
-      <menuitem label="Insert" oncommand="doInsert()"/>
-      <menuitem label="Update" oncommand="doUpdate()"/>
-      <menuitem label="Delete" oncommand="doDelete()"/>
-    </popup>
-  </popupset>
-
-  <tabbox flex="1">
-    <tabs>
-      <tab label="Sync test"/>
-      <tab label="Async test"/>
-      <tab label="Widgets"/>
-    </tabs>
-    <tabpanels flex="1">
-      <vbox>
-        <text class="label" value="Type a state code and then hit ENTER. You should get a state name."/>
-        <spacer class="spacer"/>
-        <grid>
-          <columns>
-            <column/>
-          </columns>
-          <rows>
-            <row>
-              <text class="label" value="State code:"/>
-              <hbox>
-                <textbox id="syncStateCode" size="2" maxlength="2" onkeyup="if (event.keyCode == 13) syncFindState()"/>
-              </hbox>
-            </row>
-            <row>
-              <text class="label" value="State name:"/>
-              <textbox id="syncStateName"/>
-            </row>
-          </rows>
-        </grid>
-      </vbox>
-      <vbox>
-        <text class="label" value="Type a state code and then hit ENTER. You should get a state name."/>
-        <spacer class="spacer"/>
-        <grid>
-          <columns>
-            <column/>
-          </columns>
-          <rows>
-            <row>
-              <text class="label" value="State code:"/>
-              <hbox>
-                <textbox id="asyncStateCode" size="2" maxlength="2" onkeyup="if (event.keyCode == 13) asyncFindState()"/>
-              </hbox>
-            </row>
-            <row>
-              <text class="label" value="State name:"/>
-              <textbox id="asyncStateName"/>
-            </row>
-          </rows>
-        </grid>
-      </vbox>
-      <vbox>
-        <text class="label" value="You should see a menulist filled with all the states."/>
-        <spacer class="spacer"/>
-        <hbox>
-          <menulist id="statesMenulist"
-                    datasources="rdf:null" ref="SQL:ResultRoot">
-            <template>
-              <menupopup>
-                <menuitem uri="..."
-                          value="rdf:http://www.mozilla.org/SQL-rdf#code"
-                          label="rdf:http://www.mozilla.org/SQL-rdf#name"/>
-              </menupopup>
-            </template>
-          </menulist>
-        </hbox>
-        <spacer class="spacer"/>
-        <text value="You should see codes and names of all states in this tree. You can even edit them using the context menu."/>
-        <spacer class="spacer"/>
-        <tree id="statesTree" flex="1"
-              context="editContextMenu"
-              seltype="single" enableColumnDrag="true"
-              datasources="rdf:null" ref="SQL:ResultRoot" flags="dont-build-content">
-          <treecols>
-            <treecol id="codeCol"
-                     label="State code"
-                     sort="rdf:http://www.mozilla.org/SQL-rdf#code"
-                     sortActive="true" sortDirection="ascending"/>
-            <splitter class="tree-splitter"/>
-            <treecol id="nameCol" flex="1"
-                     label="State name"
-                     sort="rdf:http://www.mozilla.org/SQL-rdf#name"/>
-          </treecols>
-          <template>
-            <treechildren>
-              <treeitem uri="rdf:*">
-                <treerow>
-                  <treecell label="rdf:http://www.mozilla.org/SQL-rdf#code"/>
-                  <treecell label="rdf:http://www.mozilla.org/SQL-rdf#name"/>
-                </treerow>
-              </treeitem>
-            </treechildren>
-          </template>
-        </tree>
-      </vbox>
-    </tabpanels>
-  </tabbox>
-
-</window>

mozilla/extensions/sql/sqltest/sqltestDialog.js

@@ -1,41 +0,0 @@
-var result;
-var enumerator;
-
-function init() {
-  result = window.arguments[0];
-  enumerator = result.enumerate();
-  if (window.arguments.length == 2) {
-    enumerator.absolute(window.arguments[1]);
-    var columnCount = result.columnCount;
-    for(var i = 0; i < columnCount; i++) {
-      if (!enumerator.isNull(i)) {
-        var element = document.getElementById(result.getColumnName(i));
-        element.value = enumerator.getVariant(i);
-      }
-    }
-  }
-}
-
-function onAccept() {
-  var columnCount = result.columnCount;
-  for (var i = 0; i < columnCount; i++) {
-    var element = document.getElementById(result.getColumnName(i));
-    if (element.value)
-      enumerator.setVariant(i, element.value);
-    else
-      enumerator.setNull(i);
-  }
-
-  try {
-    if (window.arguments.length == 2)
-      enumerator.updateRow();
-    else
-      enumerator.insertRow();
-  }
-  catch(ex) {
-    alert(enumerator.errorMessage);
-    return false;
-  }
-
-  return true;
-}

mozilla/extensions/sql/sqltest/sqltestDialog.xul

@@ -1,33 +0,0 @@
-<?xml version="1.0"?>
-
-<?xml-stylesheet href="chrome://global/skin/" type="text/css"?>
-
-<dialog id="testDialog"
-  xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
-  title="Test dialog"
-  buttons="accept,cancel" buttonpack="center"
-  ondialogaccept="return onAccept();"
-  onload="init()">
-
-  <script type="application/x-javascript" src="sqltestDialog.js"/>
-
-  <grid flex="1">
-    <columns>
-      <column/>
-      <column flex="1"/>
-    </columns>
-    <rows>
-      <row>
-        <label value="Code:"/>  
-        <hbox>
-          <textbox id="code" size="2" maxlength="2" oninput="this.value = this.value.toUpperCase()"/>
-        </hbox>
-      </row>
-      <row>
-        <label value="Name:"/>
-        <textbox id="name" size="30" maxlength="30"/>
-      </row>
-    </rows>
-  </grid>
-
-</dialog>

mozilla/extensions/sql/sqltest/states.sql

@@ -1,4 +0,0 @@
-create table states (
-  code	varchar(2) primary key,
-  name	varchar(30)
-);

mozilla/extensions/sql/sqltest/states.txt

@@ -1,51 +0,0 @@
-AL	Alabama
-AK	Alaska
-AZ	Arizona
-AR	Arkansas
-CA	California
-CO	Colorado
-CT	Connecticut
-DE	Delaware
-FL	Florida
-GA	Georgia
-HI	Hawaii
-ID	Idaho
-IL	Illinois
-IN	Indiana
-IA	Iowa
-KS	Kansas
-KY	Kentucky
-LA	Louisiana
-ME	Maine
-MD	Maryland
-MA	Massachusetts
-MI	Michigan
-MN	Minnesota
-MS	Mississippi
-MO	Missouri
-MT	Montana
-NE	Nebraska
-NV	Nevada
-NH	New Hampshire
-NJ	New Jersey
-NM	New Mexico
-NY	New York
-NC	North Carolina
-ND	North Dakota
-OH	Ohio
-OK	Oklahoma
-OR	Oregon
-PA	Pennsylvania
-RI	Rhode Island
-SC	South Carolina
-SD	South Dakota
-TN	Tennessee
-TX	Texas
-UT	Utah
-VT	Vermont
-VA	Virginia
-WA	Washington
-DC	Washington,D.C.
-WV	West Virginia
-WI	Wisconsin
-WY	Wyoming

mozilla/extensions/sql/tests/Makefile.in

@@ -1,6 +0,0 @@
-DEPTH		= ../../..
-topsrcdir	= @top_srcdir@
-srcdir		= @srcdir@
-VPATH		= @srcdir@
-
-include $(topsrcdir)/config/rules.mk