From 4b32594d67f3542162644b3f87f571ce85496981 Mon Sep 17 00:00:00 2001 From: Eric Dobson Date: Fri, 16 Sep 2011 22:23:15 -0700 Subject: [PATCH] Conversion to unsafe: naming system --- private/ffi/arithmetic.rkt | 10 ++-- private/ffi/basic-blocks.rkt | 36 ++++++------- private/ffi/builder.rkt | 26 +++++----- private/ffi/cast.rkt | 6 +-- private/ffi/constants.rkt | 66 ++++++++++++------------ private/ffi/ctypes.rkt | 86 ++++++++++++++----------------- private/ffi/define.rkt | 80 ++++++++++------------------ private/ffi/functions.rkt | 44 ++++++++-------- private/ffi/globals.rkt | 38 +++++++------- private/ffi/instructions.rkt | 28 +++++----- private/ffi/memory-buffers.rkt | 6 +-- private/ffi/memory.rkt | 16 +++--- private/ffi/misc-instructions.rkt | 22 ++++---- private/ffi/misc-operations.rkt | 38 +++++++------- private/ffi/module-io.rkt | 12 ++--- private/ffi/modules.rkt | 30 +++++------ private/ffi/passes.rkt | 26 +++++----- private/ffi/racket-ext.rkt | 14 ++--- private/ffi/runtime.rkt | 55 ++++++++++---------- private/ffi/terminators.rkt | 30 +++++------ private/ffi/types.rkt | 58 ++++++++++----------- private/ffi/unsafe.rkt | 12 +++++ private/simple/all.rkt | 2 +- private/simple/base.rkt | 2 +- private/simple/binop.rkt | 2 +- private/simple/cast.rkt | 2 +- private/simple/comparison.rkt | 2 +- private/simple/memory.rkt | 2 +- simple.rkt | 2 +- unsafe.rkt | 6 +-- 30 files changed, 369 insertions(+), 390 deletions(-) create mode 100644 private/ffi/unsafe.rkt diff --git a/private/ffi/arithmetic.rkt b/private/ffi/arithmetic.rkt index f20c191..5f1815a 100644 --- a/private/ffi/arithmetic.rkt +++ b/private/ffi/arithmetic.rkt @@ -10,7 +10,7 @@ (provide (all-defined-out)) ;/* Arithmetic */ -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMBuildAdd LLVMBuildNSWAdd LLVMBuildNUWAdd @@ -38,10 +38,10 @@ LLVMBuildXor) (_fun LLVMBuilderRef LLVMValueRef LLVMValueRef _string -> LLVMValueRef)) -(define-llvm LLVMBuildBinOp +(define-llvm-unsafe LLVMBuildBinOp (_fun LLVMBuilderRef LLVMOpcode LLVMValueRef LLVMValueRef _string -> LLVMValueRef)) -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMBuildNeg LLVMBuildNSWNeg LLVMBuildNUWNeg @@ -51,14 +51,14 @@ ;/* Comparisons */ -(define-llvm LLVMBuildICmp +(define-llvm-unsafe LLVMBuildICmp (_fun LLVMBuilderRef LLVMIntPredicate LLVMValueRef LLVMValueRef _string -> LLVMValueRef)) -(define-llvm LLVMBuildFCmp +(define-llvm-unsafe LLVMBuildFCmp (_fun LLVMBuilderRef LLVMRealPredicate LLVMValueRef diff --git a/private/ffi/basic-blocks.rkt b/private/ffi/basic-blocks.rkt index debd7a9..d098a3b 100644 --- a/private/ffi/basic-blocks.rkt +++ b/private/ffi/basic-blocks.rkt @@ -9,58 +9,58 @@ (provide (all-defined-out)) -(define-llvm LLVMBlockAddress (_fun LLVMValueRef LLVMBasicBlockRef -> LLVMValueRef)) +(define-llvm-unsafe LLVMBlockAddress (_fun LLVMValueRef LLVMBasicBlockRef -> LLVMValueRef)) ;/* Operations on basic blocks */ -(define-llvm LLVMBasicBlockAsValue (_fun LLVMBasicBlockRef -> LLVMValueRef)) -(define-llvm LLVMValueIsBasicBlock (_fun LLVMValueRef -> LLVMBool)) -(define-llvm LLVMValueAsBasicBlock (_fun LLVMValueRef -> LLVMBasicBlockRef)) -(define-llvm LLVMGetBasicBlockParent (_fun LLVMBasicBlockRef -> LLVMValueRef)) +(define-llvm-unsafe LLVMBasicBlockAsValue (_fun LLVMBasicBlockRef -> LLVMValueRef)) +(define-llvm-unsafe LLVMValueIsBasicBlock (_fun LLVMValueRef -> LLVMBool)) +(define-llvm-unsafe LLVMValueAsBasicBlock (_fun LLVMValueRef -> LLVMBasicBlockRef)) +(define-llvm-unsafe LLVMGetBasicBlockParent (_fun LLVMBasicBlockRef -> LLVMValueRef)) ;(define-llvm LLVMGetBasicBlockTerminator (_fun LLVMBasicBlockRef -> LLVMValueRef)) ;Not yet in my dev repo of llvm -(define-llvm LLVMCountBasicBlocks (_fun LLVMValueRef -> _uint)) -(define-llvm LLVMGetBasicBlocks +(define-llvm-unsafe LLVMCountBasicBlocks (_fun LLVMValueRef -> _uint)) +(define-llvm-unsafe LLVMGetBasicBlocks (_fun (fun) :: (fun : LLVMValueRef) - (blocks : (_list o LLVMBasicBlockRef (LLVMCountBasicBlocks fun))) + (blocks : (_list o LLVMBasicBlockRef (unsafe:LLVMCountBasicBlocks fun))) -> _void -> blocks)) -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMGetEntryBasicBlock LLVMGetFirstBasicBlock LLVMGetLastBasicBlock) (_fun LLVMValueRef -> LLVMBasicBlockRef)) -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMGetNextBasicBlock LLVMGetPreviousBasicBlock) (_fun LLVMBasicBlockRef -> LLVMBasicBlockRef)) -(define-llvm LLVMAppendBasicBlockInContext (_fun LLVMContextRef LLVMValueRef _string -> LLVMBasicBlockRef)) -(define-llvm LLVMInsertBasicBlockInContext (_fun LLVMContextRef LLVMBasicBlockRef _string -> LLVMBasicBlockRef)) +(define-llvm-unsafe LLVMAppendBasicBlockInContext (_fun LLVMContextRef LLVMValueRef _string -> LLVMBasicBlockRef)) +(define-llvm-unsafe LLVMInsertBasicBlockInContext (_fun LLVMContextRef LLVMBasicBlockRef _string -> LLVMBasicBlockRef)) -(define-llvm LLVMAppendBasicBlock +(define-llvm-unsafe LLVMAppendBasicBlock (_fun LLVMValueRef _string -> LLVMBasicBlockRef)) -(define-llvm LLVMInsertBasicBlock +(define-llvm-unsafe LLVMInsertBasicBlock (_fun LLVMBasicBlockRef _string -> LLVMBasicBlockRef)) -(define-llvm LLVMDeleteBasicBlock +(define-llvm-unsafe LLVMDeleteBasicBlock (_fun LLVMBasicBlockRef -> _void)) -;(define-llvm LLVMRemoveBasicBlockFromParent +;(define-llvm-unsafe LLVMRemoveBasicBlockFromParent ; (_fun LLVMBasicBlockRef -> _void)) -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMMoveBasicBlockBefore LLVMMoveBasicBlockAfter) (_fun LLVMBasicBlockRef LLVMBasicBlockRef -> _void)) -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMGetFirstInstruction LLVMGetLastInstruction) (_fun LLVMBasicBlockRef -> LLVMValueRef)) diff --git a/private/ffi/builder.rkt b/private/ffi/builder.rkt index fd172eb..279a80b 100644 --- a/private/ffi/builder.rkt +++ b/private/ffi/builder.rkt @@ -14,32 +14,32 @@ ; * exclusive means of building instructions using the C interface. ; */ -(define-llvm LLVMCreateBuilderInContext (_fun LLVMContextRef -> LLVMBuilderRef)) -(define-llvm LLVMCreateBuilder (_fun -> LLVMBuilderRef)) +(define-llvm-unsafe LLVMCreateBuilderInContext (_fun LLVMContextRef -> LLVMBuilderRef)) +(define-llvm-unsafe LLVMCreateBuilder (_fun -> LLVMBuilderRef)) -(define-llvm LLVMPositionBuilder (_fun LLVMBuilderRef LLVMBasicBlockRef LLVMValueRef -> _void)) -(define-llvm LLVMPositionBuilderBefore +(define-llvm-unsafe LLVMPositionBuilder (_fun LLVMBuilderRef LLVMBasicBlockRef LLVMValueRef -> _void)) +(define-llvm-unsafe LLVMPositionBuilderBefore (_fun LLVMBuilderRef LLVMValueRef -> _void)) -(define-llvm LLVMPositionBuilderAtEnd (_fun LLVMBuilderRef LLVMBasicBlockRef -> _void)) +(define-llvm-unsafe LLVMPositionBuilderAtEnd (_fun LLVMBuilderRef LLVMBasicBlockRef -> _void)) -(define-llvm LLVMGetInsertBlock (_fun LLVMBuilderRef -> LLVMBasicBlockRef)) +(define-llvm-unsafe LLVMGetInsertBlock (_fun LLVMBuilderRef -> LLVMBasicBlockRef)) -(define-llvm LLVMClearInsertionPosition +(define-llvm-unsafe LLVMClearInsertionPosition (_fun LLVMBuilderRef -> _void)) -(define-llvm LLVMInsertIntoBuilder +(define-llvm-unsafe LLVMInsertIntoBuilder (_fun LLVMBuilderRef LLVMValueRef -> _void)) -(define-llvm LLVMInsertIntoBuilderWithName +(define-llvm-unsafe LLVMInsertIntoBuilderWithName (_fun LLVMBuilderRef LLVMValueRef _string -> _void)) -(define-llvm LLVMDisposeBuilder (_fun LLVMBuilderRef -> _void)) +(define-llvm-unsafe LLVMDisposeBuilder (_fun LLVMBuilderRef -> _void)) ;/* Metadata */ -(define-llvm LLVMGetCurrentDebugLocation (_fun LLVMBuilderRef -> LLVMValueRef)) -(define-llvm LLVMSetCurrentDebugLocation (_fun LLVMBuilderRef LLVMValueRef -> _void)) -(define-llvm LLVMSetInstDebugLocation (_fun LLVMBuilderRef LLVMValueRef -> _void)) +(define-llvm-unsafe LLVMGetCurrentDebugLocation (_fun LLVMBuilderRef -> LLVMValueRef)) +(define-llvm-unsafe LLVMSetCurrentDebugLocation (_fun LLVMBuilderRef LLVMValueRef -> _void)) +(define-llvm-unsafe LLVMSetInstDebugLocation (_fun LLVMBuilderRef LLVMValueRef -> _void)) diff --git a/private/ffi/cast.rkt b/private/ffi/cast.rkt index d333864..57c839e 100644 --- a/private/ffi/cast.rkt +++ b/private/ffi/cast.rkt @@ -9,7 +9,7 @@ (provide (all-defined-out)) -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMBuildTrunc LLVMBuildZExt LLVMBuildSExt @@ -21,7 +21,7 @@ LLVMBuildFPExt) (_fun LLVMBuilderRef LLVMValueRef LLVMTypeRef _string -> LLVMValueRef)) -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMBuildPtrToInt LLVMBuildIntToPtr LLVMBuildBitCast @@ -33,5 +33,5 @@ LLVMBuildFPCast) (_fun LLVMBuilderRef LLVMValueRef LLVMTypeRef _string -> LLVMValueRef)) -(define-llvm LLVMBuildCast +(define-llvm-unsafe LLVMBuildCast (_fun LLVMBuilderRef LLVMOpcode LLVMValueRef LLVMTypeRef _string -> LLVMValueRef)) diff --git a/private/ffi/constants.rkt b/private/ffi/constants.rkt index 62a50ba..1a2d264 100644 --- a/private/ffi/constants.rkt +++ b/private/ffi/constants.rkt @@ -10,8 +10,8 @@ (provide (all-defined-out)) ;/* Operations on scalar constants */ -(define-llvm LLVMConstInt (_fun LLVMTypeRef _long LLVMBool -> LLVMValueRef)) -(define-llvm LLVMConstIntOfArbitraryPrecision +(define-llvm-unsafe LLVMConstInt (_fun LLVMTypeRef _long LLVMBool -> LLVMValueRef)) +(define-llvm-unsafe LLVMConstIntOfArbitraryPrecision (_fun (type words) :: (type : LLVMTypeRef) (_uint = (length words)) @@ -20,7 +20,7 @@ ;/* Operations on constants of any type */ -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMConstNull ; /* all zeroes */ LLVMConstAllOnes ; /* only for int/vector */ LLVMGetUndef @@ -28,22 +28,22 @@ (_fun LLVMTypeRef -> LLVMValueRef)) -(define-llvm LLVMConstIntOfString +(define-llvm-unsafe LLVMConstIntOfString (_fun LLVMTypeRef _string _uint8 -> LLVMValueRef)) -(define-llvm LLVMConstIntOfStringAndSize +(define-llvm-unsafe LLVMConstIntOfStringAndSize (_fun LLVMTypeRef _string _uint _uint8 -> LLVMValueRef)) -(define-llvm LLVMConstReal (_fun LLVMTypeRef _double* -> LLVMValueRef)) -(define-llvm LLVMConstRealOfString +(define-llvm-unsafe LLVMConstReal (_fun LLVMTypeRef _double* -> LLVMValueRef)) +(define-llvm-unsafe LLVMConstRealOfString (_fun LLVMTypeRef _string -> LLVMValueRef)) -(define-llvm LLVMConstRealOfStringAndSize +(define-llvm-unsafe LLVMConstRealOfStringAndSize (_fun LLVMTypeRef _string _uint -> LLVMValueRef)) -(define-llvm LLVMConstIntGetZExtValue (_fun LLVMValueRef -> _ulong)) -(define-llvm LLVMConstIntGetSExtValue (_fun LLVMValueRef -> _long)) +(define-llvm-unsafe LLVMConstIntGetZExtValue (_fun LLVMValueRef -> _ulong)) +(define-llvm-unsafe LLVMConstIntGetSExtValue (_fun LLVMValueRef -> _long)) ;/* Operations on composite constants */ -(define-llvm LLVMConstStringInContext +(define-llvm-unsafe LLVMConstStringInContext (_fun (context str dnt) :: (context : LLVMContextRef) (str : _string) @@ -52,7 +52,7 @@ -> LLVMValueRef)) -(define-llvm LLVMConstStructInContext +(define-llvm-unsafe LLVMConstStructInContext (_fun (context fields packed) :: (context : LLVMContextRef) (fields : (_list i LLVMValueRef)) @@ -61,7 +61,7 @@ -> LLVMValueRef)) -(define-llvm LLVMConstString +(define-llvm-unsafe LLVMConstString (_fun (str dnt) :: (str : _string) (_uint = (string-length str)) @@ -70,14 +70,14 @@ -(define-llvm LLVMConstStruct +(define-llvm-unsafe LLVMConstStruct (_fun (fields packed) :: (fields : (_list i LLVMValueRef)) (_uint = (length fields)) (packed : LLVMBool) -> LLVMValueRef)) -(define-llvm LLVMConstNamedStruct +(define-llvm-unsafe LLVMConstNamedStruct (_fun (type fields) :: (type : LLVMTypeRef) (fields : (_list i LLVMValueRef)) @@ -85,7 +85,7 @@ -> LLVMValueRef)) -(define-llvm LLVMConstArray +(define-llvm-unsafe LLVMConstArray (_fun (type elements) :: (type : LLVMTypeRef) (elements : (_list i LLVMValueRef)) @@ -93,18 +93,18 @@ -> LLVMValueRef)) -(define-llvm LLVMConstVector +(define-llvm-unsafe LLVMConstVector (_fun (elements) :: (elements : (_list i LLVMValueRef)) (_uint = (length elements)) -> LLVMValueRef)) -(define-llvm LLVMGetConstOpcode (_fun LLVMValueRef -> LLVMOpcode)) -(define-llvm-multiple +(define-llvm-unsafe LLVMGetConstOpcode (_fun LLVMValueRef -> LLVMOpcode)) +(define-llvm-multiple-unsafe (LLVMAlignOf LLVMSizeOf) (_fun LLVMTypeRef -> LLVMValueRef)) -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMConstNeg LLVMConstNSWNeg LLVMConstNUWNeg @@ -112,7 +112,7 @@ LLVMConstNot) (_fun LLVMValueRef -> LLVMValueRef)) -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMConstAdd LLVMConstNSWAdd LLVMConstNUWAdd @@ -138,14 +138,14 @@ (_fun LLVMValueRef LLVMValueRef -> LLVMValueRef)) -(define-llvm LLVMConstICmp +(define-llvm-unsafe LLVMConstICmp (_fun LLVMIntPredicate LLVMValueRef LLVMValueRef -> LLVMValueRef)) -(define-llvm LLVMConstFCmp +(define-llvm-unsafe LLVMConstFCmp (_fun LLVMRealPredicate LLVMValueRef LLVMValueRef -> LLVMValueRef)) -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMConstShl LLVMConstLShr LLVMConstAShr) (_fun LLVMValueRef LLVMValueRef -> LLVMValueRef)) -(define-llvm-multiple (LLVMConstGEP LLVMConstInBoundsGEP) +(define-llvm-multiple-unsafe (LLVMConstGEP LLVMConstInBoundsGEP) (_fun (ptr indices) :: (ptr : LLVMValueRef) (indices : (_list i LLVMValueRef)) @@ -153,7 +153,7 @@ -> LLVMValueRef)) -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMConstTrunc LLVMConstSExt LLVMConstZExt @@ -173,22 +173,22 @@ (_fun LLVMValueRef LLVMTypeRef -> LLVMValueRef)) -(define-llvm LLVMConstIntCast +(define-llvm-unsafe LLVMConstIntCast (_fun LLVMValueRef LLVMTypeRef LLVMBool -> LLVMValueRef)) -(define-llvm LLVMConstFPCast +(define-llvm-unsafe LLVMConstFPCast (_fun LLVMValueRef LLVMTypeRef -> LLVMValueRef)) -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMConstSelect LLVMConstInsertElement LLVMConstShuffleVector) (_fun LLVMValueRef LLVMValueRef LLVMValueRef -> LLVMValueRef)) -(define-llvm LLVMConstExtractElement +(define-llvm-unsafe LLVMConstExtractElement (_fun LLVMValueRef LLVMValueRef -> LLVMValueRef)) -(define-llvm LLVMConstExtractValue +(define-llvm-unsafe LLVMConstExtractValue (_fun (agg indices) :: (agg : LLVMValueRef) (indices : (_list i _uint)) @@ -197,7 +197,7 @@ LLVMValueRef)) -(define-llvm LLVMConstInsertValue +(define-llvm-unsafe LLVMConstInsertValue (_fun (agg elem indices) :: (agg : LLVMValueRef) (elem : LLVMValueRef) @@ -206,4 +206,4 @@ -> LLVMValueRef)) -(define-llvm LLVMConstInlineAsm (_fun LLVMTypeRef _string _string LLVMBool LLVMBool -> LLVMValueRef)) +(define-llvm-unsafe LLVMConstInlineAsm (_fun LLVMTypeRef _string _string LLVMBool LLVMBool -> LLVMValueRef)) diff --git a/private/ffi/ctypes.rkt b/private/ffi/ctypes.rkt index 43da979..2f8ce7c 100644 --- a/private/ffi/ctypes.rkt +++ b/private/ffi/ctypes.rkt @@ -1,7 +1,6 @@ #lang racket/base (require (for-syntax "../llvm-util-exptime.rkt" racket/base syntax/parse)) -(require racket/stxparam) (require ffi/unsafe) (require "define.rkt") @@ -64,6 +63,7 @@ (write-string ")" port) (write-string ">" port)))) +;TODO add pred (define-syntax-rule (llvm-ref-equal+hash acc type) (list (lambda (left right =?) @@ -96,13 +96,13 @@ (struct unsafe:llvm-type-ref (pointer) #:property prop:custom-print-quotable 'never #:property prop:custom-write - (write-llvm-type-ref LLVMGetTypeDescription) + (write-llvm-type-ref unsafe:LLVMGetTypeDescription) #:property prop:equal+hash (llvm-ref-equal+hash unsafe:llvm-type-ref-pointer unsafe:LLVMTypeRef)) (struct unsafe:llvm-value-ref (pointer) #:property prop:custom-print-quotable 'never #:property prop:custom-write - (write-llvm-value-ref LLVMGetValueDescription) + (write-llvm-value-ref unsafe:LLVMGetValueDescription) #:property prop:equal+hash (llvm-ref-equal+hash unsafe:llvm-value-ref-pointer unsafe:LLVMValueRef)) @@ -167,40 +167,15 @@ ...)))) -(define-syntax (make-syntax-parameter-types stx) +(define-syntax (make-types stx) (syntax-parse stx ((_ name:id ...) - #'(begin - (define-syntax-parameter name - (let ((unsafe-id (id-prefix 'unsafe: #'name)) - (safe-id (id-prefix 'safe: #'name))) - (lambda (stx) - (with-syntax ((id - (case (syntax-parameter-value #'llvm-safety) - ((unsafe) unsafe-id) - ((safe) safe-id) - (else (raise-syntax-error #f "Not in an llvm-safety-context" - stx))))) - (syntax-case stx () - ((_ . args) #'(id . args)) - (_ #'id)))))) - ...)))) + (with-syntax (((unsafe-id ...) (map (lambda (id) (id-prefix 'unsafe: id)) + (syntax->list #'(name ...))))) + #'(begin + (define name unsafe-id) ...))))) -(make-syntax-parameter-types - LLVMContextRef - LLVMModuleRef - LLVMTypeRef - LLVMValueRef - LLVMBasicBlockRef - LLVMBuilderRef - LLVMModuleProviderRef - LLVMMemoryBufferRef - LLVMPassManagerRef - LLVMPassRegistryRef - LLVMUseRef - LLVMTargetDataRef) - (make-llvm-types (unsafe:LLVMContextRef unsafe:llvm-context-ref unsafe:llvm-context-ref-pointer) @@ -217,6 +192,22 @@ (unsafe:LLVMTargetDataRef unsafe:llvm-target-data-ref unsafe:llvm-target-data-ref-pointer) (safe:LLVMContextRef safe:llvm-context-ref safe:llvm-context-ref-pointer)) +(make-types + LLVMContextRef + LLVMModuleRef + LLVMTypeRef + LLVMValueRef + LLVMBasicBlockRef + LLVMBuilderRef + LLVMModuleProviderRef + LLVMMemoryBufferRef + LLVMPassManagerRef + LLVMPassRegistryRef + LLVMUseRef + LLVMTargetDataRef) + + + (make-safe-llvm-types (safe:LLVMModuleRef safe:llvm-module-ref safe:llvm-module-ref-pointer) (safe:LLVMTypeRef safe:llvm-type-ref safe:llvm-type-ref-pointer) @@ -234,17 +225,19 @@ (define LLVMMessage - (make-ctype - _pointer - (lambda (scheme) - (when scheme - (error 'LLVMMessage "Cannot Convert non null pointers to C")) - #f) - (lambda (cptr) - (and cptr - (begin0 - (bytes->string/utf-8 (make-byte-string cptr)) - (LLVMDisposeMessage cptr)))))) + (let () + (define-llvm-unsafe LLVMDisposeMessage (_fun _pointer -> _void)) + (make-ctype + _pointer + (lambda (scheme) + (when scheme + (error 'LLVMMessage "Cannot Convert non null pointers to C")) + #f) + (lambda (cptr) + (and cptr + (begin0 + (bytes->string/utf-8 (make-byte-string cptr)) + (unsafe:LLVMDisposeMessage cptr))))))) (define _malloc-string (make-ctype @@ -283,12 +276,11 @@ ;/*===-- Error handling ----------------------------------------------------===*/ -(define-llvm LLVMDisposeMessage (_fun _pointer -> _void)) -(define-llvm-racket LLVMGetTypeDescription (_fun unsafe:LLVMTypeRef -> _malloc-string)) -(define-llvm-racket LLVMGetValueDescription (_fun unsafe:LLVMValueRef -> _malloc-string)) +(define-llvm-racket-unsafe LLVMGetTypeDescription (_fun unsafe:LLVMTypeRef -> _malloc-string)) +(define-llvm-racket-unsafe LLVMGetValueDescription (_fun unsafe:LLVMValueRef -> _malloc-string)) (define-llvm-racket-safe LLVMGetTypeDescription (_fun safe:LLVMTypeRef -> _malloc-string)) (define-llvm-racket-safe LLVMGetValueDescription (_fun safe:LLVMValueRef -> _malloc-string)) diff --git a/private/ffi/define.rkt b/private/ffi/define.rkt index 4daac1a..b7a6510 100644 --- a/private/ffi/define.rkt +++ b/private/ffi/define.rkt @@ -4,33 +4,18 @@ (for-syntax "../llvm-util-exptime.rkt" syntax/parse) (only-in ffi/unsafe get-ffi-obj) - "lib.rkt" - racket/splicing - racket/stxparam) + "lib.rkt") (provide - define-llvm-multiple define-llvm-safe define-llvm-racket-safe - define-llvm-both - (rename-out - (define-llvm-unsafe define-llvm) - (define-llvm-racket-unsafe define-llvm-racket)) - llvm-safety - llvm-unsafe-context - define-ffi-definer) + define-llvm-multiple-safe + define-llvm-unsafe + define-llvm-racket-unsafe + define-llvm-multiple-unsafe) -(define-syntax-parameter llvm-safety #f) - - -(define-syntax (llvm-unsafe-context stx) - (syntax-case stx () - ((_ . args) - #'(splicing-syntax-parameterize ((llvm-safety 'unsafe)) - . args)))) - (define-syntax (define-ffi-definer stx) (syntax-case stx () @@ -43,38 +28,12 @@ #'(define id (get-ffi-obj 'id lib type)))))))) -(define-syntax (define-llvm-both stx) - (syntax-case stx () - ((_ . args) - (begin - #'(splicing-syntax-parameterize ((llvm-safety 'unsafe)) - (define-llvm . args)) - #'(splicing-syntax-parameterize ((llvm-safety 'safe)) - (define-llvm . args)))))) - -(define-ffi-definer define-llvm llvm-lib) -(define-ffi-definer define-llvm-racket llvm-racket-lib) +(define-ffi-definer define-llvm-raw llvm-lib) +(define-ffi-definer define-llvm-racket-raw llvm-racket-lib) - -(define-syntax (define-llvm-unsafe stx) - (syntax-case stx () - ((_ . args) - #'(splicing-syntax-parameterize ((llvm-safety 'unsafe)) - (define-llvm . args))))) - -(define-syntax (define-llvm-racket-unsafe stx) - (syntax-case stx () - ((_ . args) - #'(splicing-syntax-parameterize ((llvm-safety 'unsafe)) - (define-llvm-racket . args))))) - - - - - (define-syntaxes (define-llvm-safe define-llvm-racket-safe) (let ((definer (lambda (define-llvm) @@ -85,21 +44,36 @@ type #:c-id name)))))) (values - (definer #'define-llvm) - (definer #'define-llvm-racket)))) - - + (definer #'define-llvm-raw) + (definer #'define-llvm-racket-raw)))) +(define-syntaxes (define-llvm-unsafe define-llvm-racket-unsafe) + (let ((definer + (lambda (define-llvm) + (syntax-parser + ((_ name:id type:expr) + #`(#,define-llvm + #,(id-prefix 'unsafe: #'name) + type + #:c-id name)))))) + (values + (definer #'define-llvm-raw) + (definer #'define-llvm-racket-raw)))) -(define-syntax (define-llvm-multiple stx) +(define-syntax (define-llvm-multiple-unsafe stx) (syntax-case stx () ((_ (name ...) type) #'(begin (define-llvm-unsafe name type) ...)))) +(define-syntax (define-llvm-multiple-safe stx) + (syntax-case stx () + ((_ (name ...) type) + #'(begin (define-llvm-safe name type) ...)))) + diff --git a/private/ffi/functions.rkt b/private/ffi/functions.rkt index 630cf7e..69ca1e4 100644 --- a/private/ffi/functions.rkt +++ b/private/ffi/functions.rkt @@ -11,76 +11,76 @@ ;/* Operations on functions */ -(define-llvm LLVMAddFunction (_fun LLVMModuleRef _string LLVMTypeRef -> LLVMValueRef)) +(define-llvm-unsafe LLVMAddFunction (_fun LLVMModuleRef _string LLVMTypeRef -> LLVMValueRef)) -(define-llvm LLVMGetNamedFunction (_fun LLVMModuleRef _string -> LLVMValueRef)) +(define-llvm-unsafe LLVMGetNamedFunction (_fun LLVMModuleRef _string -> LLVMValueRef)) -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMGetFirstFunction LLVMGetLastFunction) (_fun LLVMModuleRef -> LLVMValueRef)) -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMGetNextFunction LLVMGetPreviousFunction) (_fun LLVMValueRef -> LLVMValueRef)) -(define-llvm LLVMDeleteFunction +(define-llvm-unsafe LLVMDeleteFunction (_fun LLVMValueRef -> _void)) -(define-llvm LLVMGetIntrinsicID +(define-llvm-unsafe LLVMGetIntrinsicID (_fun LLVMValueRef -> _uint)) -(define-llvm LLVMGetFunctionCallConv +(define-llvm-unsafe LLVMGetFunctionCallConv (_fun LLVMValueRef -> LLVMCallConv)) -(define-llvm LLVMSetFunctionCallConv +(define-llvm-unsafe LLVMSetFunctionCallConv (_fun LLVMValueRef LLVMCallConv -> _void)) -(define-llvm LLVMGetGC +(define-llvm-unsafe LLVMGetGC (_fun LLVMValueRef -> _string)) -(define-llvm LLVMSetGC (_fun LLVMValueRef _string -> _void)) +(define-llvm-unsafe LLVMSetGC (_fun LLVMValueRef _string -> _void)) -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMAddFunctionAttr LLVMRemoveFunctionAttr) (_fun LLVMValueRef LLVMAttribute -> _void)) -(define-llvm LLVMGetFunctionAttr +(define-llvm-unsafe LLVMGetFunctionAttr (_fun LLVMValueRef -> LLVMAttribute)) ;/* Operations on parameters */ -(define-llvm LLVMCountParams (_fun LLVMValueRef -> _uint)) -(define-llvm LLVMGetParams +(define-llvm-unsafe LLVMCountParams (_fun LLVMValueRef -> _uint)) +(define-llvm-unsafe LLVMGetParams (_fun (fun) :: (fun : LLVMValueRef) - (params : (_list o LLVMValueRef (LLVMCountParams fun))) + (params : (_list o LLVMValueRef (unsafe:LLVMCountParams fun))) -> _void -> params)) -(define-llvm LLVMGetParam (_fun LLVMValueRef _uint -> LLVMValueRef)) +(define-llvm-unsafe LLVMGetParam (_fun LLVMValueRef _uint -> LLVMValueRef)) -(define-llvm LLVMGetParamParent (_fun LLVMValueRef -> LLVMValueRef)) +(define-llvm-unsafe LLVMGetParamParent (_fun LLVMValueRef -> LLVMValueRef)) -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMGetFirstParam LLVMGetLastParam) (_fun LLVMValueRef -> LLVMValueRef)) -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMGetNextParam LLVMGetPreviousParam) (_fun LLVMValueRef -> LLVMValueRef)) -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMAddAttribute LLVMRemoveAttribute) (_fun LLVMValueRef LLVMAttribute -> _void)) -(define-llvm LLVMGetAttribute (_fun LLVMValueRef -> LLVMAttribute)) -(define-llvm LLVMSetParamAlignment (_fun LLVMValueRef _uint -> _void)) +(define-llvm-unsafe LLVMGetAttribute (_fun LLVMValueRef -> LLVMAttribute)) +(define-llvm-unsafe LLVMSetParamAlignment (_fun LLVMValueRef _uint -> _void)) diff --git a/private/ffi/globals.rkt b/private/ffi/globals.rkt index f882dff..1cf1166 100644 --- a/private/ffi/globals.rkt +++ b/private/ffi/globals.rkt @@ -10,48 +10,48 @@ (provide (all-defined-out)) ;/* Operations on global variables, functions, and aliases (globals) */ -(define-llvm LLVMGetGlobalParent (_fun LLVMValueRef -> LLVMModuleRef)) +(define-llvm-unsafe LLVMGetGlobalParent (_fun LLVMValueRef -> LLVMModuleRef)) -(define-llvm LLVMIsDeclaration (_fun LLVMValueRef -> LLVMBool)) +(define-llvm-unsafe LLVMIsDeclaration (_fun LLVMValueRef -> LLVMBool)) -(define-llvm LLVMGetLinkage (_fun LLVMValueRef -> LLVMLinkage)) -(define-llvm LLVMSetLinkage (_fun LLVMValueRef LLVMLinkage -> _void)) +(define-llvm-unsafe LLVMGetLinkage (_fun LLVMValueRef -> LLVMLinkage)) +(define-llvm-unsafe LLVMSetLinkage (_fun LLVMValueRef LLVMLinkage -> _void)) -(define-llvm LLVMGetSection (_fun LLVMValueRef -> _string)) -(define-llvm LLVMSetSection (_fun LLVMValueRef _string -> _void)) +(define-llvm-unsafe LLVMGetSection (_fun LLVMValueRef -> _string)) +(define-llvm-unsafe LLVMSetSection (_fun LLVMValueRef _string -> _void)) -(define-llvm LLVMGetVisibility (_fun LLVMValueRef -> LLVMVisibility)) -(define-llvm LLVMSetVisibility (_fun LLVMValueRef LLVMVisibility -> _void)) +(define-llvm-unsafe LLVMGetVisibility (_fun LLVMValueRef -> LLVMVisibility)) +(define-llvm-unsafe LLVMSetVisibility (_fun LLVMValueRef LLVMVisibility -> _void)) -(define-llvm LLVMGetAlignment (_fun LLVMValueRef -> _uint)) -(define-llvm LLVMSetAlignment (_fun LLVMValueRef _uint -> _void)) +(define-llvm-unsafe LLVMGetAlignment (_fun LLVMValueRef -> _uint)) +(define-llvm-unsafe LLVMSetAlignment (_fun LLVMValueRef _uint -> _void)) ;/* Operations on global variables */ -(define-llvm LLVMAddGlobal +(define-llvm-unsafe LLVMAddGlobal (_fun LLVMModuleRef LLVMTypeRef _string -> LLVMValueRef)) -(define-llvm LLVMAddGlobalInAddressSpace +(define-llvm-unsafe LLVMAddGlobalInAddressSpace (_fun LLVMModuleRef LLVMTypeRef _string _uint -> LLVMValueRef)) -(define-llvm LLVMGetNamedGlobal (_fun LLVMModuleRef _string -> LLVMValueRef)) +(define-llvm-unsafe LLVMGetNamedGlobal (_fun LLVMModuleRef _string -> LLVMValueRef)) -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMGetFirstGlobal LLVMGetLastGlobal) (_fun LLVMModuleRef -> LLVMValueRef)) -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMGetNextGlobal LLVMGetPreviousGlobal LLVMDeleteGlobal LLVMGetInitializer) (_fun LLVMValueRef -> LLVMValueRef)) -(define-llvm LLVMSetInitializer (_fun LLVMValueRef LLVMValueRef -> _void)) +(define-llvm-unsafe LLVMSetInitializer (_fun LLVMValueRef LLVMValueRef -> _void)) -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMIsThreadLocal LLVMIsGlobalConstant) (_fun LLVMValueRef -> LLVMBool)) -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMSetThreadLocal LLVMSetGlobalConstant) (_fun LLVMValueRef LLVMBool -> _void)) @@ -59,5 +59,5 @@ ;/* Operations on aliases */ -(define-llvm LLVMAddAlias +(define-llvm-unsafe LLVMAddAlias (_fun LLVMModuleRef LLVMTypeRef LLVMValueRef _string -> LLVMValueRef)) diff --git a/private/ffi/instructions.rkt b/private/ffi/instructions.rkt index 52f8dda..61e4c5a 100644 --- a/private/ffi/instructions.rkt +++ b/private/ffi/instructions.rkt @@ -10,33 +10,33 @@ (provide (all-defined-out)) ;/* Operations on instructions */ -(define-llvm LLVMGetInstructionParent (_fun LLVMValueRef -> LLVMBasicBlockRef)) -(define-llvm-multiple +(define-llvm-unsafe LLVMGetInstructionParent (_fun LLVMValueRef -> LLVMBasicBlockRef)) +(define-llvm-multiple-unsafe (LLVMGetNextInstruction LLVMGetPreviousInstruction) (_fun LLVMValueRef -> LLVMValueRef)) ;/* Operations on call sites */ -(define-llvm LLVMGetInstructionCallConv (_fun LLVMValueRef -> LLVMCallConv)) -(define-llvm LLVMSetInstructionCallConv (_fun LLVMValueRef LLVMCallConv -> _void)) +(define-llvm-unsafe LLVMGetInstructionCallConv (_fun LLVMValueRef -> LLVMCallConv)) +(define-llvm-unsafe LLVMSetInstructionCallConv (_fun LLVMValueRef LLVMCallConv -> _void)) -(define-llvm LLVMAddInstrAttribute (_fun LLVMValueRef _uint LLVMAttribute -> _void)) -(define-llvm LLVMRemoveInstrAttribute (_fun LLVMValueRef _uint LLVMAttribute -> _void)) +(define-llvm-unsafe LLVMAddInstrAttribute (_fun LLVMValueRef _uint LLVMAttribute -> _void)) +(define-llvm-unsafe LLVMRemoveInstrAttribute (_fun LLVMValueRef _uint LLVMAttribute -> _void)) -(define-llvm LLVMSetInstrParamAlignment (_fun LLVMValueRef _uint _uint -> _void)) +(define-llvm-unsafe LLVMSetInstrParamAlignment (_fun LLVMValueRef _uint _uint -> _void)) ;/* Operations on call instructions (only) */ -(define-llvm LLVMIsTailCall (_fun LLVMValueRef -> LLVMBool)) -(define-llvm LLVMSetTailCall (_fun LLVMValueRef LLVMBool -> _void)) +(define-llvm-unsafe LLVMIsTailCall (_fun LLVMValueRef -> LLVMBool)) +(define-llvm-unsafe LLVMSetTailCall (_fun LLVMValueRef LLVMBool -> _void)) ;/* Operations on switch instructions (only) */ -;(define-llvm LLVMGetSwitchDefaultDest (_fun LLVMValueRef -> LLVMBasicBlockRef)) +;(define-llvm-unsafe LLVMGetSwitchDefaultDest (_fun LLVMValueRef -> LLVMBasicBlockRef)) ;/* Operations on phi nodes */ -(define-llvm LLVMAddIncoming +(define-llvm-unsafe LLVMAddIncoming (_fun (phi values blocks) :: (phi : LLVMValueRef) (values : (_list i LLVMValueRef)) @@ -46,7 +46,7 @@ -(define-llvm LLVMCountIncoming (_fun LLVMValueRef -> _uint)) -(define-llvm LLVMGetIncomingValue (_fun LLVMValueRef _uint -> LLVMValueRef)) -(define-llvm LLVMGetIncomingBlock (_fun LLVMValueRef _uint -> LLVMBasicBlockRef)) +(define-llvm-unsafe LLVMCountIncoming (_fun LLVMValueRef -> _uint)) +(define-llvm-unsafe LLVMGetIncomingValue (_fun LLVMValueRef _uint -> LLVMValueRef)) +(define-llvm-unsafe LLVMGetIncomingBlock (_fun LLVMValueRef _uint -> LLVMBasicBlockRef)) diff --git a/private/ffi/memory-buffers.rkt b/private/ffi/memory-buffers.rkt index a046dc8..308af79 100644 --- a/private/ffi/memory-buffers.rkt +++ b/private/ffi/memory-buffers.rkt @@ -10,7 +10,7 @@ ;/*===-- Memory buffers ----------------------------------------------------===*/ ; -(define-llvm LLVMCreateMemoryBufferWithContentsOfFile +(define-llvm-unsafe LLVMCreateMemoryBufferWithContentsOfFile (_fun (path) :: (path : _string) (buffer : (_ptr o LLVMMemoryBufferRef)) @@ -21,7 +21,7 @@ (if ans message buffer))) -(define-llvm LLVMCreateMemoryBufferWithSTDIN +(define-llvm-unsafe LLVMCreateMemoryBufferWithSTDIN (_fun () :: (buffer : (_ptr o LLVMMemoryBufferRef)) (message : (_ptr io LLVMMessage) = #f) @@ -30,7 +30,7 @@ -> (if ans message buffer))) -(define-llvm LLVMDisposeMemoryBuffer +(define-llvm-unsafe LLVMDisposeMemoryBuffer (_fun LLVMMemoryBufferRef -> _void)) diff --git a/private/ffi/memory.rkt b/private/ffi/memory.rkt index 560af19..ed3b712 100644 --- a/private/ffi/memory.rkt +++ b/private/ffi/memory.rkt @@ -10,23 +10,23 @@ ;/* Memory */ -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMBuildMalloc LLVMBuildAlloca) (_fun LLVMBuilderRef LLVMTypeRef _string -> LLVMValueRef)) -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMBuildArrayMalloc LLVMBuildArrayAlloca) (_fun LLVMBuilderRef LLVMTypeRef LLVMValueRef _string -> LLVMValueRef)) -(define-llvm LLVMBuildFree (_fun LLVMBuilderRef LLVMValueRef -> LLVMValueRef)) +(define-llvm-unsafe LLVMBuildFree (_fun LLVMBuilderRef LLVMValueRef -> LLVMValueRef)) -(define-llvm LLVMBuildLoad +(define-llvm-unsafe LLVMBuildLoad (_fun LLVMBuilderRef LLVMValueRef _string -> LLVMValueRef)) -(define-llvm LLVMBuildStore +(define-llvm-unsafe LLVMBuildStore (_fun LLVMBuilderRef LLVMValueRef LLVMValueRef -> LLVMValueRef)) -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMBuildGEP LLVMBuildInBoundsGEP) (_fun (builder ptr indices name) :: @@ -38,9 +38,9 @@ -> LLVMValueRef)) -(define-llvm LLVMBuildStructGEP +(define-llvm-unsafe LLVMBuildStructGEP (_fun LLVMBuilderRef LLVMValueRef _uint _string -> LLVMValueRef)) -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMBuildGlobalString LLVMBuildGlobalStringPtr) (_fun LLVMBuilderRef _string _string -> LLVMValueRef)) diff --git a/private/ffi/misc-instructions.rkt b/private/ffi/misc-instructions.rkt index 5e517a6..975546c 100644 --- a/private/ffi/misc-instructions.rkt +++ b/private/ffi/misc-instructions.rkt @@ -10,9 +10,9 @@ ;/* Miscellaneous instructions */ -(define-llvm LLVMBuildPhi (_fun LLVMBuilderRef LLVMTypeRef _string -> LLVMValueRef)) +(define-llvm-unsafe LLVMBuildPhi (_fun LLVMBuilderRef LLVMTypeRef _string -> LLVMValueRef)) -(define-llvm LLVMBuildCall +(define-llvm-unsafe LLVMBuildCall (_fun (builder fun args name) :: (builder : LLVMBuilderRef) (fun : LLVMValueRef) @@ -21,29 +21,29 @@ (name : _string) -> LLVMValueRef)) -(define-llvm LLVMBuildSelect +(define-llvm-unsafe LLVMBuildSelect (_fun LLVMBuilderRef LLVMValueRef LLVMValueRef LLVMValueRef _string -> LLVMValueRef)) -(define-llvm LLVMBuildVAArg +(define-llvm-unsafe LLVMBuildVAArg (_fun LLVMBuilderRef LLVMValueRef LLVMTypeRef _string -> LLVMValueRef)) -(define-llvm LLVMBuildExtractElement +(define-llvm-unsafe LLVMBuildExtractElement (_fun LLVMBuilderRef LLVMValueRef LLVMValueRef _string -> LLVMValueRef)) -(define-llvm LLVMBuildInsertElement +(define-llvm-unsafe LLVMBuildInsertElement (_fun LLVMBuilderRef LLVMValueRef LLVMValueRef LLVMValueRef _string -> LLVMValueRef)) -(define-llvm LLVMBuildShuffleVector +(define-llvm-unsafe LLVMBuildShuffleVector (_fun LLVMBuilderRef LLVMValueRef LLVMValueRef LLVMValueRef _string -> LLVMValueRef)) -(define-llvm LLVMBuildExtractValue +(define-llvm-unsafe LLVMBuildExtractValue (_fun LLVMBuilderRef LLVMValueRef _uint _string -> LLVMValueRef)) -(define-llvm LLVMBuildInsertValue +(define-llvm-unsafe LLVMBuildInsertValue (_fun LLVMBuilderRef LLVMValueRef LLVMValueRef _uint _string -> LLVMValueRef)) -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMBuildIsNull LLVMBuildIsNotNull) (_fun LLVMBuilderRef LLVMValueRef _string -> LLVMValueRef)) -(define-llvm LLVMBuildPtrDiff (_fun LLVMBuilderRef LLVMValueRef LLVMValueRef _string -> LLVMValueRef)) +(define-llvm-unsafe LLVMBuildPtrDiff (_fun LLVMBuilderRef LLVMValueRef LLVMValueRef _string -> LLVMValueRef)) diff --git a/private/ffi/misc-operations.rkt b/private/ffi/misc-operations.rkt index 59d4cfe..1c41eb8 100644 --- a/private/ffi/misc-operations.rkt +++ b/private/ffi/misc-operations.rkt @@ -84,16 +84,16 @@ macro(VAArgInst) |# ;/* Operations on all values */ -(define-llvm LLVMTypeOf (_fun LLVMValueRef -> LLVMTypeRef)) -(define-llvm LLVMGetValueName (_fun LLVMValueRef -> _string)) +(define-llvm-unsafe LLVMTypeOf (_fun LLVMValueRef -> LLVMTypeRef)) +(define-llvm-unsafe LLVMGetValueName (_fun LLVMValueRef -> _string)) -(define-llvm LLVMSetValueName (_fun LLVMValueRef _string -> _void)) +(define-llvm-unsafe LLVMSetValueName (_fun LLVMValueRef _string -> _void)) -(define-llvm LLVMDumpValue (_fun LLVMValueRef -> _void)) -(define-llvm LLVMReplaceAllUsesWith (_fun LLVMValueRef LLVMValueRef -> _void)) -(define-llvm LLVMHasMetadata (_fun LLVMValueRef -> _int)) -(define-llvm LLVMGetMetadata (_fun LLVMValueRef _uint -> LLVMValueRef)) -(define-llvm LLVMSetMetadata (_fun LLVMValueRef _uint LLVMValueRef -> _void)) +(define-llvm-unsafe LLVMDumpValue (_fun LLVMValueRef -> _void)) +(define-llvm-unsafe LLVMReplaceAllUsesWith (_fun LLVMValueRef LLVMValueRef -> _void)) +(define-llvm-unsafe LLVMHasMetadata (_fun LLVMValueRef -> _int)) +(define-llvm-unsafe LLVMGetMetadata (_fun LLVMValueRef _uint -> LLVMValueRef)) +(define-llvm-unsafe LLVMSetMetadata (_fun LLVMValueRef _uint LLVMValueRef -> _void)) ;/* Conversion functions. Return the input value if it is an instance of the @@ -105,19 +105,19 @@ LLVM_FOR_EACH_VALUE_SUBCLASS(LLVM_DECLARE_VALUE_CAST) |# ;/* Operations on Uses */ -(define-llvm LLVMGetFirstUse (_fun LLVMValueRef -> LLVMUseRef)) -(define-llvm LLVMGetNextUse (_fun LLVMUseRef -> LLVMUseRef)) -(define-llvm-multiple +(define-llvm-unsafe LLVMGetFirstUse (_fun LLVMValueRef -> LLVMUseRef)) +(define-llvm-unsafe LLVMGetNextUse (_fun LLVMUseRef -> LLVMUseRef)) +(define-llvm-multiple-unsafe (LLVMGetUser LLVMGetUsedValue) (_fun LLVMUseRef -> LLVMValueRef)) ;/* Operations on Users */ -(define-llvm LLVMGetOperand (_fun LLVMValueRef _uint -> LLVMValueRef)) -(define-llvm LLVMSetOperand (_fun LLVMValueRef _uint LLVMValueRef -> _void)) -(define-llvm LLVMGetNumOperands (_fun LLVMValueRef -> _int)) +(define-llvm-unsafe LLVMGetOperand (_fun LLVMValueRef _uint -> LLVMValueRef)) +(define-llvm-unsafe LLVMSetOperand (_fun LLVMValueRef _uint LLVMValueRef -> _void)) +(define-llvm-unsafe LLVMGetNumOperands (_fun LLVMValueRef -> _int)) -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMIsConstant LLVMIsNull LLVMIsUndef) @@ -125,13 +125,13 @@ LLVM_FOR_EACH_VALUE_SUBCLASS(LLVM_DECLARE_VALUE_CAST) ;/* Operations on metadata */ -(define-llvm LLVMMDStringInContext +(define-llvm-unsafe LLVMMDStringInContext (_fun LLVMContextRef _string _uint -> LLVMValueRef)) -(define-llvm LLVMMDString +(define-llvm-unsafe LLVMMDString (_fun _string _uint -> LLVMValueRef)) -(define-llvm LLVMMDNodeInContext +(define-llvm-unsafe LLVMMDNodeInContext (_fun LLVMContextRef LLVMValueRef _uint -> LLVMValueRef)) -(define-llvm LLVMMDNode +(define-llvm-unsafe LLVMMDNode (_fun LLVMValueRef _uint -> LLVMValueRef)) diff --git a/private/ffi/module-io.rkt b/private/ffi/module-io.rkt index 8605083..19a267b 100644 --- a/private/ffi/module-io.rkt +++ b/private/ffi/module-io.rkt @@ -11,15 +11,15 @@ ;/*===-- Operations on modules ---------------------------------------------===*/ ;/** Writes a module to the specified path. Returns 0 on success. */ -(define-llvm LLVMWriteBitcodeToFile (_fun LLVMModuleRef _string -> _int)) +(define-llvm-unsafe LLVMWriteBitcodeToFile (_fun LLVMModuleRef _string -> _int)) ;/** Writes a module to an open file descriptor. Returns 0 on success. */ -(define-llvm LLVMWriteBitcodeToFD (_fun LLVMModuleRef _int _bool _bool -> _int)) +(define-llvm-unsafe LLVMWriteBitcodeToFD (_fun LLVMModuleRef _int _bool _bool -> _int)) ;/* Builds a module from the bitcode in the specified memory buffer, returning a ; reference to the module via the OutModule parameter. Returns 0 on success. ; Optionally returns a human-readable error message via OutMessage. */ -(define-llvm LLVMParseBitcode +(define-llvm-unsafe LLVMParseBitcode (_fun (buffer) :: (buffer : LLVMMemoryBufferRef) (module : (_ptr o LLVMModuleRef)) @@ -29,7 +29,7 @@ -> (if err message module))) -(define-llvm LLVMParseBitcodeInContext +(define-llvm-unsafe LLVMParseBitcodeInContext (_fun (context buffer) :: (context : LLVMContextRef) (buffer : LLVMMemoryBufferRef) @@ -40,7 +40,7 @@ -> (if err message module))) -(define-llvm LLVMGetBitcodeModule +(define-llvm-unsafe LLVMGetBitcodeModule (_fun (buffer) :: (buffer : LLVMMemoryBufferRef) (module : (_ptr o LLVMModuleRef)) @@ -50,7 +50,7 @@ -> (if err message module))) -(define-llvm LLVMGetBitcodeModuleInContext +(define-llvm-unsafe LLVMGetBitcodeModuleInContext (_fun (context buffer) :: (context : LLVMContextRef) (buffer : LLVMMemoryBufferRef) diff --git a/private/ffi/modules.rkt b/private/ffi/modules.rkt index d22524c..45ba682 100644 --- a/private/ffi/modules.rkt +++ b/private/ffi/modules.rkt @@ -13,49 +13,49 @@ ;/* Create and destroy contexts. */ -(define-llvm LLVMContextCreate (_fun -> LLVMContextRef)) +(define-llvm-unsafe LLVMContextCreate (_fun -> LLVMContextRef)) (define-llvm-safe LLVMContextCreate safe:LLVMContextCreator) -(define-llvm LLVMGetGlobalContext (_fun -> LLVMContextRef)) -(define-llvm LLVMContextDispose (_fun LLVMContextRef -> _void)) +(define-llvm-unsafe LLVMGetGlobalContext (_fun -> LLVMContextRef)) +(define-llvm-unsafe LLVMContextDispose (_fun LLVMContextRef -> _void)) -(define-llvm LLVMGetMDKindIDInContext (_fun LLVMContextRef _string _uint -> _uint)) +(define-llvm-unsafe LLVMGetMDKindIDInContext (_fun LLVMContextRef _string _uint -> _uint)) -(define-llvm LLVMGetMDKindID (_fun _string _uint -> _uint)) +(define-llvm-unsafe LLVMGetMDKindID (_fun _string _uint -> _uint)) ;/*===-- Modules -----------------------------------------------------------===*/ ;/* Create and destroy modules. */ ;/** See llvm::Module::Module. */ -(define-llvm LLVMModuleCreateWithName (_fun _string -> LLVMModuleRef)) -(define-llvm LLVMModuleCreateWithNameInContext (_fun _string LLVMContextRef -> LLVMModuleRef)) +(define-llvm-unsafe LLVMModuleCreateWithName (_fun _string -> LLVMModuleRef)) +(define-llvm-unsafe LLVMModuleCreateWithNameInContext (_fun _string LLVMContextRef -> LLVMModuleRef)) (define-llvm-safe LLVMModuleCreateWithNameInContext safe:LLVMModuleCreator) ;/** See llvm::Module::~Module. */ -(define-llvm LLVMDisposeModule (_fun LLVMModuleRef -> _void)) +(define-llvm-unsafe LLVMDisposeModule (_fun LLVMModuleRef -> _void)) ;/** Data layout. See Module::getDataLayout. */ -(define-llvm LLVMGetDataLayout (_fun LLVMModuleRef -> _string)) -(define-llvm LLVMSetDataLayout (_fun LLVMModuleRef _string -> _void)) +(define-llvm-unsafe LLVMGetDataLayout (_fun LLVMModuleRef -> _string)) +(define-llvm-unsafe LLVMSetDataLayout (_fun LLVMModuleRef _string -> _void)) ;/** Target triple. See Module::getTargetTriple. */ -(define-llvm LLVMGetTarget (_fun LLVMModuleRef -> _string)) -(define-llvm LLVMSetTarget (_fun LLVMModuleRef _string -> _void)) +(define-llvm-unsafe LLVMGetTarget (_fun LLVMModuleRef -> _string)) +(define-llvm-unsafe LLVMSetTarget (_fun LLVMModuleRef _string -> _void)) ;/** See Module::dump. */ -(define-llvm LLVMDumpModule (_fun LLVMModuleRef -> _void)) +(define-llvm-unsafe LLVMDumpModule (_fun LLVMModuleRef -> _void)) ;/** See Module::setModuleInlineAsm. */ -(define-llvm LLVMSetModuleInlineAsm (_fun LLVMModuleRef _string -> _void)) +(define-llvm-unsafe LLVMSetModuleInlineAsm (_fun LLVMModuleRef _string -> _void)) ;/** See Module::getContext. */ -(define-llvm LLVMGetModuleContext (_fun LLVMModuleRef -> LLVMContextRef)) +(define-llvm-unsafe LLVMGetModuleContext (_fun LLVMModuleRef -> LLVMContextRef)) diff --git a/private/ffi/passes.rkt b/private/ffi/passes.rkt index 25e2cec..af462ec 100644 --- a/private/ffi/passes.rkt +++ b/private/ffi/passes.rkt @@ -14,7 +14,7 @@ ;/** Return the global pass registry, for use with initialization functions. ; See llvm::PassRegistry::getPassRegistry. */ -(define-llvm LLVMGetGlobalPassRegistry +(define-llvm-unsafe LLVMGetGlobalPassRegistry (_fun -> LLVMPassRegistryRef)) @@ -23,40 +23,40 @@ ;/** Constructs a new whole-module pass pipeline. This type of pipeline is ; suitable for link-time optimization and whole-module transformations. ; See llvm::PassManager::PassManager. */ -(define-llvm LLVMCreatePassManager (_fun -> LLVMPassManagerRef)) +(define-llvm-unsafe LLVMCreatePassManager (_fun -> LLVMPassManagerRef)) ;/** Constructs a new function-by-function pass pipeline over the module ; provider. It does not take ownership of the module provider. This type of ; pipeline is suitable for code generation and JIT compilation tasks. ; See llvm::FunctionPassManager::FunctionPassManager. */ -(define-llvm LLVMCreateFunctionPassManagerForModule (_fun LLVMModuleRef -> LLVMPassManagerRef)) +(define-llvm-unsafe LLVMCreateFunctionPassManagerForModule (_fun LLVMModuleRef -> LLVMPassManagerRef)) ;/** Initializes, executes on the provided module, and finalizes all of the ; passes scheduled in the pass manager. Returns 1 if any of the passes ; modified the module, 0 otherwise. See llvm::PassManager::run(Module&). */ -(define-llvm LLVMRunPassManager (_fun LLVMPassManagerRef LLVMModuleRef -> LLVMBool)) +(define-llvm-unsafe LLVMRunPassManager (_fun LLVMPassManagerRef LLVMModuleRef -> LLVMBool)) ;/** Initializes all of the function passes scheduled in the function pass ; manager. Returns 1 if any of the passes modified the module, 0 otherwise. ; See llvm::FunctionPassManager::doInitialization. */ -(define-llvm LLVMInitializeFunctionPassManager (_fun LLVMPassManagerRef -> LLVMBool)) +(define-llvm-unsafe LLVMInitializeFunctionPassManager (_fun LLVMPassManagerRef -> LLVMBool)) ;/** Executes all of the function passes scheduled in the function pass manager ; on the provided function. Returns 1 if any of the passes modified the ; function, false otherwise. ; See llvm::FunctionPassManager::run(Function&). */ -(define-llvm LLVMRunFunctionPassManager (_fun LLVMPassManagerRef LLVMValueRef -> LLVMBool)) +(define-llvm-unsafe LLVMRunFunctionPassManager (_fun LLVMPassManagerRef LLVMValueRef -> LLVMBool)) ;/** Finalizes all of the function passes scheduled in in the function pass ; manager. Returns 1 if any of the passes modified the module, 0 otherwise. ; See llvm::FunctionPassManager::doFinalization. */ -(define-llvm LLVMFinalizeFunctionPassManager (_fun LLVMPassManagerRef -> LLVMBool)) +(define-llvm-unsafe LLVMFinalizeFunctionPassManager (_fun LLVMPassManagerRef -> LLVMBool)) ;/** Frees the memory of a pass pipeline. For function pipelines, does not free ; the module provider. ; See llvm::PassManagerBase::~PassManagerBase. */ -(define-llvm LLVMDisposePassManager (_fun LLVMPassManagerRef -> _void)) +(define-llvm-unsafe LLVMDisposePassManager (_fun LLVMPassManagerRef -> _void)) ;Analysis @@ -70,7 +70,7 @@ ; Optionally returns a human-readable description of any invalid constructs. ; OutMessage must be disposed with LLVMDisposeMessage. */ -(define-llvm LLVMVerifyModule +(define-llvm-unsafe LLVMVerifyModule (_fun (module action) :: (module : LLVMModuleRef) (action : LLVMVerifierFailureAction) @@ -82,14 +82,14 @@ ;/* Verifies that a single function is valid, taking the specified action. Useful ; for debugging. */ -(define-llvm LLVMVerifyFunction (_fun LLVMValueRef LLVMVerifierFailureAction -> LLVMBool)) +(define-llvm-unsafe LLVMVerifyFunction (_fun LLVMValueRef LLVMVerifierFailureAction -> LLVMBool)) ;/* Open up a ghostview window that displays the CFG of the current function. ; Useful for debugging. */ -(define-llvm LLVMViewFunctionCFG (_fun LLVMValueRef -> _void)) -(define-llvm LLVMViewFunctionCFGOnly (_fun LLVMValueRef -> _void)) +(define-llvm-unsafe LLVMViewFunctionCFG (_fun LLVMValueRef -> _void)) +(define-llvm-unsafe LLVMViewFunctionCFGOnly (_fun LLVMValueRef -> _void)) -(define-llvm LLVMInitializeCore (_fun LLVMPassRegistryRef -> _void)) +(define-llvm-unsafe LLVMInitializeCore (_fun LLVMPassRegistryRef -> _void)) diff --git a/private/ffi/racket-ext.rkt b/private/ffi/racket-ext.rkt index 06aebd6..5d1d3fa 100644 --- a/private/ffi/racket-ext.rkt +++ b/private/ffi/racket-ext.rkt @@ -12,15 +12,15 @@ ;Racket added functions ; -(define-llvm-racket LLVMGetModuleDescription unsafe:LLVMModuleDescriptionMaker) -(define-llvm-racket LLVMIsValidTypeIndex (_fun LLVMTypeRef LLVMValueRef -> LLVMBool)) -(define-llvm-racket LLVMGetTypeAtIndex (_fun LLVMTypeRef LLVMValueRef -> LLVMTypeRef)) -(define-llvm-racket LLVMIsTerminatorInstruction (_fun LLVMValueRef -> LLVMBool)) +(define-llvm-racket-unsafe LLVMGetModuleDescription unsafe:LLVMModuleDescriptionMaker) +(define-llvm-racket-unsafe LLVMIsValidTypeIndex (_fun LLVMTypeRef LLVMValueRef -> LLVMBool)) +(define-llvm-racket-unsafe LLVMGetTypeAtIndex (_fun LLVMTypeRef LLVMValueRef -> LLVMTypeRef)) +(define-llvm-racket-unsafe LLVMIsTerminatorInstruction (_fun LLVMValueRef -> LLVMBool)) -(define-llvm-racket-safe LLVMGetModuleDescription safe:LLVMModuleDescriptionMaker) -(define-llvm-racket-safe LLVMIsValidTypeIndex (_fun safe:LLVMTypeRef safe:LLVMValueRef -> LLVMBool)) +;(define-llvm-racket-safe LLVMGetModuleDescription safe:LLVMModuleDescriptionMaker) +;(define-llvm-racket-safe LLVMIsValidTypeIndex (_fun safe:LLVMTypeRef safe:LLVMValueRef -> LLVMBool)) ;(define-llvm-racket-safe LLVMGetTypeAtIndex (_fun LLVMTypeRef LLVMValueRef -> LLVMTypeRef)) -(define-llvm-racket-safe LLVMIsTerminatorInstruction (_fun safe:LLVMValueRef -> LLVMBool)) +;(define-llvm-racket-safe LLVMIsTerminatorInstruction (_fun safe:LLVMValueRef -> LLVMBool)) diff --git a/private/ffi/runtime.rkt b/private/ffi/runtime.rkt index c4fef24..218c09d 100644 --- a/private/ffi/runtime.rkt +++ b/private/ffi/runtime.rkt @@ -11,45 +11,45 @@ ;Execution Engine -(define-llvm-multiple (LLVMLinkInJIT LLVMLinkInInterpreter) (_fun -> _void)) +(define-llvm-multiple-unsafe (LLVMLinkInJIT LLVMLinkInInterpreter) (_fun -> _void)) (define LLVMGenericValueRef _pointer) (define LLVMExecutionEngineRef _pointer) ;/*===-- Operations on generic values --------------------------------------===*/ -(define-llvm LLVMCreateGenericValueOfInt +(define-llvm-unsafe LLVMCreateGenericValueOfInt (_fun LLVMTypeRef _ulong LLVMBool -> LLVMGenericValueRef)) -(define-llvm LLVMCreateGenericValueOfPointer +(define-llvm-unsafe LLVMCreateGenericValueOfPointer (_fun _pointer -> LLVMGenericValueRef)) (define (LLVMCreateGenericValueOfFunctionType fun-type) (get-ffi-obj 'LLVMCreateGenericValueOfPointer llvm-lib (_fun fun-type -> LLVMGenericValueRef))) -(define-llvm LLVMCreateGenericValueOfFloat +(define-llvm-unsafe LLVMCreateGenericValueOfFloat (_fun LLVMTypeRef _double* -> LLVMGenericValueRef)) -(define-llvm LLVMGenericValueIntWidth +(define-llvm-unsafe LLVMGenericValueIntWidth (_fun LLVMGenericValueRef -> _uint)) -(define-llvm LLVMGenericValueToInt +(define-llvm-unsafe LLVMGenericValueToInt (_fun LLVMGenericValueRef LLVMBool -> _long)) -(define-llvm LLVMGenericValueToPointer +(define-llvm-unsafe LLVMGenericValueToPointer (_fun LLVMGenericValueRef -> _pointer)) -(define-llvm LLVMGenericValueToFloat +(define-llvm-unsafe LLVMGenericValueToFloat (_fun LLVMTypeRef LLVMGenericValueRef -> _double*)) -(define-llvm LLVMDisposeGenericValue +(define-llvm-unsafe LLVMDisposeGenericValue (_fun LLVMGenericValueRef -> _void)) ;/*===-- Operations on execution engines -----------------------------------===*/ -(define-llvm LLVMCreateExecutionEngineForModule +(define-llvm-unsafe LLVMCreateExecutionEngineForModule (_fun (module) :: (execution-engine : (_ptr o LLVMExecutionEngineRef)) (module : LLVMModuleRef) @@ -59,7 +59,7 @@ -> (if err message execution-engine))) -(define-llvm LLVMCreateInterpreterForModule +(define-llvm-unsafe LLVMCreateInterpreterForModule (_fun (module) :: (execution-engine : (_ptr o LLVMExecutionEngineRef)) (module : LLVMModuleRef) @@ -69,7 +69,7 @@ -> (if err message execution-engine))) -(define-llvm LLVMCreateJITCompilerForModule +(define-llvm-unsafe LLVMCreateJITCompilerForModule (_fun (module opt) :: (execution-engine : (_ptr o LLVMExecutionEngineRef)) (module : LLVMModuleRef) @@ -80,7 +80,7 @@ -> (if err message execution-engine))) -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMDisposeExecutionEngine LLVMRunStaticConstructors LLVMRunStaticDestructors) @@ -88,7 +88,7 @@ ;TODO support env -(define-llvm LLVMRunFunctionAsMain +(define-llvm-unsafe LLVMRunFunctionAsMain (_fun (ee fun args) :: (ee : LLVMExecutionEngineRef) (fun : LLVMValueRef) @@ -99,7 +99,7 @@ _sint)) -(define-llvm LLVMRunFunction +(define-llvm-unsafe LLVMRunFunction (_fun (engine function args) :: (engine : LLVMExecutionEngineRef) (function : LLVMValueRef) @@ -109,12 +109,12 @@ LLVMGenericValueRef)) -(define-llvm LLVMAddModule (_fun LLVMExecutionEngineRef LLVMModuleRef -> _void)) +(define-llvm-unsafe LLVMAddModule (_fun LLVMExecutionEngineRef LLVMModuleRef -> _void)) -(define-llvm LLVMFreeMachineCodeForFunction +(define-llvm-unsafe LLVMFreeMachineCodeForFunction (_fun LLVMExecutionEngineRef LLVMValueRef -> _void)) -(define-llvm LLVMRemoveModule +(define-llvm-unsafe LLVMRemoveModule (_fun (ee module) :: (ee : LLVMExecutionEngineRef) (module : LLVMModuleRef) @@ -125,7 +125,7 @@ -> (if err message outmod))) -(define-llvm LLVMFindFunction +(define-llvm-unsafe LLVMFindFunction (_fun (ee name) :: (ee : LLVMExecutionEngineRef) (name : _string) @@ -134,19 +134,20 @@ -> (if err #f outfun))) -(define-llvm LLVMRecompileAndRelinkFunction +(define-llvm-unsafe LLVMRecompileAndRelinkFunction (_fun LLVMExecutionEngineRef LLVMValueRef -> _pointer)) -(define-llvm LLVMGetExecutionEngineTargetData +(define-llvm-unsafe LLVMGetExecutionEngineTargetData (_fun LLVMExecutionEngineRef -> LLVMTargetDataRef)) -(define-llvm LLVMAddGlobalMapping +(define-llvm-unsafe LLVMAddGlobalMapping (_fun LLVMExecutionEngineRef LLVMValueRef _pointer -> _void)) -(llvm-unsafe-context - (define (LLVMAddGlobalMappingForFunction fun-type) - (get-ffi-obj 'LLVMAddGlobalMapping llvm-lib - (_fun LLVMExecutionEngineRef LLVMValueRef fun-type -> LLVMGenericValueRef)))) +;TODO fix this +#; +(define (LLVMAddGlobalMappingForFunction fun-type) + (get-ffi-obj 'LLVMAddGlobalMapping llvm-lib + (_fun LLVMExecutionEngineRef LLVMValueRef fun-type -> LLVMGenericValueRef))) -(define-llvm LLVMGetPointerToGlobal +(define-llvm-unsafe LLVMGetPointerToGlobal (_fun LLVMExecutionEngineRef LLVMValueRef -> _pointer)) diff --git a/private/ffi/terminators.rkt b/private/ffi/terminators.rkt index b06488c..b202bd1 100644 --- a/private/ffi/terminators.rkt +++ b/private/ffi/terminators.rkt @@ -9,9 +9,9 @@ (provide (all-defined-out)) ;/* Terminators */ -(define-llvm LLVMBuildRetVoid (_fun LLVMBuilderRef -> LLVMValueRef)) -(define-llvm LLVMBuildRet (_fun LLVMBuilderRef LLVMValueRef -> LLVMValueRef)) -(define-llvm LLVMBuildAggregateRet +(define-llvm-unsafe LLVMBuildRetVoid (_fun LLVMBuilderRef -> LLVMValueRef)) +(define-llvm-unsafe LLVMBuildRet (_fun LLVMBuilderRef LLVMValueRef -> LLVMValueRef)) +(define-llvm-unsafe LLVMBuildAggregateRet (_fun (builder vals) :: (builder : LLVMBuilderRef) (vals : (_list i LLVMValueRef)) @@ -19,22 +19,22 @@ -> LLVMValueRef)) -(define-llvm LLVMBuildBr (_fun LLVMBuilderRef LLVMBasicBlockRef -> LLVMValueRef)) +(define-llvm-unsafe LLVMBuildBr (_fun LLVMBuilderRef LLVMBasicBlockRef -> LLVMValueRef)) -(define-llvm LLVMBuildCondBr +(define-llvm-unsafe LLVMBuildCondBr (_fun LLVMBuilderRef LLVMValueRef LLVMBasicBlockRef LLVMBasicBlockRef -> LLVMValueRef)) -(define-llvm LLVMBuildSwitch +(define-llvm-unsafe LLVMBuildSwitch (_fun LLVMBuilderRef LLVMValueRef LLVMBasicBlockRef _uint -> LLVMValueRef)) -(define-llvm LLVMAddCase (_fun LLVMValueRef LLVMValueRef LLVMBasicBlockRef -> _void)) +(define-llvm-unsafe LLVMAddCase (_fun LLVMValueRef LLVMValueRef LLVMBasicBlockRef -> _void)) -(define-llvm LLVMBuildIndirectBr (_fun LLVMBuilderRef LLVMValueRef _uint -> LLVMValueRef)) -(define-llvm LLVMBuildInvoke +(define-llvm-unsafe LLVMBuildIndirectBr (_fun LLVMBuilderRef LLVMValueRef _uint -> LLVMValueRef)) +(define-llvm-unsafe LLVMBuildInvoke (_fun (builder fun args then catch name) :: (builder : LLVMBuilderRef) (fun : LLVMValueRef) @@ -46,21 +46,21 @@ -> LLVMValueRef)) -(define-llvm LLVMBuildLandingPad +(define-llvm-unsafe LLVMBuildLandingPad (_fun LLVMBuilderRef LLVMTypeRef LLVMValueRef _uint _string -> _void)) -(define-llvm LLVMBuildResume +(define-llvm-unsafe LLVMBuildResume (_fun LLVMBuilderRef LLVMValueRef -> LLVMValueRef)) -(define-llvm LLVMBuildUnreachable +(define-llvm-unsafe LLVMBuildUnreachable (_fun LLVMBuilderRef -> LLVMValueRef)) ;/* Add a destination to the indirectbr instruction */ -(define-llvm LLVMAddDestination (_fun LLVMValueRef LLVMBasicBlockRef -> _void)) +(define-llvm-unsafe LLVMAddDestination (_fun LLVMValueRef LLVMBasicBlockRef -> _void)) -(define-llvm LLVMAddClause (_fun LLVMValueRef LLVMValueRef -> _void)) -(define-llvm LLVMSetCleanup (_fun LLVMValueRef LLVMBool -> _void)) +(define-llvm-unsafe LLVMAddClause (_fun LLVMValueRef LLVMValueRef -> _void)) +(define-llvm-unsafe LLVMSetCleanup (_fun LLVMValueRef LLVMBool -> _void)) diff --git a/private/ffi/types.rkt b/private/ffi/types.rkt index 57a15f8..7273010 100644 --- a/private/ffi/types.rkt +++ b/private/ffi/types.rkt @@ -25,41 +25,41 @@ ; */ ;/** See llvm::LLVMTypeKind::getTypeID. */ -(define-llvm-both LLVMGetTypeKind (_fun LLVMTypeRef -> LLVMTypeKind)) +(define-llvm-unsafe LLVMGetTypeKind (_fun LLVMTypeRef -> LLVMTypeKind)) ;/** See llvm::LLVMType::getContext. */ -(define-llvm LLVMGetTypeContext (_fun LLVMTypeRef -> LLVMContextRef)) +(define-llvm-unsafe LLVMGetTypeContext (_fun LLVMTypeRef -> LLVMContextRef)) ;/* Operations on integer types */ -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMInt1TypeInContext LLVMInt8TypeInContext LLVMInt16TypeInContext LLVMInt32TypeInContext LLVMInt64TypeInContext) (_fun LLVMContextRef -> LLVMTypeRef)) -(define-llvm LLVMIntTypeInContext (_fun LLVMContextRef _uint -> LLVMTypeRef)) +(define-llvm-unsafe LLVMIntTypeInContext (_fun LLVMContextRef _uint -> LLVMTypeRef)) -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMInt1Type LLVMInt8Type LLVMInt16Type LLVMInt32Type LLVMInt64Type) (_fun -> LLVMTypeRef)) -(define-llvm LLVMIntType (_fun _uint -> LLVMTypeRef)) +(define-llvm-unsafe LLVMIntType (_fun _uint -> LLVMTypeRef)) -(define-llvm LLVMGetIntTypeWidth (_fun LLVMTypeRef -> _uint)) +(define-llvm-unsafe LLVMGetIntTypeWidth (_fun LLVMTypeRef -> _uint)) ;/* Operations on real types */ -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMFloatTypeInContext LLVMDoubleTypeInContext LLVMX86FP80TypeInContext LLVMFP128TypeInContext LLVMPPCFP128TypeInContext) (_fun LLVMContextRef -> LLVMTypeRef)) -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMFloatType LLVMDoubleType LLVMX86FP80Type @@ -67,7 +67,7 @@ LLVMPPCFP128Type) (_fun -> LLVMTypeRef)) ;/* Operations on function types */ -(define-llvm LLVMFunctionType +(define-llvm-unsafe LLVMFunctionType (_fun (ret-type arg-types varargs) :: (ret-type : LLVMTypeRef) (arg-types : (_list i LLVMTypeRef)) @@ -76,13 +76,13 @@ -> LLVMTypeRef)) -(define-llvm LLVMIsFunctionVarArg (_fun LLVMTypeRef -> LLVMBool)) -(define-llvm LLVMGetReturnType (_fun LLVMTypeRef -> LLVMTypeRef)) -(define-llvm LLVMCountParamTypes (_fun LLVMTypeRef -> _uint)) -(define-llvm LLVMGetParamTypes (_fun LLVMTypeRef _pointer -> _void)) +(define-llvm-unsafe LLVMIsFunctionVarArg (_fun LLVMTypeRef -> LLVMBool)) +(define-llvm-unsafe LLVMGetReturnType (_fun LLVMTypeRef -> LLVMTypeRef)) +(define-llvm-unsafe LLVMCountParamTypes (_fun LLVMTypeRef -> _uint)) +(define-llvm-unsafe LLVMGetParamTypes (_fun LLVMTypeRef _pointer -> _void)) ;/* Operations on struct types */ -(define-llvm LLVMStructTypeInContext +(define-llvm-unsafe LLVMStructTypeInContext (_fun (context types packed) :: (context : LLVMContextRef) (types : (_list i LLVMTypeRef)) @@ -90,7 +90,7 @@ (packed : LLVMBool) -> LLVMTypeRef)) -(define-llvm LLVMStructType +(define-llvm-unsafe LLVMStructType (_fun (types packed) :: (types : (_list i LLVMTypeRef)) (_uint = (length types)) @@ -98,9 +98,9 @@ -> LLVMTypeRef)) -(define-llvm LLVMStructCreateNamed (_fun LLVMContextRef _string -> LLVMTypeRef)) +(define-llvm-unsafe LLVMStructCreateNamed (_fun LLVMContextRef _string -> LLVMTypeRef)) -(define-llvm LLVMStructSetBody +(define-llvm-unsafe LLVMStructSetBody (_fun (type types packed) :: (type : LLVMTypeRef) (types : (_list i LLVMTypeRef)) @@ -109,29 +109,29 @@ -> _void)) -(define-llvm LLVMCountStructElementTypes (_fun LLVMTypeRef -> _uint)) +(define-llvm-unsafe LLVMCountStructElementTypes (_fun LLVMTypeRef -> _uint)) -(define-llvm LLVMGetStructElementTypes +(define-llvm-unsafe LLVMGetStructElementTypes (_fun (type) :: (type : LLVMTypeRef) - (types : (_list o LLVMTypeRef (LLVMCountStructElementTypes type))) + (types : (_list o LLVMTypeRef (unsafe:LLVMCountStructElementTypes type))) -> _void -> types)) -(define-llvm LLVMIsPackedStruct (_fun LLVMTypeRef -> LLVMBool)) -(define-llvm LLVMIsOpaqueStruct (_fun LLVMTypeRef -> LLVMBool)) +(define-llvm-unsafe LLVMIsPackedStruct (_fun LLVMTypeRef -> LLVMBool)) +(define-llvm-unsafe LLVMIsOpaqueStruct (_fun LLVMTypeRef -> LLVMBool)) -(define-llvm LLVMGetTypeByName (_fun LLVMModuleRef _string -> LLVMTypeRef)) +(define-llvm-unsafe LLVMGetTypeByName (_fun LLVMModuleRef _string -> LLVMTypeRef)) ;/* Operations on array, pointer, and vector types (sequence types) */ -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMArrayType LLVMPointerType LLVMVectorType) (_fun LLVMTypeRef _uint -> LLVMTypeRef)) -(define-llvm LLVMGetElementType (_fun LLVMTypeRef -> LLVMTypeRef)) +(define-llvm-unsafe LLVMGetElementType (_fun LLVMTypeRef -> LLVMTypeRef)) -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMGetArrayLength LLVMGetPointerAddressSpace LLVMGetVectorSize) (_fun LLVMTypeRef -> _uint)) @@ -139,12 +139,12 @@ ;/* Operations on other types */ -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMVoidTypeInContext LLVMLabelTypeInContext LLVMX86MMXTypeInContext) (_fun LLVMContextRef -> LLVMTypeRef)) -(define-llvm-multiple +(define-llvm-multiple-unsafe (LLVMVoidType LLVMLabelType LLVMX86MMXType) (_fun -> LLVMTypeRef)) diff --git a/private/ffi/unsafe.rkt b/private/ffi/unsafe.rkt new file mode 100644 index 0000000..fbe94ab --- /dev/null +++ b/private/ffi/unsafe.rkt @@ -0,0 +1,12 @@ +#lang racket/base + +(require racket/require + (for-syntax racket/base)) +(require (filtered-in + (lambda (name) + (cond + ((regexp-match #rx"^unsafe:(.*)$" name) => cadr) + (else #f))) + "all.rkt")) + +(provide (all-from-out "all.rkt")) diff --git a/private/simple/all.rkt b/private/simple/all.rkt index 462ba42..6edff29 100644 --- a/private/simple/all.rkt +++ b/private/simple/all.rkt @@ -1,7 +1,7 @@ #lang racket (require - "../ffi/all.rkt" + "../ffi/unsafe.rkt" "../unsafe/structs.rkt" "base.rkt" "binop.rkt" diff --git a/private/simple/base.rkt b/private/simple/base.rkt index 8896964..da35cd6 100644 --- a/private/simple/base.rkt +++ b/private/simple/base.rkt @@ -5,7 +5,7 @@ racket/list (except-in ffi/unsafe ->) "../unsafe/structs.rkt" - "../ffi/all.rkt") + "../ffi/unsafe.rkt") diff --git a/private/simple/binop.rkt b/private/simple/binop.rkt index f0ff1e0..8a81a6b 100644 --- a/private/simple/binop.rkt +++ b/private/simple/binop.rkt @@ -4,7 +4,7 @@ (require "../unsafe/structs.rkt" - "../ffi/arithmetic.rkt" + "../ffi/unsafe.rkt" "base.rkt") (require racket/contract) diff --git a/private/simple/cast.rkt b/private/simple/cast.rkt index 1a87cca..8dad8cd 100644 --- a/private/simple/cast.rkt +++ b/private/simple/cast.rkt @@ -3,7 +3,7 @@ (require racket/contract "../unsafe/structs.rkt" - "../ffi/all.rkt" + "../ffi/unsafe.rkt" "base.rkt") (provide/contract diff --git a/private/simple/comparison.rkt b/private/simple/comparison.rkt index 8d5f045..105d1a9 100644 --- a/private/simple/comparison.rkt +++ b/private/simple/comparison.rkt @@ -3,7 +3,7 @@ (require racket/contract) (require "../unsafe/structs.rkt" - "../ffi/all.rkt" + "../ffi/unsafe.rkt" "base.rkt") diff --git a/private/simple/memory.rkt b/private/simple/memory.rkt index dc99c9a..4a512e1 100644 --- a/private/simple/memory.rkt +++ b/private/simple/memory.rkt @@ -4,7 +4,7 @@ (require "../unsafe/structs.rkt" - "../ffi/all.rkt" + "../ffi/unsafe.rkt" "base.rkt") (define load/c diff --git a/simple.rkt b/simple.rkt index f8b23e3..d2959ed 100644 --- a/simple.rkt +++ b/simple.rkt @@ -5,5 +5,5 @@ (provide (all-from-out "private/simple/all.rkt" - "privete/unsafe/structs.rkt")) + "private/unsafe/structs.rkt")) diff --git a/unsafe.rkt b/unsafe.rkt index 5062fa5..aa7d173 100644 --- a/unsafe.rkt +++ b/unsafe.rkt @@ -1,9 +1,9 @@ #lang racket/base -(require "private/ffi/all.rkt") +(require "private/ffi/unsafe.rkt") (require "private/unsafe/structs.rkt") (provide (all-from-out - "private/ffi/all.rkt" - "privete/unsafe/structs.rkt")) + "private/ffi/unsafe.rkt" + "private/unsafe/structs.rkt"))