public JsonResult CreateWorkPiece(long wId, long pId, string Name, string Title, string Definition)
{
try
{
using (business.Management.WorkManagement.WorkFunctions wm = new business.Management.WorkManagement.WorkFunctions())
{
WorkList newWPiece = new WorkList
{
Name = Name,
Title = Title,
Definition = Definition,
Register_Date = DateTime.Now,
State = "Çalışılıyor",
Status = true,
WLpersonalId = pId
};
wm.addWorkPiece(newWPiece, wId);
return(Json(new { result = true }, JsonRequestBehavior.AllowGet));
}
}
catch (Exception)
{
return(Json(new { result = false }, JsonRequestBehavior.AllowGet));
}
}
public static bool ModifyWorkList(WorkList model)
{
string sql = string.Format(@"update {0} set [ProjectId]=@ProjectId,[ProjectName]=@ProjectName,[CompanyId]=@CompanyId,[CompanyName]=@CompanyName,[CusMemberId]=@CusMemberId,[CusCompanyId]=@CusCompanyId,[Name]=@Name,[Infos]=@Infos,[GetTime]=@GetTime,[NeedTime]=@NeedTime,[DoTime]=@DoTime,[UserId]=@UserId,[UserName]=@UserName,[Status]=@Status,[Length]=@Length,[IsDeleted]=@IsDeleted,[ModifyDate]=getdate(),[ModifyBy]=@ModifyBy
where Id=@Id", TableName);
return(DBAccess.ExecuteSqlWithEntity(sql, model));
}
public void Transform()
{
SetInitialValues();
var wl = new WorkList <SsaIdentifier>();
wl.AddRange(ssa.Identifiers);
while (wl.TryGetWorkItem(out var sid) && !listener.IsCanceled())
{
var oldValue = ctx.GetValue(sid.Identifier);
if (oldValue is InvalidConstant)
{
continue;
}
var newValue = Evaluate(sid);
if (!cmp.Equals(oldValue, newValue))
{
ctx.SetValue(sid.Identifier, newValue);
foreach (var use in sid.Uses)
{
var uc = new InstructionUseCollector();
var uses = uc.CollectUses(use);
wl.AddRange(uses.Keys.Select(id => ssa.Identifiers[id]));
}
}
}
}
public static bool DeleteWorkList(WorkList model)
{
string sql = string.Format(@"update {0} set [ModifyDate]=getdate(),[ModifyBy]=@ModifyBy,[IsDeleted]=@IsDeleted
where Id=@Id", TableName);
return(DBAccess.ExecuteSqlWithEntity(sql, model));
}
public async Task PrepareWorkList()
{
if (WorkListLoaded)
{
return;
}
List <Work> list = Model.GetWorkList(CourseId);
WorkList.Clear();
foreach (Work work in list)
{
WorkList.Add(new WorkVM(work));
}
string id = CourseId;
if (await Model.RefWorkList(CourseId) == MainModel.UpdateResult.Success)
{
if (id == CourseId)
{
WorkList.Clear();
foreach (Work work in list)
{
WorkList.Add(new WorkVM(work));
}
}
}
WorkListLoaded = true;
RaisePropertyChanged("WorkList");
}
public bool Edit(int?id, string name)
{
if (id.HasValue && id != 0)
{
var list = dc.WorkLists.Where(w => w.WorkListId == id).SingleOrDefault();
list.Name = name;
dc.SaveChanges();
}
else
{
dc.WorkLists.Where(l => l.IsActive).ToList().ForEach(l =>
{
l.IsActive = false;
});
var userID = User.Identity.GetUserId();
var _user = dc.Users.Where(u => u.Id == userID).SingleOrDefault();
WorkList wl = new WorkList
{
IsActive = true,
Name = name,
Date = DateTime.Now,
User = _user
};
dc.WorkLists.Add(wl);
dc.SaveChanges();
}
return(true);
}
private static void EvaluateDebuggerDisplayStringAndContinue(
DkmClrValue value,
WorkList workList,
DkmInspectionContext inspectionContext,
DkmClrType targetType,
string str,
CompletionRoutine <DkmEvaluateDebuggerDisplayStringAsyncResult> onCompleted,
CompletionRoutine <Exception> onException)
{
DkmCompletionRoutine <DkmEvaluateDebuggerDisplayStringAsyncResult> completionRoutine =
result =>
{
try
{
onCompleted(result);
}
catch (Exception e)
{
onException(e);
}
};
if (str == null)
{
completionRoutine(default(DkmEvaluateDebuggerDisplayStringAsyncResult));
}
else
{
value.EvaluateDebuggerDisplayString(workList.InnerWorkList, inspectionContext, targetType, str, completionRoutine);
}
}
/// <summary>
/// Asign index to work in worklist
/// </summary>
public void SetWorkIndex()
{
foreach (ISaveWork li in WorkList)
{
li.Index = WorkList.IndexOf(li);
}
}
/// <summary> 生成 </summary>
public T Spawn()
{
T unit = null;
while (IdleList.Count > 0 && unit == null)
{
unit = IdleList[0];
IdleList.RemoveAt(0);
}
if (unit == null)
{
unit = CreateNewUnit();
}
WorkList.Add(unit);
OnBeforeSpawn(unit);
IPoolable recyclable;
if ((recyclable = unit as IPoolable) != null)
{
recyclable.OnSpawned();
}
OnAfterSpawn(unit);
return(unit);
}
public JsonResult WorkListInfoEdit(string str, int projectId, string name, int id)
{
ResultInfo result = new ResultInfo();
var account = CookieOperate.AccountCookie;
var list = JsonConvert.DeserializeObject <List <WorkListEdit> >(str);
var project = ProjectManageDBOperate.GetModelById(projectId);
var cusMember = CustomerMemberDBOperate.GetModelById(account.AccountId);
var workList = new WorkList()
{
ProjectId = projectId,
ProjectName = project.Name,
CompanyId = CommonMethod.GetInt(ConfigSetting.eeeYoooId),
CompanyName = ConfigSetting.eeeYoooName,
CusMemberId = account.AccountId,
CusCompanyId = cusMember.CusCompanyId,
Name = name,
Id = id,
Status = WorkListStatusEnum.NotStart.ToString(),
Guid = Guid.NewGuid().ToString(),
CreateBy = account.AccountName
};
var flag = WorkListBLL.AddWorkList(workList, list);
if (flag)
{
result.Message = "操作成功"; result.IsSuccess = true;
}
else
{
result.Message = "操作成功";
}
return(Json(result));
}
void IDkmClrResultProvider.GetResult(DkmClrValue value, DkmWorkList workList, DkmClrType declaredType, DkmClrCustomTypeInfo declaredTypeInfo, DkmInspectionContext inspectionContext, ReadOnlyCollection<string> formatSpecifiers, string resultName, string resultFullName, DkmCompletionRoutine<DkmEvaluationAsyncResult> completionRoutine)
{
if (formatSpecifiers == null)
{
formatSpecifiers = Formatter.NoFormatSpecifiers;
}
if (resultFullName != null)
{
ReadOnlyCollection<string> otherSpecifiers;
resultFullName = FullNameProvider.GetClrExpressionAndFormatSpecifiers(inspectionContext, resultFullName, out otherSpecifiers);
foreach (var formatSpecifier in otherSpecifiers)
{
formatSpecifiers = Formatter.AddFormatSpecifier(formatSpecifiers, formatSpecifier);
}
}
var wl = new WorkList(workList, e => completionRoutine(DkmEvaluationAsyncResult.CreateErrorResult(e)));
wl.ContinueWith(
() => GetRootResultAndContinue(
value,
wl,
declaredType,
declaredTypeInfo,
inspectionContext,
resultName,
resultFullName,
formatSpecifiers,
result => wl.ContinueWith(() => completionRoutine(new DkmEvaluationAsyncResult(result)))));
}
/// <summary>
/// Remove any storages in the ProcedureFlow <paramref name="flow"/> associated
/// with the procedure <paramref name="proc"/> if they are dead.
/// </summary>
private bool RemoveLiveInStorages(Procedure proc, ProcedureFlow flow, WorkList <SsaState> wl)
{
var defs = proc.EntryBlock.Statements
.Select(s => s.Instruction as DefInstruction)
.Where(s => s != null)
.Select(s => s !.Identifier.Storage)
.ToHashSet();
var deadStgs = flow.BitsUsed.Keys.Except(defs).ToHashSet();
bool changed = false;
foreach (var d in deadStgs)
{
flow.BitsUsed.Remove(d);
changed = true;
}
if (changed)
{
foreach (Statement stm in program.CallGraph.CallerStatements(proc))
{
if (!(stm.Instruction is CallInstruction ci))
{
continue;
}
var ssaCaller = this.procToSsa[stm.Block.Procedure];
if (RemoveDeadCallUses(ssaCaller, stm, ci, deadStgs))
{
wl.Add(ssaCaller);
}
}
}
return(changed);
}
public override Dictionary <string, IDictionary <Address, IAddressable> > GetObjectPlacements(string fileExtension, DecompilerEventListener listener)
{
this.defaultFile = Path.ChangeExtension(program.Name, fileExtension);
this.defaultDataFile = Path.ChangeExtension(program.Name, "globals" + fileExtension);
// Find the segment for each procedure
var result = new Dictionary <string, IDictionary <Address, IAddressable> >();
foreach (var proc in program.Procedures.Values)
{
PlaceObject(proc, defaultFile, result);
}
// Place all global objects.
var wl = WorkList.Create(
MakeGlobalWorkItems()
.Concat(MakeSegmentWorkitems()));
var objectTracer = new GlobalObjectTracer(program, wl, listener);
while (wl.TryGetWorkItem(out var item))
{
var(field, addr) = item;
var globalVar = new GlobalVariable(addr, field.DataType, program.NamingPolicy.GlobalName(field));
PlaceObject(globalVar, defaultDataFile, result);
objectTracer.TraceObject(field.DataType, addr);
}
return(result);
}
/// <summary>
/// Remove any UseInstructions in the exit block of the procedure that
/// can be proved to be dead out.
/// </summary>
/// <param name="ssa">SSA of the procedure whose exit block is to be examined.</param>
/// <param name="wl">Worklist of SSA states.</param>
/// <returns>True if any change was made to SSA.</returns>
public bool RemoveUnusedDefinedValues(SsaState ssa, WorkList <SsaState> wl)
{
bool change = false;
trace.Verbose("UVR: {0}", ssa.Procedure.Name);
var(deadStms, deadStgs) = FindDeadStatementsInExitBlock(ssa, this.dataFlow[ssa.Procedure].BitsLiveOut);
// Remove 'use' statements that are known to be dead from the exit block.
foreach (var stm in deadStms)
{
trace.Verbose("UVR: {0}, deleting {1}", ssa.Procedure.Name, stm.Instruction);
ssa.DeleteStatement(stm);
change = true;
}
// If any instructions were removed, update the callers.
if (!ssa.Procedure.Signature.ParametersValid && deadStms.Count > 0)
{
DeadCode.Eliminate(ssa);
foreach (Statement stm in program.CallGraph.CallerStatements(ssa.Procedure))
{
if (!(stm.Instruction is CallInstruction ci))
{
continue;
}
var ssaCaller = this.procToSsa[stm.Block.Procedure];
if (RemoveDeadCallDefinitions(ssaCaller, ci, deadStgs))
{
wl.Add(ssaCaller);
}
}
}
return(change);
}
/// <summary>
/// Collects weakly connected components from the ICFG and gathers
/// them into Clusters.
/// </summary>
public List <Cluster> FindClusters()
{
var nodesLeft = new HashSet <RtlBlock>(sr.ICFG.Nodes);
var clusters = new List <Cluster>();
int totalCount = nodesLeft.Count;
if (totalCount > 0)
{
listener.ShowProgress("Finding procedure candidates", 0, totalCount);
var wl = WorkList.Create(nodesLeft);
while (wl.TryGetWorkItem(out var node))
{
if (listener.IsCanceled())
{
break;
}
var cluster = new Cluster();
clusters.Add(cluster);
BuildWCC(node, cluster, wl);
sr.BreakOnWatchedAddress(cluster.Blocks.Select(b => b.Address));
listener.ShowProgress("Finding procedure candidates", totalCount - nodesLeft.Count, totalCount);
}
}
return(clusters);
}
/// <summary>
/// Build the weakly connected component for a cluster by following
/// both predecessors and successors in the graph. However, we never
/// follow the predecessors of nodes that are marked directly called,
/// and we never follow successors that are marked directly called
/// (tail calls).
/// </summary>
/// <param name="node"></param>
/// <param name="cluster"></param>
/// <param name="wl"></param>
private void BuildWCC(
RtlBlock node,
Cluster cluster,
WorkList <RtlBlock> wl)
{
wl.Remove(node);
cluster.Blocks.Add(node);
foreach (var s in sr.ICFG.Successors(node))
{
if (wl.Contains(s))
{
// Only add if successor is not CALLed.
if (!procedures.Contains(s.Address))
{
BuildWCC(s, cluster, wl);
}
}
}
if (!procedures.Contains(node.Address))
{
// Only backtrack through predecessors if the node
// is not CALLed.
foreach (var p in sr.ICFG.Predecessors(node))
{
if (wl.Contains(p))
{
BuildWCC(p, cluster, wl);
}
}
}
}
/// <summary>
/// As far as possible, try fusing consecutive linear blocks in the
/// cluster.
/// </summary>
/// <param name="cluster"></param>
public void FuseLinearBlocks(Cluster cluster)
{
var wl = WorkList.Create(cluster.Blocks);
while (wl.TryGetWorkItem(out var block))
{
if (sr.ICFG.Successors(block).Count != 1)
{
continue;
}
var succ = sr.ICFG.Successors(block).First();
if (sr.ICFG.Predecessors(succ).Count != 1)
{
continue;
}
Debug.Assert(sr.ICFG.Predecessors(succ).First() == block, "Inconsistent graph");
if (!(block.Instructions.Last().Instructions.Last() is RtlAssignment))
{
continue;
}
// Move all instructions into predecessor.
block.Instructions.AddRange(succ.Instructions);
sr.ICFG.RemoveEdge(block, succ);
var succSuccs = sr.ICFG.Successors(succ).ToList();
foreach (var ss in succSuccs)
{
sr.ICFG.RemoveEdge(succ, ss);
sr.ICFG.AddEdge(block, ss);
}
cluster.Blocks.Remove(succ);
// May be more blocks.
wl.Add(block);
}
}
private void GetResultAndContinue(EvalResultDataItem dataItem, WorkList workList, DkmClrType declaredType, DkmInspectionContext inspectionContext, EvalResultDataItem parent, CompletionRoutine <DkmEvaluationResult> completionRoutine)
{
var value = dataItem.Value; // Value may have been replaced (specifically, for Nullable<T>).
DebuggerDisplayInfo displayInfo;
if (value.TryGetDebuggerDisplayInfo(out displayInfo))
{
var targetType = displayInfo.TargetType;
var attribute = displayInfo.Attribute;
CompletionRoutine <Exception> onException =
e => completionRoutine(CreateEvaluationResultFromException(e, dataItem, inspectionContext));
EvaluateDebuggerDisplayStringAndContinue(value, workList, inspectionContext, targetType, attribute.Name,
displayName => EvaluateDebuggerDisplayStringAndContinue(value, workList, inspectionContext, targetType, attribute.Value,
displayValue => EvaluateDebuggerDisplayStringAndContinue(value, workList, inspectionContext, targetType, attribute.TypeName,
displayType =>
{
completionRoutine(GetResult(inspectionContext, dataItem, declaredType, displayName.Result, displayValue.Result, displayType.Result, parent));
workList.Execute();
},
onException),
onException),
onException);
}
else
{
completionRoutine(GetResult(inspectionContext, dataItem, declaredType, displayName: null, displayValue: null, displayType: null, parent: parent));
}
}
/// <summary>
/// Can delete a save work (set to null)
/// </summary>
/// <param name="_nb">Index of the work in the list to delete</param>
public void DeleteWork(int _nb)
{
WorkList.RemoveAt(_nb);
SetWorkIndex();
UpdateSaveFile();
EditLog.DeleteWorkLogLine(_nb);
}
private void GetChildrenAndContinue(EvalResultDataItem dataItem, DkmWorkList workList, DkmStackWalkFrame stackFrame, int initialRequestSize, DkmInspectionContext inspectionContext, DkmCompletionRoutine <DkmGetChildrenAsyncResult> completionRoutine)
{
var expansion = dataItem.Expansion;
var rows = ArrayBuilder <EvalResultDataItem> .GetInstance();
int index = 0;
if (expansion != null)
{
expansion.GetRows(this, rows, inspectionContext, dataItem, dataItem.Value, 0, initialRequestSize, visitAll: true, index: ref index);
}
var numRows = rows.Count;
Debug.Assert(index >= numRows);
Debug.Assert(initialRequestSize >= numRows);
var initialChildren = new DkmEvaluationResult[numRows];
var wl = new WorkList(workList, e => completionRoutine(DkmGetChildrenAsyncResult.CreateErrorResult(e)));
GetEvaluationResultsAndContinue(rows, initialChildren, 0, numRows, wl, inspectionContext, stackFrame,
() => wl.ContinueWith(
() =>
{
var enumContext = DkmEvaluationResultEnumContext.Create(index, stackFrame, inspectionContext, new EnumContextDataItem(dataItem));
completionRoutine(new DkmGetChildrenAsyncResult(initialChildren, enumContext));
rows.Free();
}));
wl.Execute();
}
private void GetItemsAndContinue(EvalResultDataItem dataItem, DkmWorkList workList, int startIndex, int count, DkmInspectionContext inspectionContext, DkmCompletionRoutine <DkmEvaluationEnumAsyncResult> completionRoutine)
{
var expansion = dataItem.Expansion;
var value = dataItem.Value;
var rows = ArrayBuilder <EvalResultDataItem> .GetInstance();
if (expansion != null)
{
int index = 0;
expansion.GetRows(this, rows, inspectionContext, dataItem, value, startIndex, count, visitAll: false, index: ref index);
}
var numRows = rows.Count;
Debug.Assert(count >= numRows);
var results = new DkmEvaluationResult[numRows];
var wl = new WorkList(workList, e => completionRoutine(DkmEvaluationEnumAsyncResult.CreateErrorResult(e)));
GetEvaluationResultsAndContinue(rows, results, 0, numRows, wl, inspectionContext, value.StackFrame,
() => wl.ContinueWith(
() =>
{
completionRoutine(new DkmEvaluationEnumAsyncResult(results));
rows.Free();
}));
wl.Execute();
}
private void GetChild(
DkmEvaluationResult parent,
WorkList workList,
EvalResult row,
DkmCompletionRoutine <DkmEvaluationAsyncResult> completionRoutine)
{
var inspectionContext = row.InspectionContext;
if ((row.Kind != ExpansionKind.Default) || (row.Value == null))
{
CreateEvaluationResultAndContinue(
row,
workList,
row.InspectionContext,
parent.StackFrame,
child => completionRoutine(new DkmEvaluationAsyncResult(child)));
}
else
{
var typeDeclaringMember = row.TypeDeclaringMemberAndInfo;
var name = (typeDeclaringMember.Type == null) ?
row.Name :
GetQualifiedMemberName(row.InspectionContext, typeDeclaringMember, row.Name, FullNameProvider);
row.Value.GetResult(
workList.InnerWorkList,
row.DeclaredTypeAndInfo.ClrType,
row.DeclaredTypeAndInfo.Info,
row.InspectionContext,
Formatter.NoFormatSpecifiers,
name,
row.FullName,
result => workList.ContinueWith(() => completionRoutine(result)));
}
}
void IDkmClrResultProvider.GetResult(DkmClrValue value, DkmWorkList workList, DkmClrType declaredType, DkmClrCustomTypeInfo declaredTypeInfo, DkmInspectionContext inspectionContext, ReadOnlyCollection <string> formatSpecifiers, string resultName, string resultFullName, DkmCompletionRoutine <DkmEvaluationAsyncResult> completionRoutine)
{
if (formatSpecifiers == null)
{
formatSpecifiers = Formatter.NoFormatSpecifiers;
}
if (resultFullName != null)
{
ReadOnlyCollection <string> otherSpecifiers;
resultFullName = FullNameProvider.GetClrExpressionAndFormatSpecifiers(inspectionContext, resultFullName, out otherSpecifiers);
foreach (var formatSpecifier in otherSpecifiers)
{
formatSpecifiers = Formatter.AddFormatSpecifier(formatSpecifiers, formatSpecifier);
}
}
var wl = new WorkList(workList, e => completionRoutine(DkmEvaluationAsyncResult.CreateErrorResult(e)));
wl.ContinueWith(
() => GetRootResultAndContinue(
value,
wl,
declaredType,
declaredTypeInfo,
inspectionContext,
resultName,
resultFullName,
formatSpecifiers,
result => wl.ContinueWith(() => completionRoutine(new DkmEvaluationAsyncResult(result)))));
}
private void GetResultAndContinue(
EvalResult result,
WorkList workList,
DkmClrType declaredType,
DkmClrCustomTypeInfo declaredTypeInfo,
DkmInspectionContext inspectionContext,
bool useDebuggerDisplay,
CompletionRoutine <DkmEvaluationResult> completionRoutine)
{
var value = result.Value; // Value may have been replaced (specifically, for Nullable<T>).
DebuggerDisplayInfo displayInfo;
if (value.TryGetDebuggerDisplayInfo(out displayInfo))
{
var targetType = displayInfo.TargetType;
var attribute = displayInfo.Attribute;
CompletionRoutine <Exception> onException =
e => completionRoutine(CreateEvaluationResultFromException(e, result, inspectionContext));
var innerWorkList = workList.InnerWorkList;
EvaluateDebuggerDisplayStringAndContinue(value, innerWorkList, inspectionContext, targetType, attribute.Name,
displayName => EvaluateDebuggerDisplayStringAndContinue(value, innerWorkList, inspectionContext, targetType, attribute.Value,
displayValue => EvaluateDebuggerDisplayStringAndContinue(value, innerWorkList, inspectionContext, targetType, attribute.TypeName,
displayType =>
workList.ContinueWith(() =>
completionRoutine(GetResult(inspectionContext, result, declaredType, declaredTypeInfo, displayName.Result, displayValue.Result, displayType.Result, useDebuggerDisplay))),
onException),
onException),
onException);
}
else
{
completionRoutine(GetResult(inspectionContext, result, declaredType, declaredTypeInfo, displayName: null, displayValue: null, displayType: null, useDebuggerDisplay: false));
}
}
private void PushEquality(WorkList wl, SymbolicValue v1, SymbolicValue v2)
{
if (v1 == v2)
{
return;
}
wl.Add(new EqPair(v1, v2));
}
static void MergeNodesBothDirections <T>(WorkList <T> dst, WorkList <T> src, Func <T, T, bool> merge) where T : class
{
// Merge as far as we can down using the given merge strategy
MergeNodeSequenceUntilStrategyFails(dst, src, Position.Head, merge);
// Then merge backwards..
MergeNodeSequenceUntilStrategyFails(dst, src, Position.Tail, merge);
}
public BackwardSlicer(IBackWalkHost <RtlBlock, RtlInstruction> host)
{
this.host = host;
this.worklist = new WorkList <SliceState>();
this.visited = new HashSet <RtlBlock>();
this.cmp = new ExpressionValueComparer();
this.simp = new ExpressionSimplifier(host.SegmentMap, new EvalCtx(), null);
}
public List <Interval> BuildIntervals(DirectedGraph <StructureNode> graph, StructureNode entry)
{
if (graph == null)
{
throw new ArgumentNullException("graph");
}
if (entry == null)
{
throw new ArgumentNullException("entry");
}
var intervalsInGraph = new List <Interval>(); // The sequence of intervals in this graph
var headers = new WorkList <StructureNode>(); // The sequence of interval header nodes
var beenInH = new HashSet <StructureNode>(); // The set of nodes that have been in the above sequence at some stage
headers.Add(entry);
beenInH.Add(entry);
StructureNode header;
while (headers.GetWorkItem(out header))
{
Interval newInt = new Interval(intervalID++, header);
// Process each succesive node in the interval until no more nodes can be added to the interval.
for (int i = 0; i < newInt.Nodes.Count; i++)
{
StructureNode curNode = newInt.Nodes[i];
foreach (StructureNode succ in graph.Successors(curNode))
{
// Only further consider the current child if it isn't already in the interval
if (!newInt.Nodes.Contains(succ))
{
// If the current child has all its parents
// inside the interval, then add it to the interval. Remove it from the header
// sequence if it is on it.
if (IsSubSetOf(graph.Predecessors(succ), newInt))
{
newInt.AddNode(succ);
headers.Remove(succ);
}
// Otherwise, add it to the header sequence if it hasn't already been in it.
else if (!beenInH.Contains(succ))
{
headers.Add(succ);
beenInH.Add(succ);
}
}
}
}
// Add the new interval to the sequence of intervals
intervalsInGraph.Add(newInt);
}
return(intervalsInGraph);
}
/// <summary>
/// Create a save work (with a differential save algorithm)
/// </summary>
/// <param name="_name">Name of the work (must be different from existing ones)</param>
/// <param name="_source">The Source path to save</param>
/// <param name="_destination">The Target destination to save files in</param>
public void CreateDifferencialWork(string _name, string _source, string _destination, List <Extension> _extension)
{
DifferencialSaveWork work = new DifferencialSaveWork(_name, _source, _destination, _extension, SaveWorkType.differencial);
WorkList.Add(work);
SetWorkIndex();
UpdateSaveFile();
EditLog.CreateWorkLogLine(work);
}
public static WorkList GetInstance()
{
if (instance == null)
{
instance = new WorkList();
}
return(instance);
}
/// <summary>
/// Removes all of the edges to a given vertex
/// </summary>
/// <param name="vertex">The vertex being removed</param>
protected virtual void RemoveAllEdgesToVertex(object vertex)
{
WorkList wl = new WorkList(Successors(vertex));
while (!wl.IsEmpty)
{
RemoveEdge(wl.NextItem() as Edge);
}
}
public void BuildIntervals(DerivedGraph derGraph)
{
if (derGraph == null)
throw new ArgumentNullException("derGraph");
if (derGraph.Entry == null)
throw new ArgumentException("cfg graph must be non-null.", "derGraph");
var intSeq = derGraph.Intervals; // The sequence of intervals in this graph
var headerSeq = new WorkList<StructureNode>(); // The sequence of interval header nodes
var beenInH = new List<StructureNode>(); // The set of nodes that have been in the above sequence at some stage
headerSeq.Add(derGraph.Entry);
beenInH.Add(derGraph.Entry);
StructureNode header;
while (headerSeq.GetWorkItem(out header))
{
var newInt = new Interval(intervalID++, header);
// Process each succesive node in the interval until no more nodes can be added to the interval.
for (int i = 0; i < newInt.Nodes.Count; i++)
{
var curNode = newInt.Nodes[i];
// Process each child of the current node
for (int j = 0; j < curNode.OutEdges.Count; j++)
{
var succ = curNode.OutEdges[j];
// Only further consider the current child if it isn't already in the interval
if (!newInt.Nodes.Contains(succ))
{
// If the current child has all its parents
// inside the interval, then add it to the interval. Remove it from the header
// sequence if it is on it.
if (IsSubSetOf(succ.InEdges, newInt))
{
newInt.AddNode(succ);
headerSeq.Remove(succ);
}
// Otherwise, add it to the header sequence if it hasn't already been in it.
else if (!beenInH.Contains(succ))
{
headerSeq.Add(succ);
beenInH.Add(succ);
}
}
}
}
// Add the new interval to the sequence of intervals
intSeq.Add(newInt);
}
}
public void WlAdd()
{
WorkList<int> w = new WorkList<int>();
w.Add(3);
Assert.IsFalse(w.IsEmpty);
int x;
Assert.IsTrue(w.GetWorkItem(out x));
Assert.AreEqual(3, x);
Assert.IsTrue(w.IsEmpty);
}
private void Eliminate()
{
liveIds = new WorkList<SsaIdentifier>();
HashSet<Statement> marks = new HashSet<Statement>();
// Initially, just mark those statements that contain critical statements.
// These are calls to other functions, functions (which have side effects) and use statements.
// Critical instructions must never be considered dead.
foreach (var stm in proc.Statements)
{
if (critical.IsCritical(stm.Instruction))
{
if (trace.TraceInfo) Debug.WriteLineIf(trace.TraceInfo, string.Format("Critical: {0}", stm.Instruction));
marks.Add(stm);
stm.Instruction.Accept(this); // mark all used identifiers as live.
}
}
// Each identifier is live, so its defining statement is also live.
SsaIdentifier sid;
while (liveIds.GetWorkItem(out sid))
{
Statement def = sid.DefStatement;
if (def != null)
{
if (!marks.Contains(def))
{
if (trace.TraceInfo) Debug.WriteLine(string.Format("Marked: {0}", def.Instruction));
marks.Add(def);
sid.DefStatement.Instruction.Accept(this);
}
}
}
// We have now marked all the useful instructions in the code. Any non-marked
// instruction is now useless and should be deleted.
foreach (Block b in proc.ControlGraph.Blocks)
{
for (int iStm = 0; iStm < b.Statements.Count; ++iStm)
{
Statement stm = b.Statements[iStm];
if (!marks.Contains(stm))
{
if (trace.TraceInfo) Debug.WriteLineIf(trace.TraceInfo, string.Format("Deleting: {0}", stm.Instruction));
ssa.DeleteStatement(stm);
--iStm;
}
}
}
AdjustApplicationsWithDeadReturnValues();
}
public void WlRemove()
{
WorkList<int> w = new WorkList<int>();
w.Add(3);
w.Add(2);
Assert.IsFalse(w.IsEmpty);
w.Remove(3);
Assert.IsFalse(w.IsEmpty);
w.Remove(2);
Assert.IsTrue(w.IsEmpty);
int x;
Assert.IsFalse(w.GetWorkItem(out x));
}
void IDkmClrResultProvider.GetResult(DkmClrValue value, DkmWorkList workList, DkmClrType declaredType, DkmClrCustomTypeInfo declaredTypeInfo, DkmInspectionContext inspectionContext, ReadOnlyCollection<string> formatSpecifiers, string resultName, string resultFullName, DkmCompletionRoutine<DkmEvaluationAsyncResult> completionRoutine)
{
// TODO: Use full name
var wl = new WorkList(workList, e => completionRoutine(DkmEvaluationAsyncResult.CreateErrorResult(e)));
GetRootResultAndContinue(
value,
wl,
declaredType,
declaredTypeInfo,
inspectionContext,
resultName,
result => wl.ContinueWith(() => completionRoutine(new DkmEvaluationAsyncResult(result))));
wl.Execute();
}
public DataType BuildOverlappedStructure(List<StructureField> fields)
{
List<StructureType> types = new List<StructureType>();
int commonOffset = CommonOffset(fields);
StructureField field;
WorkList<StructureField> worklist = new WorkList<StructureField>(fields);
while (worklist.GetWorkItem(out field))
{
StructureType s = FindStructureToFitIn(field, commonOffset, types);
if (s == null)
{
s = new StructureType();
types.Add(s);
}
s.Fields.Add(new StructureField(field.Offset - commonOffset, field.DataType));
}
return Normalize(types);
}
public void ReplaceDefinitionsWithOutParameter(Identifier id, Identifier idOut)
{
this.idOut = idOut;
wl = new WorkList<Identifier>();
wl.Add(id);
var visited = new HashSet<Statement>();
while (wl.GetWorkItem(out id))
{
ssa = ssaIds[id];
stmDef = ssa.DefStatement;
if (stmDef != null && !visited.Contains(stmDef))
{
visited.Add(stmDef);
iStmDef = stmDef.Block.Statements.IndexOf(stmDef);
stmDef.Instruction = stmDef.Instruction.Accept(this);
}
}
}
public InterProcGenKill(Implementation impl, Program program) {
Contract.Requires(program != null);
Contract.Requires(impl != null);
this.program = program;
procICFG = new Dictionary<string/*!*/, ICFG/*!*/>();
name2Proc = new Dictionary<string/*!*/, Procedure/*!*/>();
workList = new WorkList();
this.callers = new Dictionary<string/*!*/, List<WorkItem/*!*/>/*!*/>();
this.callGraph = new Graph<string/*!*/>();
this.procPriority = new Dictionary<string/*!*/, int>();
this.maxBlocksInProc = 0;
this.mainImpl = impl;
Dictionary<string/*!*/, Implementation/*!*/>/*!*/ name2Impl = new Dictionary<string/*!*/, Implementation/*!*/>();
varsLiveAtExit.Clear();
varsLiveAtEntry.Clear();
varsLiveSummary.Clear();
foreach (var decl in program.TopLevelDeclarations) {
Contract.Assert(decl != null);
if (decl is Implementation) {
Implementation/*!*/ imp = (Implementation/*!*/)cce.NonNull(decl);
name2Impl[imp.Name] = imp;
} else if (decl is Procedure) {
Procedure/*!*/ proc = cce.NonNull(decl as Procedure);
name2Proc[proc.Name] = proc;
}
}
ICFG/*!*/ mainICFG = new ICFG(mainImpl);
Contract.Assert(mainICFG != null);
procICFG.Add(mainICFG.impl.Name, mainICFG);
callGraph.AddSource(mainICFG.impl.Name);
List<ICFG/*!*/>/*!*/ procsToConsider = new List<ICFG/*!*/>();
procsToConsider.Add(mainICFG);
while (procsToConsider.Count != 0) {
ICFG/*!*/ p = procsToConsider[0];
Contract.Assert(p != null);
procsToConsider.RemoveAt(0);
foreach (string/*!*/ callee in p.procsCalled.Keys) {
Contract.Assert(callee != null);
if (!name2Impl.ContainsKey(callee))
continue;
callGraph.AddEdge(p.impl.Name, callee);
if (maxBlocksInProc < p.nodes.Count) {
maxBlocksInProc = p.nodes.Count;
}
if (!callers.ContainsKey(callee)) {
callers.Add(callee, new List<WorkItem/*!*/>());
}
foreach (Block/*!*/ b in p.procsCalled[callee]) {
Contract.Assert(b != null);
callers[callee].Add(new WorkItem(p, b));
}
if (procICFG.ContainsKey(callee))
continue;
ICFG/*!*/ ncfg = new ICFG(name2Impl[callee]);
Contract.Assert(ncfg != null);
procICFG.Add(callee, ncfg);
procsToConsider.Add(ncfg);
}
}
bool acyclic;
List<string>/*!*/ sortedNodes;
callGraph.TarjanTopSort(out acyclic, out sortedNodes);
Contract.Assert(acyclic);
int cnt = 0;
for (int i = sortedNodes.Count - 1; i >= 0; i--) {
string s = sortedNodes[i];
if (s == null)
continue;
procPriority.Add(s, cnt);
cnt++;
}
}
void IDkmClrResultProvider.GetChildren(DkmEvaluationResult evaluationResult, DkmWorkList workList, int initialRequestSize, DkmInspectionContext inspectionContext, DkmCompletionRoutine<DkmGetChildrenAsyncResult> completionRoutine)
{
var dataItem = evaluationResult.GetDataItem<EvalResultDataItem>();
if (dataItem == null)
{
// We don't know about this result. Call next implementation
evaluationResult.GetChildren(workList, initialRequestSize, inspectionContext, completionRoutine);
return;
}
var expansion = dataItem.Expansion;
if (expansion == null)
{
var enumContext = DkmEvaluationResultEnumContext.Create(0, evaluationResult.StackFrame, inspectionContext, new EnumContextDataItem(evaluationResult));
completionRoutine(new DkmGetChildrenAsyncResult(new DkmEvaluationResult[0], enumContext));
return;
}
// Evaluate children with InspectionContext that is not the root.
inspectionContext = inspectionContext.With(NotRoot);
var rows = ArrayBuilder<EvalResult>.GetInstance();
int index = 0;
expansion.GetRows(this, rows, inspectionContext, dataItem, dataItem.Value, 0, initialRequestSize, visitAll: true, index: ref index);
var numRows = rows.Count;
Debug.Assert(index >= numRows);
Debug.Assert(initialRequestSize >= numRows);
var initialChildren = new DkmEvaluationResult[numRows];
CompletionRoutine<Exception> onException = e => completionRoutine(DkmGetChildrenAsyncResult.CreateErrorResult(e));
var wl = new WorkList(workList, onException);
wl.ContinueWith(() =>
GetEvaluationResultsAndContinue(evaluationResult, rows, initialChildren, 0, numRows, wl, inspectionContext,
() =>
wl.ContinueWith(
() =>
{
var enumContext = DkmEvaluationResultEnumContext.Create(index, evaluationResult.StackFrame, inspectionContext, new EnumContextDataItem(evaluationResult));
completionRoutine(new DkmGetChildrenAsyncResult(initialChildren, enumContext));
rows.Free();
}),
onException));
}
private void GetEvaluationResultsAndContinue(ArrayBuilder<EvalResultDataItem> rows, DkmEvaluationResult[] results, int index, int numRows, WorkList workList, DkmInspectionContext inspectionContext, DkmStackWalkFrame stackFrame, CompletionRoutine completionRoutine)
{
if (index < numRows)
{
CreateEvaluationResultAndContinue(rows[index], workList, inspectionContext, stackFrame,
result => workList.ContinueWith(
() =>
{
results[index] = result;
GetEvaluationResultsAndContinue(rows, results, index + 1, numRows, workList, inspectionContext, stackFrame, completionRoutine);
}));
}
else
{
completionRoutine();
}
}
private void GetChildrenAndContinue(EvalResultDataItem dataItem, DkmWorkList workList, DkmStackWalkFrame stackFrame, int initialRequestSize, DkmInspectionContext inspectionContext, DkmCompletionRoutine<DkmGetChildrenAsyncResult> completionRoutine)
{
var expansion = dataItem.Expansion;
var rows = ArrayBuilder<EvalResultDataItem>.GetInstance();
int index = 0;
if (expansion != null)
{
expansion.GetRows(this, rows, inspectionContext, dataItem, dataItem.Value, 0, initialRequestSize, visitAll: true, index: ref index);
}
var numRows = rows.Count;
Debug.Assert(index >= numRows);
Debug.Assert(initialRequestSize >= numRows);
var initialChildren = new DkmEvaluationResult[numRows];
var wl = new WorkList(workList, e => completionRoutine(DkmGetChildrenAsyncResult.CreateErrorResult(e)));
GetEvaluationResultsAndContinue(rows, initialChildren, 0, numRows, wl, inspectionContext, stackFrame,
() => wl.ContinueWith(
() =>
{
var enumContext = DkmEvaluationResultEnumContext.Create(index, stackFrame, inspectionContext, new EnumContextDataItem(dataItem));
completionRoutine(new DkmGetChildrenAsyncResult(initialChildren, enumContext));
rows.Free();
}));
wl.Execute();
}
private void GetResultAndContinue(
EvalResultDataItem dataItem,
WorkList workList,
DkmClrType declaredType,
DkmClrCustomTypeInfo declaredTypeInfo,
DkmInspectionContext inspectionContext,
EvalResultDataItem parent,
CompletionRoutine<DkmEvaluationResult> completionRoutine)
{
var value = dataItem.Value; // Value may have been replaced (specifically, for Nullable<T>).
DebuggerDisplayInfo displayInfo;
if (value.TryGetDebuggerDisplayInfo(out displayInfo))
{
var targetType = displayInfo.TargetType;
var attribute = displayInfo.Attribute;
CompletionRoutine<Exception> onException =
e => completionRoutine(CreateEvaluationResultFromException(e, dataItem, inspectionContext));
EvaluateDebuggerDisplayStringAndContinue(value, workList, inspectionContext, targetType, attribute.Name,
displayName => EvaluateDebuggerDisplayStringAndContinue(value, workList, inspectionContext, targetType, attribute.Value,
displayValue => EvaluateDebuggerDisplayStringAndContinue(value, workList, inspectionContext, targetType, attribute.TypeName,
displayType =>
{
completionRoutine(GetResult(inspectionContext, dataItem, declaredType, declaredTypeInfo, displayName.Result, displayValue.Result, displayType.Result, parent));
},
onException),
onException),
onException);
}
else
{
completionRoutine(GetResult(inspectionContext, dataItem, declaredType, declaredTypeInfo, displayName: null, displayValue: null, displayType: null, parent: parent));
}
}
private void GetEvaluationResultsAndContinue(
DkmEvaluationResult parent,
ArrayBuilder<EvalResult> rows,
DkmEvaluationResult[] results,
int index,
int numRows,
WorkList workList,
DkmInspectionContext inspectionContext,
CompletionRoutine onCompleted,
CompletionRoutine<Exception> onException)
{
DkmCompletionRoutine<DkmEvaluationAsyncResult> completionRoutine =
result =>
{
try
{
results[index] = result.Result;
GetEvaluationResultsAndContinue(parent, rows, results, index + 1, numRows, workList, inspectionContext, onCompleted, onException);
}
catch (Exception e)
{
onException(e);
}
};
if (index < numRows)
{
GetChild(
parent,
workList,
rows[index],
child => workList.ContinueWith(() => completionRoutine(child)));
}
else
{
onCompleted();
}
}
private State [] BuildDfaTable(Node n)
{
List<State> dStates = new List<State>();
// Create the default, error state.
State err = new State(new BitArray(n.FirstPos.Length), charClasses);
AddState(dStates, err);
// Create the initial state.
State s0 = new State(n.FirstPos, charClasses);
AddState(dStates, s0);
// Start the worklist.
WorkList<State> worklist = new WorkList<State>();
worklist.Add(s0);
State t;
while (worklist.GetWorkItem(out t))
{
Debug.WriteLine(t.ToString());
for (int a = 0; a != charClasses; ++a)
{
// Create U, a state consisting of the positions in
// FollowPos(p) where p is any position in t that has
// an 'a'.
State u = new State(new BitArray(positions.Count), charClasses);
for (int p = 0; p != t.Positions.Length; ++p)
{
if (!t.Positions[p])
continue;
ByteNode pp = (ByteNode) positions[p];
if (pp.Any || alphabet[pp.startByte] == a)
{
u.Positions.Or(pp.FollowPos);
}
t.Accepts |= pp.Accepts;
}
if (IsEmptySet(u.Positions))
{
u = null;
}
else
{
State uu = FindState(dStates, u.Positions);
if (uu == null)
{
AddState(dStates, u);
worklist.Add(u);
}
else
{
u = uu;
}
}
t.NextState[a] = u;
}
Debug.WriteLine("t complete: " + t);
}
return dStates.ToArray();
}
public List<Interval> BuildIntervals(DirectedGraph<StructureNode> graph, StructureNode entry)
{
if (graph == null)
throw new ArgumentNullException("graph");
if (entry == null)
throw new ArgumentNullException("entry");
var intervalsInGraph = new List<Interval>(); // The sequence of intervals in this graph
var headers = new WorkList<StructureNode>(); // The sequence of interval header nodes
var beenInH = new HashSet<StructureNode>(); // The set of nodes that have been in the above sequence at some stage
headers.Add(entry);
beenInH.Add(entry);
StructureNode header;
while (headers.GetWorkItem(out header))
{
Interval newInt = new Interval(intervalID++, header);
// Process each succesive node in the interval until no more nodes can be added to the interval.
for (int i = 0; i < newInt.Nodes.Count; i++)
{
StructureNode curNode = newInt.Nodes[i];
foreach (StructureNode succ in graph.Successors(curNode))
{
// Only further consider the current child if it isn't already in the interval
if (!newInt.Nodes.Contains(succ))
{
// If the current child has all its parents
// inside the interval, then add it to the interval. Remove it from the header
// sequence if it is on it.
if (IsSubSetOf(graph.Predecessors(succ), newInt))
{
newInt.AddNode(succ);
headers.Remove(succ);
}
// Otherwise, add it to the header sequence if it hasn't already been in it.
else if (!beenInH.Contains(succ))
{
headers.Add(succ);
beenInH.Add(succ);
}
}
}
}
// Add the new interval to the sequence of intervals
intervalsInGraph.Add(newInt);
}
return intervalsInGraph;
}
public void Dump(TextWriter tw) {
HashSet seen = new HashSet();
WorkList wl = new WorkList();
Console.WriteLine("LastSymbolId:{0}", this.idCounter);
foreach(IUniqueKey function in this.termMap.Keys2(this.constRoot)) {
SymbolicValue target = this[this.constRoot, function];
tw.WriteLine("{0} = {1}", Function2String(function), target);
wl.Add(target);
}
while ( ! wl.IsEmpty() ) {
SymbolicValue v = (SymbolicValue)wl.Pull();
if ( ! seen.Add(v)) continue;
foreach(IUniqueKey function in this.termMap.Keys2(v)) {
SymbolicValue target = this[v, function];
tw.WriteLine("{0}({2}) = {1}", Function2String(function), target, v);
wl.Add(target);
}
}
tw.WriteLine("**Abstract value map");
foreach (SymbolicValue v in seen) {
AbstractValue aval = this[v];
if (!this.elementLattice.IsTop(aval)) {
tw.WriteLine("{0} -> {1}", v, aval);
}
}
}
private void PushEquality(WorkList wl, SymbolicValue v1, SymbolicValue v2) {
if (v1 == v2) return;
wl.Add(new EqPair(v1, v2));
}
public void AssumeEqual(ISymValue v1, ISymValue v2) {
WorkList wl = new WorkList();
SymbolicValue v1rep = Find(v1);
SymbolicValue v2rep = Find(v2);
PushEquality(wl, v1rep, v2rep);
if (!wl.IsEmpty()) {
// TODO: there's an opportunity for optimizing the number
// of necessary updates that we need to record, since the induced
// updates of the equality may end up as duplicates.
AddEqualityUpdate(v1rep, v2rep);
}
DrainEqualityWorkList(wl);
}
private void DrainEqualityWorkList(WorkList wl) {
while ( ! wl.IsEmpty() ) {
EqPair eqpair = (EqPair)wl.Pull();
SymbolicValue v1rep = Find(eqpair.v1);
SymbolicValue v2rep = Find(eqpair.v2);
if (v1rep == v2rep) continue;
// always map new to older var
if (v1rep.UniqueId < v2rep.UniqueId) {
SymbolicValue temp = v1rep;
v1rep = v2rep;
v2rep = temp;
}
// perform congruence closure here:
foreach(IUniqueKey f in this.Functions(v1rep)) {
SymbolicValue target = this.LookupWithoutManifesting(v2rep, f);
if (target == null) {
this[v2rep, f] = this[v1rep,f];
}
else {
PushEquality(wl, this[v1rep,f], target);
}
}
MathematicalLattice.Element av1 = this[v1rep];
MathematicalLattice.Element av2 = this[v2rep];
// merge term map of v1 into v2
foreach(IUniqueKey eterm in this.eqTermMap.Keys2(v1rep)) {
this.eqTermMap = this.eqTermMap.Add(v2rep, eterm, null);
}
this.forwMap = this.forwMap.Add(v1rep, v2rep);
this[v2rep] = this.elementLattice.Meet(av1,av2);
}
}
private void CreateEvaluationResultAndContinue(EvalResultDataItem dataItem, WorkList workList, DkmInspectionContext inspectionContext, DkmStackWalkFrame stackFrame, CompletionRoutine<DkmEvaluationResult> completionRoutine)
{
switch (dataItem.Kind)
{
case ExpansionKind.Error:
completionRoutine(DkmFailedEvaluationResult.Create(
inspectionContext,
StackFrame: stackFrame,
Name: dataItem.Name,
FullName: dataItem.FullName,
ErrorMessage: dataItem.DisplayValue,
Flags: DkmEvaluationResultFlags.None,
Type: null,
DataItem: null));
break;
case ExpansionKind.NativeView:
{
var value = dataItem.Value;
var name = Resources.NativeView;
var fullName = dataItem.FullName;
var display = dataItem.Name;
DkmEvaluationResult evalResult;
if (value.IsError())
{
evalResult = DkmFailedEvaluationResult.Create(
inspectionContext,
stackFrame,
Name: name,
FullName: fullName,
ErrorMessage: display,
Flags: dataItem.Flags,
Type: null,
DataItem: dataItem);
}
else
{
// For Native View, create a DkmIntermediateEvaluationResult.
// This will allow the C++ EE to take over expansion.
var process = inspectionContext.RuntimeInstance.Process;
var cpp = process.EngineSettings.GetLanguage(new DkmCompilerId(DkmVendorId.Microsoft, DkmLanguageId.Cpp));
evalResult = DkmIntermediateEvaluationResult.Create(
inspectionContext,
stackFrame,
Name: name,
FullName: fullName,
Expression: display,
IntermediateLanguage: cpp,
TargetRuntime: process.GetNativeRuntimeInstance(),
DataItem: dataItem);
}
completionRoutine(evalResult);
}
break;
case ExpansionKind.NonPublicMembers:
completionRoutine(DkmSuccessEvaluationResult.Create(
inspectionContext,
stackFrame,
Name: Resources.NonPublicMembers,
FullName: dataItem.FullName,
Flags: dataItem.Flags,
Value: null,
EditableValue: null,
Type: string.Empty,
Category: DkmEvaluationResultCategory.Data,
Access: DkmEvaluationResultAccessType.None,
StorageType: DkmEvaluationResultStorageType.None,
TypeModifierFlags: DkmEvaluationResultTypeModifierFlags.None,
Address: dataItem.Value.Address,
CustomUIVisualizers: null,
ExternalModules: null,
DataItem: dataItem));
break;
case ExpansionKind.StaticMembers:
completionRoutine(DkmSuccessEvaluationResult.Create(
inspectionContext,
stackFrame,
Name: Formatter.StaticMembersString,
FullName: dataItem.FullName,
Flags: dataItem.Flags,
Value: null,
EditableValue: null,
Type: string.Empty,
Category: DkmEvaluationResultCategory.Class,
Access: DkmEvaluationResultAccessType.None,
StorageType: DkmEvaluationResultStorageType.None,
TypeModifierFlags: DkmEvaluationResultTypeModifierFlags.None,
Address: dataItem.Value.Address,
CustomUIVisualizers: null,
ExternalModules: null,
DataItem: dataItem));
break;
case ExpansionKind.RawView:
completionRoutine(DkmSuccessEvaluationResult.Create(
inspectionContext,
stackFrame,
Name: Resources.RawView,
FullName: dataItem.FullName,
Flags: dataItem.Flags,
Value: null,
EditableValue: dataItem.EditableValue,
Type: string.Empty,
Category: DkmEvaluationResultCategory.Data,
Access: DkmEvaluationResultAccessType.None,
StorageType: DkmEvaluationResultStorageType.None,
TypeModifierFlags: DkmEvaluationResultTypeModifierFlags.None,
Address: dataItem.Value.Address,
CustomUIVisualizers: null,
ExternalModules: null,
DataItem: dataItem));
break;
case ExpansionKind.DynamicView:
case ExpansionKind.ResultsView:
completionRoutine(DkmSuccessEvaluationResult.Create(
inspectionContext,
stackFrame,
dataItem.Name,
dataItem.FullName,
dataItem.Flags,
dataItem.DisplayValue,
EditableValue: null,
Type: string.Empty,
Category: DkmEvaluationResultCategory.Method,
Access: DkmEvaluationResultAccessType.None,
StorageType: DkmEvaluationResultStorageType.None,
TypeModifierFlags: DkmEvaluationResultTypeModifierFlags.None,
Address: dataItem.Value.Address,
CustomUIVisualizers: null,
ExternalModules: null,
DataItem: dataItem));
break;
case ExpansionKind.TypeVariable:
completionRoutine(DkmSuccessEvaluationResult.Create(
inspectionContext,
stackFrame,
dataItem.Name,
dataItem.FullName,
dataItem.Flags,
dataItem.DisplayValue,
EditableValue: null,
Type: dataItem.DisplayValue,
Category: DkmEvaluationResultCategory.Data,
Access: DkmEvaluationResultAccessType.None,
StorageType: DkmEvaluationResultStorageType.None,
TypeModifierFlags: DkmEvaluationResultTypeModifierFlags.None,
Address: dataItem.Value.Address,
CustomUIVisualizers: null,
ExternalModules: null,
DataItem: dataItem));
break;
case ExpansionKind.PointerDereference:
case ExpansionKind.Default:
// This call will evaluate DebuggerDisplayAttributes.
GetResultAndContinue(
dataItem,
workList,
declaredType: DkmClrType.Create(dataItem.Value.Type.AppDomain, dataItem.DeclaredTypeAndInfo.Type),
declaredTypeInfo: dataItem.DeclaredTypeAndInfo.Info,
inspectionContext: inspectionContext,
parent: dataItem.Parent,
completionRoutine: completionRoutine);
break;
default:
throw ExceptionUtilities.UnexpectedValue(dataItem.Kind);
}
}
private void GetResultAndContinue(
EvalResult result,
WorkList workList,
DkmClrType declaredType,
DkmClrCustomTypeInfo declaredTypeInfo,
DkmInspectionContext inspectionContext,
bool useDebuggerDisplay,
CompletionRoutine<DkmEvaluationResult> completionRoutine)
{
var value = result.Value; // Value may have been replaced (specifically, for Nullable<T>).
DebuggerDisplayInfo displayInfo;
if (value.TryGetDebuggerDisplayInfo(out displayInfo))
{
var targetType = displayInfo.TargetType;
var attribute = displayInfo.Attribute;
CompletionRoutine<Exception> onException =
e => completionRoutine(CreateEvaluationResultFromException(e, result, inspectionContext));
var innerWorkList = workList.InnerWorkList;
EvaluateDebuggerDisplayStringAndContinue(value, innerWorkList, inspectionContext, targetType, attribute.Name,
displayName => EvaluateDebuggerDisplayStringAndContinue(value, innerWorkList, inspectionContext, targetType, attribute.Value,
displayValue => EvaluateDebuggerDisplayStringAndContinue(value, innerWorkList, inspectionContext, targetType, attribute.TypeName,
displayType =>
workList.ContinueWith(() =>
completionRoutine(GetResult(inspectionContext, result, declaredType, declaredTypeInfo, displayName.Result, displayValue.Result, displayType.Result, useDebuggerDisplay))),
onException),
onException),
onException);
}
else
{
completionRoutine(GetResult(inspectionContext, result, declaredType, declaredTypeInfo, displayName: null, displayValue: null, displayType: null, useDebuggerDisplay: false));
}
}
private void GetRootResultAndContinue(
DkmClrValue value,
WorkList workList,
DkmClrType declaredType,
DkmClrCustomTypeInfo declaredTypeInfo,
DkmInspectionContext inspectionContext,
string name,
CompletionRoutine<DkmEvaluationResult> completionRoutine)
{
var type = value.Type.GetLmrType();
if (type.IsTypeVariables())
{
Debug.Assert(type.Equals(declaredType.GetLmrType()));
var declaredTypeAndInfo = new TypeAndCustomInfo(type, declaredTypeInfo);
var expansion = new TypeVariablesExpansion(declaredTypeAndInfo);
var dataItem = new EvalResultDataItem(
ExpansionKind.Default,
name,
typeDeclaringMemberAndInfo: default(TypeAndCustomInfo),
declaredTypeAndInfo: declaredTypeAndInfo,
parent: null,
value: value,
displayValue: null,
expansion: expansion,
childShouldParenthesize: false,
fullName: null,
childFullNamePrefixOpt: null,
formatSpecifiers: Formatter.NoFormatSpecifiers,
category: DkmEvaluationResultCategory.Data,
flags: DkmEvaluationResultFlags.ReadOnly,
editableValue: null,
inspectionContext: inspectionContext);
Debug.Assert(dataItem.Flags == (DkmEvaluationResultFlags.ReadOnly | DkmEvaluationResultFlags.Expandable));
// Note: We're not including value.EvalFlags in Flags parameter
// below (there shouldn't be a reason to do so).
completionRoutine(DkmSuccessEvaluationResult.Create(
InspectionContext: inspectionContext,
StackFrame: value.StackFrame,
Name: Resources.TypeVariablesName,
FullName: dataItem.FullName,
Flags: dataItem.Flags,
Value: "",
EditableValue: null,
Type: "",
Category: dataItem.Category,
Access: value.Access,
StorageType: value.StorageType,
TypeModifierFlags: value.TypeModifierFlags,
Address: value.Address,
CustomUIVisualizers: null,
ExternalModules: null,
DataItem: dataItem));
}
else if ((inspectionContext.EvaluationFlags & DkmEvaluationFlags.ResultsOnly) != 0)
{
var dataItem = ResultsViewExpansion.CreateResultsOnlyRow(
inspectionContext,
name,
declaredType,
declaredTypeInfo,
value,
this.Formatter);
CreateEvaluationResultAndContinue(
dataItem,
workList,
inspectionContext,
value.StackFrame,
completionRoutine);
}
else if ((inspectionContext.EvaluationFlags & DkmEvaluationFlags.DynamicView) != 0)
{
var dataItem = DynamicViewExpansion.CreateMembersOnlyRow(
inspectionContext,
name,
value,
this.Formatter);
CreateEvaluationResultAndContinue(
dataItem,
workList,
inspectionContext,
value.StackFrame,
completionRoutine);
}
else
{
var dataItem = ResultsViewExpansion.CreateResultsOnlyRowIfSynthesizedEnumerable(
inspectionContext,
name,
declaredType,
declaredTypeInfo,
value,
this.Formatter);
if (dataItem != null)
{
CreateEvaluationResultAndContinue(
dataItem,
workList,
inspectionContext,
value.StackFrame,
completionRoutine);
}
else
{
ReadOnlyCollection<string> formatSpecifiers;
var fullName = this.Formatter.TrimAndGetFormatSpecifiers(name, out formatSpecifiers);
dataItem = CreateDataItem(
inspectionContext,
name,
typeDeclaringMemberAndInfo: default(TypeAndCustomInfo),
declaredTypeAndInfo: new TypeAndCustomInfo(declaredType.GetLmrType(), declaredTypeInfo),
value: value,
parent: null,
expansionFlags: ExpansionFlags.All,
childShouldParenthesize: this.Formatter.NeedsParentheses(fullName),
fullName: fullName,
formatSpecifiers: formatSpecifiers,
category: DkmEvaluationResultCategory.Other,
flags: value.EvalFlags,
evalFlags: inspectionContext.EvaluationFlags);
GetResultAndContinue(dataItem, workList, declaredType, declaredTypeInfo, inspectionContext, parent: null, completionRoutine: completionRoutine);
}
}
}
private void GetChild(
DkmEvaluationResult parent,
WorkList workList,
EvalResult row,
DkmCompletionRoutine<DkmEvaluationAsyncResult> completionRoutine)
{
var inspectionContext = row.InspectionContext;
if ((row.Kind != ExpansionKind.Default) || (row.Value == null))
{
CreateEvaluationResultAndContinue(
row,
workList,
row.InspectionContext,
parent.StackFrame,
child => completionRoutine(new DkmEvaluationAsyncResult(child)));
}
else
{
var typeDeclaringMember = row.TypeDeclaringMemberAndInfo;
var name = (typeDeclaringMember.Type == null) ?
row.Name :
GetQualifiedMemberName(row.InspectionContext, typeDeclaringMember, row.Name, FullNameProvider);
row.Value.GetResult(
workList.InnerWorkList,
row.DeclaredTypeAndInfo.ClrType,
row.DeclaredTypeAndInfo.Info,
row.InspectionContext,
Formatter.NoFormatSpecifiers,
name,
row.FullName,
result => workList.ContinueWith(() => completionRoutine(result)));
}
}
private static void EvaluateDebuggerDisplayStringAndContinue(
DkmClrValue value,
WorkList workList,
DkmInspectionContext inspectionContext,
DkmClrType targetType,
string str,
CompletionRoutine<DkmEvaluateDebuggerDisplayStringAsyncResult> onCompleted,
CompletionRoutine<Exception> onException)
{
DkmCompletionRoutine<DkmEvaluateDebuggerDisplayStringAsyncResult> completionRoutine =
result =>
{
try
{
onCompleted(result);
}
catch (Exception e)
{
onException(e);
}
workList.Execute();
};
if (str == null)
{
completionRoutine(default(DkmEvaluateDebuggerDisplayStringAsyncResult));
}
else
{
value.EvaluateDebuggerDisplayString(workList.InnerWorkList, inspectionContext, targetType, str, completionRoutine);
}
}
/// <summary>
/// Must follow field edges of value types backwards as well
/// </summary>
public Variable GetLocalMappingToLoc(ISymValue loc) {
WorkList refparams = new WorkList();
WorkList fields = new WorkList();
fields.Add(loc);
while (! fields.IsEmpty()) {
ISymValue sv = (ISymValue)fields.Pull();
foreach (EGraphTerm eterm in egraph.EqTerms(sv)) {
if ( !(eterm.Function is StackVariable)) {
Variable v = eterm.Function as Variable;
if (v != null) {
return v;
}
Field f = eterm.Function as Field;
if (f != null && f.DeclaringType.IsValueType) {
if (eterm.Args.Length>0) {
fields.Add(eterm.Args[0]);
}
}
if (eterm.Function == ValueOf && eterm.Args.Length>0) {
// could be that we are looking at a ref parameter
refparams.Add(eterm.Args[0]);
}
}
}
}
while (! refparams.IsEmpty()) {
ISymValue sv = (ISymValue)refparams.Pull();
foreach (EGraphTerm eterm in egraph.EqTerms(sv)) {
if ( !(eterm.Function is StackVariable)) {
Variable v = eterm.Function as Variable;
if (v != null && (v.Type is Reference || v.Type is Pointer)) {
return v;
}
}
}
}
return null;
}
private void GetItemsAndContinue(EvalResultDataItem dataItem, DkmWorkList workList, int startIndex, int count, DkmInspectionContext inspectionContext, DkmCompletionRoutine<DkmEvaluationEnumAsyncResult> completionRoutine)
{
var expansion = dataItem.Expansion;
var value = dataItem.Value;
var rows = ArrayBuilder<EvalResultDataItem>.GetInstance();
if (expansion != null)
{
int index = 0;
expansion.GetRows(this, rows, inspectionContext, dataItem, value, startIndex, count, visitAll: false, index: ref index);
}
var numRows = rows.Count;
Debug.Assert(count >= numRows);
var results = new DkmEvaluationResult[numRows];
var wl = new WorkList(workList, e => completionRoutine(DkmEvaluationEnumAsyncResult.CreateErrorResult(e)));
GetEvaluationResultsAndContinue(rows, results, 0, numRows, wl, inspectionContext, value.StackFrame,
() => wl.ContinueWith(
() =>
{
completionRoutine(new DkmEvaluationEnumAsyncResult(results));
rows.Free();
}));
wl.Execute();
}
void IDkmClrResultProvider.GetItems(DkmEvaluationResultEnumContext enumContext, DkmWorkList workList, int startIndex, int count, DkmCompletionRoutine<DkmEvaluationEnumAsyncResult> completionRoutine)
{
var enumContextDataItem = enumContext.GetDataItem<EnumContextDataItem>();
if (enumContextDataItem == null)
{
// We don't know about this result. Call next implementation
enumContext.GetItems(workList, startIndex, count, completionRoutine);
return;
}
var evaluationResult = enumContextDataItem.Result;
var dataItem = evaluationResult.GetDataItem<EvalResultDataItem>();
var expansion = dataItem.Expansion;
if (expansion == null)
{
completionRoutine(new DkmEvaluationEnumAsyncResult(new DkmEvaluationResult[0]));
return;
}
var inspectionContext = enumContext.InspectionContext;
var rows = ArrayBuilder<EvalResult>.GetInstance();
int index = 0;
expansion.GetRows(this, rows, inspectionContext, dataItem, dataItem.Value, startIndex, count, visitAll: false, index: ref index);
var numRows = rows.Count;
Debug.Assert(count >= numRows);
var results = new DkmEvaluationResult[numRows];
CompletionRoutine<Exception> onException = e => completionRoutine(DkmEvaluationEnumAsyncResult.CreateErrorResult(e));
var wl = new WorkList(workList, onException);
wl.ContinueWith(() =>
GetEvaluationResultsAndContinue(evaluationResult, rows, results, 0, numRows, wl, inspectionContext,
() =>
wl.ContinueWith(
() =>
{
completionRoutine(new DkmEvaluationEnumAsyncResult(results));
rows.Free();
}),
onException));
}
private static void EvaluateDebuggerDisplayStringAndContinue(
DkmClrValue value,
WorkList workList,
DkmInspectionContext inspectionContext,
DkmClrType targetType,
string str,
CompletionRoutine<DkmEvaluateDebuggerDisplayStringAsyncResult> onCompleted,
CompletionRoutine<Exception> onException)
{
DkmCompletionRoutine<DkmEvaluateDebuggerDisplayStringAsyncResult> completionRoutine =
result =>
{
try
{
onCompleted(result);
}
catch (Exception e) when (ExpressionEvaluatorFatalError.ReportNonFatalException(e, DkmComponentManager.ReportCurrentNonFatalException))
{
onException(e);
}
};
if (str == null)
{
completionRoutine(default(DkmEvaluateDebuggerDisplayStringAsyncResult));
}
else
{
value.EvaluateDebuggerDisplayString(workList.InnerWorkList, inspectionContext, targetType, str, completionRoutine);
}
}
private void PlacePhiFunctions()
{
var defVars = LocateAllDefinedVariables(AOrig);
MarkTemporariesDeadIn(AOrig);
// For each defined variable in block n, collect the places where it is defined
foreach (var a in defVars)
{
// Create a worklist W of all the blocks that define a.
var W = new WorkList<Block>();
foreach (Block b in SsaState.DomGraph.ReversePostOrder.Keys)
{
byte bits;
AOrig[SsaState.RpoNumber(b)].TryGetValue(a, out bits);
if ((bits & BitDefined) != 0)
W.Add(b);
}
Block n;
while (W.GetWorkItem(out n))
{
foreach (Block y in SsaState.DomGraph.DominatorFrontier(n))
{
// Only add phi functions if there is no
// phi already and variable is not deadIn.
var dict = AOrig[SsaState.RpoNumber(y)];
byte bits;
dict.TryGetValue(a, out bits);
if ((bits & (BitHasPhi | BitDeadIn)) == 0)
{
bits |= BitHasPhi;
dict[a] = bits;
InsertPhiStatement(y, a);
if ((bits & BitDefined) == 0)
{
W.Add(y);
}
}
}
}
}
}
