public ITypeDefOrRef ResolveTypeDefOrRef(uint codedToken, GenericParamContext gpContext)
{
uint token;
if (!CodedToken.TypeDefOrRef.Decode(codedToken, out token))
{
return(null);
}
uint rid = MDToken.ToRID(token);
switch (MDToken.ToTable(token))
{
case Table.TypeDef: return(new TypeDefUser(UTF8String.Empty)
{
Rid = rid
});
case Table.TypeRef: return(new TypeRefUser(null, UTF8String.Empty)
{
Rid = rid
});
case Table.TypeSpec: return(new TypeSpecUser()
{
Rid = rid
});
}
return(null);
}
ITypeDefOrRef ISignatureReaderHelper.ResolveTypeDefOrRef(uint codedToken, GenericParamContext gpContext)
{
uint token;
bool flag = !CodedToken.TypeDefOrRef.Decode(codedToken, out token);
bool flag2 = flag;
ITypeDefOrRef result;
if (flag2)
{
result = null;
}
else
{
uint rid = MDToken.ToRID(token);
Table table = MDToken.ToTable(token);
bool flag3 = table - Table.TypeRef > 1 && table != Table.TypeSpec;
if (flag3)
{
result = null;
}
else
{
result = this.ImportType(rid);
}
}
return(result);
}
public void Add(DumpedMethod dm)
{
if (MDToken.ToTable(dm.token) != Table.Method || MDToken.ToRID(dm.token) == 0)
{
throw new ArgumentException("Invalid token");
}
methods[dm.token] = dm;
}
void InitializeInverseGenericParamOwnerRidList()
{
if (gpRidToOwnerRid != null)
{
return;
}
var gpTable = tablesStream.GenericParamTable;
var newGpRidToOwnerRid = new uint[gpTable.Rows];
// Find all owners by reading the GenericParam.Owner column
var ownerCol = gpTable.TableInfo.Columns[2];
var ownersDict = new Dictionary <uint, bool>();
#if THREAD_SAFE
tablesStream.theLock.EnterWriteLock(); try {
#endif
for (uint rid = 1; rid <= gpTable.Rows; rid++)
{
uint owner;
if (!tablesStream.ReadColumn_NoLock(gpTable, rid, ownerCol, out owner))
{
continue;
}
ownersDict[owner] = true;
}
#if THREAD_SAFE
}
finally { tablesStream.theLock.ExitWriteLock(); }
#endif
// Now that we have the owners, find all the generic params they own. An obfuscated
// module could have 2+ owners pointing to the same generic param row.
var owners = new List <uint>(ownersDict.Keys);
owners.Sort();
for (int i = 0; i < owners.Count; i++)
{
uint ownerToken;
if (!CodedToken.TypeOrMethodDef.Decode(owners[i], out ownerToken))
{
continue;
}
var ridList = GetGenericParamRidList(MDToken.ToTable(ownerToken), MDToken.ToRID(ownerToken));
for (uint j = 0; j < ridList.Length; j++)
{
uint ridIndex = ridList[j] - 1;
if (newGpRidToOwnerRid[ridIndex] != 0)
{
continue;
}
newGpRidToOwnerRid[ridIndex] = owners[i];
}
}
Interlocked.CompareExchange(ref gpRidToOwnerRid, newGpRidToOwnerRid, null);
}
protected override MethodSig ReadInlineSig(Instruction instr)
{
var token = reader.ReadUInt32();
if (MDToken.ToTable(token) != Table.StandAloneSig)
{
return(null);
}
var sas = module.ResolveStandAloneSig(MDToken.ToRID(token));
return(sas == null ? null : sas.MethodSig);
}
/// <summary>
/// Encodes a token
/// </summary>
/// <param name="token">The token</param>
/// <param name="codedToken">Coded token</param>
/// <returns><c>true</c> if successful</returns>
public bool Encode(uint token, out uint codedToken)
{
int index = Array.IndexOf(tableTypes, MDToken.ToTable(token));
if (index < 0)
{
codedToken = uint.MaxValue;
return(false);
}
// This shift can never overflow a uint since bits < 8 (it's at most 5), and
// ToRid() returns an integer <= 0x00FFFFFF.
codedToken = (MDToken.ToRID(token) << bits) | (uint)index;
return(true);
}
public ITypeDefOrRef ResolveTypeDefOrRef(uint codedToken, GenericParamContext gpContext)
{
if (!CodedToken.TypeDefOrRef.Decode(codedToken, out uint token))
{
return(null);
}
uint rid = MDToken.ToRID(token);
switch (MDToken.ToTable(token))
{
case Table.TypeDef: return(new TypeDefDndbg(mdi, rid));
case Table.TypeRef: return(new TypeRefDndbg(mdi, rid));
case Table.TypeSpec: return(new TypeSpecDndbg(mdi, rid, this));
}
return(null);
}
ITypeDefOrRef ISignatureReaderHelper.ResolveTypeDefOrRef(uint codedToken, GenericParamContext gpContext)
{
uint token;
if (!CodedToken.TypeDefOrRef.Decode(codedToken, out token))
{
return(null);
}
uint rid = MDToken.ToRID(token);
switch (MDToken.ToTable(token))
{
case Table.TypeDef:
case Table.TypeRef:
case Table.TypeSpec:
return(ImportType(rid));
}
return(null);
}