Browse Source

improve conversion of Ceq-ILAst instruction

pull/728/head
Siegfried Pammer 10 years ago
parent
commit
c8f8d9ef4e
  1. 10
      ICSharpCode.Decompiler/CSharp/ExpressionBuilder.cs
  2. 5
      ICSharpCode.Decompiler/CSharp/TranslatedExpression.cs
  3. 1
      ICSharpCode.Decompiler/ICSharpCode.Decompiler.csproj
  4. 63
      ICSharpCode.Decompiler/TypeSystem/DecompilerTypeSystemUtils.cs

10
ICSharpCode.Decompiler/CSharp/ExpressionBuilder.cs

@ -247,7 +247,15 @@ namespace ICSharpCode.Decompiler.CSharp @@ -247,7 +247,15 @@ namespace ICSharpCode.Decompiler.CSharp
var rr = resolver.ResolveBinaryOperator(BinaryOperatorType.Equality, left.ResolveResult, right.ResolveResult);
if (rr.IsError) {
// TODO: insert casts to the wider type of the two input types
var targetType = DecompilerTypeSystemUtils.GetLargerType(left.Type, right.Type);
if (targetType.Equals(left.Type)) {
right = right.ConvertTo(targetType, this);
} else {
left = left.ConvertTo(targetType, this);
}
rr = new OperatorResolveResult(compilation.FindType(KnownTypeCode.Boolean),
BinaryOperatorExpression.GetLinqNodeType(BinaryOperatorType.Equality, false),
left.ResolveResult, right.ResolveResult);
}
return new BinaryOperatorExpression(left.Expression, BinaryOperatorType.Equality, right.Expression)
.WithILInstruction(inst)

5
ICSharpCode.Decompiler/CSharp/TranslatedExpression.cs

@ -175,6 +175,11 @@ namespace ICSharpCode.Decompiler.CSharp @@ -175,6 +175,11 @@ namespace ICSharpCode.Decompiler.CSharp
return expressionBuilder.ConvertConstantValue(rr)
.WithILInstruction(this.ILInstructions);
}
if (targetType.Kind == TypeKind.Pointer && 0.Equals(ResolveResult.ConstantValue)) {
return new NullReferenceExpression()
.WithILInstruction(this.ILInstructions)
.WithRR(new ConstantResolveResult(targetType, null));
}
return Expression.CastTo(expressionBuilder.ConvertType(targetType))
.WithoutILInstruction().WithRR(rr);
}

1
ICSharpCode.Decompiler/ICSharpCode.Decompiler.csproj

@ -135,6 +135,7 @@ @@ -135,6 +135,7 @@
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="Output\TextOutputWriter.cs" />
<Compile Include="TypeSystem\DecompilerTypeSystem.cs" />
<Compile Include="TypeSystem\DecompilerTypeSystemUtils.cs" />
<Compile Include="TypeSystem\SpecializingDecompilerTypeSystem.cs" />
<Compile Include="TypeSystem\IDecompilerTypeSystem.cs" />
<Compile Include="TypeSystem\ReferenceResolvingException.cs" />

63
ICSharpCode.Decompiler/TypeSystem/DecompilerTypeSystemUtils.cs

@ -0,0 +1,63 @@ @@ -0,0 +1,63 @@
// Copyright (c) 2015 Siegfried Pammer
//
// Permission is hereby granted, free of charge, to any person obtaining a copy of this
// software and associated documentation files (the "Software"), to deal in the Software
// without restriction, including without limitation the rights to use, copy, modify, merge,
// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
// to whom the Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all copies or
// substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
using System;
using ICSharpCode.NRefactory.TypeSystem;
namespace ICSharpCode.Decompiler
{
public static class DecompilerTypeSystemUtils
{
static int GetNativeSize(IType type)
{
if (type.Kind == TypeKind.Pointer)
return 6;
var typeForConstant = (type.Kind == TypeKind.Enum) ? type.GetDefinition().EnumUnderlyingType : type;
var typeDef = typeForConstant.GetDefinition();
if (typeDef == null)
return 0;
switch (typeDef.KnownTypeCode) {
case KnownTypeCode.Boolean:
case KnownTypeCode.SByte:
case KnownTypeCode.Byte:
return 1;
case KnownTypeCode.Char:
case KnownTypeCode.Int16:
case KnownTypeCode.UInt16:
return 2;
case KnownTypeCode.Int32:
case KnownTypeCode.UInt32:
case KnownTypeCode.Single:
return 4;
case KnownTypeCode.IntPtr:
case KnownTypeCode.UIntPtr:
return 6;
case KnownTypeCode.Int64:
case KnownTypeCode.UInt64:
case KnownTypeCode.Double:
return 8;
}
return 0;
}
public static IType GetLargerType(IType type1, IType type2)
{
return GetNativeSize(type1) >= GetNativeSize(type2) ? type1 : type2;
}
}
}
Loading…
Cancel
Save