static bool ImplementsInterface(TypeInfo pObjType, TypeInfo pTargetType) { Debug.Assert(!pTargetType.IsArray, "did not expect array type"); Debug.Assert(pTargetType.IsInterface, "IsInstanceOfInterface called with non-interface EEType"); foreach (var pInterfaceType in pObjType.ImplementedInterfaces) { if (AreTypesEquivalentInternal(pInterfaceType.GetTypeInfo(), pTargetType)) { return(true); } } // We did not find the interface type in the list of supported interfaces. There's still one // chance left: if the target interface is generic and one or more of its type parameters is co or // contra variant then the object can still match if it implements a different instantiation of // the interface with type compatible generic arguments. // // An additional edge case occurs because of array covariance. This forces us to treat any generic // interfaces implemented by arrays as covariant over their one type parameter. // if (pTargetType.HasGenericVariance || (fArrayCovariance && pTargetType.IsGenericType)) // if (pTargetType.IsGenericType) { bool fArrayCovariance = pObjType.IsArray; Type pTargetGenericType = pTargetType.GetGenericTypeDefinition(); // Fetch the instantiations lazily only once we get a potential match Type[] pTargetInstantiation = null; Type[] pTargetGenericInstantiation = null; foreach (var pInterface in pObjType.ImplementedInterfaces) { TypeInfo pInterfaceType = pInterface.GetTypeInfo(); // We can ignore interfaces which are not also marked as having generic variance // unless we're dealing with array covariance. // if (pInterfaceType.HasGenericVariance || (fArrayCovariance && pInterfaceType.IsGenericType)) if (!pInterfaceType.IsGenericType) { continue; } // If the generic types aren't the same then the types aren't compatible. if (!pInterfaceType.GetGenericTypeDefinition().Equals(pTargetGenericType)) { continue; } Type[] pInterfaceInstantiation = pInterfaceType.GenericTypeArguments; if (pTargetInstantiation == null) { pTargetInstantiation = pTargetType.GenericTypeArguments; if (!fArrayCovariance) { pTargetGenericInstantiation = pTargetGenericType.GetTypeInfo().GenericTypeParameters; } } // Compare the instantiations to see if they're compatible taking variance into account. if (TypeParametersAreCompatible(pInterfaceInstantiation, pTargetInstantiation, pTargetGenericInstantiation, fArrayCovariance)) { return(true); } if (fArrayCovariance) { Debug.Assert(pInterfaceInstantiation.Length == 1, "arity mismatch for array generic interface"); Debug.Assert(pTargetInstantiation.Length == 1, "arity mismatch for array generic interface"); // Special case for generic interfaces on arrays. Arrays of integral types (including enums) // can be cast to generic interfaces over the integral types of the same size. For example // int[] . IList<uint>. if (ArePrimitveTypesEquivalentSize(pInterfaceInstantiation[0].GetTypeInfo(), pTargetInstantiation[0].GetTypeInfo())) { // We have checked that the interface type definition matches above. The checks are ordered differently // here compared with rtm\system\runtime\typecast.cs version because of TypeInfo does not let us do // the HasGenericVariance optimization. return(true); } } } } return(false); }
private void ProcessListeningThread(object state) { string processId = System.Diagnostics.Process.GetCurrentProcess().Id.ToString(CultureInfo.InvariantCulture); string appDomainName = NamedPipeUtils.GetCurrentAppDomainName(); // Logging. _tracer.WriteMessage("RemoteSessionNamedPipeServer", "StartListening", Guid.Empty, "Listener thread started on Process {0} in AppDomainName {1}.", processId, appDomainName); PSEtwLog.LogOperationalInformation( PSEventId.NamedPipeIPC_ServerListenerStarted, PSOpcode.Open, PSTask.NamedPipe, PSKeyword.UseAlwaysOperational, processId, appDomainName); Exception ex = null; string userName = string.Empty; bool restartListenerThread = true; // Wait for connection. try { // Begin listening for a client connect. this.WaitForConnection(); try { #if UNIX userName = System.Environment.UserName; #else userName = WindowsIdentity.GetCurrent().Name; #endif } catch (System.Security.SecurityException) { } // Logging. _tracer.WriteMessage("RemoteSessionNamedPipeServer", "StartListening", Guid.Empty, "Client connection started on Process {0} in AppDomainName {1} for User {2}.", processId, appDomainName, userName); PSEtwLog.LogOperationalInformation( PSEventId.NamedPipeIPC_ServerConnect, PSOpcode.Connect, PSTask.NamedPipe, PSKeyword.UseAlwaysOperational, processId, appDomainName, userName); // Create reader/writer streams. TextReader = new StreamReader(Stream); TextWriter = new StreamWriter(Stream); TextWriter.AutoFlush = true; } catch (Exception e) { ex = e; } if (ex != null) { // Error during connection handling. Don't try to restart listening thread. string errorMessage = !string.IsNullOrEmpty(ex.Message) ? ex.Message : string.Empty; _tracer.WriteMessage("RemoteSessionNamedPipeServer", "StartListening", Guid.Empty, "Unexpected error in listener thread on process {0} in AppDomainName {1}. Error Message: {2}", processId, appDomainName, errorMessage); PSEtwLog.LogOperationalError(PSEventId.NamedPipeIPC_ServerListenerError, PSOpcode.Exception, PSTask.NamedPipe, PSKeyword.UseAlwaysOperational, processId, appDomainName, errorMessage); Dispose(); return; } // Start server session on new connection. ex = null; try { Action <RemoteSessionNamedPipeServer> clientConnectCallback = state as Action <RemoteSessionNamedPipeServer>; Dbg.Assert(clientConnectCallback != null, "Client callback should never be null."); // Handle a new client connect by making the callback. // The callback must handle all exceptions except // for a named pipe disposed or disconnected exception // which propagates up to the thread listener loop. clientConnectCallback(this); } catch (IOException) { // Expected connection terminated. } catch (ObjectDisposedException) { // Expected from PS transport close/dispose. } catch (Exception e) { ex = e; restartListenerThread = false; } // Logging. _tracer.WriteMessage("RemoteSessionNamedPipeServer", "StartListening", Guid.Empty, "Client connection ended on process {0} in AppDomainName {1} for User {2}.", processId, appDomainName, userName); PSEtwLog.LogOperationalInformation( PSEventId.NamedPipeIPC_ServerDisconnect, PSOpcode.Close, PSTask.NamedPipe, PSKeyword.UseAlwaysOperational, processId, appDomainName, userName); if (ex == null) { // Normal listener exit. _tracer.WriteMessage("RemoteSessionNamedPipeServer", "StartListening", Guid.Empty, "Listener thread ended on process {0} in AppDomainName {1}.", processId, appDomainName); PSEtwLog.LogOperationalInformation(PSEventId.NamedPipeIPC_ServerListenerEnded, PSOpcode.Close, PSTask.NamedPipe, PSKeyword.UseAlwaysOperational, processId, appDomainName); } else { // Unexpected error. string errorMessage = !string.IsNullOrEmpty(ex.Message) ? ex.Message : string.Empty; _tracer.WriteMessage("RemoteSessionNamedPipeServer", "StartListening", Guid.Empty, "Unexpected error in listener thread on process {0} in AppDomainName {1}. Error Message: {2}", processId, appDomainName, errorMessage); PSEtwLog.LogOperationalError(PSEventId.NamedPipeIPC_ServerListenerError, PSOpcode.Exception, PSTask.NamedPipe, PSKeyword.UseAlwaysOperational, processId, appDomainName, errorMessage); } lock (_syncObject) { IsListenerRunning = false; } // Ensure this named pipe server object is disposed. Dispose(); ListenerEnded.SafeInvoke( this, new ListenerEndedEventArgs(ex, restartListenerThread)); }
/// <summary> /// Parses the string '<paramref name="name"/>' and returns the type corresponding to the parsed type name. /// The type name string should be in the 'SerString' format as defined by the ECMA-335 standard. /// This is the inverse of what <see cref="CustomAttributeTypeNameFormatter"/> does. /// </summary> public static TypeDesc GetTypeByCustomAttributeTypeName(this ModuleDesc module, string name, bool throwIfNotFound = true) { TypeDesc loadedType; StringBuilder genericTypeDefName = new StringBuilder(name.Length); var ch = name.Begin(); var nameEnd = name.End(); for (; ch < nameEnd; ++ch) { // Always pass escaped characters through. if (ch.Current == '\\') { genericTypeDefName.Append(ch.Current); ++ch; if (ch < nameEnd) { genericTypeDefName.Append(ch.Current); } continue; } // The type def name ends if // The start of a generic argument list if (ch.Current == '[') { break; } // Indication that the type is a pointer if (ch.Current == '*') { break; } // Indication that the type is a reference if (ch.Current == '&') { break; } // A comma that indicates that the rest of the name is an assembly reference if (ch.Current == ',') { break; } genericTypeDefName.Append(ch.Current); } ModuleDesc homeModule = module; AssemblyName homeAssembly = FindAssemblyIfNamePresent(name); if (homeAssembly != null) { homeModule = module.Context.ResolveAssembly(homeAssembly); } MetadataType typeDef = ResolveCustomAttributeTypeNameToTypeDesc(genericTypeDefName.ToString(), homeModule, throwIfNotFound); if (typeDef == null) { return(null); } ArrayBuilder <TypeDesc> genericArgs = new ArrayBuilder <TypeDesc>(); // Followed by generic instantiation parameters (but check for the array case) if (ch < nameEnd && ch.Current == '[' && (ch + 1) < nameEnd && (ch + 1).Current != ']' && (ch + 1).Current != ',') { ch++; // truncate the '[' var genericInstantiationEnd = ch + ReadTypeArgument(ch, nameEnd, true); // find the end of the instantiation list while (ch < genericInstantiationEnd) { if (ch.Current == ',') { ch++; } int argLen = ReadTypeArgument(ch, name.End(), false); string typeArgName; if (ch.Current == '[') { // This type argument name is stringified, // we need to remove the [] from around it ch++; typeArgName = StringIterator.Substring(ch, ch + (argLen - 2)); ch += argLen - 1; } else { typeArgName = StringIterator.Substring(ch, ch + argLen); ch += argLen; } TypeDesc argType = module.GetTypeByCustomAttributeTypeName(typeArgName, throwIfNotFound); if (argType == null) { return(null); } genericArgs.Add(argType); } Debug.Assert(ch == genericInstantiationEnd); ch++; loadedType = typeDef.MakeInstantiatedType(genericArgs.ToArray()); } else { // Non-generic type loadedType = typeDef; } // At this point the characters following may be any number of * characters to indicate pointer depth while (ch < nameEnd) { if (ch.Current == '*') { loadedType = loadedType.MakePointerType(); } else { break; } ch++; } // Followed by any number of "[]" or "[,*]" pairs to indicate arrays int commasSeen = 0; bool bracketSeen = false; while (ch < nameEnd) { if (ch.Current == '[') { ch++; commasSeen = 0; bracketSeen = true; } else if (ch.Current == ']') { if (!bracketSeen) { break; } ch++; if (commasSeen == 0) { loadedType = loadedType.MakeArrayType(); } else { loadedType = loadedType.MakeArrayType(commasSeen + 1); } bracketSeen = false; } else if (ch.Current == ',') { if (!bracketSeen) { break; } ch++; commasSeen++; } else { break; } } // Followed by at most one & character to indicate a byref. if (ch < nameEnd) { if (ch.Current == '&') { loadedType = loadedType.MakeByRefType(); ch++; } } return(loadedType); }
// // Returns the native layout info reader // internal unsafe NativeReader GetNativeLayoutInfoReader(RuntimeSignature signature) { Debug.Assert(signature.IsNativeLayoutSignature); return GetNativeLayoutInfoReader(new TypeManagerHandle(signature.ModuleHandle)); }
private void ImportCall(ILOpcode opcode, int token) { // We get both the canonical and runtime determined form - JitInterface mostly operates // on the canonical form. var runtimeDeterminedMethod = (MethodDesc)_methodIL.GetObject(token); var method = (MethodDesc)_canonMethodIL.GetObject(token); if (method.IsRawPInvoke()) { // Raw P/invokes don't have any dependencies. return; } string reason = null; switch (opcode) { case ILOpcode.newobj: reason = "newobj"; break; case ILOpcode.call: reason = "call"; break; case ILOpcode.callvirt: reason = "callvirt"; break; case ILOpcode.ldftn: reason = "ldftn"; break; case ILOpcode.ldvirtftn: reason = "ldvirtftn"; break; default: Debug.Assert(false); break; } if (opcode == ILOpcode.newobj) { TypeDesc owningType = runtimeDeterminedMethod.OwningType; if (owningType.IsString) { // String .ctor handled specially below } else if (owningType.IsGCPointer) { if (owningType.IsRuntimeDeterminedSubtype) { _dependencies.Add(GetGenericLookupHelper(ReadyToRunHelperId.TypeHandle, owningType), reason); } else { _dependencies.Add(_factory.ConstructedTypeSymbol(owningType), reason); } if (owningType.IsMdArray) { _dependencies.Add(GetHelperEntrypoint(ReadyToRunHelper.NewMultiDimArr_NonVarArg), reason); return; } else { _dependencies.Add(GetHelperEntrypoint(ReadyToRunHelper.NewObject), reason); } } if (owningType.IsDelegate) { // If this is a verifiable delegate construction sequence, the previous instruction is a ldftn/ldvirtftn if (_previousInstructionOffset >= 0 && _ilBytes[_previousInstructionOffset] == (byte)ILOpcode.prefix1) { // TODO: for ldvirtftn we need to also check for the `dup` instruction, otherwise this is a normal newobj. ILOpcode previousOpcode = (ILOpcode)(0x100 + _ilBytes[_previousInstructionOffset + 1]); if (previousOpcode == ILOpcode.ldvirtftn || previousOpcode == ILOpcode.ldftn) { int delTargetToken = ReadILTokenAt(_previousInstructionOffset + 2); var delTargetMethod = (MethodDesc)_methodIL.GetObject(delTargetToken); TypeDesc canonDelegateType = method.OwningType.ConvertToCanonForm(CanonicalFormKind.Specific); DelegateCreationInfo info = _compilation.GetDelegateCtor(canonDelegateType, delTargetMethod, previousOpcode == ILOpcode.ldvirtftn); if (info.NeedsRuntimeLookup) { _dependencies.Add(GetGenericLookupHelper(ReadyToRunHelperId.DelegateCtor, info), reason); } else { _dependencies.Add(_factory.ReadyToRunHelper(ReadyToRunHelperId.DelegateCtor, info), reason); } return; } } } } if (method.OwningType.IsDelegate && method.Name == "Invoke" && opcode != ILOpcode.ldftn && opcode != ILOpcode.ldvirtftn) { // This call is expanded as an intrinsic; it's not an actual function call. // Before codegen realizes this is an intrinsic, it might still ask questions about // the vtable of this virtual method, so let's make sure it's marked in the scanner's // dependency graph. _dependencies.Add(_factory.VTable(method.OwningType), reason); return; } if (method.IsIntrinsic) { if (IsRuntimeHelpersInitializeArray(method)) { if (_previousInstructionOffset >= 0 && _ilBytes[_previousInstructionOffset] == (byte)ILOpcode.ldtoken) { return; } } if (IsRuntimeTypeHandleGetValueInternal(method)) { if (_previousInstructionOffset >= 0 && _ilBytes[_previousInstructionOffset] == (byte)ILOpcode.ldtoken) { return; } } if (IsActivatorDefaultConstructorOf(method)) { if (runtimeDeterminedMethod.IsRuntimeDeterminedExactMethod) { _dependencies.Add(GetGenericLookupHelper(ReadyToRunHelperId.DefaultConstructor, runtimeDeterminedMethod.Instantiation[0]), reason); } else { MethodDesc ctor = method.Instantiation[0].GetDefaultConstructor(); if (ctor == null) { MetadataType activatorType = _compilation.TypeSystemContext.SystemModule.GetKnownType("System", "Activator"); MetadataType classWithMissingCtor = activatorType.GetKnownNestedType("ClassWithMissingConstructor"); ctor = classWithMissingCtor.GetParameterlessConstructor(); } _dependencies.Add(_factory.CanonicalEntrypoint(ctor), reason); } return; } if (method.OwningType.IsByReferenceOfT && (method.IsConstructor || method.Name == "get_Value")) { return; } if (IsEETypePtrOf(method)) { if (runtimeDeterminedMethod.IsRuntimeDeterminedExactMethod) { _dependencies.Add(GetGenericLookupHelper(ReadyToRunHelperId.TypeHandle, runtimeDeterminedMethod.Instantiation[0]), reason); } else { _dependencies.Add(_factory.ConstructedTypeSymbol(method.Instantiation[0]), reason); } return; } } TypeDesc exactType = method.OwningType; if (method.IsNativeCallable && (opcode != ILOpcode.ldftn && opcode != ILOpcode.ldvirtftn)) { ThrowHelper.ThrowInvalidProgramException(ExceptionStringID.InvalidProgramNativeCallable, method); } bool resolvedConstraint = false; bool forceUseRuntimeLookup = false; MethodDesc methodAfterConstraintResolution = method; if (_constrained != null) { // We have a "constrained." call. Try a partial resolve of the constraint call. Note that this // will not necessarily resolve the call exactly, since we might be compiling // shared generic code - it may just resolve it to a candidate suitable for // JIT compilation, and require a runtime lookup for the actual code pointer // to call. TypeDesc constrained = _constrained; if (constrained.IsRuntimeDeterminedSubtype) { constrained = constrained.ConvertToCanonForm(CanonicalFormKind.Specific); } MethodDesc directMethod = constrained.GetClosestDefType().TryResolveConstraintMethodApprox(method.OwningType, method, out forceUseRuntimeLookup); if (directMethod == null && constrained.IsEnum) { // Constrained calls to methods on enum methods resolve to System.Enum's methods. System.Enum is a reference // type though, so we would fail to resolve and box. We have a special path for those to avoid boxing. directMethod = _compilation.TypeSystemContext.TryResolveConstrainedEnumMethod(constrained, method); } if (directMethod != null) { // Either // 1. no constraint resolution at compile time (!directMethod) // OR 2. no code sharing lookup in call // OR 3. we have have resolved to an instantiating stub methodAfterConstraintResolution = directMethod; Debug.Assert(!methodAfterConstraintResolution.OwningType.IsInterface); resolvedConstraint = true; exactType = constrained; } else if (constrained.IsValueType) { // We'll need to box `this`. Note we use _constrained here, because the other one is canonical. AddBoxingDependencies(_constrained, reason); } } MethodDesc targetMethod = methodAfterConstraintResolution; bool exactContextNeedsRuntimeLookup; if (targetMethod.HasInstantiation) { exactContextNeedsRuntimeLookup = targetMethod.IsSharedByGenericInstantiations; } else { exactContextNeedsRuntimeLookup = exactType.IsCanonicalSubtype(CanonicalFormKind.Any); } // // Determine whether to perform direct call // bool directCall = false; if (targetMethod.Signature.IsStatic) { // Static methods are always direct calls directCall = true; } else if (targetMethod.OwningType.IsInterface) { // Force all interface calls to be interpreted as if they are virtual. directCall = false; } else if ((opcode != ILOpcode.callvirt && opcode != ILOpcode.ldvirtftn) || resolvedConstraint) { directCall = true; } else { if (!targetMethod.IsVirtual || targetMethod.IsFinal || targetMethod.OwningType.IsSealed()) { directCall = true; } } bool allowInstParam = opcode != ILOpcode.ldvirtftn && opcode != ILOpcode.ldftn; if (directCall && !allowInstParam && targetMethod.GetCanonMethodTarget(CanonicalFormKind.Specific).RequiresInstArg()) { // Needs a single address to call this method but the method needs a hidden argument. // We need a fat function pointer for this that captures both things. if (exactContextNeedsRuntimeLookup) { _dependencies.Add(GetGenericLookupHelper(ReadyToRunHelperId.MethodEntry, runtimeDeterminedMethod), reason); } else { _dependencies.Add(_factory.FatFunctionPointer(runtimeDeterminedMethod), reason); } } else if (directCall) { bool referencingArrayAddressMethod = false; if (targetMethod.IsIntrinsic) { // If this is an intrinsic method with a callsite-specific expansion, this will replace // the method with a method the intrinsic expands into. If it's not the special intrinsic, // method stays unchanged. targetMethod = _compilation.ExpandIntrinsicForCallsite(targetMethod, _canonMethod); // Array address method requires special dependency tracking. referencingArrayAddressMethod = targetMethod.IsArrayAddressMethod(); } MethodDesc concreteMethod = targetMethod; targetMethod = targetMethod.GetCanonMethodTarget(CanonicalFormKind.Specific); if (targetMethod.IsConstructor && targetMethod.OwningType.IsString) { _dependencies.Add(_factory.StringAllocator(targetMethod), reason); } else if (exactContextNeedsRuntimeLookup) { if (targetMethod.IsSharedByGenericInstantiations && !resolvedConstraint && !referencingArrayAddressMethod) { ISymbolNode instParam = null; if (targetMethod.RequiresInstMethodDescArg()) { instParam = GetGenericLookupHelper(ReadyToRunHelperId.MethodDictionary, runtimeDeterminedMethod); } else if (targetMethod.RequiresInstMethodTableArg()) { bool hasHiddenParameter = true; if (targetMethod.IsIntrinsic) { if (_factory.TypeSystemContext.IsSpecialUnboxingThunkTargetMethod(targetMethod)) { hasHiddenParameter = false; } } if (hasHiddenParameter) { instParam = GetGenericLookupHelper(ReadyToRunHelperId.TypeHandle, runtimeDeterminedMethod.OwningType); } } if (instParam != null) { _dependencies.Add(instParam, reason); } _dependencies.Add(_factory.CanonicalEntrypoint(targetMethod), reason); } else { Debug.Assert(!forceUseRuntimeLookup); _dependencies.Add(_factory.MethodEntrypoint(targetMethod), reason); if (targetMethod.RequiresInstMethodTableArg() && resolvedConstraint) { if (_constrained.IsRuntimeDeterminedSubtype) { _dependencies.Add(GetGenericLookupHelper(ReadyToRunHelperId.TypeHandle, _constrained), reason); } else { _dependencies.Add(_factory.ConstructedTypeSymbol(_constrained), reason); } } if (referencingArrayAddressMethod && !_isReadOnly) { // Address method is special - it expects an instantiation argument, unless a readonly prefix was applied. _dependencies.Add(GetGenericLookupHelper(ReadyToRunHelperId.TypeHandle, runtimeDeterminedMethod.OwningType), reason); } } } else { ISymbolNode instParam = null; if (targetMethod.RequiresInstMethodDescArg()) { instParam = _compilation.NodeFactory.MethodGenericDictionary(concreteMethod); } else if (targetMethod.RequiresInstMethodTableArg() || (referencingArrayAddressMethod && !_isReadOnly)) { // Ask for a constructed type symbol because we need the vtable to get to the dictionary instParam = _compilation.NodeFactory.ConstructedTypeSymbol(concreteMethod.OwningType); } if (instParam != null) { _dependencies.Add(instParam, reason); } _dependencies.Add(_compilation.NodeFactory.MethodEntrypoint(targetMethod), reason); } } else if (method.HasInstantiation) { // Generic virtual method call if (exactContextNeedsRuntimeLookup) { _dependencies.Add(GetGenericLookupHelper(ReadyToRunHelperId.MethodHandle, runtimeDeterminedMethod), reason); } else { _dependencies.Add(_factory.RuntimeMethodHandle(runtimeDeterminedMethod), reason); } _dependencies.Add(GetHelperEntrypoint(ReadyToRunHelper.GVMLookupForSlot), reason); } else if (method.OwningType.IsInterface) { if (exactContextNeedsRuntimeLookup) { _dependencies.Add(GetGenericLookupHelper(ReadyToRunHelperId.VirtualDispatchCell, runtimeDeterminedMethod), reason); } else { _dependencies.Add(_factory.InterfaceDispatchCell(method), reason); } } else if (_compilation.HasFixedSlotVTable(method.OwningType)) { // No dependencies: virtual call through the vtable } else { MethodDesc slotDefiningMethod = targetMethod.IsNewSlot ? targetMethod : MetadataVirtualMethodAlgorithm.FindSlotDefiningMethodForVirtualMethod(targetMethod); _dependencies.Add(_factory.VirtualMethodUse(slotDefiningMethod), reason); } }
private ILToken NewToken(Object value, int tokenType) { Debug.Assert(value != null); _tokens.Add(value); return((ILToken)(_tokens.Count | tokenType)); }
public static MethodIL EmitIL(MethodDesc method) { Debug.Assert(method.OwningType.IsDelegate); Debug.Assert(method.OwningType.IsTypeDefinition); Debug.Assert(method.IsRuntimeImplemented); if (method.Name == "BeginInvoke" || method.Name == "EndInvoke") { // BeginInvoke and EndInvoke are not supported on .NET Core ILEmitter emit = new ILEmitter(); ILCodeStream codeStream = emit.NewCodeStream(); MethodDesc notSupportedExceptionHelper = method.Context.GetHelperEntryPoint("ThrowHelpers", "ThrowPlatformNotSupportedException"); codeStream.EmitCallThrowHelper(emit, notSupportedExceptionHelper); return(emit.Link(method)); } if (method.Name == ".ctor") { // We only support delegate creation if the IL follows the delegate creation verifiability requirements // described in ECMA-335 III.4.21 (newobj – create a new object). The codegen is expected to // intrinsically expand the pattern. // If the delegate creation doesn't follow the pattern, we generate code that throws at runtime. // We could potentially implement this (unreliably) through the use of reflection metadata, // but it remains to be proven that this is an actual customer scenario. ILEmitter emit = new ILEmitter(); ILCodeStream codeStream = emit.NewCodeStream(); MethodDesc notSupportedExceptionHelper = method.Context.GetHelperEntryPoint("ThrowHelpers", "ThrowPlatformNotSupportedException"); codeStream.EmitCallThrowHelper(emit, notSupportedExceptionHelper); return(emit.Link(method)); } if (method.Name == "Invoke") { TypeSystemContext context = method.Context; ILEmitter emit = new ILEmitter(); TypeDesc delegateType = context.GetWellKnownType(WellKnownType.MulticastDelegate).BaseType; FieldDesc firstParameterField = delegateType.GetKnownField("m_firstParameter"); FieldDesc functionPointerField = delegateType.GetKnownField("m_functionPointer"); ILCodeStream codeStream = emit.NewCodeStream(); codeStream.EmitLdArg(0); codeStream.Emit(ILOpcode.ldfld, emit.NewToken(firstParameterField.InstantiateAsOpen())); for (int i = 0; i < method.Signature.Length; i++) { codeStream.EmitLdArg(i + 1); } codeStream.EmitLdArg(0); codeStream.Emit(ILOpcode.ldfld, emit.NewToken(functionPointerField.InstantiateAsOpen())); MethodSignature signature = method.Signature; if (method.OwningType.HasInstantiation) { // If the owning type is generic, the signature will contain T's and U's. // We need !0's and !1's. TypeDesc[] typesToReplace = new TypeDesc[method.OwningType.Instantiation.Length]; TypeDesc[] replacementTypes = new TypeDesc[typesToReplace.Length]; for (int i = 0; i < typesToReplace.Length; i++) { typesToReplace[i] = method.OwningType.Instantiation[i]; replacementTypes[i] = context.GetSignatureVariable(i, method: false); } TypeDesc[] parameters = new TypeDesc[method.Signature.Length]; for (int i = 0; i < parameters.Length; i++) { parameters[i] = method.Signature[i].ReplaceTypesInConstructionOfType(typesToReplace, replacementTypes); } TypeDesc returnType = method.Signature.ReturnType.ReplaceTypesInConstructionOfType(typesToReplace, replacementTypes); signature = new MethodSignature(signature.Flags, signature.GenericParameterCount, returnType, parameters); } codeStream.Emit(ILOpcode.calli, emit.NewToken(signature)); codeStream.Emit(ILOpcode.ret); return(emit.Link(method)); } return(null); }
public override bool IsBlocked(MetadataType type) { Debug.Assert(type.IsTypeDefinition); return(true); }
public override bool IsBlocked(MethodDesc method) { Debug.Assert(method.IsTypicalMethodDefinition); return(true); }
private static Marshaller[] InitializeMarshallers(MethodDesc targetMethod, InteropStateManager interopStateManager, PInvokeFlags flags) { MarshalDirection direction = MarshalDirection.Forward; MethodSignature methodSig; switch (targetMethod) { case DelegateMarshallingMethodThunk delegateMethod: methodSig = delegateMethod.DelegateSignature; direction = delegateMethod.Direction; break; case CalliMarshallingMethodThunk calliMethod: methodSig = calliMethod.TargetSignature; break; default: methodSig = targetMethod.Signature; break; } int indexOffset = 0; if (!methodSig.IsStatic && direction == MarshalDirection.Forward) { // For instance methods(eg. Forward delegate marshalling thunk), first argument is // the instance indexOffset = 1; } ParameterMetadata[] parameterMetadataArray = targetMethod.GetParameterMetadata(); Marshaller[] marshallers = new Marshaller[methodSig.Length + 1]; int parameterIndex = 0; ParameterMetadata parameterMetadata; for (int i = 0; i < marshallers.Length; i++) { Debug.Assert(parameterIndex == parameterMetadataArray.Length || i <= parameterMetadataArray[parameterIndex].Index); if (parameterIndex == parameterMetadataArray.Length || i < parameterMetadataArray[parameterIndex].Index) { // if we don't have metadata for the parameter, create a dummy one parameterMetadata = new ParameterMetadata(i, ParameterMetadataAttributes.None, null); } else { Debug.Assert(i == parameterMetadataArray[parameterIndex].Index); parameterMetadata = parameterMetadataArray[parameterIndex++]; } TypeDesc parameterType = (i == 0) ? methodSig.ReturnType : methodSig[i - 1]; //first item is the return type marshallers[i] = Marshaller.CreateMarshaller(parameterType, MarshallerType.Argument, parameterMetadata.MarshalAsDescriptor, direction, marshallers, interopStateManager, indexOffset + parameterMetadata.Index, flags, parameterMetadata.In, parameterMetadata.Out, parameterMetadata.Return ); } return(marshallers); }
/// <summary> /// Is there a reflection invoke stub for a method that is invokable? /// </summary> public override bool HasReflectionInvokeStubForInvokableMethod(MethodDesc method) { Debug.Assert(IsReflectionInvokable(method)); return(false); }
private void EmitDelegateCall(DelegateMarshallingMethodThunk delegateMethod, PInvokeILCodeStreams ilCodeStreams) { ILEmitter emitter = ilCodeStreams.Emitter; ILCodeStream fnptrLoadStream = ilCodeStreams.FunctionPointerLoadStream; ILCodeStream marshallingCodeStream = ilCodeStreams.MarshallingCodeStream; ILCodeStream callsiteSetupCodeStream = ilCodeStreams.CallsiteSetupCodeStream; TypeSystemContext context = _targetMethod.Context; Debug.Assert(delegateMethod != null); if (delegateMethod.Kind == DelegateMarshallingMethodThunkKind.ReverseOpenStatic) { // // For Open static delegates call // InteropHelpers.GetCurrentCalleeOpenStaticDelegateFunctionPointer() // which returns a function pointer. Just call the function pointer and we are done. // TypeDesc[] parameters = new TypeDesc[_marshallers.Length - 1]; for (int i = 1; i < _marshallers.Length; i++) { parameters[i - 1] = _marshallers[i].ManagedParameterType; } MethodSignature managedSignature = new MethodSignature( MethodSignatureFlags.Static, 0, _marshallers[0].ManagedParameterType, parameters); fnptrLoadStream.Emit(ILOpcode.call, emitter.NewToken( delegateMethod.Context.GetHelperType("InteropHelpers").GetKnownMethod( "GetCurrentCalleeOpenStaticDelegateFunctionPointer", null))); ILLocalVariable vDelegateStub = emitter.NewLocal( delegateMethod.Context.GetWellKnownType(WellKnownType.IntPtr)); fnptrLoadStream.EmitStLoc(vDelegateStub); callsiteSetupCodeStream.EmitLdLoc(vDelegateStub); callsiteSetupCodeStream.Emit(ILOpcode.calli, emitter.NewToken(managedSignature)); } else if (delegateMethod.Kind == DelegateMarshallingMethodThunkKind.ReverseClosed) { // // For closed delegates call // InteropHelpers.GetCurrentCalleeDelegate<Delegate> // which returns the delegate. Do a CallVirt on the invoke method. // MethodDesc instantiatedHelper = delegateMethod.Context.GetInstantiatedMethod( delegateMethod.Context.GetHelperType("InteropHelpers") .GetKnownMethod("GetCurrentCalleeDelegate", null), new Instantiation((delegateMethod.DelegateType))); fnptrLoadStream.Emit(ILOpcode.call, emitter.NewToken(instantiatedHelper)); ILLocalVariable vDelegateStub = emitter.NewLocal(delegateMethod.DelegateType); fnptrLoadStream.EmitStLoc(vDelegateStub); marshallingCodeStream.EmitLdLoc(vDelegateStub); MethodDesc invokeMethod = delegateMethod.DelegateType.GetKnownMethod("Invoke", null); callsiteSetupCodeStream.Emit(ILOpcode.callvirt, emitter.NewToken(invokeMethod)); } else if (delegateMethod.Kind == DelegateMarshallingMethodThunkKind .ForwardNativeFunctionWrapper) { // if the SetLastError flag is set in UnmanagedFunctionPointerAttribute, clear the error code before doing P/Invoke if (_flags.SetLastError) { callsiteSetupCodeStream.Emit(ILOpcode.call, emitter.NewToken( InteropTypes.GetPInvokeMarshal(context).GetKnownMethod("ClearLastWin32Error", null))); } // // For NativeFunctionWrapper we need to load the native function and call it // fnptrLoadStream.EmitLdArg(0); fnptrLoadStream.Emit(ILOpcode.call, emitter.NewToken(InteropTypes .GetNativeFunctionPointerWrapper(context) .GetMethod("get_NativeFunctionPointer", null))); var fnPtr = emitter.NewLocal( context.GetWellKnownType(WellKnownType.IntPtr)); fnptrLoadStream.EmitStLoc(fnPtr); callsiteSetupCodeStream.EmitLdLoc(fnPtr); TypeDesc nativeReturnType = _marshallers[0].NativeParameterType; TypeDesc[] nativeParameterTypes = new TypeDesc[_marshallers.Length - 1]; for (int i = 1; i < _marshallers.Length; i++) { nativeParameterTypes[i - 1] = _marshallers[i].NativeParameterType; } MethodSignature nativeSig = new MethodSignature( MethodSignatureFlags.Static | _flags.UnmanagedCallingConvention, 0, nativeReturnType, nativeParameterTypes); callsiteSetupCodeStream.Emit(ILOpcode.calli, emitter.NewToken(nativeSig)); // if the SetLastError flag is set in UnmanagedFunctionPointerAttribute, call the PInvokeMarshal. // SaveLastWin32Error so that last error can be used later by calling // PInvokeMarshal.GetLastWin32Error if (_flags.SetLastError) { callsiteSetupCodeStream.Emit(ILOpcode.call, emitter.NewToken( InteropTypes.GetPInvokeMarshal(context) .GetKnownMethod("SaveLastWin32Error", null))); } } else { Debug.Fail("Unexpected DelegateMarshallingMethodThunkKind"); } }
public override bool IsBlocked(MethodDesc method) { Debug.Assert(method.IsTypicalMethodDefinition); var ecmaMethod = method as EcmaMethod; if (ecmaMethod == null) { return(true); } ModuleBlockingMode moduleBlockingMode = _blockedModules.GetOrCreateValue(ecmaMethod.Module).BlockingMode; if (moduleBlockingMode == ModuleBlockingMode.None) { return(false); } else if (moduleBlockingMode == ModuleBlockingMode.FullyBlocked) { return(true); } // We are blocking internal implementation details Debug.Assert(moduleBlockingMode == ModuleBlockingMode.BlockedInternals); var owningType = (EcmaType)ecmaMethod.OwningType; if (_blockedTypes.GetOrCreateValue(owningType).IsBlocked) { return(true); } MethodAttributes accessibility = ecmaMethod.Attributes & MethodAttributes.Public; if (accessibility != MethodAttributes.Family && accessibility != MethodAttributes.FamORAssem && accessibility != MethodAttributes.Public) { // Non-public and non-protected methods should be blocked, but binary serialization // forces us to exclude a couple things if the type is serializable. if (owningType.IsSerializable) { MethodSignature signature = ecmaMethod.Signature; if (ecmaMethod.IsConstructor && signature.Length == 2 && signature[0] == SerializationInfoType /* && ecmaMethod.Signature[1] is StreamingContext */) { return(false); } // Methods with these attributes can be called during serialization if (signature.Length == 1 && !signature.IsStatic && signature.ReturnType.IsVoid && (ecmaMethod.HasCustomAttribute("System.Runtime.Serialization", "OnSerializingAttribute") || ecmaMethod.HasCustomAttribute("System.Runtime.Serialization", "OnSerializedAttribute") || ecmaMethod.HasCustomAttribute("System.Runtime.Serialization", "OnDeserializingAttribute") || ecmaMethod.HasCustomAttribute("System.Runtime.Serialization", "OnDeserializedAttribute"))) { return(false); } } return(true); } // Methods on Array`1<T> are implementation details that implement the generic interfaces on // arrays. They should not generate metadata or be reflection invokable. // We could get rid of this special casing two ways: // * Make these method stop being regular EcmaMethods with Array<T> as their owning type, or // * Make these methods implement the interfaces explicitly (they would become private and naturally blocked) if (ecmaMethod.OwningType == ArrayOfTType) { return(true); } return(false); }
protected override void OnCreate(Bundle savedInstanceState) { base.OnCreate(savedInstanceState); if (LastNonConfigurationInstance != null) { //bug in Mono for Android or whatever: after config change the extra fields are wrong // -> reload: Reload(); return; } _appTask = AppTask.GetTaskInOnCreate(savedInstanceState, Intent); SetContentView(Resource.Layout.entry_edit); _closeForReload = false; // Likely the app has been killed exit the activity if (!App.Kp2a.DatabaseIsUnlocked) { Finish(); return; } if (Intent.GetBooleanExtra(IntentContinueWithEditing, false)) { //property "State" will return the state } else { Database db = App.Kp2a.GetDb(); App.Kp2a.EntryEditActivityState = new EntryEditActivityState(); ISharedPreferences prefs = PreferenceManager.GetDefaultSharedPreferences(this); State.ShowPassword = !prefs.GetBoolean(GetString(Resource.String.maskpass_key), Resources.GetBoolean(Resource.Boolean.maskpass_default)); Intent i = Intent; String uuidBytes = i.GetStringExtra(KeyEntry); PwUuid entryId = PwUuid.Zero; if (uuidBytes != null) { entryId = new PwUuid(MemUtil.HexStringToByteArray(uuidBytes)); } State.ParentGroup = null; if (entryId.Equals(PwUuid.Zero)) { //creating new entry String groupId = i.GetStringExtra(KeyParent); State.ParentGroup = db.KpDatabase.RootGroup.FindGroup(new PwUuid(MemUtil.HexStringToByteArray(groupId)), true); PwUuid templateId = new PwUuid(MemUtil.HexStringToByteArray(i.GetStringExtra(KeyTemplateUuid))); PwEntry templateEntry = null; if (!PwUuid.Zero.Equals(templateId)) { templateEntry = db.Entries[templateId]; } if (KpEntryTemplatedEdit.IsTemplate(templateEntry)) { CreateNewFromKpEntryTemplate(db, templateEntry); } else if (templateEntry != null) { CreateNewFromStandardTemplate(templateEntry); } else { CreateNewWithoutTemplate(db); } _appTask.PrepareNewEntry(State.EntryInDatabase); State.IsNew = true; State.EntryModified = true; } else { Debug.Assert(entryId != null); State.EntryInDatabase = db.Entries [entryId]; State.IsNew = false; } State.Entry = State.EntryInDatabase.CloneDeep(); if (KpEntryTemplatedEdit.IsTemplated(db, State.Entry)) { State.EditMode = new KpEntryTemplatedEdit(db, State.Entry); } else { State.EditMode = new DefaultEdit(); } } if (!State.EntryModified) { SetResult(KeePass.ExitNormal); } else { SetResult(KeePass.ExitRefreshTitle); } FillData(); View scrollView = FindViewById(Resource.Id.entry_scroll); scrollView.ScrollBarStyle = ScrollbarStyles.InsideInset; ImageButton iconButton = (ImageButton)FindViewById(Resource.Id.icon_button); if (State.SelectedIcon) { App.Kp2a.GetDb().DrawableFactory.AssignDrawableTo(iconButton, this, App.Kp2a.GetDb().KpDatabase, (PwIcon)State.SelectedIconId, State.SelectedCustomIconId, false); } iconButton.Click += (sender, evt) => { UpdateEntryFromUi(State.Entry); IconPickerActivity.Launch(this); }; // Generate password button FindViewById(Resource.Id.generate_button).Click += (sender, e) => { UpdateEntryFromUi(State.Entry); GeneratePasswordActivity.Launch(this); }; // Save button //SupportActionBar.SetCustomView(Resource.Layout.SaveButton); if (State.IsNew) { SupportActionBar.Title = GetString(Resource.String.add_entry); } else { SupportActionBar.Title = GetString(Resource.String.edit_entry); } SupportActionBar.SetDisplayHomeAsUpEnabled(true); SupportActionBar.SetHomeButtonEnabled(true); // Respect mask password setting MakePasswordVisibleOrHidden(); ImageButton btnTogglePassword = (ImageButton)FindViewById(Resource.Id.toggle_password); btnTogglePassword.Click += (sender, e) => { State.ShowPassword = !State.ShowPassword; MakePasswordVisibleOrHidden(); }; PorterDuff.Mode mMode = PorterDuff.Mode.SrcAtop; Color color = new Color(189, 189, 189); btnTogglePassword.SetColorFilter(color, mMode); Button addButton = (Button)FindViewById(Resource.Id.add_advanced); addButton.Visibility = ViewStates.Visible; addButton.Click += (sender, e) => { LinearLayout container = (LinearLayout)FindViewById(Resource.Id.advanced_container); KeyValuePair <string, ProtectedString> pair = new KeyValuePair <string, ProtectedString>("", new ProtectedString(true, "")); View ees = CreateExtraStringView(pair); container.AddView(ees); State.EntryModified = true; /*TextView keyView = (TextView) ees.FindViewById(Resource.Id.title); * keyView.RequestFocus();*/ EditAdvancedString(ees.FindViewById(Resource.Id.edit_extra)); }; SetAddExtraStringEnabled(); ((CheckBox)FindViewById(Resource.Id.entry_expires_checkbox)).CheckedChange += (sender, e) => { State.Entry.Expires = e.IsChecked; if (e.IsChecked) { if (State.Entry.ExpiryTime < DateTime.Now) { State.Entry.ExpiryTime = DateTime.Now; } } UpdateExpires(); State.EntryModified = true; }; }
public void EndHandler(ILExceptionRegionBuilder builder) { Debug.Assert(builder._endHandlerStream == null); builder._endHandlerStream = this; builder._endHandlerOffset = _length; }
public override bool IsBlocked(FieldDesc field) { Debug.Assert(field.IsTypicalFieldDefinition); return(true); }
internal void Place(ILCodeStream codeStream, int offsetWithinCodeStream) { Debug.Assert(!IsPlaced); _codeStream = codeStream; _offsetWithinCodeStream = offsetWithinCodeStream; }
protected virtual void OutputGCDesc(ref ObjectDataBuilder builder) { // Non-constructed EETypeNodes get no GC Desc Debug.Assert(GCDescSize == 0); }
public MethodIL Link(MethodDesc owningMethod) { int totalLength = 0; int numSequencePoints = 0; for (int i = 0; i < _codeStreams.Count; i++) { ILCodeStream ilCodeStream = _codeStreams[i]; ilCodeStream._startOffsetForLinking = totalLength; totalLength += ilCodeStream._length; numSequencePoints += ilCodeStream._sequencePoints.Count; } byte[] ilInstructions = new byte[totalLength]; int copiedLength = 0; for (int i = 0; i < _codeStreams.Count; i++) { ILCodeStream ilCodeStream = _codeStreams[i]; ilCodeStream.PatchLabels(); Array.Copy(ilCodeStream._instructions, 0, ilInstructions, copiedLength, ilCodeStream._length); copiedLength += ilCodeStream._length; } MethodDebugInformation debugInfo = null; if (numSequencePoints > 0) { ILSequencePoint[] sequencePoints = new ILSequencePoint[numSequencePoints]; int copiedSequencePointLength = 0; for (int codeStreamIndex = 0; codeStreamIndex < _codeStreams.Count; codeStreamIndex++) { ILCodeStream ilCodeStream = _codeStreams[codeStreamIndex]; for (int sequencePointIndex = 0; sequencePointIndex < ilCodeStream._sequencePoints.Count; sequencePointIndex++) { ILSequencePoint sequencePoint = ilCodeStream._sequencePoints[sequencePointIndex]; sequencePoints[copiedSequencePointLength] = new ILSequencePoint( ilCodeStream._startOffsetForLinking + sequencePoint.Offset, sequencePoint.Document, sequencePoint.LineNumber); copiedSequencePointLength++; } } debugInfo = new EmittedMethodDebugInformation(sequencePoints); } ILExceptionRegion[] exceptionRegions = null; int numberOfExceptionRegions = _finallyRegions.Count; if (numberOfExceptionRegions > 0) { exceptionRegions = new ILExceptionRegion[numberOfExceptionRegions]; for (int i = 0; i < _finallyRegions.Count; i++) { ILExceptionRegionBuilder region = _finallyRegions[i]; Debug.Assert(region.IsDefined); exceptionRegions[i] = new ILExceptionRegion(ILExceptionRegionKind.Finally, region.TryOffset, region.TryLength, region.HandlerOffset, region.HandlerLength, classToken: 0, filterOffset: 0); } } var result = new ILStubMethodIL(owningMethod, ilInstructions, _locals.ToArray(), _tokens.ToArray(), exceptionRegions, debugInfo); result.CheckStackBalance(); return(result); }
protected virtual void OutputVirtualSlots(NodeFactory factory, ref ObjectDataBuilder objData, TypeDesc implType, TypeDesc declType, bool relocsOnly) { Debug.Assert(EmitVirtualSlotsAndInterfaces); declType = declType.GetClosestDefType(); var baseType = declType.BaseType; if (baseType != null) { OutputVirtualSlots(factory, ref objData, implType, baseType, relocsOnly); } // The generic dictionary pointer occupies the first slot of each type vtable slice if (declType.HasGenericDictionarySlot()) { // All generic interface types have a dictionary slot, but only some of them have an actual dictionary. bool isInterfaceWithAnEmptySlot = declType.IsInterface && declType.ConvertToCanonForm(CanonicalFormKind.Specific) == declType; // Note: Canonical type instantiations always have a generic dictionary vtable slot, but it's empty if (declType.IsCanonicalSubtype(CanonicalFormKind.Any) || factory.LazyGenericsPolicy.UsesLazyGenerics(declType) || isInterfaceWithAnEmptySlot) { objData.EmitZeroPointer(); } else { objData.EmitPointerReloc(factory.TypeGenericDictionary(declType)); } } // It's only okay to touch the actual list of slots if we're in the final emission phase // or the vtable is not built lazily. if (relocsOnly && !factory.CompilationModuleGroup.ShouldProduceFullVTable(declType)) { return; } // Actual vtable slots follow IReadOnlyList <MethodDesc> virtualSlots = factory.VTable(declType).Slots; for (int i = 0; i < virtualSlots.Count; i++) { MethodDesc declMethod = virtualSlots[i]; // No generic virtual methods can appear in the vtable! Debug.Assert(!declMethod.HasInstantiation); MethodDesc implMethod = implType.GetClosestDefType().FindVirtualFunctionTargetMethodOnObjectType(declMethod); if (!implMethod.IsAbstract) { MethodDesc canonImplMethod = implMethod.GetCanonMethodTarget(CanonicalFormKind.Specific); objData.EmitPointerReloc(factory.MethodEntrypoint(canonImplMethod, implMethod.OwningType.IsValueType)); } else { objData.EmitZeroPointer(); } } }
protected override void ProcessRecord() { List <PSRepositoryInfo> items = new List <PSRepositoryInfo>(); switch (ParameterSetName) { case NameParameterSet: if (!Utils.TryCreateValidUri(uriString: Uri, cmdletPassedIn: this, uriResult: out _uri, errorRecord: out ErrorRecord errorRecord)) { ThrowTerminatingError(errorRecord); } try { items.Add(RepositorySettings.AddRepository(Name, _uri, Priority, Trusted, CredentialInfo, Force, this, out string errorMsg)); if (!string.IsNullOrEmpty(errorMsg)) { ThrowTerminatingError(new ErrorRecord( new PSInvalidOperationException(errorMsg), "ErrorInNameParameterSet", ErrorCategory.InvalidArgument, this)); } } catch (Exception e) { ThrowTerminatingError(new ErrorRecord( new PSInvalidOperationException(e.Message), "ErrorInNameParameterSet", ErrorCategory.InvalidArgument, this)); } break; case PSGalleryParameterSet: try { items.Add(PSGalleryParameterSetHelper(Priority, Trusted)); } catch (Exception e) { ThrowTerminatingError(new ErrorRecord( new PSInvalidOperationException(e.Message), "ErrorInPSGalleryParameterSet", ErrorCategory.InvalidArgument, this)); } break; case RepositoriesParameterSet: try { items = RepositoriesParameterSetHelper(); } catch (Exception e) { ThrowTerminatingError(new ErrorRecord( new PSInvalidOperationException(e.Message), "ErrorInRepositoriesParameterSet", ErrorCategory.InvalidArgument, this)); } break; default: Dbg.Assert(false, "Invalid parameter set"); break; } if (PassThru) { foreach (PSRepositoryInfo repo in items) { WriteObject(repo); } } }
private void EmitILForAccessor() { Debug.Assert(!_method.OwningType.IsSzArray); var codeStream = _emitter.NewCodeStream(); var context = _method.Context; var int32Type = context.GetWellKnownType(WellKnownType.Int32); var totalLocalNum = _emitter.NewLocal(int32Type); var lengthLocalNum = _emitter.NewLocal(int32Type); int pointerSize = context.Target.PointerSize; var rangeExceptionLabel = _emitter.NewCodeLabel(); ILCodeLabel typeMismatchExceptionLabel = null; if (!_elementType.IsValueType) { // Type check if (_method.Kind == ArrayMethodKind.Set) { MethodDesc checkArrayStore = context.SystemModule.GetKnownType("System.Runtime", "RuntimeImports").GetKnownMethod("RhCheckArrayStore", null); codeStream.EmitLdArg(0); codeStream.EmitLdArg(_rank + 1); codeStream.Emit(ILOpcode.call, _emitter.NewToken(checkArrayStore)); } else if (_method.Kind == ArrayMethodKind.Address) { TypeDesc objectType = context.GetWellKnownType(WellKnownType.Object); TypeDesc eetypePtrType = context.SystemModule.GetKnownType("System", "EETypePtr"); MethodDesc eetypePtrOfMethod = eetypePtrType.GetKnownMethod("EETypePtrOf", null) .MakeInstantiatedMethod(new Instantiation(new[] { _elementType })); typeMismatchExceptionLabel = _emitter.NewCodeLabel(); ILLocalVariable thisEEType = _emitter.NewLocal(eetypePtrType); // EETypePtr actualElementType = this.EETypePtr.ArrayElementType; codeStream.EmitLdArg(0); codeStream.Emit(ILOpcode.call, _emitter.NewToken(objectType.GetKnownMethod("get_EETypePtr", null))); codeStream.EmitStLoc(thisEEType); codeStream.EmitLdLoca(thisEEType); codeStream.Emit(ILOpcode.call, _emitter.NewToken(eetypePtrType.GetKnownMethod("get_ArrayElementType", null))); // EETypePtr expectedElementType = EETypePtr.EETypePtrOf<_elementType>(); codeStream.Emit(ILOpcode.call, _emitter.NewToken(eetypePtrOfMethod)); // if (expectedElementType != actualElementType) // ThrowHelpers.ThrowArrayTypeMismatchException(); codeStream.Emit(ILOpcode.call, _emitter.NewToken(eetypePtrType.GetKnownMethod("op_Equality", null))); codeStream.Emit(ILOpcode.brfalse, typeMismatchExceptionLabel); } } for (int i = 0; i < _rank; i++) { // The first two fields are EEType pointer and total length. Lengths for each dimension follows. int lengthOffset = (2 * pointerSize + i * int32Type.GetElementSize()); EmitLoadInteriorAddress(codeStream, lengthOffset); codeStream.Emit(ILOpcode.ldind_i4); codeStream.EmitStLoc(lengthLocalNum); codeStream.EmitLdArg(i + 1); // Compare with length codeStream.Emit(ILOpcode.dup); codeStream.EmitLdLoc(lengthLocalNum); codeStream.Emit(ILOpcode.bge_un, rangeExceptionLabel); // Add to the running total if we have one already if (i > 0) { codeStream.EmitLdLoc(totalLocalNum); codeStream.EmitLdLoc(lengthLocalNum); codeStream.Emit(ILOpcode.mul); codeStream.Emit(ILOpcode.add); } codeStream.EmitStLoc(totalLocalNum); } // Compute element offset // TODO: This leaves unused space for lower bounds to match CoreCLR... int firstElementOffset = (2 * pointerSize + 2 * _rank * int32Type.GetElementSize()); EmitLoadInteriorAddress(codeStream, firstElementOffset); codeStream.EmitLdLoc(totalLocalNum); int elementSize = _elementType.GetElementSize(); if (elementSize != 1) { codeStream.EmitLdc(elementSize); codeStream.Emit(ILOpcode.mul); } codeStream.Emit(ILOpcode.add); switch (_method.Kind) { case ArrayMethodKind.Get: codeStream.Emit(ILOpcode.ldobj, _emitter.NewToken(_elementType)); break; case ArrayMethodKind.Set: codeStream.EmitLdArg(_rank + 1); codeStream.Emit(ILOpcode.stobj, _emitter.NewToken(_elementType)); break; case ArrayMethodKind.Address: break; } codeStream.Emit(ILOpcode.ret); codeStream.EmitLdc(0); codeStream.EmitLabel(rangeExceptionLabel); // Assumes that there is one "int" pushed on the stack codeStream.Emit(ILOpcode.pop); MethodDesc throwHelper = context.GetHelperEntryPoint("ThrowHelpers", "ThrowIndexOutOfRangeException"); codeStream.EmitCallThrowHelper(_emitter, throwHelper); if (typeMismatchExceptionLabel != null) { codeStream.EmitLabel(typeMismatchExceptionLabel); codeStream.EmitCallThrowHelper(_emitter, context.GetHelperEntryPoint("ThrowHelpers", "ThrowArrayTypeMismatchException")); } }
internal static bool ObjectHasComponentSize(object obj) { Debug.Assert(obj != null); return(obj.EETypePtr.ComponentSize != 0); }
public AnalysisBasedMetadataManager( CompilerTypeSystemContext typeSystemContext, MetadataBlockingPolicy blockingPolicy, ManifestResourceBlockingPolicy resourceBlockingPolicy, string logFile, StackTraceEmissionPolicy stackTracePolicy, DynamicInvokeThunkGenerationPolicy invokeThunkGenerationPolicy, IEnumerable <ModuleDesc> modulesWithMetadata, IEnumerable <ReflectableEntity <TypeDesc> > reflectableTypes, IEnumerable <ReflectableEntity <MethodDesc> > reflectableMethods, IEnumerable <ReflectableEntity <FieldDesc> > reflectableFields, IEnumerable <TypeDesc> ldtokenReferenceableTypes) : base(typeSystemContext, blockingPolicy, resourceBlockingPolicy, logFile, stackTracePolicy, invokeThunkGenerationPolicy) { _modulesWithMetadata = new List <ModuleDesc>(modulesWithMetadata); foreach (var refType in reflectableTypes) { _reflectableTypes.Add(refType.Entity, refType.Category); } foreach (var refMethod in reflectableMethods) { // Asking for description or runtime mapping for a member without asking // for the owning type would mean we can't actually satisfy the request. Debug.Assert((refMethod.Category & MetadataCategory.Description) == 0 || (_reflectableTypes[refMethod.Entity.OwningType] & MetadataCategory.Description) != 0); Debug.Assert((refMethod.Category & MetadataCategory.RuntimeMapping) == 0 || (_reflectableTypes[refMethod.Entity.OwningType] & MetadataCategory.RuntimeMapping) != 0); _reflectableMethods.Add(refMethod.Entity, refMethod.Category); } foreach (var refField in reflectableFields) { // Asking for description or runtime mapping for a member without asking // for the owning type would mean we can't actually satisfy the request. Debug.Assert((refField.Category & MetadataCategory.Description) == 0 || (_reflectableTypes[refField.Entity.OwningType] & MetadataCategory.Description) != 0); Debug.Assert((refField.Category & MetadataCategory.RuntimeMapping) == 0 || (_reflectableTypes[refField.Entity.OwningType] & MetadataCategory.RuntimeMapping) != 0); _reflectableFields.Add(refField.Entity, refField.Category); } _ldtokenReferenceableTypes = new HashSet <TypeDesc>(ldtokenReferenceableTypes); #if DEBUG HashSet <ModuleDesc> moduleHash = new HashSet <ModuleDesc>(_modulesWithMetadata); foreach (var refType in reflectableTypes) { // The instantiated types need to agree on the Description bit with the definition. // GetMetadataCategory relies on that. Debug.Assert((GetMetadataCategory(refType.Entity.GetTypeDefinition()) & MetadataCategory.Description) == (GetMetadataCategory(refType.Entity) & MetadataCategory.Description)); Debug.Assert(!(refType.Entity is MetadataType) || moduleHash.Contains(((MetadataType)refType.Entity).Module)); } foreach (var refMethod in reflectableMethods) { // The instantiated methods need to agree on the Description bit with the definition. // GetMetadataCategory relies on that. Debug.Assert((GetMetadataCategory(refMethod.Entity.GetTypicalMethodDefinition()) & MetadataCategory.Description) == (GetMetadataCategory(refMethod.Entity) & MetadataCategory.Description)); // Canonical form of the method needs to agree with the logical form Debug.Assert(GetMetadataCategory(refMethod.Entity) == GetMetadataCategory(refMethod.Entity.GetCanonMethodTarget(CanonicalFormKind.Specific))); } foreach (var refField in reflectableFields) { // The instantiated fields need to agree on the Description bit with the definition. // GetMetadataCategory relies on that. Debug.Assert((GetMetadataCategory(refField.Entity.GetTypicalFieldDefinition()) & MetadataCategory.Description) == (GetMetadataCategory(refField.Entity) & MetadataCategory.Description)); } #endif }
private void ImportLdToken(int token) { object obj = _methodIL.GetObject(token); if (obj is TypeDesc) { var type = (TypeDesc)obj; if (type.IsRuntimeDeterminedSubtype) { _dependencies.Add(GetGenericLookupHelper(ReadyToRunHelperId.TypeHandle, type), "ldtoken"); } else { _dependencies.Add(_factory.MaximallyConstructableType(type), "ldtoken"); } // If this is a ldtoken Type / GetValueInternal sequence, we're done. BasicBlock nextBasicBlock = _basicBlocks[_currentOffset]; if (nextBasicBlock == null) { if ((ILOpcode)_ilBytes[_currentOffset] == ILOpcode.call) { int methodToken = ReadILTokenAt(_currentOffset + 1); var method = (MethodDesc)_methodIL.GetObject(methodToken); if (IsRuntimeTypeHandleGetValueInternal(method)) { // Codegen expands this and doesn't do the normal ldtoken. return; } } } _dependencies.Add(GetHelperEntrypoint(ReadyToRunHelper.GetRuntimeTypeHandle), "ldtoken"); } else if (obj is MethodDesc) { var method = (MethodDesc)obj; if (method.IsRuntimeDeterminedExactMethod) { _dependencies.Add(GetGenericLookupHelper(ReadyToRunHelperId.MethodHandle, method), "ldtoken"); } else { _dependencies.Add(_factory.RuntimeMethodHandle(method), "ldtoken"); } _dependencies.Add(GetHelperEntrypoint(ReadyToRunHelper.GetRuntimeMethodHandle), "ldtoken"); } else { Debug.Assert(obj is FieldDesc); // First check if this is a ldtoken Field / InitializeArray sequence. BasicBlock nextBasicBlock = _basicBlocks[_currentOffset]; if (nextBasicBlock == null) { if ((ILOpcode)_ilBytes[_currentOffset] == ILOpcode.call) { int methodToken = ReadILTokenAt(_currentOffset + 1); var method = (MethodDesc)_methodIL.GetObject(methodToken); if (IsRuntimeHelpersInitializeArray(method)) { // Codegen expands this and doesn't do the normal ldtoken. return; } } } var field = (FieldDesc)obj; if (field.OwningType.IsRuntimeDeterminedSubtype) { _dependencies.Add(GetGenericLookupHelper(ReadyToRunHelperId.FieldHandle, field), "ldtoken"); } else { _dependencies.Add(_factory.RuntimeFieldHandle(field), "ldtoken"); } _dependencies.Add(GetHelperEntrypoint(ReadyToRunHelper.GetRuntimeFieldHandle), "ldtoken"); } }
internal int RelativeToAbsoluteOffset(int relativeOffset) { Debug.Assert(_startOffsetForLinking != StartOffsetNotSet); return(_startOffsetForLinking + relativeOffset); }
public RemoteSessionHyperVSocketServer(bool LoopbackMode) { // TODO: uncomment below code when .NET supports Hyper-V socket duplication /* * NamedPipeClientStream clientPipeStream; * byte[] buffer = new byte[1000]; * int bytesRead; */ _syncObject = new object(); Exception ex = null; try { // TODO: uncomment below code when .NET supports Hyper-V socket duplication /* * if (!LoopbackMode) * { * // * // Create named pipe client. * // * using (clientPipeStream = new NamedPipeClientStream(".", * "PS_VMSession", * PipeDirection.InOut, * PipeOptions.None, * TokenImpersonationLevel.None)) * { * // * // Connect to named pipe server. * // * clientPipeStream.Connect(10*1000); * * // * // Read LPWSAPROTOCOL_INFO. * // * bytesRead = clientPipeStream.Read(buffer, 0, 1000); * } * } * * // * // Create duplicate socket. * // * byte[] protocolInfo = new byte[bytesRead]; * Array.Copy(buffer, protocolInfo, bytesRead); * * SocketInformation sockInfo = new SocketInformation(); * sockInfo.ProtocolInformation = protocolInfo; * sockInfo.Options = SocketInformationOptions.Connected; * * socket = new Socket(sockInfo); * if (socket == null) * { * Dbg.Assert(false, "Unexpected error in RemoteSessionHyperVSocketServer."); * * tracer.WriteMessage("RemoteSessionHyperVSocketServer", "RemoteSessionHyperVSocketServer", Guid.Empty, * "Unexpected error in constructor: {0}", "socket duplication failure"); * } */ // TODO: remove below 6 lines of code when .NET supports Hyper-V socket duplication Guid serviceId = new Guid("a5201c21-2770-4c11-a68e-f182edb29220"); // HV_GUID_VM_SESSION_SERVICE_ID_2 HyperVSocketEndPoint endpoint = new HyperVSocketEndPoint(HyperVSocketEndPoint.AF_HYPERV, Guid.Empty, serviceId); Socket listenSocket = new Socket(endpoint.AddressFamily, SocketType.Stream, (System.Net.Sockets.ProtocolType) 1); listenSocket.Bind(endpoint); listenSocket.Listen(1); HyperVSocket = listenSocket.Accept(); Stream = new NetworkStream(HyperVSocket, true); // Create reader/writer streams. TextReader = new StreamReader(Stream); TextWriter = new StreamWriter(Stream); TextWriter.AutoFlush = true; // // listenSocket is not closed when it goes out of scope here. Sometimes it is // closed later in this thread, while other times it is not closed at all. This will // cause problem when we set up a second PowerShell Direct session. Let's // explicitly close listenSocket here for safe. // if (listenSocket != null) { try { listenSocket.Dispose(); } catch (ObjectDisposedException) { } } } catch (Exception e) { ex = e; } if (ex != null) { Dbg.Assert(false, "Unexpected error in RemoteSessionHyperVSocketServer."); // Unexpected error. string errorMessage = !string.IsNullOrEmpty(ex.Message) ? ex.Message : string.Empty; _tracer.WriteMessage("RemoteSessionHyperVSocketServer", "RemoteSessionHyperVSocketServer", Guid.Empty, "Unexpected error in constructor: {0}", errorMessage); throw new PSInvalidOperationException( PSRemotingErrorInvariants.FormatResourceString(RemotingErrorIdStrings.RemoteSessionHyperVSocketServerConstructorFailure), ex, PSRemotingErrorId.RemoteSessionHyperVSocketServerConstructorFailure.ToString(), ErrorCategory.InvalidOperation, null); } }
public void BeginTry(ILExceptionRegionBuilder builder) { Debug.Assert(builder._beginTryStream == null); builder._beginTryStream = this; builder._beginTryOffset = _length; }
public StringIterator(string s, int index) { Debug.Assert(index <= s.Length); _string = s; _index = index; }
// Compare two sets of generic type parameters to see if they're assignment compatible taking generic // variance into account. It's assumed they've already had their type definition matched (which // implies their arities are the same as well). The fForceCovariance argument tells the method to // override the defined variance of each parameter and instead assume it is covariant. This is used to // implement covariant array interfaces. static bool TypeParametersAreCompatible(Type[] pSourceInstantiation, Type[] pTargetInstantiation, Type[] pVarianceInfo, bool fForceCovariance) { // The types represent different instantiations of the same generic type. The // arity of both had better be the same. Debug.Assert(pSourceInstantiation.Length == pTargetInstantiation.Length, "arity mismatch betweeen generic instantiations"); Debug.Assert(fForceCovariance || pTargetInstantiation.Length == pVarianceInfo.Length, "arity mismatch betweeen generic instantiations"); // Walk through the instantiations comparing the cast compatibility of each pair // of type args. for (int i = 0; i < pTargetInstantiation.Length; i++) { TypeInfo pTargetArgType = pTargetInstantiation[i].GetTypeInfo(); TypeInfo pSourceArgType = pSourceInstantiation[i].GetTypeInfo(); GenericParameterAttributes varType; if (fForceCovariance) { varType = GenericParameterAttributes.Covariant; } else { varType = pVarianceInfo[i].GetTypeInfo().GenericParameterAttributes & GenericParameterAttributes.VarianceMask; } switch (varType) { case GenericParameterAttributes.None: // Non-variant type params need to be identical. if (!AreTypesEquivalentInternal(pSourceArgType, pTargetArgType)) { return(false); } break; case GenericParameterAttributes.Covariant: // For covariance (or out type params in C#) the object must implement an // interface with a more derived type arg than the target interface. Or // the object interface can have a type arg that is an interface // implemented by the target type arg. // For instance: // class Foo : ICovariant<String> is ICovariant<Object> // class Foo : ICovariant<Bar> is ICovariant<IBar> // class Foo : ICovariant<IBar> is ICovariant<Object> if (!AreTypesAssignableInternal(pSourceArgType, pTargetArgType, false, false)) { return(false); } break; case GenericParameterAttributes.Contravariant: // For contravariance (or in type params in C#) the object must implement // an interface with a less derived type arg than the target interface. Or // the object interface can have a type arg that is a class implementing // the interface that is the target type arg. // For instance: // class Foo : IContravariant<Object> is IContravariant<String> // class Foo : IContravariant<IBar> is IContravariant<Bar> // class Foo : IContravariant<Object> is IContravariant<IBar> if (!AreTypesAssignableInternal(pTargetArgType, pSourceArgType, false, false)) { return(false); } break; default: Debug.Assert(false, "unknown generic variance type"); return(false); } } return(true); }