public Addressable AddressOf(IReferenceable value)
{
if (value is InstanceFieldAccess)
{
return(dispatcher.AddressOf(value as InstanceFieldAccess));
}
else if (value is StaticFieldAccess)
{
return(dispatcher.AddressOf(value as StaticFieldAccess));
}
else if (value is IVariable)
{
return(dispatcher.AddressOf(value as IVariable));
}
else if (value is ArrayElementAccess)
{
throw new NotImplementedException();
}
else if (value is Dereference dereference)
{
return(dispatcher.AddressOf(dereference.Reference));
}
// I should have covered all possible cases
throw new NotImplementedException();
}
void IPersistable.ResolveReferences(Dictionary <AspNetCore.ReportingServices.ReportIntermediateFormat.Persistence.ObjectType, List <MemberReference> > memberReferencesCollection, Dictionary <int, IReferenceable> referenceableItems)
{
List <MemberReference> list = default(List <MemberReference>);
if (memberReferencesCollection.TryGetValue(ParameterDef.m_Declaration.ObjectType, out list))
{
foreach (MemberReference item2 in list)
{
MemberName memberName = item2.MemberName;
if (memberName == MemberName.DependencyRefList)
{
IReferenceable referenceable = default(IReferenceable);
referenceableItems.TryGetValue(item2.RefID, out referenceable);
ParameterDef item = referenceable as ParameterDef;
if (this.m_dependencyList == null)
{
this.m_dependencyList = new List <ParameterDef>();
}
this.m_dependencyList.Add(item);
}
else
{
Global.Tracer.Assert(false);
}
}
}
}
private bool RequiresAllocation(IReferenceable referenceable)
{
// we are assuming that a IManagedPointerType can not be a pointer of a pointer
Contract.Assume(!(referenceable is IManagedPointerType) || !ReferenceFinder.IsReferenced(referenceable));
return(ReferenceFinder.IsReferenced(referenceable));
}
public override void ResolveReferences(Dictionary <AspNetCore.ReportingServices.ReportIntermediateFormat.Persistence.ObjectType, List <MemberReference> > memberReferencesCollection, Dictionary <int, IReferenceable> referenceableItems)
{
List <MemberReference> list = default(List <MemberReference>);
if (memberReferencesCollection.TryGetValue(Page.m_Declaration.ObjectType, out list))
{
foreach (MemberReference item2 in list)
{
MemberName memberName = item2.MemberName;
if (memberName == MemberName.InScopeTextBoxes)
{
if (this.m_inScopeTextBoxes == null)
{
this.m_inScopeTextBoxes = new List <TextBox>();
}
IReferenceable referenceable = default(IReferenceable);
referenceableItems.TryGetValue(item2.RefID, out referenceable);
TextBox item = (TextBox)referenceable;
this.m_inScopeTextBoxes.Add(item);
}
else
{
Global.Tracer.Assert(false);
}
}
}
}
private Expression GetExpressionFromIValue(IValue value)
{
if (RequiresAllocation(value) || value is Dereference) // if true, value is in a subset of IReferenceable stuff
{
// something requires an allocation because it has been reference (it is referenceable)
IReferenceable referenceable = value as IReferenceable;
return(memAddr.ReadAddr(memAddr.AddressOf(referenceable)));
}
if (value.Type is IManagedPointerType)
{
AddressExpression addr = memAddr.AddressOf(value) as AddressExpression;
return(addr.Expr);
}
if (value is Constant constant)
{
return(BoogieLiteral.FromDotNetConstant(constant));
}
// we use old memory model here because they were not referenced
if (value is IReferenceable || value is Reference)
{
Addressable addressable = memBCT.AddressOf(value);
return(memBCT.ReadAddr(addressable));
}
throw new NotImplementedException();
}
internal IEnumerable <AnalysisVariable> ToVariables(IReferenceable referenceable)
{
LocatedVariableDef locatedDef = referenceable as LocatedVariableDef;
if (locatedDef != null &&
locatedDef.Entry.Tree != null && // null tree if there are errors in the file
locatedDef.DeclaringVersion == locatedDef.Entry.AnalysisVersion)
{
var start = locatedDef.Node.GetStart(locatedDef.Entry.Tree);
yield return(new AnalysisVariable(VariableType.Definition, new LocationInfo(locatedDef.Entry, start.Line, start.Column)));
}
VariableDef def = referenceable as VariableDef;
if (def != null)
{
foreach (var location in def.TypesNoCopy.SelectMany(type => type.Locations))
{
yield return(new AnalysisVariable(VariableType.Value, location));
}
}
foreach (var reference in referenceable.Definitions)
{
yield return(new AnalysisVariable(VariableType.Definition, reference.Value.GetLocationInfo(reference.Key)));
}
foreach (var reference in referenceable.References)
{
yield return(new AnalysisVariable(VariableType.Reference, reference.Value.GetLocationInfo(reference.Key)));
}
}
public static void AddReference(IReferenceable referenceable)
{
Contract.Assert(!(referenceable is StaticFieldAccess) && !(referenceable is InstanceFieldAccess));
// this is just to be aware when this happens, we should support arrays!
Contract.Assert(!(referenceable is ArrayElementAccess));
ReferencedSet.Add(referenceable);
}
public PersistenceFixture(IReferenceable refs, IConfigurable conf, IOpenable open, IClosable close, ICleanable clean,
IWriter<Dummy, string> write, IGetter<Dummy, string> get, ISetter<Dummy> set)
{
Assert.NotNull(refs);
_refs = refs;
Assert.NotNull(conf);
_conf = conf;
Assert.NotNull(open);
_open = open;
Assert.NotNull(close);
_close = close;
Assert.NotNull(clean);
_clean = clean;
Assert.NotNull(write);
_write = write;
Assert.NotNull(get);
_get = get;
Assert.NotNull(set);
_set = set;
}
/// <summary>
/// Tracks the reference to the given
/// <paramref name="objectToReference"/>
/// </summary>
/// <param name="objectToReference">Object for which a reference should be stored</param>
/// <param name="referenceToObject">Reference of the given object</param>
public void AddReference(object objectToReference, IReferenceable referenceToObject)
{
if (_references.Contains(objectToReference))
{
return;
}
_references.Add(objectToReference, new Reference(referenceToObject));
}
public static IRef <TCast> CastRef <TCast>(this IReferenceable sourceRef)
where TCast : IReferenceable
{
if (sourceRef == null)
{
return(null);
}
return(sourceRef.id.AsRef <TCast>());
}
public ReferenceEvent(ReferenceEventType type, IReferenceable source)
{
Type = type;
if (source != null)
{
Source = source.IsUser() ? ReferenceEventSource.User : ReferenceEventSource.Organization;
Id = source.Id;
ReferenceData = source.ReferenceData;
}
}
public static ReferenceTypeId GetResourceType <T>(this IReferenceable <T> identifier)
{
var attr = typeof(T).GetCustomAttributes(typeof(ResourceTypeAttribute)).FirstOrDefault();
if (attr != null)
{
return(((ResourceTypeAttribute)attr).Value);
}
throw new ArgumentException($"Missing ResourceTypeAttribute for type {typeof(T)}");
}
public override void ResolveReferences(Dictionary <AspNetCore.ReportingServices.ReportIntermediateFormat.Persistence.ObjectType, List <MemberReference> > memberReferencesCollection, Dictionary <int, IReferenceable> referenceableItems)
{
List <MemberReference> list = default(List <MemberReference>);
if (memberReferencesCollection.TryGetValue(Cell.m_Declaration.ObjectType, out list))
{
foreach (MemberReference item2 in list)
{
switch (item2.MemberName)
{
case MemberName.ParentRowID:
Global.Tracer.Assert(referenceableItems.ContainsKey(item2.RefID), "ParentRowID");
base.m_parentIDOwner = (IDOwner)referenceableItems[item2.RefID];
this.m_parentRowID = item2.RefID;
break;
case MemberName.ParentColumnID:
Global.Tracer.Assert(referenceableItems.ContainsKey(item2.RefID), "ParentColumnID");
this.m_parentColumnIDOwner = (IDOwner)referenceableItems[item2.RefID];
this.m_parentColumnID = item2.RefID;
break;
case MemberName.DataRegionDef:
{
IReferenceable referenceable2 = default(IReferenceable);
referenceableItems.TryGetValue(item2.RefID, out referenceable2);
Global.Tracer.Assert(referenceable2 != null && ((ReportItem)referenceable2).IsDataRegion, "DataRegionDef");
this.m_dataRegionDef = (DataRegion)referenceable2;
break;
}
case MemberName.InScopeEventSources:
{
IReferenceable referenceable = default(IReferenceable);
referenceableItems.TryGetValue(item2.RefID, out referenceable);
IInScopeEventSource item = (IInScopeEventSource)referenceable;
if (this.m_inScopeEventSources == null)
{
this.m_inScopeEventSources = new List <IInScopeEventSource>();
}
this.m_inScopeEventSources.Add(item);
break;
}
default:
Global.Tracer.Assert(false);
break;
}
}
}
}
static public bool IsReferenced(IReferenceable referenceable)
{
if (referenceable is StaticFieldAccess staticFieldAccess)
{
return(IsReferenced(staticFieldAccess.Field));
}
else if (referenceable is InstanceFieldAccess instanceFieldAccess)
{
return(IsReferenced(instanceFieldAccess.Field));
}
else
{
return(ReferencedSet.Contains(referenceable));
}
}
internal IEnumerable <AnalysisVariable> ToVariables(AnalysisUnit unit, IReferenceable referenceable)
{
LocatedVariableDef locatedDef = referenceable as LocatedVariableDef;
if (locatedDef != null &&
locatedDef.Entry.Tree != null && // null tree if there are errors in the file
locatedDef.DeclaringVersion == locatedDef.Entry.AnalysisVersion)
{
var start = locatedDef.Node;
yield return(new AnalysisVariable(VariableType.Definition, locatedDef.Entry.Tree.ResolveLocation(locatedDef.Entry, start)));
}
VariableDef def = referenceable as VariableDef;
if (def != null)
{
foreach (var location in def.GetTypesNoCopy(unit).SelectMany(type => type.Value.Locations))
{
yield return(new AnalysisVariable(VariableType.Value, location));
}
}
UserFunctionValue func = referenceable as UserFunctionValue;
if (func != null &&
func.ProjectEntry.Tree != null &&
func.DeclaringVersion == func.ProjectEntry.AnalysisVersion)
{
var start = func.FunctionObject;
yield return(new AnalysisVariable(VariableType.Definition, func.ProjectEntry.Tree.ResolveLocation(func.ProjectEntry, start)));
}
foreach (var reference in referenceable.Definitions)
{
yield return(new AnalysisVariable(
_definitionsAreReferences ? VariableType.Reference : VariableType.Definition,
reference.Value.GetLocationInfo(reference.Key)
));
}
foreach (var reference in referenceable.References)
{
yield return(new AnalysisVariable(VariableType.Reference, reference.Value.GetLocationInfo(reference.Key)));
}
}
public override void Visit(LoadInstruction instruction)
{
if (instruction.Operand is Reference reference)
{
// Reference object is an expression of the form &<...>
// <...> is the pointedObj
IReferenceable pointedObj = reference.Value;
if (pointedObj is InstanceFieldAccess ||
pointedObj is StaticFieldAccess)
{
return;
}
ReferenceFinder.AddReference(pointedObj);
}
}
public override void ResolveReferences(Dictionary <AspNetCore.ReportingServices.ReportIntermediateFormat.Persistence.ObjectType, List <MemberReference> > memberReferencesCollection, Dictionary <int, IReferenceable> referenceableItems)
{
base.ResolveReferences(memberReferencesCollection, referenceableItems);
List <MemberReference> list = default(List <MemberReference>);
if (memberReferencesCollection.TryGetValue(TextBox.m_Declaration.ObjectType, out list))
{
foreach (MemberReference item in list)
{
switch (item.MemberName)
{
case MemberName.ContainingScopes:
if (this.m_containingScopes == null)
{
this.m_containingScopes = new GroupingList();
}
if (item.RefID != -2)
{
Global.Tracer.Assert(referenceableItems.ContainsKey(item.RefID));
Global.Tracer.Assert(referenceableItems[item.RefID] is Grouping);
Global.Tracer.Assert(!this.m_containingScopes.Contains((Grouping)referenceableItems[item.RefID]));
this.m_containingScopes.Add((Grouping)referenceableItems[item.RefID]);
}
else
{
this.m_containingScopes.Add(null);
}
break;
case MemberName.RecursiveMember:
{
IReferenceable referenceable = default(IReferenceable);
if (referenceableItems.TryGetValue(item.RefID, out referenceable))
{
this.m_recursiveMember = (referenceable as TablixMember);
}
break;
}
default:
Global.Tracer.Assert(false);
break;
}
}
}
}
public override void Visit(LoadInstruction instruction)
{
if (instruction.Operand is Reference reference)
{
// Reference object is an expression of the form &<...>
// <...> is the pointedObj
IReferenceable pointedObj = reference.Value;
if (pointedObj is StaticFieldAccess staticFieldAccess)
{
FieldReferencedSet.Add(staticFieldAccess.Field);
}
else if (pointedObj is InstanceFieldAccess instanceFieldAccess)
{
FieldReferencedSet.Add(instanceFieldAccess.Field);
}
}
}
private IEnumerable <IAnalysisVariable> ToVariables(IReferenceable referenceable)
{
LocatedVariableDef locatedDef = referenceable as LocatedVariableDef;
if (locatedDef != null)
{
yield return(new AnalysisVariable(VariableType.Definition, new LocationInfo(locatedDef.Entry, locatedDef.Node.Start.Line, locatedDef.Node.Start.Column)));
}
foreach (var reference in referenceable.Definitions)
{
yield return(new AnalysisVariable(VariableType.Definition, new LocationInfo(reference.Key, reference.Value.Line, reference.Value.Column)));
}
foreach (var reference in referenceable.References)
{
yield return(new AnalysisVariable(VariableType.Reference, new LocationInfo(reference.Key, reference.Value.Line, reference.Value.Column)));
}
}
public void ResolveReferences(Dictionary <AspNetCore.ReportingServices.ReportIntermediateFormat.Persistence.ObjectType, List <MemberReference> > memberReferencesCollection, Dictionary <int, IReferenceable> referenceableItems)
{
List <MemberReference> list = default(List <MemberReference>);
if (memberReferencesCollection.TryGetValue(Visibility.m_Declaration.ObjectType, out list))
{
foreach (MemberReference item in list)
{
switch (item.MemberName)
{
case MemberName.ToggleSender:
{
IReferenceable referenceable2 = default(IReferenceable);
if (referenceableItems.TryGetValue(item.RefID, out referenceable2))
{
this.m_toggleSender = (referenceable2 as TextBox);
}
break;
}
case MemberName.RecursiveMember:
{
IReferenceable referenceable = default(IReferenceable);
if (referenceableItems.TryGetValue(item.RefID, out referenceable))
{
this.m_recursiveMember = (referenceable as TablixMember);
}
break;
}
default:
Global.Tracer.Assert(false);
break;
}
}
}
}
internal void WriteReference(IReferenceable referenceableItem)
{
WriteReferenceID(referenceableItem?.ID ?? (-1));
}
internal IEnumerable<AnalysisVariable> ToVariables(IReferenceable referenceable) {
LocatedVariableDef locatedDef = referenceable as LocatedVariableDef;
if (locatedDef != null &&
locatedDef.Entry.Tree != null && // null tree if there are errors in the file
locatedDef.DeclaringVersion == locatedDef.Entry.AnalysisVersion) {
var start = locatedDef.Node;
yield return new AnalysisVariable(VariableType.Definition, locatedDef.Entry.Tree.ResolveLocation(locatedDef.Entry, start));
}
VariableDef def = referenceable as VariableDef;
if (def != null) {
foreach (var location in def.GetTypesNoCopy(_unit).SelectMany(type => type.Value.Locations)) {
yield return new AnalysisVariable(VariableType.Value, location);
}
}
foreach (var reference in referenceable.Definitions) {
yield return new AnalysisVariable(VariableType.Definition, reference.Value.GetLocationInfo(reference.Key));
}
foreach (var reference in referenceable.References) {
yield return new AnalysisVariable(VariableType.Reference, reference.Value.GetLocationInfo(reference.Key));
}
}
private void WriteReferenceInList(IReferenceable referenceableItem)
{
WriteReferenceID(referenceableItem?.ID ?? (-2));
}
public Reference(IReferenceable referenceable)
{
Referenceable = referenceable;
}
public Reference(IReferenceable value)
{
this.Value = value;
}
internal static string ReferenceWithPage(IReferenceable referenceable)
{
return(ReferenceWithPage(referenceable.Label));
}
static public bool IsReferenced(IReferenceable referenceable)
{
return(ReferencedSet.Contains(referenceable));
}
private IEnumerable<IAnalysisVariable> ToVariables(IReferenceable referenceable)
{
LocatedVariableDef locatedDef = referenceable as LocatedVariableDef;
if (locatedDef != null) {
yield return new AnalysisVariable(VariableType.Definition, new LocationInfo(locatedDef.Entry, locatedDef.Node.Start.Line, locatedDef.Node.Start.Column, locatedDef.Node.Span.Length));
}
foreach (var reference in referenceable.Definitions) {
yield return new AnalysisVariable(VariableType.Definition, new LocationInfo(reference.Key, reference.Value.Line, reference.Value.Column, reference.Value.Length));
}
foreach (var reference in referenceable.References) {
yield return new AnalysisVariable(VariableType.Reference, new LocationInfo(reference.Key, reference.Value.Line, reference.Value.Column, reference.Value.Length));
}
}
internal IEnumerable<AnalysisVariable> ToVariables(IReferenceable referenceable)
{
LocatedVariableDef locatedDef = referenceable as LocatedVariableDef;
if (locatedDef != null &&
locatedDef.Entry.Tree != null && // null tree if there are errors in the file
locatedDef.DeclaringVersion == locatedDef.Entry.AnalysisVersion) {
var start = locatedDef.Node.GetStart(locatedDef.Entry.Tree);
yield return new AnalysisVariable(VariableType.Definition, new LocationInfo(locatedDef.Entry.FilePath, start.Line, start.Column));
}
VariableDef def = referenceable as VariableDef;
if (def != null) {
foreach (var location in def.TypesNoCopy.SelectMany(type => type.Locations)) {
yield return new AnalysisVariable(VariableType.Value, location);
}
}
foreach (var reference in referenceable.Definitions) {
yield return new AnalysisVariable(
VariableType.Definition,
reference.GetLocationInfo()
);
}
foreach (var reference in referenceable.References) {
yield return new AnalysisVariable(
VariableType.Reference,
reference.GetLocationInfo()
);
}
}
public static CartDraft DefaultCartDraftInStore(CartDraft cartDraft, IReferenceable <Store> store)
{
cartDraft.Currency = DefaultCurrency;
cartDraft.Store = store;
return(cartDraft);
}
public void VisitMethod(MethodBody mBody, ControlFlowGraph cfg)
{
VisitLocals(mBody);
// Going through the instructions via cfg nodes instead of directly iterating over the instructions
// of the methodBody becuase Phi instructions may not have been inserted in the insts of the methodBody.
foreach (var node in cfg.Nodes)
{
foreach (var instruction in node.Instructions)
{
// System.Console.WriteLine("{0}", instruction.ToString());
// System.Console.WriteLine("{0}", instruction.GetType().FullName());
// System.Console.WriteLine();
if (instruction is LoadInstruction)
{
LoadInstruction lInst = instruction as LoadInstruction;
IValue rhsOperand = lInst.Operand;
if (rhsOperand is StaticFieldAccess)
{
StaticFieldAccess rhsAcc = rhsOperand as StaticFieldAccess;
IFieldReference fld = rhsAcc.Field;
ITypeDefinition fldType = fld.ContainingType.ResolvedType;
Stubber.CheckAndAdd(fldType);
}
// Note: calls to static methods and instance methods appear as a StaticMethodReference
else if (rhsOperand is StaticMethodReference)
{
StaticMethodReference sMethAddr = rhsOperand as StaticMethodReference;
IMethodDefinition tgtMeth = sMethAddr.Method.ResolvedMethod;
ITypeDefinition containingTy = tgtMeth.ContainingTypeDefinition;
Stubber.CheckAndAdd(containingTy);
IMethodDefinition addedMeth = Stubber.CheckAndAdd(tgtMeth);
// addrTakenMethods do not contain templates.
if (addedMeth != null)
{
addrTakenMethods.Add(addedMeth);
}
}
//Note: calls to virtual, abstract or interface methods appear as VirtualMethodReference
else if (rhsOperand is VirtualMethodReference)
{
VirtualMethodReference sMethAddr = rhsOperand as VirtualMethodReference;
IMethodDefinition tgtMeth = sMethAddr.Method.ResolvedMethod;
ITypeDefinition containingTy = tgtMeth.ContainingTypeDefinition;
ITypeDefinition addedTy = Stubber.CheckAndAdd(containingTy);
IMethodDefinition addedMeth = Stubber.CheckAndAdd(tgtMeth);
if (addedTy != null && addedMeth != null)
{
// addrTakenMethods do not contain templates.
addrTakenMethods.Add(addedMeth);
ProcessVirtualInvoke(addedMeth, addedTy, true);
}
}
else if (rhsOperand is Reference)
{
Reference rhsRef = rhsOperand as Reference;
IReferenceable refOf = rhsRef.Value;
if (refOf is StaticFieldAccess)
{
StaticFieldAccess refAcc = refOf as StaticFieldAccess;
IFieldDefinition fld = refAcc.Field.ResolvedField;
ITypeDefinition fldType = fld.ContainingType.ResolvedType;
Stubber.CheckAndAdd(fldType);
addrTakenStatFlds.Add(fld);
}
else if (refOf is IVariable)
{
IVariable refVar = refOf as IVariable;
if (!refVar.Type.IsValueType || refVar.Type.ResolvedType.IsStruct)
{
addrTakenLocals.Add(refVar);
}
}
else if (refOf is InstanceFieldAccess)
{
InstanceFieldAccess refAcc = refOf as InstanceFieldAccess;
IFieldDefinition fld = refAcc.Field.ResolvedField;
addrTakenInstFlds.Add(fld);
}
else if (refOf is ArrayElementAccess)
{
// All arrays will be added into domX as potential address taken.
}
}
}
else if (instruction is StoreInstruction)
{
StoreInstruction sInst = instruction as StoreInstruction;
IAssignableValue lhs = sInst.Result;
if (lhs is StaticFieldAccess)
{
StaticFieldAccess lhsAcc = lhs as StaticFieldAccess;
IFieldReference fld = lhsAcc.Field;
ITypeDefinition fldType = fld.ContainingType.ResolvedType;
Stubber.CheckAndAdd(fldType);
}
}
else if (instruction is CreateObjectInstruction)
{
CreateObjectInstruction newObjInst = instruction as CreateObjectInstruction;
ITypeReference objType = newObjInst.AllocationType;
ITypeDefinition objTypeDef = objType.ResolvedType;
if (objTypeDef is IGenericTypeInstance)
{
objTypeDef = objTypeDef.ResolvedType;
}
ITypeDefinition addedTy = Stubber.CheckAndAdd(objTypeDef);
if (addedTy != null && !allocClasses.Contains(addedTy))
{
allocClasses.Add(addedTy);
}
}
else if (instruction is CreateArrayInstruction)
{
CreateArrayInstruction newArrInst = instruction as CreateArrayInstruction;
ITypeReference elemType = newArrInst.ElementType;
ITypeDefinition elemTypeDef = elemType.ResolvedType;
ITypeDefinition addedTy = Stubber.CheckAndAdd(elemTypeDef);
if (addedTy != null && !allocClasses.Contains(addedTy))
{
allocClasses.Add(addedTy);
}
}
else if (instruction is MethodCallInstruction)
{
MethodCallInstruction invkInst = instruction as MethodCallInstruction;
IMethodReference callTgt = invkInst.Method;
ITypeReference containingType = callTgt.ContainingType;
ITypeDefinition declType = containingType.ResolvedType;
IMethodDefinition callTgtDef = callTgt.ResolvedMethod;
ITypeDefinition addedType = Stubber.CheckAndAdd(declType);
IMethodDefinition addedMeth = Stubber.CheckAndAdd(callTgtDef);
MethodCallOperation callType = invkInst.Operation;
if (callType == MethodCallOperation.Virtual && addedType != null && addedMeth != null)
{
ProcessVirtualInvoke(addedMeth, addedType, false);
}
}
else
{
// System.Console.WriteLine("{0}", instruction.ToString());
// System.Console.WriteLine("Not currently handled: {0}", instruction.GetType().ToString());
// System.Console.WriteLine();
}
}
}
}
public static ShoppingListDraft DefaultShoppingListDraftInStore(ShoppingListDraft draft, IReferenceable <Store> store)
{
draft.Store = store;
return(draft);
}
