~ubuntu-branches/ubuntu/trusty/monodevelop/trusty-proposed

return new SymbolicValue(expr.Code == ILCode.Ceq ? SymbolicValueType.StateEquals : SymbolicValueType.StateInEquals, unchecked(right.Constant - left.Constant));

645

case ILCode.LogicNot:

646

SymbolicValue val = Eval(expr.Arguments[0]);

647

if (val.Type == SymbolicValueType.StateEquals)

648

return new SymbolicValue(SymbolicValueType.StateInEquals, val.Constant);

649

else if (val.Type == SymbolicValueType.StateInEquals)

650

return new SymbolicValue(SymbolicValueType.StateEquals, val.Constant);

651

else

652

throw new YieldAnalysisFailedException();

653

default:

654

throw new YieldAnalysisFailedException();

655

}

345

rangeAnalysis = null;

656

346

}

657

347

#endregion

658

348

667

357

ILBlock ilMethod = CreateILAst(moveNextMethod);

668

358

669

359

if (ilMethod.Body.Count == 0)

670

throw new YieldAnalysisFailedException();

360

throw new SymbolicAnalysisFailedException();

671

361

ILExpression lastReturnArg;

672

362

if (!ilMethod.Body.Last().Match(ILCode.Ret, out lastReturnArg))

673

throw new YieldAnalysisFailedException();

363

throw new SymbolicAnalysisFailedException();

674

364

675

365

// There are two possibilities:

676

366

if (lastReturnArg.Code == ILCode.Ldloc) {

678

368

returnVariable = (ILVariable)lastReturnArg.Operand;

679

369

returnLabel = ilMethod.Body.ElementAtOrDefault(ilMethod.Body.Count - 2) as ILLabel;

680

370

if (returnLabel == null)

681

throw new YieldAnalysisFailedException();

371

throw new SymbolicAnalysisFailedException();

682

372

} else {

683

373

// b) the compiler directly returns constants

684

374

returnVariable = null;

685

375

returnLabel = null;

686

376

// In this case, the last return must return false.

687

377

if (lastReturnArg.Code != ILCode.Ldc_I4 || (int)lastReturnArg.Operand != 0)

688

throw new YieldAnalysisFailedException();

378

throw new SymbolicAnalysisFailedException();

689

379

}

690

380

691

381

ILTryCatchBlock tryFaultBlock = ilMethod.Body[0] as ILTryCatchBlock;

694

384

if (tryFaultBlock != null) {

695

385

// there are try-finally blocks

696

386

if (returnVariable == null) // in this case, we must use a return variable

697

throw new YieldAnalysisFailedException();

387

throw new SymbolicAnalysisFailedException();

698

388

// must be a try-fault block:

699

389

if (tryFaultBlock.CatchBlocks.Count != 0 || tryFaultBlock.FinallyBlock != null || tryFaultBlock.FaultBlock == null)

700

throw new YieldAnalysisFailedException();

390

throw new SymbolicAnalysisFailedException();

701

391

702

392

ILBlock faultBlock = tryFaultBlock.FaultBlock;

703

393

// Ensure the fault block contains the call to Dispose().

704

394

if (faultBlock.Body.Count != 2)

705

throw new YieldAnalysisFailedException();

395

throw new SymbolicAnalysisFailedException();

706

396

MethodReference disposeMethodRef;

707

397

ILExpression disposeArg;

708

398

if (!faultBlock.Body[0].Match(ILCode.Call, out disposeMethodRef, out disposeArg))

709

throw new YieldAnalysisFailedException();

399

throw new SymbolicAnalysisFailedException();

710

400

if (GetMethodDefinition(disposeMethodRef) != disposeMethod || !disposeArg.MatchThis())

711

throw new YieldAnalysisFailedException();

401

throw new SymbolicAnalysisFailedException();

712

402

if (!faultBlock.Body[1].Match(ILCode.Endfinally))

713

throw new YieldAnalysisFailedException();

403

throw new SymbolicAnalysisFailedException();

714

404

715

405

body = tryFaultBlock.TryBlock.Body;

716

406

bodyLength = body.Count;

734

424

bodyLength--;

735

425

ILExpression store0 = body.ElementAtOrDefault(bodyLength - 1) as ILExpression;

736

426

if (store0 == null || store0.Code != ILCode.Stloc || store0.Operand != returnVariable)

737

throw new YieldAnalysisFailedException();

427

throw new SymbolicAnalysisFailedException();

738

428

if (store0.Arguments[0].Code != ILCode.Ldc_I4 || (int)store0.Arguments[0].Operand != 0)

739

throw new YieldAnalysisFailedException();

429

throw new SymbolicAnalysisFailedException();

740

430

741

431

bodyLength--; // don't conside the stloc instruction to be part of the body

742

432

}

743

433

// verify that the last element in the body is a label pointing to the 'ret(false)'

744

434

returnFalseLabel = body.ElementAtOrDefault(bodyLength - 1) as ILLabel;

745

435

if (returnFalseLabel == null)

746

throw new YieldAnalysisFailedException();

747

748

InitStateRanges(body[0]);

749

int pos = AssignStateRanges(body, bodyLength, forDispose: false);

750

if (pos > 0 && body[pos - 1] is ILLabel) {

751

pos--;

752

} else {

753

// ensure that the first element at body[pos] is a label:

754

ILLabel newLabel = new ILLabel();

755

newLabel.Name = "YieldReturnEntryPoint";

756

ranges[newLabel] = ranges[body[pos]]; // give the label the range of the instruction at body[pos]

757

758

body.Insert(pos, newLabel);

759

bodyLength++;

760

}

