Remove new lines when printing method/type names

de4dot.code/MethodReturnValueInliner.cs

@@ -242,7 +242,9 @@ namespace de4dot.code {
 					// We're here if there were no cflow deobfuscation, or if there are two or
 					// more blocks branching to the decrypter method, or the two blocks can't be
 					// merged because one is outside the exception handler (eg. buggy obfuscator).
-					Log.v("Could not find all arguments to method {0}", method);
+					Log.v("Could not find all arguments to method {0} ({1:X8})",
+								Utils.removeNewlines(method),
+								method.MetadataToken.ToInt32());
 					return false;
 				}
 
@@ -288,7 +290,10 @@ namespace de4dot.code {
 					break;
 
 				default:
-					Log.v("Could not find all arguments to method {0}, instr: {1}", method, instr);
+					Log.v("Could not find all arguments to method {0} ({1:X8}), instr: {2}",
+								Utils.removeNewlines(method),
+								method.MetadataToken.ToInt32(),
+								instr);
 					return false;
 				}
 				break;

de4dot.code/ObfuscatedFile.cs

@@ -445,7 +445,7 @@ namespace de4dot.code {
 						}
 					}
 
-					Log.v("Adding string decrypter; token: {0:X8}, method: {1}", method.MetadataToken.ToInt32(), method.FullName);
+					Log.v("Adding string decrypter; token: {0:X8}, method: {1}", method.MetadataToken.ToInt32(), Utils.removeNewlines(method.FullName));
 					tokens.Add(method.MetadataToken.ToInt32());
 				}
 			}
