Implement remaining ILGenertorImpl methods, excluding scope. Add max stack calculation for branching.

src/libraries/System.Reflection.Emit/src/Resources/Strings.resx

@@ -228,6 +228,9 @@
   <data name="Arg_NotGenericMethodDefinition" xml:space="preserve">
     <value>{0} is not a GenericMethodDefinition. MakeGenericMethod may only be called on a method for which MethodBase.IsGenericMethodDefinition is true.</value>
   </data>
+  <data name="InvalidOperation_NotAVarArgCallingConvention" xml:space="preserve">
+    <value>Calling convention must be VarArgs.</value>
+  </data>
   <data name="ArgumentException_BadMethodImplBody" xml:space="preserve">
     <value>MethodOverride's body must be from this type.</value>
   </data>
@@ -261,4 +264,7 @@
   <data name="InvalidOperation_BadEmptyMethodBody" xml:space="preserve">
     <value>Method '{0}' does not have a method body.</value>
   </data>
+  <data name="Argument_RedefinedLabel" xml:space="preserve">
+    <value>Label multiply defined.</value>
+  </data>
 </root>

src/libraries/System.Reflection.Emit/src/System/Reflection/Emit/AssemblyBuilderImpl.cs

@@ -40,20 +40,22 @@ internal AssemblyBuilderImpl(AssemblyName name, Assembly coreAssembly, IEnumerab
             }
         }
 
-        internal static AssemblyBuilderImpl DefinePersistedAssembly(AssemblyName name, Assembly coreAssembly, IEnumerable<CustomAttributeBuilder>? assemblyAttributes)
+        internal static AssemblyBuilderImpl DefinePersistedAssembly(AssemblyName name, Assembly coreAssembly,
+            IEnumerable<CustomAttributeBuilder>? assemblyAttributes)
                 => new AssemblyBuilderImpl(name, coreAssembly, assemblyAttributes);
 
         private void WritePEImage(Stream peStream, BlobBuilder ilBuilder)
         {
-            // Create executable with the managed metadata from the specified MetadataBuilder.
             var peHeaderBuilder = new PEHeaderBuilder(
-                imageCharacteristics: Characteristics.Dll // Start off with a simple DLL
-                );
+                // When only Characteristics.Dll is set and try to load the generated assembly from file,
+                // runtime throws BadImageFormatException, had to add Characteristics.ExecutableImage.
+                imageCharacteristics: Characteristics.ExecutableImage | Characteristics.Dll);
 
             var peBuilder = new ManagedPEBuilder(
-                peHeaderBuilder,
-                new MetadataRootBuilder(_metadataBuilder),
-                ilBuilder);
+                header: peHeaderBuilder,
+                metadataRootBuilder: new MetadataRootBuilder(_metadataBuilder),
+                ilStream: ilBuilder,
+                strongNameSignatureSize: 0);
 
             // Write executable into the specified stream.
             var peBlob = new BlobBuilder();

src/libraries/System.Reflection.Emit/src/System/Reflection/Emit/MethodBuilderImpl.cs

@@ -84,8 +84,8 @@ internal MethodBuilderImpl(string name, MethodAttributes attributes, CallingConv
             }
         }
 
