//////////////////////////////////////////////////////////////////////////////
// Type map implementation

// Type maps are created and used to map the type indices used by symbols in
// the current module, into type indices corresponding to type records
// stored in the types section of the output PDB.
//
// Type maps are organized according to this class hierarchy:
//	TM		// abstract base class
//	 TMTS	// TypeServer type map (for "cl /Zi" modules)
//	 TMR	// single-module type record type map (for "cl /Z7" modules)
//	  TMPCT	// precompiled type type map (for "cl /Yc /Z7" modules)
//
// TM lifetimes.  Whereas each TMR object is created to pack types for a single
// /Z7 module before its subsequent destruction at Mod1::Close, both TMTS (/Zi) and
// TMPCT (/Yc /Z7) type map objects, once created, are kept alive and associated
// with the current DBI object until DBI1::Close.
//
// For TMTSs, this is done for efficiency: if several modules reference types
// in some other PDB, it would be wasteful to continually open and close that
// PDB and continually remap its types.  Consider:
//
//	// mod1.cpp						// mod2.cpp
//	#include "x.h"					#include "x.h"
//	X x1;							X x2;
//
//	// Generated CV information (/Zi):
//	mod1.obj:						mod2.obj:
//	 symbols:						 symbols:
//	  S_GDATA32 x1 ti(X)			  S_GDATA32 x2 ti(X)
//	 types:							  S_GDATA32 p  ti(int**)
//	  LF_TYPESERVER foo.pdb			 types:
//									   LF_TYPESERVER foo.pdb
//
// Here if mod1.obj and then mod2.obj are packed using DBI::OpenMod, etc., it
// would be inefficient to open, use, establish a type map for X and the types
// X transitively refers to, and then close foo.pdb, for mod1.obj, only to do
// the same thing over again for mod2.obj.  Rather, the TMTS for mod1.obj
// can be completely reused by mod2.obj, which can then further augment the
// type map with additional types (e.g. int** in the example above).
//
//
// In contrast, TMPCTs persist across modules, not for efficiency, but rather
// to ensure a correct packing of modules which use the C7 PCT (precompiled
// types) feature.  PCTs arise when the /Yc /Z7 and /Yu /Z7 flags are specified.
// For the /Yc /Z7 ("PCH create"), one module (the "PCT module") is compiled
// and all types it sees are written to its module's .obj's types section.
// For subsequent /Yu /Z7 ("PCH use") modules, a special record referencing
// types in the PCT module is emitted rather than repeating types known to be
// in the PCT module's type information.  Thus, a module's symbols may refer to
// type records located in the PCT module rather than the current module's
// type records.
//
// Therefore type information, including raw types and the current partial
// type map, must be retained across modules.  Consider:
//
//	// pct.cpp			// a.cpp			// b.cpp
//	#include "x.h"		#include "x.h"		#include "x.h"
//	#pragma hdrstop		#pragma hdrstop		#pragma hdrstop
//	#include "y.h"		#include "a.h"		#include "b.h"
//	...					...					...
//
//	// Generated CV info (/Yc /Z7 pct.cpp, /Yu /Z7 a.cpp, /Yu /Z7 b.cpp):
//	pct.obj:			a.obj:				b.obj:
//	 symbols:			 symbols:			 symbols:
//	  ...				  ...				  ...
//	 types:				 types:				 types:
//	  <0x1000-0x4000>	  LF_PRECOMP(pct.obj) LF_PRECOMP(pct.obj)
//	  LF_ENDPRECOMP		  <0x4001-...>		  <0x4001-...>
//	  <0x4001-...>
//
// In the example above, we see that each module contains types with type
// indices (ti's) starting at 0x1000; however a.obj and b.obj's modules
// do not actually contain copies of the types known to be in pct.obj; rather
// they reference those types with a PRECOMP record.  Note that pct.obj's
// type 0x4001 is probably different from a.obj's and likewise from b.obj's.
//
// To deal with this kind of module type information, cvpack or link must
// ensure that modules containing LF_ENDPRECOMP are passed to DBI::OpenMod
// and Mod::AddTypes before other modules whose types' LF_PRECOMP's refer
// to PCT modules.
//
// For its part, DBI1 will keep alive (across modules) any TMPCTs that get
// created when types containing LF_ENDPRECOMPs are seen.  Thus subsequent
// modules which contain LF_PRECOMP records referencing those types
// (e.g. compiled "cl /Yu /Z7") can simply load these types from their TMPCT.
// Therefore, for modules containing LF_PRECOMP records, we use a TMPCT to help
// initialize each module's TMR.
//
//
// By the way, someday we may elect to further extend the lifetime of TMTS and
// TMPCT type maps to make them persistent across link/cvpack invocations...

