2 // ikvm.cs: IKVM.Reflection and IKVM.Reflection.Emit specific implementations
4 // Author: Marek Safar (marek.safar@gmail.com)
6 // Dual licensed under the terms of the MIT X11 or GNU GPL
8 // Copyright 2009-2010 Novell, Inc.
9 // Copyright 2011 Xamarin Inc
14 using System.Collections.Generic;
15 using MetaType = IKVM.Reflection.Type;
16 using IKVM.Reflection;
17 using IKVM.Reflection.Emit;
19 using System.Configuration.Assemblies;
24 public class StaticImporter
26 public StaticImporter (BuiltinTypes builtin)
28 throw new NotSupportedException ();
31 public void ImportAssembly (Assembly assembly, RootNamespace targetNamespace)
33 throw new NotSupportedException ();
36 public void ImportModule (Module module, RootNamespace targetNamespace)
38 throw new NotSupportedException ();
41 public TypeSpec ImportType (System.Type type)
43 throw new NotSupportedException ();
49 sealed class StaticImporter : MetadataImporter
51 public StaticImporter (ModuleContainer module)
56 public void AddCompiledAssembly (AssemblyDefinitionStatic assembly)
58 assembly_2_definition.Add (assembly.Builder, assembly);
61 public override void AddCompiledType (TypeBuilder type, TypeSpec spec)
63 compiled_types.Add (type, spec);
66 protected override MemberKind DetermineKindFromBaseType (MetaType baseType)
68 string name = baseType.Name;
70 if (name == "ValueType" && baseType.Namespace == "System")
71 return MemberKind.Struct;
73 if (name == "Enum" && baseType.Namespace == "System")
74 return MemberKind.Enum;
76 if (name == "MulticastDelegate" && baseType.Namespace == "System")
77 return MemberKind.Delegate;
79 return MemberKind.Class;
82 protected override bool HasVolatileModifier (MetaType[] modifiers)
84 foreach (var t in modifiers) {
85 if (t.Name == "IsVolatile" && t.Namespace == CompilerServicesNamespace)
92 public void ImportAssembly (Assembly assembly, RootNamespace targetNamespace)
94 // It can be used more than once when importing same assembly
95 // into 2 or more global aliases
96 var definition = GetAssemblyDefinition (assembly);
98 var all_types = assembly.GetTypes ();
99 ImportTypes (all_types, targetNamespace, definition.HasExtensionMethod);
101 all_types = assembly.ManifestModule.__GetExportedTypes ();
102 if (all_types.Length != 0)
103 ImportForwardedTypes (all_types, targetNamespace);
106 public ImportedModuleDefinition ImportModule (Module module, RootNamespace targetNamespace)
108 var module_definition = new ImportedModuleDefinition (module);
109 module_definition.ReadAttributes ();
111 var all_types = module.GetTypes ();
112 ImportTypes (all_types, targetNamespace, false);
114 return module_definition;
117 void ImportForwardedTypes (MetaType[] types, Namespace targetNamespace)
119 Namespace ns = targetNamespace;
120 string prev_namespace = null;
121 foreach (var t in types) {
122 // IsMissing tells us the type has been forwarded and target assembly is missing
126 if (t.Name[0] == '<')
129 var it = CreateType (t, null, new DynamicTypeReader (t), true);
133 if (prev_namespace != t.Namespace) {
134 ns = t.Namespace == null ? targetNamespace : targetNamespace.GetNamespace (t.Namespace, true);
135 prev_namespace = t.Namespace;
138 ns.AddType (module, it);
142 public void InitializeBuiltinTypes (BuiltinTypes builtin, Assembly corlib)
145 // Setup mapping for build-in types to avoid duplication of their definition
147 foreach (var type in builtin.AllTypes) {
148 compiled_types.Add (corlib.GetType (type.FullName), type);
154 class AssemblyDefinitionStatic : AssemblyDefinition
156 readonly StaticLoader loader;
159 // Assembly container with file output
161 public AssemblyDefinitionStatic (ModuleContainer module, StaticLoader loader, string name, string fileName)
162 : base (module, name, fileName)
164 this.loader = loader;
165 Importer = loader.MetadataImporter;
169 // Initializes the assembly SRE domain
171 public void Create (Universe domain)
173 ResolveAssemblySecurityAttributes ();
174 var an = CreateAssemblyName ();
176 Builder = domain.DefineDynamicAssembly (an, AssemblyBuilderAccess.Save, Path.GetDirectoryName (file_name));
177 module.Create (this, CreateModuleBuilder ());
180 public override void Emit ()
182 if (loader.Corlib != null && !(loader.Corlib is AssemblyBuilder)) {
183 Builder.__SetImageRuntimeVersion (loader.Corlib.ImageRuntimeVersion, 0x20000);
185 // Sets output file metadata version when there is no mscorlib
186 switch (module.Compiler.Settings.StdLibRuntimeVersion) {
187 case RuntimeVersion.v4:
188 Builder.__SetImageRuntimeVersion ("v4.0.30319", 0x20000);
190 case RuntimeVersion.v2:
191 Builder.__SetImageRuntimeVersion ("v2.0.50727", 0x20000);
193 case RuntimeVersion.v1:
194 // Compiler does not do any checks whether the produced metadata
195 // are valid in the context of 1.0 stream version
196 Builder.__SetImageRuntimeVersion ("v1.1.4322", 0x10000);
199 throw new NotImplementedException ();
203 builder_extra = new AssemblyBuilderIKVM (Builder, Compiler);
208 public Module IncludeModule (RawModule moduleFile)
210 return Builder.__AddModule (moduleFile);
213 protected override void SaveModule (PortableExecutableKinds pekind, ImageFileMachine machine)
215 module.Builder.__Save (pekind, machine);
219 class StaticLoader : AssemblyReferencesLoader<Assembly>, IDisposable
221 readonly StaticImporter importer;
222 readonly Universe domain;
224 List<Tuple<AssemblyName, string, Assembly>> loaded_names;
225 static readonly Dictionary<string, string[]> sdk_directory;
227 static StaticLoader ()
229 sdk_directory = new Dictionary<string, string[]> ();
230 sdk_directory.Add ("2", new string[] { "2.0", "net_2_0", "v2.0.50727" });
231 sdk_directory.Add ("4", new string[] { "4.0", "net_4_0", "v4.0.30319" });
232 sdk_directory.Add ("4.5", new string[] { "4.5", "net_4_5", "v4.0.30319" });
235 public StaticLoader (StaticImporter importer, CompilerContext compiler)
238 this.importer = importer;
239 domain = new Universe ();
240 domain.EnableMissingMemberResolution ();
241 domain.AssemblyResolve += AssemblyReferenceResolver;
242 loaded_names = new List<Tuple<AssemblyName, string, Assembly>> ();
244 if (compiler.Settings.StdLib) {
245 var corlib_path = Path.GetDirectoryName (typeof (object).Assembly.Location);
246 string fx_path = corlib_path.Substring (0, corlib_path.LastIndexOf (Path.DirectorySeparatorChar));
248 string sdk_path = null;
250 string sdk_version = compiler.Settings.SdkVersion ?? "4.5";
251 string[] sdk_sub_dirs;
253 if (!sdk_directory.TryGetValue (sdk_version, out sdk_sub_dirs))
254 sdk_sub_dirs = new string[] { sdk_version };
256 foreach (var dir in sdk_sub_dirs) {
257 sdk_path = Path.Combine (fx_path, dir);
258 if (File.Exists (Path.Combine (sdk_path, "mscorlib.dll")))
264 if (sdk_path == null) {
265 compiler.Report.Warning (-1, 1, "SDK path could not be resolved");
266 sdk_path = corlib_path;
269 paths.Add (sdk_path);
275 public Assembly Corlib {
281 public Universe Domain {
287 public StaticImporter MetadataImporter {
295 Assembly AssemblyReferenceResolver (object sender, IKVM.Reflection.ResolveEventArgs args)
297 var refname = args.Name;
298 if (refname == "mscorlib")
301 Assembly version_mismatch = null;
302 bool is_fx_assembly = false;
304 foreach (var assembly in domain.GetAssemblies ()) {
305 AssemblyComparisonResult result;
306 if (!Fusion.CompareAssemblyIdentityPure (refname, false, assembly.FullName, false, out result)) {
307 if ((result == AssemblyComparisonResult.NonEquivalentVersion || result == AssemblyComparisonResult.NonEquivalentPartialVersion) &&
308 (version_mismatch == null || version_mismatch.GetName ().Version < assembly.GetName ().Version) &&
310 version_mismatch = assembly;
316 if (result == AssemblyComparisonResult.EquivalentFullMatch ||
317 result == AssemblyComparisonResult.EquivalentWeakNamed ||
318 result == AssemblyComparisonResult.EquivalentPartialMatch) {
322 if (result == AssemblyComparisonResult.EquivalentFXUnified) {
323 is_fx_assembly = true;
325 if (version_mismatch == null || version_mismatch.GetName ().Version < assembly.GetName ().Version)
326 version_mismatch = assembly;
331 throw new NotImplementedException ("Assembly equality = " + result.ToString ());
334 if (version_mismatch != null) {
335 if (version_mismatch is AssemblyBuilder)
336 return version_mismatch;
338 var v1 = new AssemblyName (refname).Version;
339 var v2 = version_mismatch.GetName ().Version;
342 // compiler.Report.SymbolRelatedToPreviousError (args.RequestingAssembly.Location);
343 compiler.Report.Error (1705, "Assembly `{0}' references `{1}' which has a higher version number than imported assembly `{2}'",
344 args.RequestingAssembly.FullName, refname, version_mismatch.GetName ().FullName);
346 return domain.CreateMissingAssembly (args.Name);
349 if (!is_fx_assembly) {
350 if (v1.Major != v2.Major || v1.Minor != v2.Minor) {
351 compiler.Report.Warning (1701, 2,
352 "Assuming assembly reference `{0}' matches assembly `{1}'. You may need to supply runtime policy",
353 refname, version_mismatch.GetName ().FullName);
355 compiler.Report.Warning (1702, 3,
356 "Assuming assembly reference `{0}' matches assembly `{1}'. You may need to supply runtime policy",
357 refname, version_mismatch.GetName ().FullName);
361 return version_mismatch;
364 // AssemblyReference has not been found in the domain
365 // create missing reference and continue
366 return domain.CreateMissingAssembly (args.Name);
369 public void Dispose ()
374 protected override string[] GetDefaultReferences ()
377 // For now the "default config" is harcoded into the compiler
378 // we can move this outside later
380 var default_references = new List<string> (4);
382 default_references.Add ("System.dll");
383 default_references.Add ("System.Xml.dll");
384 default_references.Add ("System.Core.dll");
386 if (corlib != null && corlib.GetName ().Version.Major >= 4) {
387 default_references.Add ("Microsoft.CSharp.dll");
390 return default_references.ToArray ();
393 public override bool HasObjectType (Assembly assembly)
395 return assembly.GetType (compiler.BuiltinTypes.Object.FullName) != null;
398 public override Assembly LoadAssemblyFile (string fileName, bool isImplicitReference)
400 bool? has_extension = null;
401 foreach (var path in paths) {
402 var file = Path.Combine (path, fileName);
403 if (compiler.Settings.DebugFlags > 0)
404 Console.WriteLine ("Probing assembly location `{0}'", file);
406 if (!File.Exists (file)) {
407 if (!has_extension.HasValue)
408 has_extension = fileName.EndsWith (".dll", StringComparison.Ordinal) || fileName.EndsWith (".exe", StringComparison.Ordinal);
410 if (has_extension.Value)
414 if (!File.Exists (file))
419 using (RawModule module = domain.OpenRawModule (file)) {
420 if (!module.IsManifestModule) {
421 Error_AssemblyIsModule (fileName);
426 // check whether the assembly can be actually imported without
429 var an = module.GetAssemblyName ();
430 foreach (var entry in loaded_names) {
431 var loaded_name = entry.Item1;
432 if (an.Name != loaded_name.Name)
435 if (module.ModuleVersionId == entry.Item3.ManifestModule.ModuleVersionId)
438 if (((an.Flags | loaded_name.Flags) & AssemblyNameFlags.PublicKey) == 0) {
439 compiler.Report.SymbolRelatedToPreviousError (entry.Item2);
440 compiler.Report.SymbolRelatedToPreviousError (fileName);
441 compiler.Report.Error (1704,
442 "An assembly with the same name `{0}' has already been imported. Consider removing one of the references or sign the assembly",
447 if ((an.Flags & AssemblyNameFlags.PublicKey) == (loaded_name.Flags & AssemblyNameFlags.PublicKey) && an.Version.Equals (loaded_name.Version)) {
448 compiler.Report.SymbolRelatedToPreviousError (entry.Item2);
449 compiler.Report.SymbolRelatedToPreviousError (fileName);
450 compiler.Report.Error (1703,
451 "An assembly with the same identity `{0}' has already been imported. Consider removing one of the references",
457 if (compiler.Settings.DebugFlags > 0)
458 Console.WriteLine ("Loading assembly `{0}'", fileName);
460 var assembly = domain.LoadAssembly (module);
461 if (assembly != null)
462 loaded_names.Add (Tuple.Create (an, fileName, assembly));
467 if (!isImplicitReference)
468 Error_FileCorrupted (file);
474 if (!isImplicitReference)
475 Error_FileNotFound (fileName);
480 public RawModule LoadModuleFile (string moduleName)
482 foreach (var path in paths) {
483 var file = Path.Combine (path, moduleName);
484 if (!File.Exists (file)) {
485 if (moduleName.EndsWith (".netmodule", StringComparison.Ordinal))
488 file += ".netmodule";
489 if (!File.Exists (file))
494 return domain.OpenRawModule (file);
496 Error_FileCorrupted (file);
501 Error_FileNotFound (moduleName);
505 public override void LoadReferences (ModuleContainer module)
507 List<Tuple<RootNamespace, Assembly>> loaded;
508 base.LoadReferencesCore (module, out corlib, out loaded);
510 compiler.TimeReporter.Start (TimeReporter.TimerType.ReferencesImporting);
512 if (corlib == null) {
513 // System.Object was not found in any referenced assembly, use compiled assembly as corlib
514 corlib = module.DeclaringAssembly.Builder;
516 importer.InitializeBuiltinTypes (compiler.BuiltinTypes, corlib);
517 importer.ImportAssembly (corlib, module.GlobalRootNamespace);
520 foreach (var entry in loaded) {
521 importer.ImportAssembly (entry.Item2, entry.Item1);
524 compiler.TimeReporter.Stop (TimeReporter.TimerType.ReferencesImporting);
527 public void LoadModules (AssemblyDefinitionStatic assembly, RootNamespace targetNamespace)
529 foreach (var moduleName in compiler.Settings.Modules) {
530 var m = LoadModuleFile (moduleName);
534 if (m.IsManifestModule) {
535 Error_ModuleIsAssembly (moduleName);
539 var md = importer.ImportModule (assembly.IncludeModule (m), targetNamespace);
540 assembly.AddModule (md);
545 class AssemblyBuilderIKVM : AssemblyBuilderExtension
547 readonly AssemblyBuilder builder;
549 public AssemblyBuilderIKVM (AssemblyBuilder builder, CompilerContext ctx)
552 this.builder = builder;
555 public override void AddTypeForwarder (TypeSpec type, Location loc)
557 builder.__AddTypeForwarder (type.GetMetaInfo ());
560 public override void DefineWin32IconResource (string fileName)
562 builder.__DefineIconResource (File.ReadAllBytes (fileName));
565 public override void SetAlgorithmId (uint value, Location loc)
567 builder.__SetAssemblyAlgorithmId ((AssemblyHashAlgorithm) value);
570 public override void SetCulture (string culture, Location loc)
572 builder.__SetAssemblyCulture (culture);
575 public override void SetFlags (uint flags, Location loc)
577 builder.__AssemblyFlags = (AssemblyNameFlags) flags;
580 public override void SetVersion (Version version, Location loc)
582 builder.__SetAssemblyVersion (version);