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 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 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 Expression GetValue(MemoryAccess access, SegmentMap segmentMap) { return(access); }
public override Expression VisitMemoryAccess(MemoryAccess access) { var oldBase = this.basePtr; this.basePtr = null; var ea = Rewrite(access.EffectiveAddress, true); this.basePtr = oldBase; return ea; }