public CompilationUnitSet(ReadyToRunCompilationModuleGroupBase compilationGroup, ModuleDesc module) { CompilationUnitIndex compilationIndex = compilationGroup.ModuleToCompilationUnitIndex(module); _bits = new BitArray(((int)compilationIndex) + 1); _bits.Set((int)compilationIndex, true); }
// Compilation Unit Index is the compilation unit of a given module. If the compilation unit // is unknown the module will be given an independent index from other modules, but // IsCompilationUnitIndexExact will return false for that index. All compilation unit indices // are >= 2, to allow for 0 and 1 to be sentinel values. private CompilationUnitIndex ModuleToCompilationUnitIndex(ModuleDesc nonEcmaModule) { EcmaModule module = (EcmaModule)nonEcmaModule; if (IsModuleInCompilationGroup(module)) { return(CompilationUnitIndex.Current); } if (!VersionsWithModule(module)) { return(CompilationUnitIndex.OutsideOfVersionBubble); } // Assemblies within the version bubble, but not compiled as part of this compilation unit are given // unique separate compilation units. The practical effect of this is that the compiler can assume that // types which are entirely defined in one module can be laid out in an optimal fashion, but types // which are laid out relying on multiple modules cannot have their type layout precisely known as // it is unknown if the modules are bounding into a single composite image or into individual assemblies. lock (_moduleCompilationUnits) { if (!_moduleCompilationUnits.TryGetValue(module, out CompilationUnitIndex compilationUnit)) { compilationUnit = _nextCompilationUnit; _nextCompilationUnit = (CompilationUnitIndex)(((int)_nextCompilationUnit) + 1); _moduleCompilationUnits.Add(module, compilationUnit); } return(compilationUnit); } }
// Indicate whether or not the compiler can take a hard dependency on the meaning of // the compilation unit index. private bool IsCompilationUnitIndexExact(CompilationUnitIndex compilationUnitIndex) { // Currently the implementation is only allowed to assume 2 details. // 1. That any assembly which is compiled with inputbubble set shall have its entire set of dependencies compiled as R2R // 2. That any assembly which is compiled in the current process may be considered to be part of a single unit. // // At some point, the compiler could take new parameters to allow the compiler to know that assemblies not in the current compilation // unit are to be compiled into composite images or into separate binaries, and this helper function could return true for these other // compilation unit shapes. if (compilationUnitIndex != CompilationUnitIndex.Current) { return(false); } else { return(true); } }