private UserProcedure?LoadUserProcedure(
Program program,
Procedure_v1 sup)
{
if (!program.Architecture.TryParseAddress(sup.Address, out Address addr))
{
return(null);
}
if (!sup.Decompile && sup.Signature == null && string.IsNullOrEmpty(sup.CSignature))
{
listener.Warn(
listener.CreateAddressNavigator(program, addr),
"User procedure '{0}' has been marked 'no decompile' but its signature " +
"has not been specified.",
sup.Name ?? "<unnamed>");
}
string name = sup.Name ?? NamingPolicy.Instance.ProcedureName(addr);
var up = new UserProcedure(addr, name)
{
Ordinal = sup.Ordinal,
Signature = sup.Signature,
Characteristics = sup.Characteristics ?? new ProcedureCharacteristics(),
Decompile = sup.Decompile,
Assume = sup.Assume?.ToList() ?? new List <RegisterValue_v2>(),
CSignature = sup.CSignature,
OutputFile = sup.OutputFile
};
return(up);
}
private void Given_Signature(Address addr, string procName, SerializedSignature ssig)
{
userSigs[addr] = new UserProcedure(addr, procName)
{
Signature = ssig,
};
}
private string GuessName(UserProcedure userProc, Procedure proc = null)
{
if (userProc != null)
{
if (!string.IsNullOrEmpty(userProc.Name))
{
return(userProc.Name);
}
if (!string.IsNullOrEmpty(userProc.CSignature))
{
int i = userProc.CSignature.IndexOf('(');
if (i > 0)
{
var name = userProc.CSignature.Remove(i);
do
{
--i;
} while (i > 0 && (char.IsLetterOrDigit(name[i]) || name[i] == '_'));
return(name.Substring(i + 1));
}
}
}
if (proc != null)
{
return(proc.Name);
}
else
{
return(null);
}
}
public Procedure Add(UserProcedure userProc, Action <ProcedureBuilder> testCodeBuilder)
{
var mock = new ProcedureBuilder(Program.Architecture, GuessName(userProc));
mock.ProgramBuilder = this;
mock.LinearAddress = (uint)userProc.Address.ToLinear();
testCodeBuilder(mock);
Add(mock.Procedure, userProc);
unresolvedProcedures.AddRange(mock.UnresolvedProcedures);
return(mock.Procedure);
}
/// <summary>
/// Gets default user procedure based on data discovered by scanner.
/// Returns true if there is procedure discovered by scanner at
/// specified address; otherwise, false
/// </summary>
private bool TryMakeDefaultUserProcedure(
Address addr, [NotNullWhen(true)] out UserProcedure?userProc)
{
if (!program.Procedures.TryGetValue(addr, out var proc))
{
userProc = null;
return(false);
}
userProc = new UserProcedure(addr, proc.Name);
return(true);
}
public void Add(Procedure proc, UserProcedure userProc = null)
{
++procCount;
var addr = Address.Ptr32(procCount * 0x1000u);
Program.Procedures[addr] = proc;
Program.CallGraph.AddProcedure(proc);
nameToProcedure[GuessName(userProc, proc)] = proc;
if (userProc != null)
{
Program.User.Procedures[addr] = userProc;
}
}
private bool TryGetNoDecompiledParsedProcedure(Address addr, [NotNullWhen(true)] out UserProcedure?parsedProc)
{
if (!TryGetNoDecompiledProcedure(addr, out UserProcedure? sProc))
{
parsedProc = null;
return(false);
}
if (noDecompiledProcs.TryGetValue(addr, out parsedProc))
{
return(true);
}
parsedProc = new UserProcedure(addr, sProc.Name)
{
Name = sProc.Name,
Signature = new SerializedSignature
{
ParametersValid = false,
},
};
noDecompiledProcs[addr] = parsedProc;
if (string.IsNullOrEmpty(sProc.CSignature))
{
Warn(addr, "The user-defined procedure at address {0} did not have a signature.", addr);
return(true);
}
var usb = new UserSignatureBuilder(Program);
var procDecl = usb.ParseFunctionDeclaration(sProc.CSignature);
if (procDecl == null)
{
Warn(addr, "The user-defined procedure signature at address {0} could not be parsed.", addr);
return(true);
}
parsedProc.Signature = procDecl.Signature;
return(true);
}
public void Scanner_JumpToUserProcedureEntry()
{
var scan = CreateScanner(0x1000, 0x2000);
Given_Trace(new RtlTrace(0x1000)
{
// 0x1000:
m => { m.Goto(Address.Ptr32(0x1100)); }
});
Given_Trace(new RtlTrace(0x1100)
{
// 0x1100:
m => { m.Assign(reg1, m.Word32(1)); },
// 0x1104:
m => { m.Return(4, 8); },
});
var address = Address.Ptr32(0x1100);
var userProcedure = new UserProcedure(address, "user_proc");
scan.EnqueueUserProcedure(arch, userProcedure);
scan.EnqueueImageSymbol(
ImageSymbol.Procedure(
arch,
Address.Ptr32(0x1000),
state: arch.CreateProcessorState()),
true);
scan.ScanImage();
var sExp =
#region Expected
@"// fn00001000
// Return size: 4
define fn00001000
// stackDelta: 12; fpuStackDelta: 0; fpuMaxParam: -1
fn00001000_entry:
r63 = fp
l00001000:
l00001000_thunk_user_proc:
call user_proc (retsize: 0;)
return
fn00001000_exit:
// user_proc
// Return size: 4
define user_proc
// stackDelta: 12; fpuStackDelta: 0; fpuMaxParam: -1
user_proc_entry:
r63 = fp
l00001100:
r1 = 1<32>
return
user_proc_exit:
";
#endregion
AssertProgram(sExp, false, true, program);
}