class TM { // abstract type map
public:
	TM(PDB1* ppdb1To_, DBI1* pdbi1To_, TPI* ptpiTo_);
	BOOL fMapRti(TI& rti);
	virtual void endMod();
	virtual void endDBI();
	virtual BOOL IsTMPCT(){return FALSE;}
	virtual ~TM() = 0;
	virtual BOOL fEliminateUDTs() 
	{
		return FALSE;
	}
	virtual BOOL fPackDeferredUDTDefns()
	{
		return TRUE;
	}
	BOOL fNotOutOfTIs(){return ptpiTo->QueryTiMac() < ::tiMax;};
	virtual PTYPE ptypeForTi(TI ti) const pure;
	virtual BOOL QueryTiForUDT(char* sz, BOOL fCase, OUT TI* pti) pure;

protected:
	BOOL fInit(TI tiMin_, TI tiMac_);
	virtual BOOL fMapRti(TI& rti, int depth, BOOL useDefn) = 0;
	inline TI& rtiMapped(TI ti) const;
	inline TI tiBias(TI ti) const;
	inline BOOL isValidTi(TI ti) const;
	
	PDB1* ppdb1To;		// 'to' PDB
	DBI1* pdbi1To;		// 'to' DBI
	TPI* ptpiTo;		// 'to' TypeServer
	TI tiMin;			// minimum TI in this module
	TI tiMac;			// maximum TI in this module + 1
	unsigned ctiFrom;	// tiBias(tiMac)
	TI* mptiti;			// memoization of mapping to project PDB TIs
};

class TMTS : public TM { // type map for modules which use a different TypeServer
public:
	TMTS(PDB1* ppdb1To_, DBI1* pdbi1To_, TPI* ptpiTo_);
	BOOL fInit(PDB* ppdbFrom);
	~TMTS();
	BOOL fEliminateUDTs()
	{
		dassert(ptpiFrom);
		return ptpiFrom->SupportQueryTiForUDT();
	}
	BOOL fPackDeferredUDTDefns();
	inline PTYPE ptypeForTi(TI ti) const;
	BOOL QueryTiForUDT(char* sz, BOOL fCase, OUT TI* pti);

private:
	BOOL fMapRti(TI& rti, int depth, BOOL);
	PDB* ppdbFrom;		// 'from' PDB
	DBI* pdbiFrom;		// 'from' DBI
	TPI* ptpiFrom;		// 'from' TPI
	UDTRefs* pUDTRefs;			// bit maps to track deferred UDT output
};

class TMR : public TM { // type map for module with type records
public:
	TMR(PDB1* ppdb1To_, DBI1* pdbi1To_, TPI* ptpiTo_);
	BOOL fInit(PB pbTypes_, CB cb, SZ szModule);
	void endMod();
	void endDBI();
	BOOL IsTMPCT(){return fTMPCT;}
	SIG Sig(){return signature;}
	~TMR();
	inline PTYPE ptypeForTi(TI ti) const;
	BOOL QueryTiForUDT(char* sz, BOOL fCase, OUT TI* pti);
protected:
	BOOL fMapRti(TI& rti, int depth, BOOL useDefn);
	inline TI& rtiMapped(TI ti) const;
	inline TI& rtiDefnMapped(TI ti) const;
	PTYPE ptypeCreateFwdRef(PTYPE ptype);
	PTYPE ptypeCatenateFieldList(PTYPE ptype);

	TMPCT* ptmpct;		// (if non-0) type map for PCT types
	TI* mptitiDefn;		// memoization of mapping /Z7 struct defn TIs 
						//  to project PDB TIs
	PTYPE* mptiptype;	// mapping from old TI to old type record address
private:
	PB pbTypes;			// group type records referenced by the PCT's mptiptype
	BOOL fTMPCT;        // TRUE if PCT
	SIG signature;		// signature on the TMPCT
};

class TMPCT : public TMR { // type map for a PCT module
public:
	TMPCT(PDB1* ppdb1To_, DBI1* pdbi1To_, TPI* ptpiTo_);
	BOOL fInit(PB pbTypes_, CB cb, SZ szModule);
	void endMod();
	void endDBI();
	~TMPCT();
};

struct OTM {  			// DBI1 helper to find some currently Open TM
	OTM(OTM* pNext_, SZ szName, SIG signature, TM* ptm, BOOL fAlias = FALSE);
	~OTM();
	
	OTM* pNext;			// next OTM in this list
	SIG signature;		// signature on this TM
	SZ szName;			// name of the TM (TMTS: PDB name; TMPCT: module name)
	TM* ptm;	 		// TM (TMTS or TMPCT)
	BOOL fAlias;		// this OTM is an alias for a TMPCT
};