-        internal BlobBuilder GetMethodSignatureBlob() => MetadataSignatureHelper.MethodSignatureEncoder(_module,
-            _parameterTypes, ReturnType, GetSignatureConvention(_callingConventions, _dllImportData), GetGenericArguments().Length, !IsStatic);
+        internal BlobBuilder GetMethodSignatureBlob() => MetadataSignatureHelper.GetMethodSignature(_module, _parameterTypes,
+            _returnType, GetSignatureConvention(_callingConventions, _dllImportData), GetGenericArguments().Length, !IsStatic);
 
         internal static SignatureCallingConvention GetSignatureConvention(CallingConventions callingConvention, DllImportData? dllImportData = null)
         {

src/libraries/System.Reflection.Emit/src/System/Reflection/Emit/SignatureHelper.cs

@@ -8,10 +8,9 @@
 
 namespace System.Reflection.Emit
 {
-    // TODO: Only support simple signatures. More complex signatures (generics, array, byref, pointers etc) will be added.
     internal static class MetadataSignatureHelper
     {
-        internal static BlobBuilder LocalSignatureEncoder(List<LocalBuilder> locals, ModuleBuilderImpl module)
+        internal static BlobBuilder GetLocalSignature(List<LocalBuilder> locals, ModuleBuilderImpl module)
         {
             BlobBuilder localSignature = new();
             LocalVariablesEncoder encoder = new BlobEncoder(localSignature).LocalVariableSignature(locals.Count);
@@ -25,15 +24,15 @@ internal static BlobBuilder LocalSignatureEncoder(List<LocalBuilder> locals, Mod
             return localSignature;
         }
 
-        internal static BlobBuilder FieldSignatureEncoder(Type fieldType, ModuleBuilderImpl module)
+        internal static BlobBuilder GetFieldSignature(Type fieldType, ModuleBuilderImpl module)
         {
             BlobBuilder fieldSignature = new();
             WriteSignatureForType(new BlobEncoder(fieldSignature).Field().Type(), fieldType, module);
 
             return fieldSignature;
         }
 
-        internal static BlobBuilder ConstructorSignatureEncoder(ParameterInfo[]? parameters, ModuleBuilderImpl module)
+        internal static BlobBuilder GetConstructorSignature(ParameterInfo[]? parameters, ModuleBuilderImpl module)
         {
             BlobBuilder constructorSignature = new();
 
@@ -71,27 +70,32 @@ internal static BlobBuilder GetMethodSpecificationSignature(Type[] genericArgume
             return methodSpecSignature;
         }
 
-        internal static BlobBuilder MethodSignatureEncoder(ModuleBuilderImpl module, Type[]? parameters,
-            Type? returnType, SignatureCallingConvention convention, int genParamCount, bool isInstance)
+        internal static BlobBuilder GetMethodSignature(ModuleBuilderImpl module, Type[]? parameters, Type? returnType,
+            SignatureCallingConvention convention, int genParamCount = 0, bool isInstance = false, Type[]? optionalParameterTypes = null)
         {
-            // Encoding return type and parameters.
             BlobBuilder methodSignature = new();
 
-            new BlobEncoder(methodSignature).
-                MethodSignature(convention: convention, genericParameterCount: genParamCount, isInstanceMethod: isInstance).
-                Parameters((parameters == null) ? 0 : parameters.Length, out ReturnTypeEncoder retEncoder, out ParametersEncoder parEncoder);
+            int paramsLength = ((parameters == null) ? 0 : parameters.Length) + ((optionalParameterTypes == null) ? 0 : optionalParameterTypes.Length);
+
+            new BlobEncoder(methodSignature).MethodSignature(convention, genParamCount, isInstance).
+                    Parameters(paramsLength, out ReturnTypeEncoder retEncoder, out ParametersEncoder parEncoder);
 
             if (returnType != null && returnType != module.GetTypeFromCoreAssembly(CoreTypeId.Void))
             {
                 WriteSignatureForType(retEncoder.Type(), returnType, module);
             }
-            else // If null mark ReturnTypeEncoder as void
+            else
             {
                 retEncoder.Void();
             }
 
             WriteParametersSignature(module, parameters, parEncoder);
 
+            if (optionalParameterTypes != null && optionalParameterTypes.Length != 0)
+            {
+                WriteParametersSignature(module, optionalParameterTypes, parEncoder.StartVarArgs());
+            }
+
             return methodSignature;
         }
 
@@ -106,7 +110,7 @@ private static void WriteParametersSignature(ModuleBuilderImpl module, Type[]? p
             }
         }
 
-        internal static BlobBuilder PropertySignatureEncoder(PropertyBuilderImpl property, ModuleBuilderImpl module)
+        internal static BlobBuilder GetPropertySignature(PropertyBuilderImpl property, ModuleBuilderImpl module)
         {
             BlobBuilder propertySignature = new();