761

762

List<KeyValuePair<ILLabel, StateRange>> labels = new List<KeyValuePair<ILLabel, StateRange>>();

763

for (int i = pos; i < bodyLength; i++) {

764

ILLabel label = body[i] as ILLabel;

765

if (label != null) {

766

labels.Add(new KeyValuePair<ILLabel, StateRange>(label, ranges[label]));

767

}

768

}

769

436

throw new SymbolicAnalysisFailedException();

437

438

var rangeAnalysis = new StateRangeAnalysis(body[0], StateRangeAnalysisMode.IteratorMoveNext, stateField);

439

int pos = rangeAnalysis.AssignStateRanges(body, bodyLength);

440

rangeAnalysis.EnsureLabelAtPos(body, ref pos, ref bodyLength);

441

442

var labels = rangeAnalysis.CreateLabelRangeMapping(body, pos, bodyLength);

770

443

ConvertBody(body, pos, bodyLength, labels);

771

444

}

772

445

#endregion

797

470

// Handle stores to 'state' or 'current'

798

471

if (GetFieldDefinition(expr.Operand as FieldReference) == stateField) {

799

472

if (expr.Arguments[1].Code != ILCode.Ldc_I4)

800

throw new YieldAnalysisFailedException();

473

throw new SymbolicAnalysisFailedException();

801

474

currentState = (int)expr.Arguments[1].Operand;

802

475

stateChanges.Add(new SetState(newBody.Count, currentState));

803

476

} else if (GetFieldDefinition(expr.Operand as FieldReference) == currentField) {

809

482

// handle store+branch to the returnVariable

810

483

ILExpression br = body.ElementAtOrDefault(++pos) as ILExpression;

811

484

if (br == null || !(br.Code == ILCode.Br || br.Code == ILCode.Leave) || br.Operand != returnLabel || expr.Arguments[0].Code != ILCode.Ldc_I4)

812

throw new YieldAnalysisFailedException();

485

throw new SymbolicAnalysisFailedException();

813

486

int val = (int)expr.Arguments[0].Operand;

814

487

if (val == 0) {

815

488

newBody.Add(MakeGoTo(returnFalseLabel));

816

489

} else if (val == 1) {

817

490

newBody.Add(MakeGoTo(labels, currentState));

818

491

} else {

819

throw new YieldAnalysisFailedException();

492

throw new SymbolicAnalysisFailedException();

820

493

}

821

494

} else if (expr != null && expr.Code == ILCode.Ret) {

822

495

if (expr.Arguments.Count != 1 || expr.Arguments[0].Code != ILCode.Ldc_I4)

823

throw new YieldAnalysisFailedException();

496

throw new SymbolicAnalysisFailedException();

824

497

// handle direct return (e.g. in release builds)

825

498

int val = (int)expr.Arguments[0].Operand;

826

499

if (val == 0) {

828

501

} else if (val == 1) {

829

502

newBody.Add(MakeGoTo(labels, currentState));

830

503

} else {

831

throw new YieldAnalysisFailedException();

504

throw new SymbolicAnalysisFailedException();

832

505

}

833

506

} else if (expr != null && expr.Code == ILCode.Call && expr.Arguments.Count == 1 && expr.Arguments[0].MatchThis()) {

834

507

MethodDefinition method = GetMethodDefinition(expr.Operand as MethodReference);

835

508

if (method == null)

836

throw new YieldAnalysisFailedException();

509

throw new SymbolicAnalysisFailedException();

837

510

Interval interval;

838

511

if (method == disposeMethod) {

839

512

// Explicit call to dispose is used for "yield break;" within the method.

840

513

ILExpression br = body.ElementAtOrDefault(++pos) as ILExpression;

841

514

if (br == null || !(br.Code == ILCode.Br || br.Code == ILCode.Leave) || br.Operand != returnFalseLabel)

842

throw new YieldAnalysisFailedException();

515

throw new SymbolicAnalysisFailedException();

843

516

newBody.Add(MakeGoTo(returnFalseLabel));

844

517

} else if (finallyMethodToStateInterval.TryGetValue(method, out interval)) {

845

518

// Call to Finally-method

846

519

int index = stateChanges.FindIndex(ss => ss.NewState >= interval.Start && ss.NewState <= interval.End);

847

520

if (index < 0)

848

throw new YieldAnalysisFailedException();

521

throw new SymbolicAnalysisFailedException();

849

522

850

523

ILLabel label = new ILLabel();

851

524

label.Name = "JumpOutOfTryFinally" + interval.Start + "_" + interval.End;

883

556

if (pair.Value.Contains(state))

884

557

return MakeGoTo(pair.Key);

885

558

}

886

throw new YieldAnalysisFailedException();

559

throw new SymbolicAnalysisFailedException();

887

560

}

888

561

889

562

ILBlock ConvertFinallyBlock(MethodDefinition finallyMethod)

908

581

#region TranslateFieldsToLocalAccess

909

582

void TranslateFieldsToLocalAccess()

910

583

{

584

TranslateFieldsToLocalAccess(newBody, fieldToParameterMap);

585

}

586

587

internal static void TranslateFieldsToLocalAccess(List<ILNode> newBody, Dictionary<FieldDefinition, ILVariable> fieldToParameterMap)

588

{

911

589

var fieldToLocalMap = new DefaultDictionary<FieldDefinition, ILVariable>(f => new ILVariable { Name = f.Name, Type = f.FieldType });

912

590

foreach (ILNode node in newBody) {

913

591

foreach (ILExpression expr in node.GetSelfAndChildrenRecursive<ILExpression>()) {

Older »