csharpfftfsharpintegrationinterpolationlinear-algebramathdifferentiationmatrixnumericsrandomregressionstatisticsmathnet
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
152 lines
6.1 KiB
152 lines
6.1 KiB
|
|
/// Functions associated with writing binaries which
|
|
/// vary between supported implementations of the CLI Common Language
|
|
/// Runtime, e.g. between the SSCLI, Mono and the Microsoft CLR.
|
|
///
|
|
/// The implementation of the functions can be found in ilsupp-*.ml
|
|
// (c) Microsoft Corporation 2005-2009.
|
|
module Microsoft.FSharp.Compiler.AbstractIL.Internal.Support
|
|
open System
|
|
open System.Runtime.InteropServices
|
|
open System.Diagnostics.SymbolStore
|
|
open Internal.Utilities
|
|
open Microsoft.FSharp.Compiler.AbstractIL
|
|
open Microsoft.FSharp.Compiler.AbstractIL.Internal
|
|
|
|
module Il = Microsoft.FSharp.Compiler.AbstractIL.IL
|
|
|
|
open Il
|
|
|
|
type IStream = System.Runtime.InteropServices.ComTypes.IStream
|
|
|
|
type clr_kind =
|
|
| SSCLI (* all calls allowed *)
|
|
| Microsoft (* all calls allowed *)
|
|
| Mono (* not investigated *)
|
|
| Neutral (* no PDB writing, reading, strong name signing, clrInstallationDirectory calls allowed *)
|
|
|
|
/// Globally configure the Abstract IL toolset to use a particular
|
|
/// set of auxiliary tools, e.g. debug writer, strong-name signer etc.
|
|
///
|
|
/// The configurations available will depend on the flags you've
|
|
/// set when compiling the Abstract IL source code, or will depend
|
|
/// on the particular binary release you are using. For example,
|
|
/// a typical Windows x86 binary release will support all Microsoft
|
|
/// CLR implementations and the Rotor SSCLI implementation.
|
|
val configure: clr_kind -> unit
|
|
val current_configuration: unit -> clr_kind
|
|
|
|
/// detect which configurations Abstract IL was compiled to support
|
|
val supported_configurations: clr_kind list
|
|
|
|
val pdb_suffix_for_configuration: clr_kind -> string
|
|
|
|
/// Unmanaged resource file linker - for native resources (not managed ones).
|
|
/// The function may be called twice, once with a zero-RVA and
|
|
/// arbitrary buffer, and once with the real buffer. The size of the
|
|
/// required buffer is returned.
|
|
type PEFileType = X86 | X64
|
|
|
|
val linkNativeResources: unlinkedResources:byte[] list -> rva:int32 -> PEFileType -> tempFilePath:string -> byte[]
|
|
val unlinkResource: int32 -> byte[] -> byte[]
|
|
|
|
/// PDB reader and associated types
|
|
type pdb_reader
|
|
type pdb_document
|
|
type pdb_method
|
|
type pdb_variable
|
|
type pdb_method_scope
|
|
|
|
type pdb_sequence_point =
|
|
{ pdbSeqPointOffset: int;
|
|
pdbSeqPointDocument: pdb_document;
|
|
pdbSeqPointLine: int;
|
|
pdbSeqPointColumn: int;
|
|
pdbSeqPointEndLine: int;
|
|
pdbSeqPointEndColumn: int; }
|
|
|
|
val pdbReadOpen: string (* module *) -> string (* path *) -> pdb_reader
|
|
val pdbReadClose: pdb_reader -> unit
|
|
val pdbReaderGetMethod: pdb_reader -> int32 (* token *) -> pdb_method
|
|
val pdbReaderGetMethodFromDocumentPosition: pdb_reader -> pdb_document -> int (* line *) -> int (* col *) -> pdb_method
|
|
val pdbReaderGetDocuments: pdb_reader -> pdb_document array
|
|
val pdbReaderGetDocument: pdb_reader -> string (* url *) -> byte[] (* guid *) -> byte[] (* guid *) -> byte[] (* guid *) -> pdb_document
|
|
|
|
val pdbDocumentGetURL: pdb_document -> string
|
|
val pdbDocumentGetType: pdb_document -> byte[] (* guid *)
|
|
val pdbDocumentGetLanguage: pdb_document -> byte[] (* guid *)
|
|
val pdbDocumentGetLanguageVendor: pdb_document -> byte[] (* guid *)
|
|
val pdbDocumentFindClosestLine: pdb_document -> int -> int
|
|
|
|
val pdbMethodGetToken: pdb_method -> int32
|
|
val pdbMethodGetRootScope: pdb_method -> pdb_method_scope
|
|
val pdbMethodGetSequencePoints: pdb_method -> pdb_sequence_point array
|
|
|
|
val pdbScopeGetChildren: pdb_method_scope -> pdb_method_scope array
|
|
val pdbScopeGetOffsets: pdb_method_scope -> int * int
|
|
val pdbScopeGetLocals: pdb_method_scope -> pdb_variable array
|
|
|
|
val pdbVariableGetName: pdb_variable -> string
|
|
val pdbVariableGetSignature: pdb_variable -> byte[]
|
|
val pdbVariableGetAddressAttributes: pdb_variable -> int32 (* kind *) * int32 (* addrField1 *)
|
|
|
|
/// Access installation directory. Not actually used by the core
|
|
/// Abstract IL libraries but invariably useful to client programs
|
|
/// when setting up paths etc.
|
|
///
|
|
/// This returns "." is a CLR installation cannot be detected.
|
|
val clrInstallationDirectory: unit -> string
|
|
val clrVersion: unit -> string
|
|
|
|
(*---------------------------------------------------------------------
|
|
* PDB writer.
|
|
*---------------------------------------------------------------------*)
|
|
|
|
type pdb_writer
|
|
type pdb_document_writer
|
|
|
|
type idd =
|
|
{ iddCharacteristics: int32;
|
|
iddMajorVersion: int32; (* actually u16 in IMAGE_DEBUG_DIRECTORY *)
|
|
iddMinorVersion: int32; (* acutally u16 in IMAGE_DEBUG_DIRECTORY *)
|
|
iddType: int32;
|
|
iddData: byte[];}
|
|
|
|
val pdbInitialize:
|
|
string (* .exe/.dll already written and closed *) ->
|
|
string (* .pdb to write *) ->
|
|
pdb_writer
|
|
val pdbClose: pdb_writer -> unit
|
|
val pdbSetUserEntryPoint: pdb_writer -> int32 -> unit
|
|
val pdbDefineDocument: pdb_writer -> string -> pdb_document_writer
|
|
val pdbOpenMethod: pdb_writer -> int32 -> unit
|
|
val pdbCloseMethod: pdb_writer -> unit
|
|
val pdbOpenScope: pdb_writer -> int -> unit
|
|
val pdbCloseScope: pdb_writer -> int -> unit
|
|
val pdbDefineLocalVariable: pdb_writer -> string -> byte[] -> int32 -> unit
|
|
val pdbSetMethodRange: pdb_writer -> pdb_document_writer -> int -> int -> pdb_document_writer -> int -> int -> unit
|
|
val pdbDefineSequencePoints: pdb_writer -> pdb_document_writer -> (int * int * int * int * int) array -> unit
|
|
val pdbGetDebugInfo: pdb_writer -> idd
|
|
|
|
(*---------------------------------------------------------------------
|
|
* Misc writing support
|
|
*---------------------------------------------------------------------*)
|
|
|
|
val absilWriteGetTimeStamp: unit -> int32
|
|
|
|
(*---------------------------------------------------------------------
|
|
* Strong name signing
|
|
*---------------------------------------------------------------------*)
|
|
|
|
type keyContainerName = string
|
|
type keyPair = byte[]
|
|
type pubkey = byte[]
|
|
|
|
val signerOpenPublicKeyFile: string -> pubkey
|
|
val signerOpenKeyPairFile: string -> keyPair
|
|
val signerGetPublicKeyForKeyPair: keyPair -> pubkey
|
|
val signerGetPublicKeyForKeyContainer: string -> pubkey
|
|
val signerCloseKeyContainer: keyContainerName -> unit
|
|
val signerSignatureSize: pubkey -> int
|
|
val signerSignFileWithKeyPair: string -> keyPair -> unit
|
|
val signerSignFileWithKeyContainer: string -> keyContainerName -> unit
|
|
|