Exemple #1
0
            internal override ScopeBounds GetIteratorScopes(ArrayBuilder <Cci.LocalScope> scopesWithIteratorLocals, bool edgeInclusive)
            {
                uint begin = uint.MaxValue;
                uint end   = 0;

                // It may seem overkill to scan all blocks,
                // but blocks may be reordered so we cannot be sure which ones are first/last.
                if (Blocks != null)
                {
                    for (int i = 0; i < Blocks.Count; i++)
                    {
                        var block = Blocks[i];

                        if (block.Reachability != Reachability.NotReachable)
                        {
                            begin = Math.Min(begin, (uint)block.Start);
                            end   = Math.Max(end, (uint)(block.Start + block.TotalSize));
                        }
                    }
                }

                // if there are nested scopes, dump them too
                // also may need to adjust current scope bounds.
                if (NestedScopes != null)
                {
                    ScopeBounds nestedBounds = GetIteratorScopes(scopesWithIteratorLocals, NestedScopes, edgeInclusive);
                    begin = Math.Min(begin, nestedBounds.Begin);
                    end   = Math.Max(end, nestedBounds.End);
                }

                // we are not interested in scopes with no variables or no code in them.
                if (this.IteratorVariables != null && end > begin)
                {
                    uint endAdjusted = edgeInclusive ? end - 1 : end;

                    var newScope = new Cci.LocalScope(
                        begin,
                        endAdjusted - begin,
                        ImmutableArray <Cci.ILocalDefinition> .Empty,
                        ImmutableArray <Cci.ILocalDefinition> .Empty);

                    foreach (var iv in this.IteratorVariables)
                    {
                        while (scopesWithIteratorLocals.Count <= iv)
                        {
                            scopesWithIteratorLocals.Add(default(Cci.LocalScope));
                        }

                        scopesWithIteratorLocals[iv] = newScope;
                    }
                }

                return(new ScopeBounds(begin, end));
            }
Exemple #2
0
            internal override ScopeBounds GetLocalScopes(ArrayBuilder <Cci.LocalScope> result, bool edgeInclusive)
            {
                uint begin = uint.MaxValue;
                uint end   = 0;

                // It may seem overkill to scan all blocks,
                // but blocks may be reordered so we cannot be sure which ones are first/last.
                if (Blocks != null)
                {
                    for (int i = 0; i < Blocks.Count; i++)
                    {
                        var block = Blocks[i];

                        if (block.Reachability != Reachability.NotReachable)
                        {
                            begin = Math.Min(begin, (uint)block.Start);
                            end   = Math.Max(end, (uint)(block.Start + block.TotalSize));
                        }
                    }
                }

                // if there are nested scopes, dump them too
                // also may need to adjust current scope bounds.
                if (_nestedScopes != null)
                {
                    ScopeBounds nestedBounds = GetLocalScopes(result, _nestedScopes, edgeInclusive);
                    begin = Math.Min(begin, nestedBounds.Begin);
                    end   = Math.Max(end, nestedBounds.End);
                }

                // we are not interested in scopes with no variables or no code in them.
                if ((_localVariables != null || _localConstants != null) && end > begin)
                {
                    uint endAdjusted = edgeInclusive ? end - 1 : end;

                    var newScope = new Cci.LocalScope(
                        begin,
                        endAdjusted - begin,
                        _localConstants.AsImmutableOrEmpty <Cci.ILocalDefinition>(),
                        _localVariables.AsImmutableOrEmpty <Cci.ILocalDefinition>());

                    result.Add(newScope);
                }

                return(new ScopeBounds(begin, end));
            }
Exemple #3
0
 private static void SerializeTupleElementNames(ArrayBuilder <LocalAndScope> locals, BlobBuilder cmw)
 {
     cmw.WriteInt32(locals.Count);
     foreach (LocalAndScope localAndScope in locals)
     {
         ILocalDefinition local = localAndScope.Local;
         LocalScope       scope = localAndScope.Scope;
         System.Collections.Immutable.ImmutableArray <TypedConstant> tupleElementNames = local.TupleElementNames;
         cmw.WriteInt32(tupleElementNames.Length);
         foreach (TypedConstant tupleElementName in tupleElementNames)
         {
             WriteUtf8String(cmw, (string)tupleElementName.Value ?? string.Empty);
         }
         cmw.WriteInt32(local.SlotIndex);
         cmw.WriteInt32(scope.StartOffset);
         cmw.WriteInt32(scope.EndOffset);
         WriteUtf8String(cmw, local.Name);
     }
 }
Exemple #4
0
        private void DefineScopeLocals(LocalScope currentScope, uint localSignatureToken)
        {
            foreach (ILocalDefinition scopeConstant in currentScope.Constants)
            {
                uint token = _metadataWriter.SerializeLocalConstantSignature(scopeConstant);
                if (!_metadataWriter.IsLocalNameTooLong(scopeConstant))
                {
                    DefineLocalConstant(scopeConstant.Name, scopeConstant.CompileTimeValue.Value, _metadataWriter.GetConstantTypeCode(scopeConstant), token);
                }
            }

            foreach (ILocalDefinition scopeLocal in currentScope.Variables)
            {
                if (!_metadataWriter.IsLocalNameTooLong(scopeLocal))
                {
                    Debug.Assert(scopeLocal.SlotIndex >= 0);
                    DefineLocalVariable((uint)scopeLocal.SlotIndex, scopeLocal.Name, scopeLocal.PdbAttributes, localSignatureToken);
                }
            }
        }
