public override Expression VisitMemoryAccess(MemoryAccess access)
{
access.EffectiveAddress = access.EffectiveAddress.Accept(this);
if (aem.Match(access.EffectiveAddress))
{
if (aem.ArrayPointer == null)
{
aem.ArrayPointer = Constant.Create(
PrimitiveType.Create(
Domain.Pointer,
access.EffectiveAddress.DataType.Size),
0);
}
return aem.Transform(null, access.DataType);
}
else if (access.EffectiveAddress is Identifier)
{
access.EffectiveAddress = AddZeroToEffectiveAddress(access.EffectiveAddress);
return access;
}
else
{
return access;
}
}
public override Expression VisitMemoryAccess(MemoryAccess access)
{
access.EffectiveAddress = access.EffectiveAddress.Accept(this);
if (aem.Match(access.EffectiveAddress))
{
if (aem.ArrayPointer == null)
{
aem.ArrayPointer = Constant.Create(
PrimitiveType.Create(
Domain.Pointer,
access.EffectiveAddress.DataType.Size),
0);
}
return aem.Transform(null, access.DataType);
}
BinaryExpression bin;
if (access.EffectiveAddress.As(out bin) && bin.Operator == Operator.IAdd)
return access;
if (access.EffectiveAddress is Constant)
return access;
access.EffectiveAddress = AddZeroToEffectiveAddress(access.EffectiveAddress);
return access;
}
public override Expression VisitMemoryAccess(MemoryAccess access)
{
Expression ea = access.EffectiveAddress.Accept(this);
DataType type = access.DataType;
Constant c = ea as Constant;
if (c != null)
{
return new Identifier(string.Format("g_{0}{1:X8}", type.Prefix, c.ToUInt32()), type, new MemoryStorage());
}
Identifier id = ea as Identifier;
if (id != null)
{
return new FieldAccess(type, new Dereference(type, id), CreateField(type, 0));
}
BinaryExpression b = ea as BinaryExpression;
if (b != null)
{
c = b.Right as Constant;
if (c != null && b.Operator == Operator.IAdd)
return new FieldAccess(type, new Dereference(type, b.Left), CreateField(type, c.ToInt32()));
}
return new Dereference(null, ea);
}
static Game()
{
Version = (GameVersion)MemoryAccess.GetGameVersion();
}
public override void VisitMemoryAccess(MemoryAccess access)
{
access.EffectiveAddress.Accept(this);
EnsureTypeVariable(access);
}
public void VisitMemoryAccess(MemoryAccess access)
{
handler.MemAccessTrait(basePointer, access, access.DataType.Size, eField, 0);
}
public Expression GetValue(MemoryAccess access)
{
return access;
}
public Expression GetValue(MemoryAccess access)
{
int stackOffset;
if (GetStackOffset(access.EffectiveAddress, out stackOffset))
{
Expression value;
if (stackState.TryGetValue(stackOffset, out value))
return value;
}
return Constant.Invalid;
}
/// <summary>
/// Given a memory access, attempts to determine the index register.
/// </summary>
/// <param name="mem"></param>
/// <returns></returns>
public RegisterStorage DetermineIndexRegister(MemoryAccess mem)
{
Stride = 0;
var id = mem.EffectiveAddress as Identifier; // Mem[reg]
if (id != null)
{
Stride = 1;
return RegisterOf(id);
}
var bin = mem.EffectiveAddress as BinaryExpression;
if (bin == null)
return null;
var idLeft = bin.Left as Identifier;
var idRight = bin.Right as Identifier;
if (idRight != null && idLeft == null)
{
// Rearrange so that the effective address is [id + C]
var t = idLeft;
idLeft = idRight;
idRight = t;
}
if (idLeft != null && idRight != null)
{
// Can't handle [id1 + id2] yet.
return null;
}
if (idLeft != null)
{
// We have [id + C]
Stride = 1;
DetermineVector(mem, bin.Right);
if (host.IsValidAddress(VectorAddress))
return RegisterOf(idLeft);
else
return null;
}
var binLeft = bin.Left as BinaryExpression;
if (IsScaledIndex(binLeft))
{
// We have [(id * C1) + C2]
return DetermineVectorWithScaledIndex(mem, bin.Right, binLeft);
}
var binRight = bin.Right as BinaryExpression;
if (IsScaledIndex(binRight))
{
// We may have [C1 + (id * C2)]
return DetermineVectorWithScaledIndex(mem, bin.Left, binRight);
}
return null;
}
public static WeaponComponent[] GetComponentsFromHash(WeaponHash hash)
{
switch (hash)
{
case WeaponHash.Pistol:
return(new WeaponComponent[] {
WeaponComponent.PistolClip01,
WeaponComponent.PistolClip02,
WeaponComponent.AtPiFlsh,
WeaponComponent.AtPiSupp02,
WeaponComponent.PistolVarmodLuxe,
});
case WeaponHash.CombatPistol:
return(new WeaponComponent[] {
WeaponComponent.CombatPistolClip01,
WeaponComponent.CombatPistolClip02,
WeaponComponent.AtPiFlsh,
WeaponComponent.AtPiSupp,
WeaponComponent.CombatPistolVarmodLowrider,
});
case WeaponHash.APPistol:
return(new WeaponComponent[] {
WeaponComponent.APPistolClip01,
WeaponComponent.APPistolClip02,
WeaponComponent.AtPiFlsh,
WeaponComponent.AtPiSupp,
WeaponComponent.APPistolVarmodLuxe,
});
case WeaponHash.MicroSMG:
return(new WeaponComponent[] {
WeaponComponent.MicroSMGClip01,
WeaponComponent.MicroSMGClip02,
WeaponComponent.AtPiFlsh,
WeaponComponent.AtScopeMacro,
WeaponComponent.AtArSupp02,
WeaponComponent.MicroSMGVarmodLuxe,
});
case WeaponHash.SMG:
return(new WeaponComponent[] {
WeaponComponent.SMGClip01,
WeaponComponent.SMGClip02,
WeaponComponent.SMGClip03,
WeaponComponent.AtArFlsh,
WeaponComponent.AtPiSupp,
WeaponComponent.AtScopeMacro02,
WeaponComponent.AtArAfGrip,
WeaponComponent.SMGVarmodLuxe,
});
case WeaponHash.AssaultRifle:
return(new WeaponComponent[] {
WeaponComponent.AssaultRifleClip01,
WeaponComponent.AssaultRifleClip02,
WeaponComponent.AssaultRifleClip03,
WeaponComponent.AtArAfGrip,
WeaponComponent.AtArFlsh,
WeaponComponent.AtScopeMacro,
WeaponComponent.AtArSupp02,
WeaponComponent.AssaultRifleVarmodLuxe,
});
case WeaponHash.CarbineRifle:
return(new WeaponComponent[] {
WeaponComponent.CarbineRifleClip01,
WeaponComponent.CarbineRifleClip02,
WeaponComponent.CarbineRifleClip03,
WeaponComponent.AtRailCover01,
WeaponComponent.AtArAfGrip,
WeaponComponent.AtArFlsh,
WeaponComponent.AtScopeMedium,
WeaponComponent.AtArSupp,
WeaponComponent.CarbineRifleVarmodLuxe,
});
case WeaponHash.AdvancedRifle:
return(new WeaponComponent[] {
WeaponComponent.AdvancedRifleClip01,
WeaponComponent.AdvancedRifleClip02,
WeaponComponent.AtArFlsh,
WeaponComponent.AtScopeSmall,
WeaponComponent.AtArSupp,
WeaponComponent.AdvancedRifleVarmodLuxe,
});
case WeaponHash.MG:
return(new WeaponComponent[] {
WeaponComponent.MGClip01,
WeaponComponent.MGClip02,
WeaponComponent.AtScopeSmall02,
WeaponComponent.AtArAfGrip,
WeaponComponent.MGVarmodLowrider,
});
case WeaponHash.CombatMG:
return(new WeaponComponent[] {
WeaponComponent.CombatMGClip01,
WeaponComponent.CombatMGClip02,
WeaponComponent.AtArAfGrip,
WeaponComponent.AtScopeMedium,
WeaponComponent.CombatMGVarmodLowrider,
});
case WeaponHash.PumpShotgun:
return(new WeaponComponent[] {
WeaponComponent.AtSrSupp,
WeaponComponent.AtArFlsh,
WeaponComponent.PumpShotgunVarmodLowrider,
});
case WeaponHash.AssaultShotgun:
return(new WeaponComponent[] {
WeaponComponent.AssaultShotgunClip01,
WeaponComponent.AssaultShotgunClip02,
WeaponComponent.AtArAfGrip,
WeaponComponent.AtArFlsh,
WeaponComponent.AtArSupp,
});
case WeaponHash.SniperRifle:
return(new WeaponComponent[] {
WeaponComponent.SniperRifleClip01,
WeaponComponent.AtScopeLarge,
WeaponComponent.AtScopeMax,
WeaponComponent.AtArSupp02,
WeaponComponent.SniperRifleVarmodLuxe,
});
case WeaponHash.HeavySniper:
return(new WeaponComponent[] {
WeaponComponent.HeavySniperClip01,
WeaponComponent.AtScopeLarge,
WeaponComponent.AtScopeMax,
});
case WeaponHash.GrenadeLauncher:
return(new WeaponComponent[] {
WeaponComponent.AtArAfGrip,
WeaponComponent.AtArFlsh,
WeaponComponent.AtScopeSmall,
});
case WeaponHash.Minigun:
return(new WeaponComponent[] {
WeaponComponent.MinigunClip01,
});
case WeaponHash.AssaultSMG:
return(new WeaponComponent[] {
WeaponComponent.AssaultSMGClip01,
WeaponComponent.AssaultSMGClip02,
WeaponComponent.AtArFlsh,
WeaponComponent.AtScopeMacro,
WeaponComponent.AtArSupp02,
WeaponComponent.AssaultSMGVarmodLowrider,
});
case WeaponHash.BullpupShotgun:
return(new WeaponComponent[] {
WeaponComponent.AtArAfGrip,
WeaponComponent.AtArFlsh,
WeaponComponent.AtArSupp02,
});
case WeaponHash.Pistol50:
return(new WeaponComponent[] {
WeaponComponent.Pistol50Clip01,
WeaponComponent.Pistol50Clip02,
WeaponComponent.AtPiFlsh,
WeaponComponent.AtArSupp02,
WeaponComponent.Pistol50VarmodLuxe,
});
case WeaponHash.CombatPDW:
return(new WeaponComponent[] {
WeaponComponent.CombatPDWClip01,
WeaponComponent.CombatPDWClip02,
WeaponComponent.CombatPDWClip03,
WeaponComponent.AtArFlsh,
WeaponComponent.AtScopeSmall,
WeaponComponent.AtArAfGrip,
});
case WeaponHash.SawnOffShotgun:
return(new WeaponComponent[] {
WeaponComponent.SawnoffShotgunVarmodLuxe,
});
case WeaponHash.BullpupRifle:
return(new WeaponComponent[] {
WeaponComponent.BullpupRifleClip01,
WeaponComponent.BullpupRifleClip02,
WeaponComponent.AtArFlsh,
WeaponComponent.AtScopeSmall,
WeaponComponent.AtArSupp,
WeaponComponent.AtArAfGrip,
WeaponComponent.BullpupRifleVarmodLow,
});
case WeaponHash.SNSPistol:
return(new WeaponComponent[] {
WeaponComponent.SNSPistolClip01,
WeaponComponent.SNSPistolClip02,
WeaponComponent.SNSPistolVarmodLowrider,
});
case WeaponHash.SpecialCarbine:
return(new WeaponComponent[] {
WeaponComponent.SpecialCarbineClip01,
WeaponComponent.SpecialCarbineClip02,
WeaponComponent.SpecialCarbineClip03,
WeaponComponent.AtArFlsh,
WeaponComponent.AtScopeMedium,
WeaponComponent.AtArSupp02,
WeaponComponent.AtArAfGrip,
WeaponComponent.SpecialCarbineVarmodLowrider,
});
case WeaponHash.KnuckleDuster:
return(new WeaponComponent[] {
WeaponComponent.KnuckleVarmodPimp,
WeaponComponent.KnuckleVarmodBallas,
WeaponComponent.KnuckleVarmodDollar,
WeaponComponent.KnuckleVarmodDiamond,
WeaponComponent.KnuckleVarmodHate,
WeaponComponent.KnuckleVarmodLove,
WeaponComponent.KnuckleVarmodPlayer,
WeaponComponent.KnuckleVarmodKing,
WeaponComponent.KnuckleVarmodVagos,
});
case WeaponHash.MachinePistol:
return(new WeaponComponent[] {
WeaponComponent.MachinePistolClip01,
WeaponComponent.MachinePistolClip02,
WeaponComponent.MachinePistolClip03,
WeaponComponent.AtPiSupp,
});
case WeaponHash.SwitchBlade:
return(new WeaponComponent[] {
WeaponComponent.SwitchbladeVarmodVar1,
WeaponComponent.SwitchbladeVarmodVar2,
});
case WeaponHash.Revolver:
return(new WeaponComponent[] {
WeaponComponent.RevolverClip01,
WeaponComponent.RevolverVarmodBoss,
WeaponComponent.RevolverVarmodGoon,
});
}
IntPtr data = Marshal.AllocCoTaskMem(39 * 8);
WeaponComponent[] result = null;
for (int i = 0, count = Function.Call <int>(Native.Hash.GET_NUM_DLC_WEAPONS); i < count; i++)
{
if (Function.Call <bool>(Native.Hash.GET_DLC_WEAPON_DATA, i, data))
{
if (MemoryAccess.ReadInt(data + 8) == (int)hash)
{
result = new WeaponComponent[Function.Call <int>(Native.Hash.GET_NUM_DLC_WEAPON_COMPONENTS, i)];
for (int j = 0; j < result.Length; j++)
{
if (Function.Call <bool>(Native.Hash.GET_DLC_WEAPON_COMPONENT_DATA, i, j, data))
{
result[j] = (WeaponComponent)MemoryAccess.ReadInt(data + 3 * 8);
}
else
{
result[j] = WeaponComponent.Invalid;
}
}
break;
}
}
}
Marshal.FreeCoTaskMem(data);
if (result == null)
{
result = new WeaponComponent[0];
}
return(result);
}
private Constant GetOffset(MemoryAccess access)
{
if (memOffset.Match(access))
{
return (Constant) memOffset.CapturedExpression("offset");
}
if (segMemOffset.Match(access))
{
return (Constant)segMemOffset.CapturedExpression("offset");
}
return null;
}
public override Expression CreateStackAccess(Frame frame, int offset, DataType dataType)
{
var rsp = frame.EnsureRegister(Registers.rsp);
return(MemoryAccess.Create(rsp, offset, dataType));
}
public static string GetDisplayNameFromHash(WeaponHash hash)
{
switch (hash)
{
case WeaponHash.Pistol:
return("WTT_PIST");
case WeaponHash.CombatPistol:
return("WTT_PIST_CBT");
case WeaponHash.APPistol:
return("WTT_PIST_AP");
case WeaponHash.SMG:
return("WTT_SMG");
case WeaponHash.MicroSMG:
return("WTT_SMG_MCR");
case WeaponHash.AssaultRifle:
return("WTT_RIFLE_ASL");
case WeaponHash.CarbineRifle:
return("WTT_RIFLE_CBN");
case WeaponHash.AdvancedRifle:
return("WTT_RIFLE_ADV");
case WeaponHash.MG:
return("WTT_MG");
case WeaponHash.CombatMG:
return("WTT_MG_CBT");
case WeaponHash.PumpShotgun:
return("WTT_SG_PMP");
case WeaponHash.SawnOffShotgun:
return("WTT_SG_SOF");
case WeaponHash.AssaultShotgun:
return("WTT_SG_ASL");
case WeaponHash.HeavySniper:
return("WTT_SNIP_HVY");
case WeaponHash.SniperRifle:
return("WTT_SNIP_RIF");
case WeaponHash.GrenadeLauncher:
return("WTT_GL");
case WeaponHash.RPG:
return("WTT_RPG");
case WeaponHash.Minigun:
return("WTT_MINIGUN");
case WeaponHash.AssaultSMG:
return("WTT_SMG_ASL");
case WeaponHash.BullpupShotgun:
return("WTT_SG_BLP");
case WeaponHash.Pistol50:
return("WTT_PIST_50");
case WeaponHash.Bottle:
return("WTT_BOTTLE");
case WeaponHash.Gusenberg:
return("WTT_GUSENBERG");
case WeaponHash.SNSPistol:
return("WTT_SNSPISTOL");
case WeaponHash.VintagePistol:
return("WTT_VPISTOL");
case WeaponHash.Dagger:
return("WTT_DAGGER");
case WeaponHash.FlareGun:
return("WTT_FLAREGUN");
case WeaponHash.Musket:
return("WTT_MUSKET");
case WeaponHash.Firework:
return("WTT_FWRKLNCHR");
case WeaponHash.MarksmanRifle:
return("WTT_HMKRIFLE");
case WeaponHash.HeavyShotgun:
return("WTT_HVYSHOT");
case WeaponHash.ProximityMine:
return("WTT_PRXMINE");
case WeaponHash.HomingLauncher:
return("WTT_HOMLNCH");
case WeaponHash.CombatPDW:
return("WTT_COMBATPDW");
case WeaponHash.KnuckleDuster:
return("WTT_KNUCKLE");
case WeaponHash.MarksmanPistol:
return("WTT_MKPISTOL");
case WeaponHash.Machete:
return("WTT_MACHETE");
case WeaponHash.MachinePistol:
return("WTT_MCHPIST");
case WeaponHash.Flashlight:
return("WTT_FLASHLIGHT");
case WeaponHash.DoubleBarrelShotgun:
return("WTT_DBSHGN");
case WeaponHash.CompactRifle:
return("WTT_CMPRIFLE");
case WeaponHash.SwitchBlade:
return("WTT_SWBLADE");
case WeaponHash.Revolver:
return("WTT_REVOLVER");
}
IntPtr data = Marshal.AllocCoTaskMem(39 * 8);
string result = string.Empty;
for (int i = 0, count = Function.Call <int>(Native.Hash.GET_NUM_DLC_WEAPONS); i < count; i++)
{
if (Function.Call <bool>(Native.Hash.GET_DLC_WEAPON_DATA, i, data))
{
if (MemoryAccess.ReadInt(data + 8) == (int)hash)
{
result = MemoryAccess.ReadString(data + 23 * 8);
break;
}
}
}
Marshal.FreeCoTaskMem(data);
return(result);
}
public static Entity[] GetNearbyEntities(Vector3 position, float radius)
{
return(Array.ConvertAll <int, Entity>(MemoryAccess.GetEntityHandles(position, radius), Entity.FromHandle));
}
public override void VisitMemoryAccess(MemoryAccess access)
{
isCritical = IsCritical(access.EffectiveAddress);
}
public override Expression VisitMemoryAccess(MemoryAccess access)
{
var tmer = new TypedMemoryExpressionRewriter(prog);
return tmer.Rewrite(access);
}
public override void VisitMemoryAccess(MemoryAccess access)
{
access.EffectiveAddress.Accept(this);
}
public static string GetComponentDisplayNameFromHash(WeaponHash hash, WeaponComponent component)
{
if (hash == WeaponHash.KnuckleDuster)
{
switch (component)
{
case WeaponComponent.KnuckleVarmodBase:
return("WT_KNUCKLE");
case WeaponComponent.KnuckleVarmodPimp:
return("WCT_KNUCK_02");
case WeaponComponent.KnuckleVarmodBallas:
return("WCT_KNUCK_BG");
case WeaponComponent.KnuckleVarmodDollar:
return("WCT_KNUCK_DLR");
case WeaponComponent.KnuckleVarmodDiamond:
return("WCT_KNUCK_DMD");
case WeaponComponent.KnuckleVarmodHate:
return("WCT_KNUCK_HT");
case WeaponComponent.KnuckleVarmodLove:
return("WCT_KNUCK_LV");
case WeaponComponent.KnuckleVarmodPlayer:
return("WCT_KNUCK_PC");
case WeaponComponent.KnuckleVarmodKing:
return("WCT_KNUCK_SLG");
case WeaponComponent.KnuckleVarmodVagos:
return("WCT_KNUCK_VG");
}
}
else
{
switch (component)
{
case WeaponComponent.AtRailCover01:
return("WCT_RAIL");
case WeaponComponent.AtArAfGrip:
return("WCT_GRIP");
case WeaponComponent.AtPiFlsh:
case WeaponComponent.AtArFlsh:
return("WCT_FLASH");
case WeaponComponent.AtScopeMacro:
return("WCT_SCOPE_MAC");
case WeaponComponent.AtScopeMacro02:
return("WCT_SCOPE_MAC");
case WeaponComponent.AtScopeSmall:
return("WCT_SCOPE_SML");
case WeaponComponent.AtScopeSmall02:
return("WCT_SCOPE_SML");
case WeaponComponent.AtScopeMedium:
return("WCT_SCOPE_MED");
case WeaponComponent.AtScopeLarge:
return("WCT_SCOPE_LRG");
case WeaponComponent.AtScopeMax:
return("WCT_SCOPE_MAX");
case WeaponComponent.AtPiSupp:
case WeaponComponent.AtArSupp:
case WeaponComponent.AtArSupp02:
case WeaponComponent.AtSrSupp:
return("WCT_SUPP");
case WeaponComponent.PistolClip01:
case WeaponComponent.CombatPistolClip01:
case WeaponComponent.APPistolClip01:
case WeaponComponent.MicroSMGClip01:
case WeaponComponent.AssaultRifleClip01:
case WeaponComponent.CarbineRifleClip01:
case WeaponComponent.AdvancedRifleClip01:
case WeaponComponent.MGClip01:
case WeaponComponent.CombatMGClip01:
case WeaponComponent.AssaultShotgunClip01:
case WeaponComponent.SniperRifleClip01:
case WeaponComponent.HeavySniperClip01:
case WeaponComponent.AssaultSMGClip01:
case WeaponComponent.Pistol50Clip01:
case (WeaponComponent)0x0BAAB157:
case (WeaponComponent)0x5AF49386:
case (WeaponComponent)0xCAEBD246:
case (WeaponComponent)0xF8955D89:
case WeaponComponent.SNSPistolClip01:
case WeaponComponent.VintagePistolClip01:
case WeaponComponent.HeavyShotgunClip01:
case WeaponComponent.MarksmanRifleClip01:
case WeaponComponent.CombatPDWClip01:
case WeaponComponent.MarksmanPistolClip01:
case WeaponComponent.MachinePistolClip01:
return("WCT_CLIP1");
case WeaponComponent.PistolClip02:
case WeaponComponent.CombatPistolClip02:
case WeaponComponent.APPistolClip02:
case WeaponComponent.MicroSMGClip02:
case WeaponComponent.SMGClip02:
case WeaponComponent.AssaultRifleClip02:
case WeaponComponent.CarbineRifleClip02:
case WeaponComponent.AdvancedRifleClip02:
case WeaponComponent.MGClip02:
case WeaponComponent.CombatMGClip02:
case WeaponComponent.AssaultShotgunClip02:
case WeaponComponent.MinigunClip01:
case WeaponComponent.AssaultSMGClip02:
case WeaponComponent.Pistol50Clip02:
case (WeaponComponent)0x6CBF371B:
case (WeaponComponent)0xE1C5FFFA:
case (WeaponComponent)0x3E7E6956:
case WeaponComponent.SNSPistolClip02:
case WeaponComponent.VintagePistolClip02:
case WeaponComponent.HeavyShotgunClip02:
case WeaponComponent.MarksmanRifleClip02:
case WeaponComponent.CombatPDWClip02:
case WeaponComponent.MachinePistolClip02:
return("WCT_CLIP2");
case WeaponComponent.AtScopeLargeFixedZoom:
return("WCT_SCOPE_LRG");
case WeaponComponent.AtPiSupp02:
return("WCT_SUPP");
case WeaponComponent.AssaultRifleVarmodLuxe:
case WeaponComponent.CarbineRifleVarmodLuxe:
case WeaponComponent.PistolVarmodLuxe:
case WeaponComponent.SMGVarmodLuxe:
case WeaponComponent.MicroSMGVarmodLuxe:
case (WeaponComponent)0x161E9241:
case WeaponComponent.AssaultSMGVarmodLowrider:
case WeaponComponent.CombatPistolVarmodLowrider:
case WeaponComponent.MGVarmodLowrider:
case WeaponComponent.PumpShotgunVarmodLowrider:
return("WCT_VAR_GOLD");
case WeaponComponent.AdvancedRifleVarmodLuxe:
case WeaponComponent.APPistolVarmodLuxe:
case WeaponComponent.SawnoffShotgunVarmodLuxe:
case WeaponComponent.BullpupRifleVarmodLow:
return("WCT_VAR_METAL");
case WeaponComponent.Pistol50VarmodLuxe:
return("WCT_VAR_SIL");
case WeaponComponent.HeavyPistolVarmodLuxe:
case WeaponComponent.SniperRifleVarmodLuxe:
case WeaponComponent.SNSPistolVarmodLowrider:
return("WCT_VAR_WOOD");
case WeaponComponent.CombatMGVarmodLowrider:
case WeaponComponent.SpecialCarbineVarmodLowrider:
return("WCT_VAR_ETCHM");
case WeaponComponent.SwitchbladeVarmodBase:
return("WCT_SB_BASE");
case WeaponComponent.SwitchbladeVarmodVar1:
return("WCT_SB_VAR1");
case WeaponComponent.SwitchbladeVarmodVar2:
return("WCT_SB_VAR2");
case WeaponComponent.RevolverClip01:
return("WCT_CLIP1");
case WeaponComponent.RevolverVarmodBoss:
return("WCT_REV_VARB");
case WeaponComponent.RevolverVarmodGoon:
return("WCT_REV_VARG");
case WeaponComponent.SMGClip03:
case WeaponComponent.AssaultRifleClip03:
case WeaponComponent.HeavyShotgunClip03:
return("WCT_CLIP_DRM");
case WeaponComponent.CarbineRifleClip03:
return("WCT_CLIP_BOX");
}
}
IntPtr data = Marshal.AllocCoTaskMem(39 * 8);
string result = string.Empty;
for (int i = 0, count = Function.Call <int>(Native.Hash.GET_NUM_DLC_WEAPONS); i < count; i++)
{
if (Function.Call <bool>(Native.Hash.GET_DLC_WEAPON_DATA, i, data))
{
if (MemoryAccess.ReadInt(data + 8) == (int)hash)
{
int maxComp = Function.Call <int>(Native.Hash.GET_NUM_DLC_WEAPON_COMPONENTS, i);
for (int j = 0; j < maxComp; j++)
{
if (Function.Call <bool>(Native.Hash.GET_DLC_WEAPON_COMPONENT_DATA, i, j, data))
{
if (MemoryAccess.ReadInt(data + 3 * 8) == (int)component)
{
result = MemoryAccess.ReadString(data + 6 * 8);
break;
}
}
}
break;
}
}
}
Marshal.FreeCoTaskMem(data);
return(result);
}
public bool MemoryOperandsAdjacent(MemoryAccess m1, MemoryAccess m2)
{
//$TODO: endianness?
var off1 = GetOffset(m1);
var off2 = GetOffset(m2);
if (off1 == null || off2 == null)
return false;
return off1.ToInt32() + m1.DataType.Size == off2.ToInt32();
}
public BitRange VisitMemoryAccess(MemoryAccess access)
{
return(access.EffectiveAddress.Accept(this));
}
public Expression GetValue(MemoryAccess access)
{
throw new NotImplementedException();
}
public T UncheckedGet(int index) => MemoryAccess.ReadValue <T>(this.data + (index * ElementSize));
public void VisitMemoryAccess(MemoryAccess access)
{
access.MemoryId.Accept(this);
writer.Write("[");
WriteExpression(access.EffectiveAddress);
writer.Write(":");
writer.Write(access.DataType.ToString());
writer.Write("]");
}
public bool VisitMemoryAccess(MemoryAccess access)
{
access.EffectiveAddress.Accept(this);
return(false);
}
private void DetermineVector(MemoryAccess mem, Expression possibleVector)
{
var vector = possibleVector as Constant;
if (vector == null)
return;
var pt = vector.DataType as PrimitiveType;
if (pt != null && pt.Domain == Domain.SignedInt)
return;
var segmem = mem as SegmentedAccess;
if (segmem != null)
{
var selector = segmem.BasePointer.Accept(eval) as Constant;
if (selector != null)
{
VectorAddress = host.MakeSegmentedAddress(selector, vector);
}
}
else
{
VectorAddress = host.MakeAddressFromConstant(vector); //$BUG: 32-bit only, what about 16- and 64-
}
}
public override Expression CreateStackAccess(IStorageBinder binder, int cbOffset, DataType dataType)
{
var sp = binder.EnsureRegister(this.StackRegister);
return(MemoryAccess.Create(sp, cbOffset, dataType));
}
public void UncheckedSet(int index, T value) => MemoryAccess.WriteValue(value, this.data + (index * ElementSize));
public Expression Transform()
{
ctx.RemoveIdentifierUse(seg);
ctx.RemoveIdentifierUse(idOff);
Expression ea;
if (segMem.EffectiveAddress == idOff)
{
ea = new MemoryAccess(segPtr, segMem.DataType);
}
else
{
var bin = (BinaryExpression)segMem.EffectiveAddress;
if (bin.Left == idOff)
{
ea = new BinaryExpression(bin.Operator, bin.DataType, segPtr, bin.Right);
}
else
throw new NotImplementedException();
}
ctx.UseExpression(segPtr);
return new MemoryAccess(ea, segMem.DataType);
}
public void VisitMemoryAccess(MemoryAccess access)
{
handler.MemAccessTrait(basePointer, access, access.DataType.BitSize, eField !, 0);
}
public virtual void VisitMemoryAccess(MemoryAccess access)
{
access.EffectiveAddress.Accept(this);
access.MemoryId.Accept(this);
}
public override void VisitMemoryAccess(MemoryAccess access)
{
bitUseOffset = 0;
cbitsUse = 0;
access.EffectiveAddress.Accept(this);
}
public override Expression CreateStackAccess(IStorageBinder binder, int offset, DataType dataType)
{
var rsp = binder.EnsureRegister(Registers.rsp);
return(MemoryAccess.Create(rsp, offset, dataType));
}
/// <summary>
/// Returns a localized <see cref="string"/> from the games language files with a specified GXT key hash.
/// </summary>
/// <param name="entryLabelHash">The GXT key hash.</param>
/// <returns>The localized <see cref="string"/> if the key hash exists; otherwise, <see cref="string.Empty"/></returns>
public static string GetLocalizedString(int entryLabelHash)
{
return(MemoryAccess.GetGXTEntryByHash(entryLabelHash));
}
public bool VisitMemoryAccess(MemoryAccess access) => access.EffectiveAddress.Accept(this);
public Expression GetValue(MemoryAccess access, SegmentMap segmentMap)
{
return(Constant.Invalid);
}
public virtual Expression VisitMemoryAccess(MemoryAccess access)
{
access.EffectiveAddress = access.EffectiveAddress.Accept(this);
access.MemoryId = (MemoryIdentifier)access.MemoryId.Accept(this);
return(access);
}
public override void VisitMemoryAccess(MemoryAccess access)
{
base.VisitMemoryAccess(access);
flags |= SideEffectFlags.Load;
}
public Expression Rewrite(MemoryAccess access)
{
basePointer = null;
dtResult = new Pointer(access.TypeVariable.DataType, access.EffectiveAddress.DataType.Size);
return(access.EffectiveAddress.Accept(this));
}
private Expression CreateMemoryAccess(MemoryAccess mem, DataType totalSize)
{
var segmem = mem as SegmentedAccess;
if (segmem != null)
{
return new SegmentedAccess(segmem.MemoryId, segmem.BasePointer, segmem.EffectiveAddress, totalSize);
}
else
{
return new MemoryAccess(mem.MemoryId, mem.EffectiveAddress, totalSize);
}
}
public override void VisitMemoryAccess(MemoryAccess access)
{
base.VisitMemoryAccess(access);
flags |= SideEffectFlags.Load;
}
public void TrcoInductionVariable()
{
Identifier i = new Identifier("i", PrimitiveType.Word32, null);
MemoryAccess load = new MemoryAccess(MemoryIdentifier.GlobalMemory, i, PrimitiveType.Int32);
Identifier i2 = new Identifier("i2", PrimitiveType.Word32, null);
MemoryAccess ld2 = new MemoryAccess(MemoryIdentifier.GlobalMemory, i2, PrimitiveType.Int32);
LinearInductionVariable iv = new LinearInductionVariable(
Constant.Word32(0),
Constant.Word32(1),
Constant.Word32(10),
false);
LinearInductionVariable iv2 = new LinearInductionVariable(
Constant.Word32(0x0010000),
Constant.Word32(4),
Constant.Word32(0x0010040),
false);
Program prog = CreateProgram();
prog.InductionVariables.Add(i, iv);
prog.InductionVariables.Add(i2, iv2);
coll = CreateCollector(prog);
prog.Globals.Accept(eqb);
load.Accept(eqb);
ld2.Accept(eqb);
prog.Globals.Accept(coll);
load.Accept(coll);
ld2.Accept(coll);
Verify(null, "Typing/TrcoInductionVariable.txt");
}
public Expression GetValue(MemoryAccess access)
{
return(GetValueEa(access));
}
public override Expression VisitMemoryAccess(MemoryAccess access)
{
if (this.renameFrameAccess && IsFrameAccess(proc, access.EffectiveAddress))
{
var idFrame = EnsureStackVariable(proc, access.EffectiveAddress, access.DataType);
var idNew = NewUse(idFrame, stmCur);
return idNew;
}
return base.VisitMemoryAccess(access);
}
/// <summary>
/// Given a memory access, attempts to determine the index register.
/// </summary>
/// <param name="mem"></param>
/// <returns></returns>
public RegisterStorage DetermineIndexRegister(MemoryAccess mem)
{
Stride = 0;
// Mem[reg]
if (mem.EffectiveAddress is Identifier id)
{
Stride = 1;
return(RegisterOf(id));
}
var bin = mem.EffectiveAddress as BinaryExpression;
if (bin == null)
{
return(null);
}
var idLeft = bin.Left as Identifier;
var idRight = bin.Right as Identifier;
if (idRight != null && idLeft == null)
{
// Rearrange so that the effective address is [id + C]
var t = idLeft;
idLeft = idRight;
idRight = t;
}
if (idLeft != null && idRight != null)
{
// Can't handle [id1 + id2] yet.
return(null);
}
if (idLeft != null)
{
// We have [id + C]
Stride = 1;
if (host.IsStackRegister(idLeft.Storage))
{
return(null);
}
DetermineVector(mem, bin.Right);
if (VectorAddress != null && host.IsValidAddress(VectorAddress))
{
return(RegisterOf(idLeft));
}
else
{
return(null);
}
}
var binLeft = bin.Left as BinaryExpression;
if (IsScaledIndex(binLeft))
{
// We have [(id * C1) + C2]
return(DetermineVectorWithScaledIndex(mem, bin.Right, binLeft));
}
var binRight = bin.Right as BinaryExpression;
if (IsScaledIndex(binRight))
{
// We may have [C1 + (id * C2)]
return(DetermineVectorWithScaledIndex(mem, bin.Left, binRight));
}
return(null);
}
private RegisterStorage DetermineVectorWithScaledIndex(MemoryAccess mem, Expression possibleVector, BinaryExpression scaledIndex)
{
Stride = ((Constant)scaledIndex.Right).ToInt32(); // Mem[x + reg * C]
DetermineVector(mem, possibleVector);
return(RegisterOf(scaledIndex.Left as Identifier));
}
public override void VisitMemoryAccess(MemoryAccess access)
{
isCritical = IsCritical(access.EffectiveAddress);
}
public void DtbInductionVariables()
{
Identifier i = new Identifier("i", PrimitiveType.Word32, null);
MemoryAccess load = new MemoryAccess(MemoryIdentifier.GlobalMemory, i, PrimitiveType.Int32);
Identifier i2 = new Identifier("i2", PrimitiveType.Word32, null);
MemoryAccess ld2 = new MemoryAccess(MemoryIdentifier.GlobalMemory, i2, PrimitiveType.Int32);
LinearInductionVariable iv = new LinearInductionVariable(
Constant.Word32(0),
Constant.Word32(1),
Constant.Word32(10),
false);
LinearInductionVariable iv2 = new LinearInductionVariable(
Constant.Word32(0x0010000),
Constant.Word32(4),
Constant.Word32(0x0010040),
false);
prog.InductionVariables.Add(i, iv);
prog.InductionVariables.Add(i2, iv2);
prog.Platform = new DefaultPlatform(null, arch);
TraitCollector trco = new TraitCollector(factory, store, dtb, prog);
prog.Globals.Accept(eqb);
load.Accept(eqb);
ld2.Accept(eqb);
prog.Globals.Accept(trco);
load.Accept(trco);
ld2.Accept(trco);
dtb.BuildEquivalenceClassDataTypes();
Verify("Typing/DtbInductionVariables.txt");
}
public bool VisitMemoryAccess(MemoryAccess access, TypeVariable tv)
{
return(VisitMemoryAccess(null, access.TypeVariable, access.EffectiveAddress, globals));
}
private RegisterStorage DetermineVectorWithScaledIndex(MemoryAccess mem, Expression possibleVector, BinaryExpression scaledIndex)
{
Stride = ((Constant)scaledIndex.Right).ToInt32(); // Mem[x + reg * C]
DetermineVector(mem, possibleVector);
return RegisterOf(scaledIndex.Left as Identifier);
}
public override LinearInductionVariable VisitMemoryAccess(MemoryAccess access)
{
return(null);
}
public override void VisitMemoryAccess(MemoryAccess access)
{
access.EffectiveAddress.Accept(this);
EnsureTypeVariable(access);
}
public Expression GetValue(MemoryAccess access, SegmentMap segmentMap)
{
return(access);
}
public virtual void VisitMemoryAccess(MemoryAccess access)
{
access.EffectiveAddress.Accept(this);
access.MemoryId.Accept(this);
}
public override Expression VisitMemoryAccess(MemoryAccess access)
{
var oldBase = this.basePtr;
this.basePtr = null;
var ea = Rewrite(access.EffectiveAddress, true);
this.basePtr = oldBase;
return ea;
}