@@ -527,7 +527,7 @@ namespace de4dot.code {
 			var methodPrinter = new MethodPrinter();
 			var cflowDeobfuscator = new BlocksCflowDeobfuscator { InlineMethods = deob.CanInlineMethods };
 			foreach (var method in allMethods) {
-				Log.v("Deobfuscating {0} ({1:X8})", method, method.MetadataToken.ToUInt32());
+				Log.v("Deobfuscating {0} ({1:X8})", Utils.removeNewlines(method), method.MetadataToken.ToUInt32());
 				Log.indent();
 
 				try {
@@ -708,9 +708,9 @@ namespace de4dot.code {
 					if (operandString == "")
 						Log.log(logLevel, "{0}", instrString);
 					else if (memberReference != null)
-						Log.log(logLevel, "{0,-9} {1} // {2:X8}", instrString, operandString, memberReference.MetadataToken.ToUInt32());
+						Log.log(logLevel, "{0,-9} {1} // {2:X8}", instrString, Utils.removeNewlines(operandString), memberReference.MetadataToken.ToUInt32());
 					else
-						Log.log(logLevel, "{0,-9} {1}", instrString, operandString);
+						Log.log(logLevel, "{0,-9} {1}", instrString, Utils.removeNewlines(operandString));
 				}
 				printExInfo(lastExInfo);
 				Log.deIndent();
@@ -859,7 +859,7 @@ namespace de4dot.code {
 			if (savedMethodBodies != null)
 				savedMethodBodies.save(method);
 
-			Log.v("{0}: {1} ({2:X8})", msg, method, method.MetadataToken.ToUInt32());
+			Log.v("{0}: {1} ({2:X8})", msg, Utils.removeNewlines(method), method.MetadataToken.ToUInt32());
 			Log.indent();
 
 			if (hasNonEmptyBody(method)) {

de4dot.code/Utils.cs

@@ -107,6 +107,14 @@ namespace de4dot.code {
 			sb.Append(c);
 		}
 
+		public static string removeNewlines(object o) {
+			return removeNewlines(o.ToString());
+		}
+
+		public static string removeNewlines(string s) {
+			return s.Replace('\n', ' ').Replace('\r', ' ');
+		}
+
 		public static string getFullPath(string path) {
 			try {
 				return Path.GetFullPath(path);

de4dot.code/deobfuscators/DeobfuscatorBase.cs

@@ -239,7 +239,7 @@ namespace de4dot.code.deobfuscators {
 							continue;
 
 						if (info.find(destMethod)) {
-							Log.v("Removed call to {0}", destMethod);
+							Log.v("Removed call to {0}", Utils.removeNewlines(destMethod));
 							instrsToDelete.Add(i);
 						}
 					}
@@ -329,7 +329,10 @@ namespace de4dot.code.deobfuscators {
 			foreach (var cctor in emptyCctorsToRemove) {
 				var type = cctor.DeclaringType;
 				if (type.Methods.Remove(cctor))
-					Log.v("{0:X8}, type: {1} ({2:X8})", cctor.MetadataToken.ToUInt32(), type, type.MetadataToken.ToUInt32());
+					Log.v("{0:X8}, type: {1} ({2:X8})",
+								cctor.MetadataToken.ToUInt32(),
+								Utils.removeNewlines(type),
+								type.MetadataToken.ToUInt32());
 			}
 			Log.deIndent();
 		}
@@ -346,7 +349,11 @@ namespace de4dot.code.deobfuscators {
 					continue;
 				var type = method.DeclaringType;
 				if (type.Methods.Remove(method))
-					Log.v("Removed method {0} ({1:X8}) (Type: {2}) (reason: {3})", method, method.MetadataToken.ToUInt32(), type, info.reason);
+					Log.v("Removed method {0} ({1:X8}) (Type: {2}) (reason: {3})",
+								Utils.removeNewlines(method),
+								method.MetadataToken.ToUInt32(),
+								Utils.removeNewlines(type),
+								info.reason);
 			}
 			Log.deIndent();
 		}
@@ -363,7 +370,11 @@ namespace de4dot.code.deobfuscators {
 					continue;
 				var type = field.DeclaringType;
 				if (type.Fields.Remove(field))
-					Log.v("Removed field {0} ({1:X8}) (Type: {2}) (reason: {3})", field, field.MetadataToken.ToUInt32(), type, info.reason);
+					Log.v("Removed field {0} ({1:X8}) (Type: {2}) (reason: {3})",
+								Utils.removeNewlines(field),
+								field.MetadataToken.ToUInt32(),
+								Utils.removeNewlines(type),
+								info.reason);
 			}
 			Log.deIndent();
 		}
@@ -385,7 +396,10 @@ namespace de4dot.code.deobfuscators {
 				else
 					removed = types.Remove(typeDef);
 				if (removed)
-					Log.v("Removed type {0} ({1:X8}) (reason: {2})", typeDef, typeDef.MetadataToken.ToUInt32(), info.reason);
+					Log.v("Removed type {0} ({1:X8}) (reason: {2})",
+								Utils.removeNewlines(typeDef),
+								typeDef.MetadataToken.ToUInt32(),
+								info.reason);
 			}
 			Log.deIndent();
 		}
@@ -412,7 +426,10 @@ namespace de4dot.code.deobfuscators {
 				for (int i = 0; i < customAttrs.Count; i++) {
 					if (MemberReferenceHelper.compareTypes(customAttrs[i].AttributeType, typeDef)) {
 						customAttrs.RemoveAt(i);
-						Log.v("Removed custom attribute {0} ({1:X8}) (reason: {2})", typeDef, typeDef.MetadataToken.ToUInt32(), info.reason);
+						Log.v("Removed custom attribute {0} ({1:X8}) (reason: {2})",
+									Utils.removeNewlines(typeDef),
+									typeDef.MetadataToken.ToUInt32(),
+									info.reason);
 						break;
 					}
 				}
@@ -432,7 +449,7 @@ namespace de4dot.code.deobfuscators {
 			for (int i = customAttributes.Count - 1; i >= 0; i--) {
 				var attr = customAttributes[i].AttributeType;
 				if (attr.FullName == "System.Runtime.CompilerServices.SuppressIldasmAttribute") {
-					Log.v("Removed attribute {0}", attr.FullName);
+					Log.v("Removed attribute {0}", Utils.removeNewlines(attr.FullName));
 					customAttributes.RemoveAt(i);
 				}
 			}

de4dot.code/deobfuscators/Dotfuscator/StringDecrypter.cs

@@ -86,7 +86,7 @@ namespace de4dot.code.deobfuscators.Dotfuscator {
 
 					var info = new StringDecrypterInfo(method, DotNetUtils.getLdcI4Value(ldci4));
 					stringDecrypterMethods[info.method] = info;
-					Log.v("Found string decrypter method: {0}, magic: 0x{1:X8}", info.method, info.magic);
+					Log.v("Found string decrypter method: {0}, magic: 0x{1:X8}", Utils.removeNewlines(info.method), info.magic);
 					break;
 				}
 			}

de4dot.code/deobfuscators/ProxyDelegateFinderBase.cs

@@ -100,7 +100,7 @@ namespace de4dot.code.deobfuscators {
 				if (context == null)
 					continue;
 
-				Log.v("Found proxy delegate: {0} ({1:X8})", type, type.MetadataToken.ToUInt32());
+				Log.v("Found proxy delegate: {0} ({1:X8})", Utils.removeNewlines(type), type.MetadataToken.ToUInt32());
 				RemovedDelegateCreatorCalls++;
 				onFoundProxyDelegate(type);
 
@@ -116,7 +116,11 @@ namespace de4dot.code.deobfuscators {
 					if (calledMethod == null)
 						continue;
 					addDelegateInfo(new DelegateInfo(field, calledMethod, callOpcode));
-					Log.v("Field: {0}, Opcode: {1}, Method: {2} ({3:X8})", field.Name, callOpcode, calledMethod, calledMethod.MetadataToken.ToUInt32());
+					Log.v("Field: {0}, Opcode: {1}, Method: {2} ({3:X8})",
+								Utils.removeNewlines(field.Name),
+								callOpcode,
+								Utils.removeNewlines(calledMethod),
+								calledMethod.MetadataToken.ToUInt32());
 				}
 				Log.deIndent();
 				delegateTypesDict[type] = true;
@@ -182,8 +186,10 @@ namespace de4dot.code.deobfuscators {
 						else {
 							errors++;
 							Log.w("Could not fix proxy call. Method: {0} ({1:X8}), Proxy type: {2} ({3:X8})",
-								blocks.Method, blocks.Method.MetadataToken.ToInt32(),
-								di.field.DeclaringType, di.field.DeclaringType.MetadataToken.ToInt32());
+								Utils.removeNewlines(blocks.Method),
+								blocks.Method.MetadataToken.ToInt32(),
+								Utils.removeNewlines(di.field.DeclaringType),
+								di.field.DeclaringType.MetadataToken.ToInt32());
 						}
 					}
 					else if (instr.OpCode == OpCodes.Call) {

de4dot.code/deobfuscators/SmartAssembly/TamperProtectionRemover.cs

@@ -296,7 +296,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 
 			if (tamperBlocks == null) {
 				if (isTamperProtected(allBlocks))
-					Log.w("Could not remove tamper protection code: {0} ({1:X8})", blocks.Method, blocks.Method.MetadataToken.ToUInt32());
+					Log.w("Could not remove tamper protection code: {0} ({1:X8})", Utils.removeNewlines(blocks.Method), blocks.Method.MetadataToken.ToUInt32());
 				return false;
 			}
 

de4dot.code/deobfuscators/TypesRestorer.cs

@@ -157,7 +157,7 @@ namespace de4dot.code.deobfuscators {
 				fields.Sort((a, b) => Utils.compareInt32(a.token, b.token));
 				Log.indent();
 				foreach (var updatedField in fields)
-					Log.v("Field {0:X8}: type {1} ({2:X8})", updatedField.token, updatedField.newFieldType.FullName, updatedField.newFieldType.MetadataToken.ToInt32());
+					Log.v("Field {0:X8}: type {1} ({2:X8})", updatedField.token, Utils.removeNewlines(updatedField.newFieldType.FullName), updatedField.newFieldType.MetadataToken.ToInt32());
 				Log.deIndent();
 			}
 
@@ -170,12 +170,12 @@ namespace de4dot.code.deobfuscators {
 					Log.v("Method {0:X8}", updatedMethod.token);
 					Log.indent();
 					if (updatedMethod.newReturnType != null)
-						Log.v("ret: {0} ({1:X8})", updatedMethod.newReturnType.FullName, updatedMethod.newReturnType.MetadataToken.ToInt32());
+						Log.v("ret: {0} ({1:X8})", Utils.removeNewlines(updatedMethod.newReturnType.FullName), updatedMethod.newReturnType.MetadataToken.ToInt32());
 					for (int i = 0; i < updatedMethod.newArgTypes.Length; i++) {
 						var updatedArg = updatedMethod.newArgTypes[i];
 						if (updatedArg == null)
 							continue;
-						Log.v("arg {0}: {1} ({2:X8})", i, updatedArg.FullName, updatedArg.MetadataToken.ToInt32());
+						Log.v("arg {0}: {1} ({2:X8})", i, Utils.removeNewlines(updatedArg.FullName), updatedArg.MetadataToken.ToInt32());
 					}
 					Log.deIndent();
 				}

de4dot.code/renamer/Renamer.cs

@@ -104,7 +104,7 @@ namespace de4dot.code.renamer {
 						if (method.MethodDefinition.Name != overrideMethod.Name)
 							continue;
 						Log.v("Removed useless override from method {0} ({1:X8}), override: {2:X8}",
-									method.MethodDefinition,
+									Utils.removeNewlines(method.MethodDefinition),
 									method.MethodDefinition.MetadataToken.ToInt32(),
 									overrideMethod.MetadataToken.ToInt32());
 						overrides.RemoveAt(i);
@@ -154,7 +154,7 @@ namespace de4dot.code.renamer {
 				if (list.Count != maxClasses)
 					continue;
 				var ns = list[0].TypeDefinition.Namespace;
-				Log.v("Removing namespace: {0}", ns);
+				Log.v("Removing namespace: {0}", Utils.removeNewlines(ns));
 				foreach (var type in list)
 					memberInfos.type(type).newNamespace = "";
 			}
@@ -173,7 +173,7 @@ namespace de4dot.code.renamer {
 			var typeDefinition = type.TypeDefinition;
 			var info = memberInfos.type(type);
 
-			Log.v("Type: {0} ({1:X8})", typeDefinition.FullName, typeDefinition.MetadataToken.ToUInt32());
+			Log.v("Type: {0} ({1:X8})", Utils.removeNewlines(typeDefinition.FullName), typeDefinition.MetadataToken.ToUInt32());
 			Log.indent();
 
 			renameGenericParams(type.GenericParams);
@@ -181,13 +181,13 @@ namespace de4dot.code.renamer {
 			if (RenameTypes && info.gotNewName()) {
 				var old = typeDefinition.Name;
 				typeDefinition.Name = info.newName;
-				Log.v("Name: {0} => {1}", old, typeDefinition.Name);
+				Log.v("Name: {0} => {1}", Utils.removeNewlines(old), typeDefinition.Name);
 			}
 
 			if (RenameNamespaces && info.newNamespace != null) {
 				var old = typeDefinition.Namespace;
 				typeDefinition.Namespace = info.newNamespace;
-				Log.v("Namespace: {0} => {1}", old, typeDefinition.Namespace);
+				Log.v("Namespace: {0} => {1}", Utils.removeNewlines(old), typeDefinition.Namespace);
 			}
 
 			Log.deIndent();
@@ -201,7 +201,7 @@ namespace de4dot.code.renamer {
 				if (!info.gotNewName())
 					continue;
 				param.GenericParameter.Name = info.newName;
-				Log.v("GenParam: {0} => {1}", info.oldFullName, param.GenericParameter.FullName);
+				Log.v("GenParam: {0} => {1}", Utils.removeNewlines(info.oldFullName), param.GenericParameter.FullName);
 			}
 		}
 
@@ -220,7 +220,7 @@ namespace de4dot.code.renamer {
 		void renameMembers(TypeDef type) {
 			var info = memberInfos.type(type);
 
-			Log.v("Type: {0}", info.type.TypeDefinition.FullName);
+			Log.v("Type: {0}", Utils.removeNewlines(info.type.TypeDefinition.FullName));
 			Log.indent();
 
 			renameFields(info);
@@ -239,7 +239,7 @@ namespace de4dot.code.renamer {
 				if (!fieldInfo.gotNewName())
 					continue;
 				fieldDef.FieldDefinition.Name = fieldInfo.newName;
-				Log.v("Field: {0} ({1:X8}) => {2}", fieldInfo.oldFullName, fieldDef.FieldDefinition.MetadataToken.ToUInt32(), fieldDef.FieldDefinition.FullName);
+				Log.v("Field: {0} ({1:X8}) => {2}", Utils.removeNewlines(fieldInfo.oldFullName), fieldDef.FieldDefinition.MetadataToken.ToUInt32(), fieldDef.FieldDefinition.FullName);
 			}
 		}
 
@@ -251,7 +251,7 @@ namespace de4dot.code.renamer {
 				if (!propInfo.gotNewName())
 					continue;
 				propDef.PropertyDefinition.Name = propInfo.newName;
-				Log.v("Property: {0} ({1:X8}) => {2}", propInfo.oldFullName, propDef.PropertyDefinition.MetadataToken.ToUInt32(), propDef.PropertyDefinition.FullName);
+				Log.v("Property: {0} ({1:X8}) => {2}", Utils.removeNewlines(propInfo.oldFullName), propDef.PropertyDefinition.MetadataToken.ToUInt32(), propDef.PropertyDefinition.FullName);
 			}
 		}
 
@@ -263,7 +263,7 @@ namespace de4dot.code.renamer {
 				if (!eventInfo.gotNewName())
 					continue;
 				eventDef.EventDefinition.Name = eventInfo.newName;
-				Log.v("Event: {0} ({1:X8}) => {2}", eventInfo.oldFullName, eventDef.EventDefinition.MetadataToken.ToUInt32(), eventDef.EventDefinition.FullName);
+				Log.v("Event: {0} ({1:X8}) => {2}", Utils.removeNewlines(eventInfo.oldFullName), eventDef.EventDefinition.MetadataToken.ToUInt32(), eventDef.EventDefinition.FullName);
 			}
 		}
 
@@ -272,14 +272,14 @@ namespace de4dot.code.renamer {
 				return;
 			foreach (var methodDef in info.type.AllMethodsSorted) {
 				var methodInfo = memberInfos.method(methodDef);
-				Log.v("Method {0} ({1:X8})", methodInfo.oldFullName, methodDef.MethodDefinition.MetadataToken.ToUInt32());
+				Log.v("Method {0} ({1:X8})", Utils.removeNewlines(methodInfo.oldFullName), methodDef.MethodDefinition.MetadataToken.ToUInt32());
 				Log.indent();
 
 				renameGenericParams(methodDef.GenericParams);
 
 				if (RenameMethods && methodInfo.gotNewName()) {
 					methodDef.MethodDefinition.Name = methodInfo.newName;
-					Log.v("Name: {0} => {1}", methodInfo.oldFullName, methodDef.MethodDefinition.FullName);
+					Log.v("Name: {0} => {1}", Utils.removeNewlines(methodInfo.oldFullName), methodDef.MethodDefinition.FullName);
 				}
 
 				if (RenameMethodArgs) {
@@ -288,7 +288,7 @@ namespace de4dot.code.renamer {
 						if (!paramInfo.gotNewName())
 							continue;
 						param.ParameterDefinition.Name = paramInfo.newName;
-						Log.v("Param ({0}/{1}): {2} => {3}", param.Index + 1, methodDef.ParamDefs.Count, paramInfo.oldName, paramInfo.newName);
+						Log.v("Param ({0}/{1}): {2} => {3}", param.Index + 1, methodDef.ParamDefs.Count, Utils.removeNewlines(paramInfo.oldName), paramInfo.newName);
 					}
 				}
 
@@ -395,10 +395,10 @@ namespace de4dot.code.renamer {
 						continue;
 
 					if (s == "" || !module.ObfuscatedFile.RenameResourcesInCode)
-						Log.v("Possible resource name in code: '{0}' => '{1}' in method {2}", s, newName, method);
+						Log.v("Possible resource name in code: '{0}' => '{1}' in method {2}", Utils.removeNewlines(s), newName, Utils.removeNewlines(method));
 					else {
 						instr.Operand = newName;
-						Log.v("Renamed resource string in code: '{0}' => '{1}' ({2})", s, newName, method);
+						Log.v("Renamed resource string in code: '{0}' => '{1}' ({2})", Utils.removeNewlines(s), newName, Utils.removeNewlines(method));
 						break;
 					}
 				}
@@ -414,7 +414,7 @@ namespace de4dot.code.renamer {
 					var newName = renameResourceString(s, info.oldFullName, info.type.TypeDefinition.FullName);
 					if (newName != s) {
 						resource.Name = newName;
-						Log.v("Renamed resource in resources: {0} => {1}", s, newName);
+						Log.v("Renamed resource in resources: {0} => {1}", Utils.removeNewlines(s), newName);
 						break;
 					}
 				}
@@ -601,9 +601,9 @@ namespace de4dot.code.renamer {
 			if (propDef.GetMethod != null)
 				return null;
 			Log.v("Restoring property getter {0} ({1:X8}), Property: {2} ({3:X8})",
-						propMethod,
+						Utils.removeNewlines(propMethod),
 						propMethod.MethodDefinition.MetadataToken.ToInt32(),
-						propDef.PropertyDefinition,
+						Utils.removeNewlines(propDef.PropertyDefinition),
 						propDef.PropertyDefinition.MetadataToken.ToInt32());
 			propDef.PropertyDefinition.GetMethod = propMethod.MethodDefinition;
 			propDef.GetMethod = propMethod;
@@ -630,9 +630,9 @@ namespace de4dot.code.renamer {
 			if (propDef.SetMethod != null)
 				return null;
 			Log.v("Restoring property setter {0} ({1:X8}), Property: {2} ({3:X8})",
-						propMethod,
+						Utils.removeNewlines(propMethod),
 						propMethod.MethodDefinition.MetadataToken.ToInt32(),
-						propDef.PropertyDefinition,
+						Utils.removeNewlines(propDef.PropertyDefinition),
 						propDef.PropertyDefinition.MetadataToken.ToInt32());
 			propDef.PropertyDefinition.SetMethod = propMethod.MethodDefinition;
 			propDef.SetMethod = propMethod;
@@ -650,7 +650,7 @@ namespace de4dot.code.renamer {
 
 			propDef = ownerType.create(newProp);
 			memberInfos.add(propDef);
-			Log.v("Restoring property: {0}", newProp);
+			Log.v("Restoring property: {0}", Utils.removeNewlines(newProp));
 			return propDef;
 		}
 
@@ -801,9 +801,9 @@ namespace de4dot.code.renamer {
 			if (eventDef.AddMethod != null)
 				return null;
 			Log.v("Restoring event adder {0} ({1:X8}), Event: {2} ({3:X8})",
-						eventMethod,
+						Utils.removeNewlines(eventMethod),
 						eventMethod.MethodDefinition.MetadataToken.ToInt32(),
-						eventDef.EventDefinition,
+						Utils.removeNewlines(eventDef.EventDefinition),
 						eventDef.EventDefinition.MetadataToken.ToInt32());
 			eventDef.EventDefinition.AddMethod = eventMethod.MethodDefinition;
 			eventDef.AddMethod = eventMethod;
@@ -827,9 +827,9 @@ namespace de4dot.code.renamer {
 			if (eventDef.RemoveMethod != null)
 				return null;
 			Log.v("Restoring event remover {0} ({1:X8}), Event: {2} ({3:X8})",
-						eventMethod,
+						Utils.removeNewlines(eventMethod),
 						eventMethod.MethodDefinition.MetadataToken.ToInt32(),
-						eventDef.EventDefinition,
+						Utils.removeNewlines(eventDef.EventDefinition),
 						eventDef.EventDefinition.MetadataToken.ToInt32());
 			eventDef.EventDefinition.RemoveMethod = eventMethod.MethodDefinition;
 			eventDef.RemoveMethod = eventMethod;
@@ -855,7 +855,7 @@ namespace de4dot.code.renamer {
 
 			eventDef = ownerType.create(newEvent);
 			memberInfos.add(eventDef);
-			Log.v("Restoring event: {0}", newEvent);
+			Log.v("Restoring event: {0}", Utils.removeNewlines(newEvent));
 			return eventDef;
 		}
 
@@ -1565,7 +1565,7 @@ namespace de4dot.code.renamer {
 					continue;
 				var methodDef = modules.resolve(entryPoint);
 				if (methodDef == null) {
-					Log.w(string.Format("Could not find entry point. Module: {0}, Method: {1}", module.ModuleDefinition.FullyQualifiedName, entryPoint));
+					Log.w(string.Format("Could not find entry point. Module: {0}, Method: {1}", module.ModuleDefinition.FullyQualifiedName, Utils.removeNewlines(entryPoint)));
 					continue;
 				}
 				if (!methodDef.isStatic())

de4dot.code/renamer/asmmodules/Modules.cs

@@ -450,7 +450,7 @@ namespace de4dot.code.renamer.asmmodules {
 			if (isAutoCreatedType(typeReference))
 				return null;
 			Log.e("Could not resolve TypeReference {0} ({1:X8}) (from {2} -> {3})",
-						typeReference,
+						Utils.removeNewlines(typeReference),
 						typeReference.MetadataToken.ToInt32(),
 						typeReference.Module,
 						typeReference.Scope);
@@ -471,7 +471,7 @@ namespace de4dot.code.renamer.asmmodules {
 			if (isAutoCreatedType(methodReference.DeclaringType))
 				return null;
 			Log.e("Could not resolve MethodReference {0} ({1:X8}) (from {2} -> {3})",
-						methodReference,
+						Utils.removeNewlines(methodReference),
 						methodReference.MetadataToken.ToInt32(),
 						methodReference.DeclaringType.Module,
 						methodReference.DeclaringType.Scope);
@@ -492,7 +492,7 @@ namespace de4dot.code.renamer.asmmodules {
 			if (isAutoCreatedType(fieldReference.DeclaringType))
 				return null;
 			Log.e("Could not resolve FieldReference {0} ({1:X8}) (from {2} -> {3})",
-						fieldReference,
+						Utils.removeNewlines(fieldReference),
 						fieldReference.MetadataToken.ToInt32(),
 						fieldReference.DeclaringType.Module,
 						fieldReference.DeclaringType.Scope);

de4dot.code/renamer/asmmodules/TypeDef.cs

@@ -609,9 +609,9 @@ namespace de4dot.code.renamer.asmmodules {
 						continue;
 					string errMsg = string.Format(
 							"Could not find interface method {0} ({1:X8}). Type: {2} ({3:X8})",
-							pair.Key.MethodDefinition,
+							Utils.removeNewlines(pair.Key.MethodDefinition),
 							pair.Key.MethodDefinition.MetadataToken.ToInt32(),
-							TypeDefinition,
+							Utils.removeNewlines(TypeDefinition),
 							TypeDefinition.MetadataToken.ToInt32());
 					// Ignore if COM class
 					if (!hasAttribute("System.Runtime.InteropServices.TypeLibTypeAttribute"))