Exemple #5
0
        private void DefineLocalScopes(ImmutableArray <LocalScope> scopes, uint localSignatureToken)
        {
            // VB scope ranges are end-inclusive
            bool endInclusive = this.Module.GenerateVisualBasicStylePdb;

            // The order of OpenScope and CloseScope calls must follow the scope nesting.
            var scopeStack = ArrayBuilder <LocalScope> .GetInstance();

            for (int i = 1; i < scopes.Length; i++)
            {
                var currentScope = scopes[i];

                // Close any scopes that have finished.
                while (scopeStack.Count > 0)
                {
                    LocalScope topScope = scopeStack.Last();
                    if (currentScope.StartOffset < topScope.StartOffset + topScope.Length)
                    {
                        break;
                    }

                    scopeStack.RemoveLast();
                    CloseScope(endInclusive ? topScope.EndOffset - 1 : topScope.EndOffset);
                }

                // Open this scope.
                scopeStack.Add(currentScope);
                OpenScope(currentScope.StartOffset);
                this.DefineScopeLocals(currentScope, localSignatureToken);
            }

            // Close remaining scopes.
            for (int i = scopeStack.Count - 1; i >= 0; i--)
            {
                LocalScope scope = scopeStack[i];
                CloseScope(endInclusive ? scope.EndOffset - 1 : scope.EndOffset);
            }

            scopeStack.Free();
        }
Exemple #6
0
        private void DefineLocalScopes(ImmutableArray <LocalScope> scopes, uint localSignatureToken)
        {
            // The order of OpenScope and CloseScope calls must follow the scope nesting.
            var scopeStack = ArrayBuilder <LocalScope> .GetInstance();

            for (int i = 1; i < scopes.Length; i++)
            {
                var currentScope = scopes[i];

                // Close any scopes that have finished.
                while (scopeStack.Count > 0)
                {
                    LocalScope topScope = scopeStack.Last();
                    if (currentScope.Offset < topScope.Offset + topScope.Length)
                    {
                        break;
                    }

                    scopeStack.RemoveLast();
                    CloseScope(topScope.Offset + topScope.Length);
                }

                // Open this scope.
                scopeStack.Add(currentScope);
                OpenScope(currentScope.Offset);
                this.DefineScopeLocals(currentScope, localSignatureToken);
            }

            // Close remaining scopes.
            for (int i = scopeStack.Count - 1; i >= 0; i--)
            {
                LocalScope scope = scopeStack[i];
                CloseScope(scope.Offset + scope.Length);
            }

            scopeStack.Free();
        }
Exemple #7
0
        private void DefineScopeLocals(LocalScope currentScope, uint localSignatureToken)
        {
            foreach (ILocalDefinition scopeConstant in currentScope.Constants)
            {
                int token = _metadataWriter.SerializeLocalConstantStandAloneSignature(scopeConstant);
                if (!_metadataWriter.IsLocalNameTooLong(scopeConstant))
                {
                    DefineLocalConstant(scopeConstant.Name, scopeConstant.CompileTimeValue.Value, _metadataWriter.GetConstantTypeCode(scopeConstant), (uint)token);
                }
            }

            foreach (ILocalDefinition scopeLocal in currentScope.Variables)
            {
                if (!_metadataWriter.IsLocalNameTooLong(scopeLocal))
                {
                    Debug.Assert(scopeLocal.SlotIndex >= 0);
                    DefineLocalVariable((uint)scopeLocal.SlotIndex, scopeLocal.Name, scopeLocal.PdbAttributes, localSignatureToken);
                }
            }
        }
Exemple #8
0
 internal LocalAndScope(ILocalDefinition local, LocalScope scope)
 {
     Local = local;
     Scope = scope;
 }
Exemple #9
0
        private void DefineScopeLocals(LocalScope currentScope, uint localSignatureToken)
        {
            foreach (ILocalDefinition scopeConstant in currentScope.Constants)
            {
                uint token = peWriter.SerializeLocalConstantSignature(scopeConstant);
                if (!peWriter.IsLocalNameTooLong(scopeConstant))
                {
                    DefineLocalConstant(scopeConstant.Name, scopeConstant.CompileTimeValue.Value, peWriter.GetConstantTypeCode(scopeConstant), token);
                }
            }

            foreach (ILocalDefinition scopeLocal in currentScope.Variables)
            {
                if (!peWriter.IsLocalNameTooLong(scopeLocal))
                {
                    Debug.Assert(scopeLocal.SlotIndex >= 0);
                    DefineLocalVariable((uint)scopeLocal.SlotIndex, scopeLocal.Name, scopeLocal.IsCompilerGenerated, localSignatureToken);
                }
            }
        }