bindings/ada/llvm/llvm_wrap.cxx

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 1.3.36
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11
  12 #ifdef __cplusplus
  13 template<typename T> class SwigValueWrapper {
  14     T *tt;
  15 public:
  16     SwigValueWrapper() : tt(0) { }
  17     SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
  18     SwigValueWrapper(const T& t) : tt(new T(t)) { }
  19     ~SwigValueWrapper() { delete tt; }
  20     SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
  21     operator T&() const { return *tt; }
  22     T *operator&() { return tt; }
  23 private:
  24     SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  25 };
  26
  27 template <typename T> T SwigValueInit() {
  28   return T();
  29 }
  30 #endif
  31
  32 /* -----------------------------------------------------------------------------
  33  *  This section contains generic SWIG labels for method/variable
  34  *  declarations/attributes, and other compiler dependent labels.
  35  * ----------------------------------------------------------------------------- */
  36
  37 /* template workaround for compilers that cannot correctly implement the C++ standard */
  38 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  39 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  40 #  define SWIGTEMPLATEDISAMBIGUATOR template
  41 # elif defined(__HP_aCC)
  42 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  43 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  44 #  define SWIGTEMPLATEDISAMBIGUATOR template
  45 # else
  46 #  define SWIGTEMPLATEDISAMBIGUATOR
  47 # endif
  48 #endif
  49
  50 /* inline attribute */
  51 #ifndef SWIGINLINE
  52 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  53 #   define SWIGINLINE inline
  54 # else
  55 #   define SWIGINLINE
  56 # endif
  57 #endif
  58
  59 /* attribute recognised by some compilers to avoid 'unused' warnings */
  60 #ifndef SWIGUNUSED
  61 # if defined(__GNUC__)
  62 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  63 #     define SWIGUNUSED __attribute__ ((__unused__))
  64 #   else
  65 #     define SWIGUNUSED
  66 #   endif
  67 # elif defined(__ICC)
  68 #   define SWIGUNUSED __attribute__ ((__unused__))
  69 # else
  70 #   define SWIGUNUSED
  71 # endif
  72 #endif
  73
  74 #ifndef SWIGUNUSEDPARM
  75 # ifdef __cplusplus
  76 #   define SWIGUNUSEDPARM(p)
  77 # else
  78 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  79 # endif
  80 #endif
  81
  82 /* internal SWIG method */
  83 #ifndef SWIGINTERN
  84 # define SWIGINTERN static SWIGUNUSED
  85 #endif
  86
  87 /* internal inline SWIG method */
  88 #ifndef SWIGINTERNINLINE
  89 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
  90 #endif
  91
  92 /* exporting methods */
  93 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
  94 #  ifndef GCC_HASCLASSVISIBILITY
  95 #    define GCC_HASCLASSVISIBILITY
  96 #  endif
  97 #endif
  98
  99 #ifndef SWIGEXPORT
 100 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 101 #   if defined(STATIC_LINKED)
 102 #     define SWIGEXPORT
 103 #   else
 104 #     define SWIGEXPORT __declspec(dllexport)
 105 #   endif
 106 # else
 107 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 108 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 109 #   else
 110 #     define SWIGEXPORT
 111 #   endif
 112 # endif
 113 #endif
 114
 115 /* calling conventions for Windows */
 116 #ifndef SWIGSTDCALL
 117 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 118 #   define SWIGSTDCALL __stdcall
 119 # else
 120 #   define SWIGSTDCALL
 121 # endif
 122 #endif
 123
 124 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 125 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 126 # define _CRT_SECURE_NO_DEPRECATE
 127 #endif
 128
 129 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 130 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 131 # define _SCL_SECURE_NO_DEPRECATE
 132 #endif
 133
 134
 135
 136 #include <stdlib.h>
 137 #include <string.h>
 138 #include <stdio.h>
 139 #if defined(_WIN32) || defined(__CYGWIN32__)
 140 #  define DllExport   __declspec( dllexport )
 141 #  define SWIGSTDCALL __stdcall
 142 #else
 143 #  define DllExport
 144 #  define SWIGSTDCALL
 145 #endif
 146
 147
 148 #ifdef __cplusplus
 149 #  include <new>
 150 #endif
 151
 152
 153
 154
 155 /* Support for throwing Ada exceptions from C/C++ */
 156
 157 typedef enum
 158 {
 159   SWIG_AdaException,
 160   SWIG_AdaOutOfMemoryException,
 161   SWIG_AdaIndexOutOfRangeException,
 162   SWIG_AdaDivideByZeroException,
 163   SWIG_AdaArgumentOutOfRangeException,
 164   SWIG_AdaNullReferenceException
 165 } SWIG_AdaExceptionCodes;
 166
 167
 168 typedef void (SWIGSTDCALL* SWIG_AdaExceptionCallback_t)(const char *);
 169
 170
 171 typedef struct
 172 {
 173   SWIG_AdaExceptionCodes code;
 174   SWIG_AdaExceptionCallback_t callback;
 175 }
 176   SWIG_AdaExceptions_t;
 177
 178
 179 static
 180 SWIG_AdaExceptions_t
 181 SWIG_ada_exceptions[] =
 182 {
 183   { SWIG_AdaException, NULL },
 184   { SWIG_AdaOutOfMemoryException, NULL },
 185   { SWIG_AdaIndexOutOfRangeException, NULL },
 186   { SWIG_AdaDivideByZeroException, NULL },
 187   { SWIG_AdaArgumentOutOfRangeException, NULL },
 188   { SWIG_AdaNullReferenceException, NULL }
 189 };
 190
 191
 192 static
 193 void
 194 SWIG_AdaThrowException (SWIG_AdaExceptionCodes code, const char *msg)
 195 {
 196   SWIG_AdaExceptionCallback_t callback = SWIG_ada_exceptions[SWIG_AdaException].callback;
 197   if (code >=0 && (size_t)code < sizeof(SWIG_ada_exceptions)/sizeof(SWIG_AdaExceptions_t)) {
 198     callback = SWIG_ada_exceptions[code].callback;
 199   }
 200   callback(msg);
 201 }
 202
 203
 204
 205 #ifdef __cplusplus
 206 extern "C"
 207 #endif
 208
 209 DllExport void SWIGSTDCALL SWIGRegisterExceptionCallbacks_llvm (SWIG_AdaExceptionCallback_t systemException,
 210                                                                    SWIG_AdaExceptionCallback_t outOfMemory,
 211                                                                    SWIG_AdaExceptionCallback_t indexOutOfRange,
 212                                                                    SWIG_AdaExceptionCallback_t divideByZero,
 213                                                                    SWIG_AdaExceptionCallback_t argumentOutOfRange,
 214                                                                    SWIG_AdaExceptionCallback_t nullReference)
 215 {
 216   SWIG_ada_exceptions [SWIG_AdaException].callback                   = systemException;
 217   SWIG_ada_exceptions [SWIG_AdaOutOfMemoryException].callback        = outOfMemory;
 218   SWIG_ada_exceptions [SWIG_AdaIndexOutOfRangeException].callback    = indexOutOfRange;
 219   SWIG_ada_exceptions [SWIG_AdaDivideByZeroException].callback       = divideByZero;
 220   SWIG_ada_exceptions [SWIG_AdaArgumentOutOfRangeException].callback = argumentOutOfRange;
 221   SWIG_ada_exceptions [SWIG_AdaNullReferenceException].callback      = nullReference;
 222 }
 223
 224
 225 /* Callback for returning strings to Ada without leaking memory */
 226
 227 typedef char * (SWIGSTDCALL* SWIG_AdaStringHelperCallback)(const char *);
 228 static SWIG_AdaStringHelperCallback SWIG_ada_string_callback = NULL;
 229
 230
 231
 232 /* probably obsolete ...
 233 #ifdef __cplusplus
 234 extern "C"
 235 #endif
 236 DllExport void SWIGSTDCALL SWIGRegisterStringCallback_llvm(SWIG_AdaStringHelperCallback callback) {
 237   SWIG_ada_string_callback = callback;
 238 }
 239 */
 240
 241
 242
 243 /* Contract support */
 244
 245 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_AdaThrowException(SWIG_AdaArgumentOutOfRangeException, msg); return nullreturn; } else
 246
 247
 248 #define protected public
 249 #define private   public
 250
 251 //#include "llvm-c/Analysis.h"
 252 //#include "llvm-c/BitReader.h"
 253 //#include "llvm-c/BitWriter.h"
 254 #include "llvm-c/Core.h"
 255 //#include "llvm-c/ExecutionEngine.h"
 256 //#include "llvm-c/LinkTimeOptimizer.h"
 257 //#include "llvm-c/lto.h"
 258 //#include "llvm-c/Target.h"
 259
 260
 261
 262   struct LLVMCtxt;
 263 //  struct LLVMOpaqueType;
 264 //  struct LLVMOpaqueValue;
 265
 266 #undef protected
 267 #undef private
 268 #ifdef __cplusplus
 269 extern "C" {
 270 #endif
 271 DllExport void SWIGSTDCALL Ada_LLVMDisposeMessage (
 272   char * jarg1
 273   )
 274 {
 275   char *arg1 = (char *) 0 ;
 276
 277   arg1 = jarg1;
 278
 279   LLVMDisposeMessage(arg1);
 280
 281
 282 }
 283
 284
 285
 286 DllExport void * SWIGSTDCALL Ada_LLVMContextCreate (
 287   )
 288 {
 289   void * jresult ;
 290   LLVMContextRef result;
 291
 292   result = (LLVMContextRef)LLVMContextCreate();
 293   jresult = (void *) result;
 294
 295
 296
 297   return jresult;
 298
 299 }
 300
 301
 302
 303 DllExport void * SWIGSTDCALL Ada_LLVMGetGlobalContext (
 304   )
 305 {
 306   void * jresult ;
 307   LLVMContextRef result;
 308
 309   result = (LLVMContextRef)LLVMGetGlobalContext();
 310   jresult = (void *) result;
 311
 312
 313
 314   return jresult;
 315
 316 }
 317
 318
 319
 320 DllExport void SWIGSTDCALL Ada_LLVMContextDispose (
 321   void * jarg1
 322   )
 323 {
 324   LLVMContextRef arg1 = (LLVMContextRef) 0 ;
 325
 326   arg1 = (LLVMContextRef)jarg1;
 327
 328   LLVMContextDispose(arg1);
 329
 330
 331 }
 332
 333
 334
 335 DllExport void * SWIGSTDCALL Ada_LLVMModuleCreateWithName (
 336   char * jarg1
 337   )
 338 {
 339   void * jresult ;
 340   char *arg1 = (char *) 0 ;
 341   LLVMModuleRef result;
 342
 343   arg1 = jarg1;
 344
 345   result = (LLVMModuleRef)LLVMModuleCreateWithName((char const *)arg1);
 346   jresult = (void *) result;
 347
 348
 349
 350   return jresult;
 351
 352 }
 353
 354
 355
 356 DllExport void * SWIGSTDCALL Ada_LLVMModuleCreateWithNameInContext (
 357   char * jarg1
 358   ,
 359
 360   void * jarg2
 361   )
 362 {
 363   void * jresult ;
 364   char *arg1 = (char *) 0 ;
 365   LLVMContextRef arg2 = (LLVMContextRef) 0 ;
 366   LLVMModuleRef result;
 367
 368   arg1 = jarg1;
 369
 370   arg2 = (LLVMContextRef)jarg2;
 371
 372   result = (LLVMModuleRef)LLVMModuleCreateWithNameInContext((char const *)arg1,arg2);
 373   jresult = (void *) result;
 374
 375
 376
 377   return jresult;
 378
 379 }
 380
 381
 382
 383 DllExport void SWIGSTDCALL Ada_LLVMDisposeModule (
 384   void * jarg1
 385   )
 386 {
 387   LLVMModuleRef arg1 = (LLVMModuleRef) 0 ;
 388
 389   arg1 = (LLVMModuleRef)jarg1;
 390
 391   LLVMDisposeModule(arg1);
 392
 393
 394 }
 395
 396
 397
 398 DllExport char * SWIGSTDCALL Ada_LLVMGetDataLayout (
 399   void * jarg1
 400   )
 401 {
 402   char * jresult ;
 403   LLVMModuleRef arg1 = (LLVMModuleRef) 0 ;
 404   char *result = 0 ;
 405
 406   arg1 = (LLVMModuleRef)jarg1;
 407
 408   result = (char *)LLVMGetDataLayout(arg1);
 409   jresult = result;
 410
 411
 412
 413   return jresult;
 414
 415 }
 416
 417
 418
 419 DllExport void SWIGSTDCALL Ada_LLVMSetDataLayout (
 420   void * jarg1
 421   ,
 422
 423   char * jarg2
 424   )
 425 {
 426   LLVMModuleRef arg1 = (LLVMModuleRef) 0 ;
 427   char *arg2 = (char *) 0 ;
 428
 429   arg1 = (LLVMModuleRef)jarg1;
 430
 431   arg2 = jarg2;
 432
 433   LLVMSetDataLayout(arg1,(char const *)arg2);
 434
 435
 436 }
 437
 438
 439
 440 DllExport char * SWIGSTDCALL Ada_LLVMGetTarget (
 441   void * jarg1
 442   )
 443 {
 444   char * jresult ;
 445   LLVMModuleRef arg1 = (LLVMModuleRef) 0 ;
 446   char *result = 0 ;
 447
 448   arg1 = (LLVMModuleRef)jarg1;
 449
 450   result = (char *)LLVMGetTarget(arg1);
 451   jresult = result;
 452
 453
 454
 455   return jresult;
 456
 457 }
 458
 459
 460
 461 DllExport void SWIGSTDCALL Ada_LLVMSetTarget (
 462   void * jarg1
 463   ,
 464
 465   char * jarg2
 466   )
 467 {
 468   LLVMModuleRef arg1 = (LLVMModuleRef) 0 ;
 469   char *arg2 = (char *) 0 ;
 470
 471   arg1 = (LLVMModuleRef)jarg1;
 472
 473   arg2 = jarg2;
 474
 475   LLVMSetTarget(arg1,(char const *)arg2);
 476
 477
 478 }
 479
 480
 481
 482 DllExport int SWIGSTDCALL Ada_LLVMAddTypeName (
 483   void * jarg1
 484   ,
 485
 486   char * jarg2
 487   ,
 488
 489   void * jarg3
 490   )
 491 {
 492   int jresult ;
 493   LLVMModuleRef arg1 = (LLVMModuleRef) 0 ;
 494   char *arg2 = (char *) 0 ;
 495   LLVMTypeRef arg3 = (LLVMTypeRef) 0 ;
 496   int result;
 497
 498   arg1 = (LLVMModuleRef)jarg1;
 499
 500   arg2 = jarg2;
 501
 502   arg3 = (LLVMTypeRef)jarg3;
 503
 504   result = (int)LLVMAddTypeName(arg1,(char const *)arg2,arg3);
 505   jresult = result;
 506
 507
 508
 509   return jresult;
 510
 511 }
 512
 513
 514
 515 DllExport void SWIGSTDCALL Ada_LLVMDeleteTypeName (
 516   void * jarg1
 517   ,
 518
 519   char * jarg2
 520   )
 521 {
 522   LLVMModuleRef arg1 = (LLVMModuleRef) 0 ;
 523   char *arg2 = (char *) 0 ;
 524
 525   arg1 = (LLVMModuleRef)jarg1;
 526
 527   arg2 = jarg2;
 528
 529   LLVMDeleteTypeName(arg1,(char const *)arg2);
 530
 531
 532 }
 533
 534
 535
 536 DllExport void * SWIGSTDCALL Ada_LLVMGetTypeByName (
 537   void * jarg1
 538   ,
 539
 540   char * jarg2
 541   )
 542 {
 543   void * jresult ;
 544   LLVMModuleRef arg1 = (LLVMModuleRef) 0 ;
 545   char *arg2 = (char *) 0 ;
 546   LLVMTypeRef result;
 547
 548   arg1 = (LLVMModuleRef)jarg1;
 549
 550   arg2 = jarg2;
 551
 552   result = (LLVMTypeRef)LLVMGetTypeByName(arg1,(char const *)arg2);
 553   jresult = (void *) result;
 554
 555
 556
 557   return jresult;
 558
 559 }
 560
 561
 562
 563 DllExport void SWIGSTDCALL Ada_LLVMDumpModule (
 564   void * jarg1
 565   )
 566 {
 567   LLVMModuleRef arg1 = (LLVMModuleRef) 0 ;
 568
 569   arg1 = (LLVMModuleRef)jarg1;
 570
 571   LLVMDumpModule(arg1);
 572
 573
 574 }
 575
 576
 577
 578 DllExport int SWIGSTDCALL Ada_LLVMGetTypeKind (
 579   void * jarg1
 580   )
 581 {
 582   int jresult ;
 583   LLVMTypeRef arg1 = (LLVMTypeRef) 0 ;
 584   LLVMTypeKind result;
 585
 586   arg1 = (LLVMTypeRef)jarg1;
 587
 588   result = (LLVMTypeKind)LLVMGetTypeKind(arg1);
 589   jresult = result;
 590
 591
 592
 593   return jresult;
 594
 595 }
 596
 597
 598
 599 DllExport void * SWIGSTDCALL Ada_LLVMInt1Type (
 600   )
 601 {
 602   void * jresult ;
 603   LLVMTypeRef result;
 604
 605   result = (LLVMTypeRef)LLVMInt1Type();
 606   jresult = (void *) result;
 607
 608
 609
 610   return jresult;
 611
 612 }
 613
 614
 615
 616 DllExport void * SWIGSTDCALL Ada_LLVMInt8Type (
 617   )
 618 {
 619   void * jresult ;
 620   LLVMTypeRef result;
 621
 622   result = (LLVMTypeRef)LLVMInt8Type();
 623   jresult = (void *) result;
 624
 625
 626
 627   return jresult;
 628
 629 }
 630
 631
 632
 633 DllExport void * SWIGSTDCALL Ada_LLVMInt16Type (
 634   )
 635 {
 636   void * jresult ;
 637   LLVMTypeRef result;
 638
 639   result = (LLVMTypeRef)LLVMInt16Type();
 640   jresult = (void *) result;
 641
 642
 643
 644   return jresult;
 645
 646 }
 647
 648
 649
 650 DllExport void * SWIGSTDCALL Ada_LLVMInt32Type (
 651   )
 652 {
 653   void * jresult ;
 654   LLVMTypeRef result;
 655
 656   result = (LLVMTypeRef)LLVMInt32Type();
 657   jresult = (void *) result;
 658
 659
 660
 661   return jresult;
 662
 663 }
 664
 665
 666
 667 DllExport void * SWIGSTDCALL Ada_LLVMInt64Type (
 668   )
 669 {
 670   void * jresult ;
 671   LLVMTypeRef result;
 672
 673   result = (LLVMTypeRef)LLVMInt64Type();
 674   jresult = (void *) result;
 675
 676
 677
 678   return jresult;
 679
 680 }
 681
 682
 683
 684 DllExport void * SWIGSTDCALL Ada_LLVMIntType (
 685   unsigned int jarg1
 686   )
 687 {
 688   void * jresult ;
 689   unsigned int arg1 ;
 690   LLVMTypeRef result;
 691
 692
 693   arg1 = (unsigned int) jarg1;
 694
 695
 696   result = (LLVMTypeRef)LLVMIntType(arg1);
 697   jresult = (void *) result;
 698
 699
 700
 701   return jresult;
 702
 703 }
 704
 705
 706
 707 DllExport unsigned int SWIGSTDCALL Ada_LLVMGetIntTypeWidth (
 708   void * jarg1
 709   )
 710 {
 711   unsigned int jresult ;
 712   LLVMTypeRef arg1 = (LLVMTypeRef) 0 ;
 713   unsigned int result;
 714
 715   arg1 = (LLVMTypeRef)jarg1;
 716
 717   result = (unsigned int)LLVMGetIntTypeWidth(arg1);
 718   jresult = result;
 719
 720
 721
 722   return jresult;
 723
 724 }
 725
 726
 727
 728 DllExport void * SWIGSTDCALL Ada_LLVMFloatType (
 729   )
 730 {
 731   void * jresult ;
 732   LLVMTypeRef result;
 733
 734   result = (LLVMTypeRef)LLVMFloatType();
 735   jresult = (void *) result;
 736
 737
 738
 739   return jresult;
 740
 741 }
 742
 743
 744
 745 DllExport void * SWIGSTDCALL Ada_LLVMDoubleType (
 746   )
 747 {
 748   void * jresult ;
 749   LLVMTypeRef result;
 750
 751   result = (LLVMTypeRef)LLVMDoubleType();
 752   jresult = (void *) result;
 753
 754
 755
 756   return jresult;
 757
 758 }
 759
 760
 761
 762 DllExport void * SWIGSTDCALL Ada_LLVMX86FP80Type (
 763   )
 764 {
 765   void * jresult ;
 766   LLVMTypeRef result;
 767
 768   result = (LLVMTypeRef)LLVMX86FP80Type();
 769   jresult = (void *) result;
 770
 771
 772
 773   return jresult;
 774
 775 }
 776
 777
 778
 779 DllExport void * SWIGSTDCALL Ada_LLVMFP128Type (
 780   )
 781 {
 782   void * jresult ;
 783   LLVMTypeRef result;
 784
 785   result = (LLVMTypeRef)LLVMFP128Type();
 786   jresult = (void *) result;
 787
 788
 789
 790   return jresult;
 791
 792 }
 793
 794
 795
 796 DllExport void * SWIGSTDCALL Ada_LLVMPPCFP128Type (
 797   )
 798 {
 799   void * jresult ;
 800   LLVMTypeRef result;
 801
 802   result = (LLVMTypeRef)LLVMPPCFP128Type();
 803   jresult = (void *) result;
 804
 805
 806
 807   return jresult;
 808
 809 }
 810
 811
 812
 813 DllExport void * SWIGSTDCALL Ada_LLVMFunctionType (
 814   void * jarg1
 815   ,
 816
 817   void * jarg2
 818   ,
 819
 820   unsigned int jarg3
 821   ,
 822
 823   int jarg4
 824   )
 825 {
 826   void * jresult ;
 827   LLVMTypeRef arg1 = (LLVMTypeRef) 0 ;
 828   LLVMTypeRef *arg2 = (LLVMTypeRef *) 0 ;
 829   unsigned int arg3 ;
 830   int arg4 ;
 831   LLVMTypeRef result;
 832
 833   arg1 = (LLVMTypeRef)jarg1;
 834
 835   arg2 = (LLVMTypeRef *)jarg2;
 836
 837
 838   arg3 = (unsigned int) jarg3;
 839
 840
 841
 842   arg4 = (int) jarg4;
 843
 844
 845   result = (LLVMTypeRef)LLVMFunctionType(arg1,arg2,arg3,arg4);
 846   jresult = (void *) result;
 847
 848
 849
 850   return jresult;
 851
 852 }
 853
 854
 855
 856 DllExport int SWIGSTDCALL Ada_LLVMIsFunctionVarArg (
 857   void * jarg1
 858   )
 859 {
 860   int jresult ;
 861   LLVMTypeRef arg1 = (LLVMTypeRef) 0 ;
 862   int result;
 863
 864   arg1 = (LLVMTypeRef)jarg1;
 865
 866   result = (int)LLVMIsFunctionVarArg(arg1);
 867   jresult = result;
 868
 869
 870
 871   return jresult;
 872
 873 }
 874
 875
 876
 877 DllExport void * SWIGSTDCALL Ada_LLVMGetReturnType (
 878   void * jarg1
 879   )
 880 {
 881   void * jresult ;
 882   LLVMTypeRef arg1 = (LLVMTypeRef) 0 ;
 883   LLVMTypeRef result;
 884
 885   arg1 = (LLVMTypeRef)jarg1;
 886
 887   result = (LLVMTypeRef)LLVMGetReturnType(arg1);
 888   jresult = (void *) result;
 889
 890
 891
 892   return jresult;
 893
 894 }
 895
 896
 897
 898 DllExport unsigned int SWIGSTDCALL Ada_LLVMCountParamTypes (
 899   void * jarg1
 900   )
 901 {
 902   unsigned int jresult ;
 903   LLVMTypeRef arg1 = (LLVMTypeRef) 0 ;
 904   unsigned int result;
 905
 906   arg1 = (LLVMTypeRef)jarg1;
 907
 908   result = (unsigned int)LLVMCountParamTypes(arg1);
 909   jresult = result;
 910
 911
 912
 913   return jresult;
 914
 915 }
 916
 917
 918
 919 DllExport void SWIGSTDCALL Ada_LLVMGetParamTypes (
 920   void * jarg1
 921   ,
 922
 923   void * jarg2
 924   )
 925 {
 926   LLVMTypeRef arg1 = (LLVMTypeRef) 0 ;
 927   LLVMTypeRef *arg2 = (LLVMTypeRef *) 0 ;
 928
 929   arg1 = (LLVMTypeRef)jarg1;
 930
 931   arg2 = (LLVMTypeRef *)jarg2;
 932
 933   LLVMGetParamTypes(arg1,arg2);
 934
 935
 936 }
 937
 938
 939
 940 DllExport void * SWIGSTDCALL Ada_LLVMStructType (
 941   void * jarg1
 942   ,
 943
 944   unsigned int jarg2
 945   ,
 946
 947   int jarg3
 948   )
 949 {
 950   void * jresult ;
 951   LLVMTypeRef *arg1 = (LLVMTypeRef *) 0 ;
 952   unsigned int arg2 ;
 953   int arg3 ;
 954   LLVMTypeRef result;
 955
 956   arg1 = (LLVMTypeRef *)jarg1;
 957
 958
 959   arg2 = (unsigned int) jarg2;
 960
 961
 962
 963   arg3 = (int) jarg3;
 964
 965
 966   result = (LLVMTypeRef)LLVMStructType(arg1,arg2,arg3);
 967   jresult = (void *) result;
 968
 969
 970
 971   return jresult;
 972
 973 }
 974
 975
 976
 977 DllExport unsigned int SWIGSTDCALL Ada_LLVMCountStructElementTypes (
 978   void * jarg1
 979   )
 980 {
 981   unsigned int jresult ;
 982   LLVMTypeRef arg1 = (LLVMTypeRef) 0 ;
 983   unsigned int result;
 984
 985   arg1 = (LLVMTypeRef)jarg1;
 986
 987   result = (unsigned int)LLVMCountStructElementTypes(arg1);
 988   jresult = result;
 989
 990
 991
 992   return jresult;
 993
 994 }
 995
 996
 997
 998 DllExport void SWIGSTDCALL Ada_LLVMGetStructElementTypes (
 999   void * jarg1
1000   ,
1001
1002   void * jarg2
1003   )
1004 {
1005   LLVMTypeRef arg1 = (LLVMTypeRef) 0 ;
1006   LLVMTypeRef *arg2 = (LLVMTypeRef *) 0 ;
1007
1008   arg1 = (LLVMTypeRef)jarg1;
1009
1010   arg2 = (LLVMTypeRef *)jarg2;
1011
1012   LLVMGetStructElementTypes(arg1,arg2);
1013
1014
1015 }
1016
1017
1018
1019 DllExport int SWIGSTDCALL Ada_LLVMIsPackedStruct (
1020   void * jarg1
1021   )
1022 {
1023   int jresult ;
1024   LLVMTypeRef arg1 = (LLVMTypeRef) 0 ;
1025   int result;
1026
1027   arg1 = (LLVMTypeRef)jarg1;
1028
1029   result = (int)LLVMIsPackedStruct(arg1);
1030   jresult = result;
1031
1032
1033
1034   return jresult;
1035
1036 }
1037
1038
1039
1040 DllExport void * SWIGSTDCALL Ada_LLVMArrayType (
1041   void * jarg1
1042   ,
1043
1044   unsigned int jarg2
1045   )
1046 {
1047   void * jresult ;
1048   LLVMTypeRef arg1 = (LLVMTypeRef) 0 ;
1049   unsigned int arg2 ;
1050   LLVMTypeRef result;
1051
1052   arg1 = (LLVMTypeRef)jarg1;
1053
1054
1055   arg2 = (unsigned int) jarg2;
1056
1057
1058   result = (LLVMTypeRef)LLVMArrayType(arg1,arg2);
1059   jresult = (void *) result;
1060
1061
1062
1063   return jresult;
1064
1065 }
1066
1067
1068
1069 DllExport void * SWIGSTDCALL Ada_LLVMPointerType (
1070   void * jarg1
1071   ,
1072
1073   unsigned int jarg2
1074   )
1075 {
1076   void * jresult ;
1077   LLVMTypeRef arg1 = (LLVMTypeRef) 0 ;
1078   unsigned int arg2 ;
1079   LLVMTypeRef result;
1080
1081   arg1 = (LLVMTypeRef)jarg1;
1082
1083
1084   arg2 = (unsigned int) jarg2;
1085
1086
1087   result = (LLVMTypeRef)LLVMPointerType(arg1,arg2);
1088   jresult = (void *) result;
1089
1090
1091
1092   return jresult;
1093
1094 }
1095
1096
1097
1098 DllExport void * SWIGSTDCALL Ada_LLVMVectorType (
1099   void * jarg1
1100   ,
1101
1102   unsigned int jarg2
1103   )
1104 {
1105   void * jresult ;
1106   LLVMTypeRef arg1 = (LLVMTypeRef) 0 ;
1107   unsigned int arg2 ;
1108   LLVMTypeRef result;
1109
1110   arg1 = (LLVMTypeRef)jarg1;
1111
1112
1113   arg2 = (unsigned int) jarg2;
1114
1115
1116   result = (LLVMTypeRef)LLVMVectorType(arg1,arg2);
1117   jresult = (void *) result;
1118
1119
1120
1121   return jresult;
1122
1123 }
1124
1125
1126
1127 DllExport void * SWIGSTDCALL Ada_LLVMGetElementType (
1128   void * jarg1
1129   )
1130 {
1131   void * jresult ;
1132   LLVMTypeRef arg1 = (LLVMTypeRef) 0 ;
1133   LLVMTypeRef result;
1134
1135   arg1 = (LLVMTypeRef)jarg1;
1136
1137   result = (LLVMTypeRef)LLVMGetElementType(arg1);
1138   jresult = (void *) result;
1139
1140
1141
1142   return jresult;
1143
1144 }
1145
1146
1147
1148 DllExport unsigned int SWIGSTDCALL Ada_LLVMGetArrayLength (
1149   void * jarg1
1150   )
1151 {
1152   unsigned int jresult ;
1153   LLVMTypeRef arg1 = (LLVMTypeRef) 0 ;
1154   unsigned int result;
1155
1156   arg1 = (LLVMTypeRef)jarg1;
1157
1158   result = (unsigned int)LLVMGetArrayLength(arg1);
1159   jresult = result;
1160
1161
1162
1163   return jresult;
1164
1165 }
1166
1167
1168
1169 DllExport unsigned int SWIGSTDCALL Ada_LLVMGetPointerAddressSpace (
1170   void * jarg1
1171   )
1172 {
1173   unsigned int jresult ;
1174   LLVMTypeRef arg1 = (LLVMTypeRef) 0 ;
1175   unsigned int result;
1176
1177   arg1 = (LLVMTypeRef)jarg1;
1178
1179   result = (unsigned int)LLVMGetPointerAddressSpace(arg1);
1180   jresult = result;
1181
1182
1183
1184   return jresult;
1185
1186 }
1187
1188
1189
1190 DllExport unsigned int SWIGSTDCALL Ada_LLVMGetVectorSize (
1191   void * jarg1
1192   )
1193 {
1194   unsigned int jresult ;
1195   LLVMTypeRef arg1 = (LLVMTypeRef) 0 ;
1196   unsigned int result;
1197
1198   arg1 = (LLVMTypeRef)jarg1;
1199
1200   result = (unsigned int)LLVMGetVectorSize(arg1);
1201   jresult = result;
1202
1203
1204
1205   return jresult;
1206
1207 }
1208
1209
1210
1211 DllExport void * SWIGSTDCALL Ada_LLVMVoidType (
1212   )
1213 {
1214   void * jresult ;
1215   LLVMTypeRef result;
1216
1217   result = (LLVMTypeRef)LLVMVoidType();
1218   jresult = (void *) result;
1219
1220
1221
1222   return jresult;
1223
1224 }
1225
1226
1227
1228 DllExport void * SWIGSTDCALL Ada_LLVMLabelType (
1229   )
1230 {
1231   void * jresult ;
1232   LLVMTypeRef result;
1233
1234   result = (LLVMTypeRef)LLVMLabelType();
1235   jresult = (void *) result;
1236
1237
1238
1239   return jresult;
1240
1241 }
1242
1243
1244
1245 DllExport void * SWIGSTDCALL Ada_LLVMOpaqueType (
1246   )
1247 {
1248   void * jresult ;
1249   LLVMTypeRef result;
1250
1251   result = (LLVMTypeRef)LLVMOpaqueType();
1252   jresult = (void *) result;
1253
1254
1255
1256   return jresult;
1257
1258 }
1259
1260
1261
1262 DllExport void * SWIGSTDCALL Ada_LLVMCreateTypeHandle (
1263   void * jarg1
1264   )
1265 {
1266   void * jresult ;
1267   LLVMTypeRef arg1 = (LLVMTypeRef) 0 ;
1268   LLVMTypeHandleRef result;
1269
1270   arg1 = (LLVMTypeRef)jarg1;
1271
1272   result = (LLVMTypeHandleRef)LLVMCreateTypeHandle(arg1);
1273   jresult = (void *) result;
1274
1275
1276
1277   return jresult;
1278
1279 }
1280
1281
1282
1283 DllExport void SWIGSTDCALL Ada_LLVMRefineType (
1284   void * jarg1
1285   ,
1286
1287   void * jarg2
1288   )
1289 {
1290   LLVMTypeRef arg1 = (LLVMTypeRef) 0 ;
1291   LLVMTypeRef arg2 = (LLVMTypeRef) 0 ;
1292
1293   arg1 = (LLVMTypeRef)jarg1;
1294
1295   arg2 = (LLVMTypeRef)jarg2;
1296
1297   LLVMRefineType(arg1,arg2);
1298
1299
1300 }
1301
1302
1303
1304 DllExport void * SWIGSTDCALL Ada_LLVMResolveTypeHandle (
1305   void * jarg1
1306   )
1307 {
1308   void * jresult ;
1309   LLVMTypeHandleRef arg1 = (LLVMTypeHandleRef) 0 ;
1310   LLVMTypeRef result;
1311
1312   arg1 = (LLVMTypeHandleRef)jarg1;
1313
1314   result = (LLVMTypeRef)LLVMResolveTypeHandle(arg1);
1315   jresult = (void *) result;
1316
1317
1318
1319   return jresult;
1320
1321 }
1322
1323
1324
1325 DllExport void SWIGSTDCALL Ada_LLVMDisposeTypeHandle (
1326   void * jarg1
1327   )
1328 {
1329   LLVMTypeHandleRef arg1 = (LLVMTypeHandleRef) 0 ;
1330
1331   arg1 = (LLVMTypeHandleRef)jarg1;
1332
1333   LLVMDisposeTypeHandle(arg1);
1334
1335
1336 }
1337
1338
1339
1340 DllExport void * SWIGSTDCALL Ada_LLVMTypeOf (
1341   void * jarg1
1342   )
1343 {
1344   void * jresult ;
1345   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
1346   LLVMTypeRef result;
1347
1348   arg1 = (LLVMValueRef)jarg1;
1349
1350   result = (LLVMTypeRef)LLVMTypeOf(arg1);
1351   jresult = (void *) result;
1352
1353
1354
1355   return jresult;
1356
1357 }
1358
1359
1360
1361 DllExport char * SWIGSTDCALL Ada_LLVMGetValueName (
1362   void * jarg1
1363   )
1364 {
1365   char * jresult ;
1366   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
1367   char *result = 0 ;
1368
1369   arg1 = (LLVMValueRef)jarg1;
1370
1371   result = (char *)LLVMGetValueName(arg1);
1372   jresult = result;
1373
1374
1375
1376   return jresult;
1377
1378 }
1379
1380
1381
1382 DllExport void SWIGSTDCALL Ada_LLVMSetValueName (
1383   void * jarg1
1384   ,
1385
1386   char * jarg2
1387   )
1388 {
1389   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
1390   char *arg2 = (char *) 0 ;
1391
1392   arg1 = (LLVMValueRef)jarg1;
1393
1394   arg2 = jarg2;
1395
1396   LLVMSetValueName(arg1,(char const *)arg2);
1397
1398
1399 }
1400
1401
1402
1403 DllExport void SWIGSTDCALL Ada_LLVMDumpValue (
1404   void * jarg1
1405   )
1406 {
1407   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
1408
1409   arg1 = (LLVMValueRef)jarg1;
1410
1411   LLVMDumpValue(arg1);
1412
1413
1414 }
1415
1416
1417
1418 DllExport void * SWIGSTDCALL Ada_LLVMIsAArgument (
1419   void * jarg1
1420   )
1421 {
1422   void * jresult ;
1423   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
1424   LLVMValueRef result;
1425
1426   arg1 = (LLVMValueRef)jarg1;
1427
1428   result = (LLVMValueRef)LLVMIsAArgument(arg1);
1429   jresult = (void *) result;
1430
1431
1432
1433   return jresult;
1434
1435 }
1436
1437
1438
1439 DllExport void * SWIGSTDCALL Ada_LLVMIsABasicBlock (
1440   void * jarg1
1441   )
1442 {
1443   void * jresult ;
1444   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
1445   LLVMValueRef result;
1446
1447   arg1 = (LLVMValueRef)jarg1;
1448
1449   result = (LLVMValueRef)LLVMIsABasicBlock(arg1);
1450   jresult = (void *) result;
1451
1452
1453
1454   return jresult;
1455
1456 }
1457
1458
1459
1460 DllExport void * SWIGSTDCALL Ada_LLVMIsAInlineAsm (
1461   void * jarg1
1462   )
1463 {
1464   void * jresult ;
1465   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
1466   LLVMValueRef result;
1467
1468   arg1 = (LLVMValueRef)jarg1;
1469
1470   result = (LLVMValueRef)LLVMIsAInlineAsm(arg1);
1471   jresult = (void *) result;
1472
1473
1474
1475   return jresult;
1476
1477 }
1478
1479
1480
1481 DllExport void * SWIGSTDCALL Ada_LLVMIsAUser (
1482   void * jarg1
1483   )
1484 {
1485   void * jresult ;
1486   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
1487   LLVMValueRef result;
1488
1489   arg1 = (LLVMValueRef)jarg1;
1490
1491   result = (LLVMValueRef)LLVMIsAUser(arg1);
1492   jresult = (void *) result;
1493
1494
1495
1496   return jresult;
1497
1498 }
1499
1500
1501
1502 DllExport void * SWIGSTDCALL Ada_LLVMIsAConstant (
1503   void * jarg1
1504   )
1505 {
1506   void * jresult ;
1507   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
1508   LLVMValueRef result;
1509
1510   arg1 = (LLVMValueRef)jarg1;
1511
1512   result = (LLVMValueRef)LLVMIsAConstant(arg1);
1513   jresult = (void *) result;
1514
1515
1516
1517   return jresult;
1518
1519 }
1520
1521
1522
1523 DllExport void * SWIGSTDCALL Ada_LLVMIsAConstantAggregateZero (
1524   void * jarg1
1525   )
1526 {
1527   void * jresult ;
1528   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
1529   LLVMValueRef result;
1530
1531   arg1 = (LLVMValueRef)jarg1;
1532
1533   result = (LLVMValueRef)LLVMIsAConstantAggregateZero(arg1);
1534   jresult = (void *) result;
1535
1536
1537
1538   return jresult;
1539
1540 }
1541
1542
1543
1544 DllExport void * SWIGSTDCALL Ada_LLVMIsAConstantArray (
1545   void * jarg1
1546   )
1547 {
1548   void * jresult ;
1549   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
1550   LLVMValueRef result;
1551
1552   arg1 = (LLVMValueRef)jarg1;
1553
1554   result = (LLVMValueRef)LLVMIsAConstantArray(arg1);
1555   jresult = (void *) result;
1556
1557
1558
1559   return jresult;
1560
1561 }
1562
1563
1564
1565 DllExport void * SWIGSTDCALL Ada_LLVMIsAConstantExpr (
1566   void * jarg1
1567   )
1568 {
1569   void * jresult ;
1570   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
1571   LLVMValueRef result;
1572
1573   arg1 = (LLVMValueRef)jarg1;
1574
1575   result = (LLVMValueRef)LLVMIsAConstantExpr(arg1);
1576   jresult = (void *) result;
1577
1578
1579
1580   return jresult;
1581
1582 }
1583
1584
1585
1586 DllExport void * SWIGSTDCALL Ada_LLVMIsAConstantFP (
1587   void * jarg1
1588   )
1589 {
1590   void * jresult ;
1591   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
1592   LLVMValueRef result;
1593
1594   arg1 = (LLVMValueRef)jarg1;
1595
1596   result = (LLVMValueRef)LLVMIsAConstantFP(arg1);
1597   jresult = (void *) result;
1598
1599
1600
1601   return jresult;
1602
1603 }
1604
1605
1606
1607 DllExport void * SWIGSTDCALL Ada_LLVMIsAConstantInt (
1608   void * jarg1
1609   )
1610 {
1611   void * jresult ;
1612   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
1613   LLVMValueRef result;
1614
1615   arg1 = (LLVMValueRef)jarg1;
1616
1617   result = (LLVMValueRef)LLVMIsAConstantInt(arg1);
1618   jresult = (void *) result;
1619
1620
1621
1622   return jresult;
1623
1624 }
1625
1626
1627
1628 DllExport void * SWIGSTDCALL Ada_LLVMIsAConstantPointerNull (
1629   void * jarg1
1630   )
1631 {
1632   void * jresult ;
1633   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
1634   LLVMValueRef result;
1635
1636   arg1 = (LLVMValueRef)jarg1;
1637
1638   result = (LLVMValueRef)LLVMIsAConstantPointerNull(arg1);
1639   jresult = (void *) result;
1640
1641
1642
1643   return jresult;
1644
1645 }
1646
1647
1648
1649 DllExport void * SWIGSTDCALL Ada_LLVMIsAConstantStruct (
1650   void * jarg1
1651   )
1652 {
1653   void * jresult ;
1654   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
1655   LLVMValueRef result;
1656
1657   arg1 = (LLVMValueRef)jarg1;
1658
1659   result = (LLVMValueRef)LLVMIsAConstantStruct(arg1);
1660   jresult = (void *) result;
1661
1662
1663
1664   return jresult;
1665
1666 }
1667
1668
1669
1670 DllExport void * SWIGSTDCALL Ada_LLVMIsAConstantVector (
1671   void * jarg1
1672   )
1673 {
1674   void * jresult ;
1675   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
1676   LLVMValueRef result;
1677
1678   arg1 = (LLVMValueRef)jarg1;
1679
1680   result = (LLVMValueRef)LLVMIsAConstantVector(arg1);
1681   jresult = (void *) result;
1682
1683
1684
1685   return jresult;
1686
1687 }
1688
1689
1690
1691 DllExport void * SWIGSTDCALL Ada_LLVMIsAGlobalValue (
1692   void * jarg1
1693   )
1694 {
1695   void * jresult ;
1696   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
1697   LLVMValueRef result;
1698
1699   arg1 = (LLVMValueRef)jarg1;
1700
1701   result = (LLVMValueRef)LLVMIsAGlobalValue(arg1);
1702   jresult = (void *) result;
1703
1704
1705
1706   return jresult;
1707
1708 }
1709
1710
1711
1712 DllExport void * SWIGSTDCALL Ada_LLVMIsAFunction (
1713   void * jarg1
1714   )
1715 {
1716   void * jresult ;
1717   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
1718   LLVMValueRef result;
1719
1720   arg1 = (LLVMValueRef)jarg1;
1721
1722   result = (LLVMValueRef)LLVMIsAFunction(arg1);
1723   jresult = (void *) result;
1724
1725
1726
1727   return jresult;
1728
1729 }
1730
1731
1732
1733 DllExport void * SWIGSTDCALL Ada_LLVMIsAGlobalAlias (
1734   void * jarg1
1735   )
1736 {
1737   void * jresult ;
1738   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
1739   LLVMValueRef result;
1740
1741   arg1 = (LLVMValueRef)jarg1;
1742
1743   result = (LLVMValueRef)LLVMIsAGlobalAlias(arg1);
1744   jresult = (void *) result;
1745
1746
1747
1748   return jresult;
1749
1750 }
1751
1752
1753
1754 DllExport void * SWIGSTDCALL Ada_LLVMIsAGlobalVariable (
1755   void * jarg1
1756   )
1757 {
1758   void * jresult ;
1759   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
1760   LLVMValueRef result;
1761
1762   arg1 = (LLVMValueRef)jarg1;
1763
1764   result = (LLVMValueRef)LLVMIsAGlobalVariable(arg1);
1765   jresult = (void *) result;
1766
1767
1768
1769   return jresult;
1770
1771 }
1772
1773
1774
1775 DllExport void * SWIGSTDCALL Ada_LLVMIsAUndefValue (
1776   void * jarg1
1777   )
1778 {
1779   void * jresult ;
1780   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
1781   LLVMValueRef result;
1782
1783   arg1 = (LLVMValueRef)jarg1;
1784
1785   result = (LLVMValueRef)LLVMIsAUndefValue(arg1);
1786   jresult = (void *) result;
1787
1788
1789
1790   return jresult;
1791
1792 }
1793
1794
1795
1796 DllExport void * SWIGSTDCALL Ada_LLVMIsAInstruction (
1797   void * jarg1
1798   )
1799 {
1800   void * jresult ;
1801   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
1802   LLVMValueRef result;
1803
1804   arg1 = (LLVMValueRef)jarg1;
1805
1806   result = (LLVMValueRef)LLVMIsAInstruction(arg1);
1807   jresult = (void *) result;
1808
1809
1810
1811   return jresult;
1812
1813 }
1814
1815
1816
1817 DllExport void * SWIGSTDCALL Ada_LLVMIsABinaryOperator (
1818   void * jarg1
1819   )
1820 {
1821   void * jresult ;
1822   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
1823   LLVMValueRef result;
1824
1825   arg1 = (LLVMValueRef)jarg1;
1826
1827   result = (LLVMValueRef)LLVMIsABinaryOperator(arg1);
1828   jresult = (void *) result;
1829
1830
1831
1832   return jresult;
1833
1834 }
1835
1836
1837
1838 DllExport void * SWIGSTDCALL Ada_LLVMIsACallInst (
1839   void * jarg1
1840   )
1841 {
1842   void * jresult ;
1843   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
1844   LLVMValueRef result;
1845
1846   arg1 = (LLVMValueRef)jarg1;
1847
1848   result = (LLVMValueRef)LLVMIsACallInst(arg1);
1849   jresult = (void *) result;
1850
1851
1852
1853   return jresult;
1854
1855 }
1856
1857
1858
1859 DllExport void * SWIGSTDCALL Ada_LLVMIsAIntrinsicInst (
1860   void * jarg1
1861   )
1862 {
1863   void * jresult ;
1864   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
1865   LLVMValueRef result;
1866
1867   arg1 = (LLVMValueRef)jarg1;
1868
1869   result = (LLVMValueRef)LLVMIsAIntrinsicInst(arg1);
1870   jresult = (void *) result;
1871
1872
1873
1874   return jresult;
1875
1876 }
1877
1878
1879
1880 DllExport void * SWIGSTDCALL Ada_LLVMIsADbgInfoIntrinsic (
1881   void * jarg1
1882   )
1883 {
1884   void * jresult ;
1885   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
1886   LLVMValueRef result;
1887
1888   arg1 = (LLVMValueRef)jarg1;
1889
1890   result = (LLVMValueRef)LLVMIsADbgInfoIntrinsic(arg1);
1891   jresult = (void *) result;
1892
1893
1894
1895   return jresult;
1896
1897 }
1898
1899
1900
1901 DllExport void * SWIGSTDCALL Ada_LLVMIsADbgDeclareInst (
1902   void * jarg1
1903   )
1904 {
1905   void * jresult ;
1906   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
1907   LLVMValueRef result;
1908
1909   arg1 = (LLVMValueRef)jarg1;
1910
1911   result = (LLVMValueRef)LLVMIsADbgDeclareInst(arg1);
1912   jresult = (void *) result;
1913
1914
1915
1916   return jresult;
1917
1918 }
1919
1920
1921
1922 DllExport void * SWIGSTDCALL Ada_LLVMIsADbgFuncStartInst (
1923   void * jarg1
1924   )
1925 {
1926   void * jresult ;
1927   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
1928   LLVMValueRef result;
1929
1930   arg1 = (LLVMValueRef)jarg1;
1931
1932   result = (LLVMValueRef)LLVMIsADbgFuncStartInst(arg1);
1933   jresult = (void *) result;
1934
1935
1936
1937   return jresult;
1938
1939 }
1940
1941
1942
1943 DllExport void * SWIGSTDCALL Ada_LLVMIsADbgRegionEndInst (
1944   void * jarg1
1945   )
1946 {
1947   void * jresult ;
1948   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
1949   LLVMValueRef result;
1950
1951   arg1 = (LLVMValueRef)jarg1;
1952
1953   result = (LLVMValueRef)LLVMIsADbgRegionEndInst(arg1);
1954   jresult = (void *) result;
1955
1956
1957
1958   return jresult;
1959
1960 }
1961
1962
1963
1964 DllExport void * SWIGSTDCALL Ada_LLVMIsADbgRegionStartInst (
1965   void * jarg1
1966   )
1967 {
1968   void * jresult ;
1969   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
1970   LLVMValueRef result;
1971
1972   arg1 = (LLVMValueRef)jarg1;
1973
1974   result = (LLVMValueRef)LLVMIsADbgRegionStartInst(arg1);
1975   jresult = (void *) result;
1976
1977
1978
1979   return jresult;
1980
1981 }
1982
1983
1984
1985 DllExport void * SWIGSTDCALL Ada_LLVMIsADbgStopPointInst (
1986   void * jarg1
1987   )
1988 {
1989   void * jresult ;
1990   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
1991   LLVMValueRef result;
1992
1993   arg1 = (LLVMValueRef)jarg1;
1994
1995   result = (LLVMValueRef)LLVMIsADbgStopPointInst(arg1);
1996   jresult = (void *) result;
1997
1998
1999
2000   return jresult;
2001
2002 }
2003
2004
2005
2006 DllExport void * SWIGSTDCALL Ada_LLVMIsAEHSelectorInst (
2007   void * jarg1
2008   )
2009 {
2010   void * jresult ;
2011   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2012   LLVMValueRef result;
2013
2014   arg1 = (LLVMValueRef)jarg1;
2015
2016   result = (LLVMValueRef)LLVMIsAEHSelectorInst(arg1);
2017   jresult = (void *) result;
2018
2019
2020
2021   return jresult;
2022
2023 }
2024
2025
2026
2027 DllExport void * SWIGSTDCALL Ada_LLVMIsAMemIntrinsic (
2028   void * jarg1
2029   )
2030 {
2031   void * jresult ;
2032   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2033   LLVMValueRef result;
2034
2035   arg1 = (LLVMValueRef)jarg1;
2036
2037   result = (LLVMValueRef)LLVMIsAMemIntrinsic(arg1);
2038   jresult = (void *) result;
2039
2040
2041
2042   return jresult;
2043
2044 }
2045
2046
2047
2048 DllExport void * SWIGSTDCALL Ada_LLVMIsAMemCpyInst (
2049   void * jarg1
2050   )
2051 {
2052   void * jresult ;
2053   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2054   LLVMValueRef result;
2055
2056   arg1 = (LLVMValueRef)jarg1;
2057
2058   result = (LLVMValueRef)LLVMIsAMemCpyInst(arg1);
2059   jresult = (void *) result;
2060
2061
2062
2063   return jresult;
2064
2065 }
2066
2067
2068
2069 DllExport void * SWIGSTDCALL Ada_LLVMIsAMemMoveInst (
2070   void * jarg1
2071   )
2072 {
2073   void * jresult ;
2074   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2075   LLVMValueRef result;
2076
2077   arg1 = (LLVMValueRef)jarg1;
2078
2079   result = (LLVMValueRef)LLVMIsAMemMoveInst(arg1);
2080   jresult = (void *) result;
2081
2082
2083
2084   return jresult;
2085
2086 }
2087
2088
2089
2090 DllExport void * SWIGSTDCALL Ada_LLVMIsAMemSetInst (
2091   void * jarg1
2092   )
2093 {
2094   void * jresult ;
2095   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2096   LLVMValueRef result;
2097
2098   arg1 = (LLVMValueRef)jarg1;
2099
2100   result = (LLVMValueRef)LLVMIsAMemSetInst(arg1);
2101   jresult = (void *) result;
2102
2103
2104
2105   return jresult;
2106
2107 }
2108
2109
2110
2111 DllExport void * SWIGSTDCALL Ada_LLVMIsACmpInst (
2112   void * jarg1
2113   )
2114 {
2115   void * jresult ;
2116   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2117   LLVMValueRef result;
2118
2119   arg1 = (LLVMValueRef)jarg1;
2120
2121   result = (LLVMValueRef)LLVMIsACmpInst(arg1);
2122   jresult = (void *) result;
2123
2124
2125
2126   return jresult;
2127
2128 }
2129
2130
2131
2132 DllExport void * SWIGSTDCALL Ada_LLVMIsAFCmpInst (
2133   void * jarg1
2134   )
2135 {
2136   void * jresult ;
2137   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2138   LLVMValueRef result;
2139
2140   arg1 = (LLVMValueRef)jarg1;
2141
2142   result = (LLVMValueRef)LLVMIsAFCmpInst(arg1);
2143   jresult = (void *) result;
2144
2145
2146
2147   return jresult;
2148
2149 }
2150
2151
2152
2153 DllExport void * SWIGSTDCALL Ada_LLVMIsAICmpInst (
2154   void * jarg1
2155   )
2156 {
2157   void * jresult ;
2158   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2159   LLVMValueRef result;
2160
2161   arg1 = (LLVMValueRef)jarg1;
2162
2163   result = (LLVMValueRef)LLVMIsAICmpInst(arg1);
2164   jresult = (void *) result;
2165
2166
2167
2168   return jresult;
2169
2170 }
2171
2172
2173
2174 DllExport void * SWIGSTDCALL Ada_LLVMIsAExtractElementInst (
2175   void * jarg1
2176   )
2177 {
2178   void * jresult ;
2179   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2180   LLVMValueRef result;
2181
2182   arg1 = (LLVMValueRef)jarg1;
2183
2184   result = (LLVMValueRef)LLVMIsAExtractElementInst(arg1);
2185   jresult = (void *) result;
2186
2187
2188
2189   return jresult;
2190
2191 }
2192
2193
2194
2195 DllExport void * SWIGSTDCALL Ada_LLVMIsAGetElementPtrInst (
2196   void * jarg1
2197   )
2198 {
2199   void * jresult ;
2200   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2201   LLVMValueRef result;
2202
2203   arg1 = (LLVMValueRef)jarg1;
2204
2205   result = (LLVMValueRef)LLVMIsAGetElementPtrInst(arg1);
2206   jresult = (void *) result;
2207
2208
2209
2210   return jresult;
2211
2212 }
2213
2214
2215
2216 DllExport void * SWIGSTDCALL Ada_LLVMIsAInsertElementInst (
2217   void * jarg1
2218   )
2219 {
2220   void * jresult ;
2221   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2222   LLVMValueRef result;
2223
2224   arg1 = (LLVMValueRef)jarg1;
2225
2226   result = (LLVMValueRef)LLVMIsAInsertElementInst(arg1);
2227   jresult = (void *) result;
2228
2229
2230
2231   return jresult;
2232
2233 }
2234
2235
2236
2237 DllExport void * SWIGSTDCALL Ada_LLVMIsAInsertValueInst (
2238   void * jarg1
2239   )
2240 {
2241   void * jresult ;
2242   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2243   LLVMValueRef result;
2244
2245   arg1 = (LLVMValueRef)jarg1;
2246
2247   result = (LLVMValueRef)LLVMIsAInsertValueInst(arg1);
2248   jresult = (void *) result;
2249
2250
2251
2252   return jresult;
2253
2254 }
2255
2256
2257
2258 DllExport void * SWIGSTDCALL Ada_LLVMIsAPHINode (
2259   void * jarg1
2260   )
2261 {
2262   void * jresult ;
2263   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2264   LLVMValueRef result;
2265
2266   arg1 = (LLVMValueRef)jarg1;
2267
2268   result = (LLVMValueRef)LLVMIsAPHINode(arg1);
2269   jresult = (void *) result;
2270
2271
2272
2273   return jresult;
2274
2275 }
2276
2277
2278
2279 DllExport void * SWIGSTDCALL Ada_LLVMIsASelectInst (
2280   void * jarg1
2281   )
2282 {
2283   void * jresult ;
2284   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2285   LLVMValueRef result;
2286
2287   arg1 = (LLVMValueRef)jarg1;
2288
2289   result = (LLVMValueRef)LLVMIsASelectInst(arg1);
2290   jresult = (void *) result;
2291
2292
2293
2294   return jresult;
2295
2296 }
2297
2298
2299
2300 DllExport void * SWIGSTDCALL Ada_LLVMIsAShuffleVectorInst (
2301   void * jarg1
2302   )
2303 {
2304   void * jresult ;
2305   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2306   LLVMValueRef result;
2307
2308   arg1 = (LLVMValueRef)jarg1;
2309
2310   result = (LLVMValueRef)LLVMIsAShuffleVectorInst(arg1);
2311   jresult = (void *) result;
2312
2313
2314
2315   return jresult;
2316
2317 }
2318
2319
2320
2321 DllExport void * SWIGSTDCALL Ada_LLVMIsAStoreInst (
2322   void * jarg1
2323   )
2324 {
2325   void * jresult ;
2326   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2327   LLVMValueRef result;
2328
2329   arg1 = (LLVMValueRef)jarg1;
2330
2331   result = (LLVMValueRef)LLVMIsAStoreInst(arg1);
2332   jresult = (void *) result;
2333
2334
2335
2336   return jresult;
2337
2338 }
2339
2340
2341
2342 DllExport void * SWIGSTDCALL Ada_LLVMIsATerminatorInst (
2343   void * jarg1
2344   )
2345 {
2346   void * jresult ;
2347   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2348   LLVMValueRef result;
2349
2350   arg1 = (LLVMValueRef)jarg1;
2351
2352   result = (LLVMValueRef)LLVMIsATerminatorInst(arg1);
2353   jresult = (void *) result;
2354
2355
2356
2357   return jresult;
2358
2359 }
2360
2361
2362
2363 DllExport void * SWIGSTDCALL Ada_LLVMIsABranchInst (
2364   void * jarg1
2365   )
2366 {
2367   void * jresult ;
2368   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2369   LLVMValueRef result;
2370
2371   arg1 = (LLVMValueRef)jarg1;
2372
2373   result = (LLVMValueRef)LLVMIsABranchInst(arg1);
2374   jresult = (void *) result;
2375
2376
2377
2378   return jresult;
2379
2380 }
2381
2382
2383
2384 DllExport void * SWIGSTDCALL Ada_LLVMIsAInvokeInst (
2385   void * jarg1
2386   )
2387 {
2388   void * jresult ;
2389   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2390   LLVMValueRef result;
2391
2392   arg1 = (LLVMValueRef)jarg1;
2393
2394   result = (LLVMValueRef)LLVMIsAInvokeInst(arg1);
2395   jresult = (void *) result;
2396
2397
2398
2399   return jresult;
2400
2401 }
2402
2403
2404
2405 DllExport void * SWIGSTDCALL Ada_LLVMIsAReturnInst (
2406   void * jarg1
2407   )
2408 {
2409   void * jresult ;
2410   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2411   LLVMValueRef result;
2412
2413   arg1 = (LLVMValueRef)jarg1;
2414
2415   result = (LLVMValueRef)LLVMIsAReturnInst(arg1);
2416   jresult = (void *) result;
2417
2418
2419
2420   return jresult;
2421
2422 }
2423
2424
2425
2426 DllExport void * SWIGSTDCALL Ada_LLVMIsASwitchInst (
2427   void * jarg1
2428   )
2429 {
2430   void * jresult ;
2431   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2432   LLVMValueRef result;
2433
2434   arg1 = (LLVMValueRef)jarg1;
2435
2436   result = (LLVMValueRef)LLVMIsASwitchInst(arg1);
2437   jresult = (void *) result;
2438
2439
2440
2441   return jresult;
2442
2443 }
2444
2445
2446
2447 DllExport void * SWIGSTDCALL Ada_LLVMIsAUnreachableInst (
2448   void * jarg1
2449   )
2450 {
2451   void * jresult ;
2452   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2453   LLVMValueRef result;
2454
2455   arg1 = (LLVMValueRef)jarg1;
2456
2457   result = (LLVMValueRef)LLVMIsAUnreachableInst(arg1);
2458   jresult = (void *) result;
2459
2460
2461
2462   return jresult;
2463
2464 }
2465
2466
2467
2468 DllExport void * SWIGSTDCALL Ada_LLVMIsAUnwindInst (
2469   void * jarg1
2470   )
2471 {
2472   void * jresult ;
2473   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2474   LLVMValueRef result;
2475
2476   arg1 = (LLVMValueRef)jarg1;
2477
2478   result = (LLVMValueRef)LLVMIsAUnwindInst(arg1);
2479   jresult = (void *) result;
2480
2481
2482
2483   return jresult;
2484
2485 }
2486
2487
2488
2489 DllExport void * SWIGSTDCALL Ada_LLVMIsAUnaryInstruction (
2490   void * jarg1
2491   )
2492 {
2493   void * jresult ;
2494   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2495   LLVMValueRef result;
2496
2497   arg1 = (LLVMValueRef)jarg1;
2498
2499   result = (LLVMValueRef)LLVMIsAUnaryInstruction(arg1);
2500   jresult = (void *) result;
2501
2502
2503
2504   return jresult;
2505
2506 }
2507
2508
2509
2510 DllExport void * SWIGSTDCALL Ada_LLVMIsAAllocationInst (
2511   void * jarg1
2512   )
2513 {
2514   void * jresult ;
2515   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2516   LLVMValueRef result;
2517
2518   arg1 = (LLVMValueRef)jarg1;
2519
2520   result = (LLVMValueRef)LLVMIsAAllocationInst(arg1);
2521   jresult = (void *) result;
2522
2523
2524
2525   return jresult;
2526
2527 }
2528
2529
2530
2531 DllExport void * SWIGSTDCALL Ada_LLVMIsAAllocaInst (
2532   void * jarg1
2533   )
2534 {
2535   void * jresult ;
2536   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2537   LLVMValueRef result;
2538
2539   arg1 = (LLVMValueRef)jarg1;
2540
2541   result = (LLVMValueRef)LLVMIsAAllocaInst(arg1);
2542   jresult = (void *) result;
2543
2544
2545
2546   return jresult;
2547
2548 }
2549
2550
2551
2552 DllExport void * SWIGSTDCALL Ada_LLVMIsAMallocInst (
2553   void * jarg1
2554   )
2555 {
2556   void * jresult ;
2557   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2558   LLVMValueRef result;
2559
2560   arg1 = (LLVMValueRef)jarg1;
2561
2562   result = (LLVMValueRef)LLVMIsAMallocInst(arg1);
2563   jresult = (void *) result;
2564
2565
2566
2567   return jresult;
2568
2569 }
2570
2571
2572
2573 DllExport void * SWIGSTDCALL Ada_LLVMIsACastInst (
2574   void * jarg1
2575   )
2576 {
2577   void * jresult ;
2578   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2579   LLVMValueRef result;
2580
2581   arg1 = (LLVMValueRef)jarg1;
2582
2583   result = (LLVMValueRef)LLVMIsACastInst(arg1);
2584   jresult = (void *) result;
2585
2586
2587
2588   return jresult;
2589
2590 }
2591
2592
2593
2594 DllExport void * SWIGSTDCALL Ada_LLVMIsABitCastInst (
2595   void * jarg1
2596   )
2597 {
2598   void * jresult ;
2599   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2600   LLVMValueRef result;
2601
2602   arg1 = (LLVMValueRef)jarg1;
2603
2604   result = (LLVMValueRef)LLVMIsABitCastInst(arg1);
2605   jresult = (void *) result;
2606
2607
2608
2609   return jresult;
2610
2611 }
2612
2613
2614
2615 DllExport void * SWIGSTDCALL Ada_LLVMIsAFPExtInst (
2616   void * jarg1
2617   )
2618 {
2619   void * jresult ;
2620   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2621   LLVMValueRef result;
2622
2623   arg1 = (LLVMValueRef)jarg1;
2624
2625   result = (LLVMValueRef)LLVMIsAFPExtInst(arg1);
2626   jresult = (void *) result;
2627
2628
2629
2630   return jresult;
2631
2632 }
2633
2634
2635
2636 DllExport void * SWIGSTDCALL Ada_LLVMIsAFPToSIInst (
2637   void * jarg1
2638   )
2639 {
2640   void * jresult ;
2641   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2642   LLVMValueRef result;
2643
2644   arg1 = (LLVMValueRef)jarg1;
2645
2646   result = (LLVMValueRef)LLVMIsAFPToSIInst(arg1);
2647   jresult = (void *) result;
2648
2649
2650
2651   return jresult;
2652
2653 }
2654
2655
2656
2657 DllExport void * SWIGSTDCALL Ada_LLVMIsAFPToUIInst (
2658   void * jarg1
2659   )
2660 {
2661   void * jresult ;
2662   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2663   LLVMValueRef result;
2664
2665   arg1 = (LLVMValueRef)jarg1;
2666
2667   result = (LLVMValueRef)LLVMIsAFPToUIInst(arg1);
2668   jresult = (void *) result;
2669
2670
2671
2672   return jresult;
2673
2674 }
2675
2676
2677
2678 DllExport void * SWIGSTDCALL Ada_LLVMIsAFPTruncInst (
2679   void * jarg1
2680   )
2681 {
2682   void * jresult ;
2683   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2684   LLVMValueRef result;
2685
2686   arg1 = (LLVMValueRef)jarg1;
2687
2688   result = (LLVMValueRef)LLVMIsAFPTruncInst(arg1);
2689   jresult = (void *) result;
2690
2691
2692
2693   return jresult;
2694
2695 }
2696
2697
2698
2699 DllExport void * SWIGSTDCALL Ada_LLVMIsAIntToPtrInst (
2700   void * jarg1
2701   )
2702 {
2703   void * jresult ;
2704   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2705   LLVMValueRef result;
2706
2707   arg1 = (LLVMValueRef)jarg1;
2708
2709   result = (LLVMValueRef)LLVMIsAIntToPtrInst(arg1);
2710   jresult = (void *) result;
2711
2712
2713
2714   return jresult;
2715
2716 }
2717
2718
2719
2720 DllExport void * SWIGSTDCALL Ada_LLVMIsAPtrToIntInst (
2721   void * jarg1
2722   )
2723 {
2724   void * jresult ;
2725   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2726   LLVMValueRef result;
2727
2728   arg1 = (LLVMValueRef)jarg1;
2729
2730   result = (LLVMValueRef)LLVMIsAPtrToIntInst(arg1);
2731   jresult = (void *) result;
2732
2733
2734
2735   return jresult;
2736
2737 }
2738
2739
2740
2741 DllExport void * SWIGSTDCALL Ada_LLVMIsASExtInst (
2742   void * jarg1
2743   )
2744 {
2745   void * jresult ;
2746   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2747   LLVMValueRef result;
2748
2749   arg1 = (LLVMValueRef)jarg1;
2750
2751   result = (LLVMValueRef)LLVMIsASExtInst(arg1);
2752   jresult = (void *) result;
2753
2754
2755
2756   return jresult;
2757
2758 }
2759
2760
2761
2762 DllExport void * SWIGSTDCALL Ada_LLVMIsASIToFPInst (
2763   void * jarg1
2764   )
2765 {
2766   void * jresult ;
2767   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2768   LLVMValueRef result;
2769
2770   arg1 = (LLVMValueRef)jarg1;
2771
2772   result = (LLVMValueRef)LLVMIsASIToFPInst(arg1);
2773   jresult = (void *) result;
2774
2775
2776
2777   return jresult;
2778
2779 }
2780
2781
2782
2783 DllExport void * SWIGSTDCALL Ada_LLVMIsATruncInst (
2784   void * jarg1
2785   )
2786 {
2787   void * jresult ;
2788   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2789   LLVMValueRef result;
2790
2791   arg1 = (LLVMValueRef)jarg1;
2792
2793   result = (LLVMValueRef)LLVMIsATruncInst(arg1);
2794   jresult = (void *) result;
2795
2796
2797
2798   return jresult;
2799
2800 }
2801
2802
2803
2804 DllExport void * SWIGSTDCALL Ada_LLVMIsAUIToFPInst (
2805   void * jarg1
2806   )
2807 {
2808   void * jresult ;
2809   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2810   LLVMValueRef result;
2811
2812   arg1 = (LLVMValueRef)jarg1;
2813
2814   result = (LLVMValueRef)LLVMIsAUIToFPInst(arg1);
2815   jresult = (void *) result;
2816
2817
2818
2819   return jresult;
2820
2821 }
2822
2823
2824
2825 DllExport void * SWIGSTDCALL Ada_LLVMIsAZExtInst (
2826   void * jarg1
2827   )
2828 {
2829   void * jresult ;
2830   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2831   LLVMValueRef result;
2832
2833   arg1 = (LLVMValueRef)jarg1;
2834
2835   result = (LLVMValueRef)LLVMIsAZExtInst(arg1);
2836   jresult = (void *) result;
2837
2838
2839
2840   return jresult;
2841
2842 }
2843
2844
2845
2846 DllExport void * SWIGSTDCALL Ada_LLVMIsAExtractValueInst (
2847   void * jarg1
2848   )
2849 {
2850   void * jresult ;
2851   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2852   LLVMValueRef result;
2853
2854   arg1 = (LLVMValueRef)jarg1;
2855
2856   result = (LLVMValueRef)LLVMIsAExtractValueInst(arg1);
2857   jresult = (void *) result;
2858
2859
2860
2861   return jresult;
2862
2863 }
2864
2865
2866
2867 DllExport void * SWIGSTDCALL Ada_LLVMIsAFreeInst (
2868   void * jarg1
2869   )
2870 {
2871   void * jresult ;
2872   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2873   LLVMValueRef result;
2874
2875   arg1 = (LLVMValueRef)jarg1;
2876
2877   result = (LLVMValueRef)LLVMIsAFreeInst(arg1);
2878   jresult = (void *) result;
2879
2880
2881
2882   return jresult;
2883
2884 }
2885
2886
2887
2888 DllExport void * SWIGSTDCALL Ada_LLVMIsALoadInst (
2889   void * jarg1
2890   )
2891 {
2892   void * jresult ;
2893   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2894   LLVMValueRef result;
2895
2896   arg1 = (LLVMValueRef)jarg1;
2897
2898   result = (LLVMValueRef)LLVMIsALoadInst(arg1);
2899   jresult = (void *) result;
2900
2901
2902
2903   return jresult;
2904
2905 }
2906
2907
2908
2909 DllExport void * SWIGSTDCALL Ada_LLVMIsAVAArgInst (
2910   void * jarg1
2911   )
2912 {
2913   void * jresult ;
2914   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2915   LLVMValueRef result;
2916
2917   arg1 = (LLVMValueRef)jarg1;
2918
2919   result = (LLVMValueRef)LLVMIsAVAArgInst(arg1);
2920   jresult = (void *) result;
2921
2922
2923
2924   return jresult;
2925
2926 }
2927
2928
2929
2930 DllExport void * SWIGSTDCALL Ada_LLVMConstNull (
2931   void * jarg1
2932   )
2933 {
2934   void * jresult ;
2935   LLVMTypeRef arg1 = (LLVMTypeRef) 0 ;
2936   LLVMValueRef result;
2937
2938   arg1 = (LLVMTypeRef)jarg1;
2939
2940   result = (LLVMValueRef)LLVMConstNull(arg1);
2941   jresult = (void *) result;
2942
2943
2944
2945   return jresult;
2946
2947 }
2948
2949
2950
2951 DllExport void * SWIGSTDCALL Ada_LLVMConstAllOnes (
2952   void * jarg1
2953   )
2954 {
2955   void * jresult ;
2956   LLVMTypeRef arg1 = (LLVMTypeRef) 0 ;
2957   LLVMValueRef result;
2958
2959   arg1 = (LLVMTypeRef)jarg1;
2960
2961   result = (LLVMValueRef)LLVMConstAllOnes(arg1);
2962   jresult = (void *) result;
2963
2964
2965
2966   return jresult;
2967
2968 }
2969
2970
2971
2972 DllExport void * SWIGSTDCALL Ada_LLVMGetUndef (
2973   void * jarg1
2974   )
2975 {
2976   void * jresult ;
2977   LLVMTypeRef arg1 = (LLVMTypeRef) 0 ;
2978   LLVMValueRef result;
2979
2980   arg1 = (LLVMTypeRef)jarg1;
2981
2982   result = (LLVMValueRef)LLVMGetUndef(arg1);
2983   jresult = (void *) result;
2984
2985
2986
2987   return jresult;
2988
2989 }
2990
2991
2992
2993 DllExport int SWIGSTDCALL Ada_LLVMIsConstant (
2994   void * jarg1
2995   )
2996 {
2997   int jresult ;
2998   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
2999   int result;
3000
3001   arg1 = (LLVMValueRef)jarg1;
3002
3003   result = (int)LLVMIsConstant(arg1);
3004   jresult = result;
3005
3006
3007
3008   return jresult;
3009
3010 }
3011
3012
3013
3014 DllExport int SWIGSTDCALL Ada_LLVMIsNull (
3015   void * jarg1
3016   )
3017 {
3018   int jresult ;
3019   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
3020   int result;
3021
3022   arg1 = (LLVMValueRef)jarg1;
3023
3024   result = (int)LLVMIsNull(arg1);
3025   jresult = result;
3026
3027
3028
3029   return jresult;
3030
3031 }
3032
3033
3034
3035 DllExport int SWIGSTDCALL Ada_LLVMIsUndef (
3036   void * jarg1
3037   )
3038 {
3039   int jresult ;
3040   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
3041   int result;
3042
3043   arg1 = (LLVMValueRef)jarg1;
3044
3045   result = (int)LLVMIsUndef(arg1);
3046   jresult = result;
3047
3048
3049
3050   return jresult;
3051
3052 }
3053
3054
3055
3056 DllExport void * SWIGSTDCALL Ada_LLVMConstPointerNull (
3057   void * jarg1
3058   )
3059 {
3060   void * jresult ;
3061   LLVMTypeRef arg1 = (LLVMTypeRef) 0 ;
3062   LLVMValueRef result;
3063
3064   arg1 = (LLVMTypeRef)jarg1;
3065
3066   result = (LLVMValueRef)LLVMConstPointerNull(arg1);
3067   jresult = (void *) result;
3068
3069
3070
3071   return jresult;
3072
3073 }
3074
3075
3076
3077 DllExport void * SWIGSTDCALL Ada_LLVMConstInt (
3078   void * jarg1
3079   ,
3080
3081   unsigned long long jarg2
3082   ,
3083
3084   int jarg3
3085   )
3086 {
3087   void * jresult ;
3088   LLVMTypeRef arg1 = (LLVMTypeRef) 0 ;
3089   unsigned long long arg2 ;
3090   int arg3 ;
3091   LLVMValueRef result;
3092
3093   arg1 = (LLVMTypeRef)jarg1;
3094
3095
3096   arg2 = (unsigned long long) jarg2;
3097
3098
3099
3100   arg3 = (int) jarg3;
3101
3102
3103   result = (LLVMValueRef)LLVMConstInt(arg1,arg2,arg3);
3104   jresult = (void *) result;
3105
3106
3107
3108   return jresult;
3109
3110 }
3111
3112
3113
3114 DllExport void * SWIGSTDCALL Ada_LLVMConstReal (
3115   void * jarg1
3116   ,
3117
3118   double jarg2
3119   )
3120 {
3121   void * jresult ;
3122   LLVMTypeRef arg1 = (LLVMTypeRef) 0 ;
3123   double arg2 ;
3124   LLVMValueRef result;
3125
3126   arg1 = (LLVMTypeRef)jarg1;
3127
3128
3129   arg2 = (double) jarg2;
3130
3131
3132   result = (LLVMValueRef)LLVMConstReal(arg1,arg2);
3133   jresult = (void *) result;
3134
3135
3136
3137   return jresult;
3138
3139 }
3140
3141
3142
3143 DllExport void * SWIGSTDCALL Ada_LLVMConstRealOfString (
3144   void * jarg1
3145   ,
3146
3147   char * jarg2
3148   )
3149 {
3150   void * jresult ;
3151   LLVMTypeRef arg1 = (LLVMTypeRef) 0 ;
3152   char *arg2 = (char *) 0 ;
3153   LLVMValueRef result;
3154
3155   arg1 = (LLVMTypeRef)jarg1;
3156
3157   arg2 = jarg2;
3158
3159   result = (LLVMValueRef)LLVMConstRealOfString(arg1,(char const *)arg2);
3160   jresult = (void *) result;
3161
3162
3163
3164   return jresult;
3165
3166 }
3167
3168
3169
3170 DllExport void * SWIGSTDCALL Ada_LLVMConstString (
3171   char * jarg1
3172   ,
3173
3174   unsigned int jarg2
3175   ,
3176
3177   int jarg3
3178   )
3179 {
3180   void * jresult ;
3181   char *arg1 = (char *) 0 ;
3182   unsigned int arg2 ;
3183   int arg3 ;
3184   LLVMValueRef result;
3185
3186   arg1 = jarg1;
3187
3188
3189   arg2 = (unsigned int) jarg2;
3190
3191
3192
3193   arg3 = (int) jarg3;
3194
3195
3196   result = (LLVMValueRef)LLVMConstString((char const *)arg1,arg2,arg3);
3197   jresult = (void *) result;
3198
3199
3200
3201   return jresult;
3202
3203 }
3204
3205
3206
3207 DllExport void * SWIGSTDCALL Ada_LLVMConstArray (
3208   void * jarg1
3209   ,
3210
3211   void * jarg2
3212   ,
3213
3214   unsigned int jarg3
3215   )
3216 {
3217   void * jresult ;
3218   LLVMTypeRef arg1 = (LLVMTypeRef) 0 ;
3219   LLVMValueRef *arg2 = (LLVMValueRef *) 0 ;
3220   unsigned int arg3 ;
3221   LLVMValueRef result;
3222
3223   arg1 = (LLVMTypeRef)jarg1;
3224
3225   arg2 = (LLVMValueRef *)jarg2;
3226
3227
3228   arg3 = (unsigned int) jarg3;
3229
3230
3231   result = (LLVMValueRef)LLVMConstArray(arg1,arg2,arg3);
3232   jresult = (void *) result;
3233
3234
3235
3236   return jresult;
3237
3238 }
3239
3240
3241
3242 DllExport void * SWIGSTDCALL Ada_LLVMConstStruct (
3243   void * jarg1
3244   ,
3245
3246   unsigned int jarg2
3247   ,
3248
3249   int jarg3
3250   )
3251 {
3252   void * jresult ;
3253   LLVMValueRef *arg1 = (LLVMValueRef *) 0 ;
3254   unsigned int arg2 ;
3255   int arg3 ;
3256   LLVMValueRef result;
3257
3258   arg1 = (LLVMValueRef *)jarg1;
3259
3260
3261   arg2 = (unsigned int) jarg2;
3262
3263
3264
3265   arg3 = (int) jarg3;
3266
3267
3268   result = (LLVMValueRef)LLVMConstStruct(arg1,arg2,arg3);
3269   jresult = (void *) result;
3270
3271
3272
3273   return jresult;
3274
3275 }
3276
3277
3278
3279 DllExport void * SWIGSTDCALL Ada_LLVMConstVector (
3280   void * jarg1
3281   ,
3282
3283   unsigned int jarg2
3284   )
3285 {
3286   void * jresult ;
3287   LLVMValueRef *arg1 = (LLVMValueRef *) 0 ;
3288   unsigned int arg2 ;
3289   LLVMValueRef result;
3290
3291   arg1 = (LLVMValueRef *)jarg1;
3292
3293
3294   arg2 = (unsigned int) jarg2;
3295
3296
3297   result = (LLVMValueRef)LLVMConstVector(arg1,arg2);
3298   jresult = (void *) result;
3299
3300
3301
3302   return jresult;
3303
3304 }
3305
3306
3307
3308 DllExport void * SWIGSTDCALL Ada_LLVMSizeOf (
3309   void * jarg1
3310   )
3311 {
3312   void * jresult ;
3313   LLVMTypeRef arg1 = (LLVMTypeRef) 0 ;
3314   LLVMValueRef result;
3315
3316   arg1 = (LLVMTypeRef)jarg1;
3317
3318   result = (LLVMValueRef)LLVMSizeOf(arg1);
3319   jresult = (void *) result;
3320
3321
3322
3323   return jresult;
3324
3325 }
3326
3327
3328
3329 DllExport void * SWIGSTDCALL Ada_LLVMConstNeg (
3330   void * jarg1
3331   )
3332 {
3333   void * jresult ;
3334   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
3335   LLVMValueRef result;
3336
3337   arg1 = (LLVMValueRef)jarg1;
3338
3339   result = (LLVMValueRef)LLVMConstNeg(arg1);
3340   jresult = (void *) result;
3341
3342
3343
3344   return jresult;
3345
3346 }
3347
3348
3349
3350 DllExport void * SWIGSTDCALL Ada_LLVMConstNot (
3351   void * jarg1
3352   )
3353 {
3354   void * jresult ;
3355   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
3356   LLVMValueRef result;
3357
3358   arg1 = (LLVMValueRef)jarg1;
3359
3360   result = (LLVMValueRef)LLVMConstNot(arg1);
3361   jresult = (void *) result;
3362
3363
3364
3365   return jresult;
3366
3367 }
3368
3369
3370
3371 DllExport void * SWIGSTDCALL Ada_LLVMConstAdd (
3372   void * jarg1
3373   ,
3374
3375   void * jarg2
3376   )
3377 {
3378   void * jresult ;
3379   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
3380   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
3381   LLVMValueRef result;
3382
3383   arg1 = (LLVMValueRef)jarg1;
3384
3385   arg2 = (LLVMValueRef)jarg2;
3386
3387   result = (LLVMValueRef)LLVMConstAdd(arg1,arg2);
3388   jresult = (void *) result;
3389
3390
3391
3392   return jresult;
3393
3394 }
3395
3396
3397
3398 DllExport void * SWIGSTDCALL Ada_LLVMConstSub (
3399   void * jarg1
3400   ,
3401
3402   void * jarg2
3403   )
3404 {
3405   void * jresult ;
3406   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
3407   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
3408   LLVMValueRef result;
3409
3410   arg1 = (LLVMValueRef)jarg1;
3411
3412   arg2 = (LLVMValueRef)jarg2;
3413
3414   result = (LLVMValueRef)LLVMConstSub(arg1,arg2);
3415   jresult = (void *) result;
3416
3417
3418
3419   return jresult;
3420
3421 }
3422
3423
3424
3425 DllExport void * SWIGSTDCALL Ada_LLVMConstMul (
3426   void * jarg1
3427   ,
3428
3429   void * jarg2
3430   )
3431 {
3432   void * jresult ;
3433   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
3434   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
3435   LLVMValueRef result;
3436
3437   arg1 = (LLVMValueRef)jarg1;
3438
3439   arg2 = (LLVMValueRef)jarg2;
3440
3441   result = (LLVMValueRef)LLVMConstMul(arg1,arg2);
3442   jresult = (void *) result;
3443
3444
3445
3446   return jresult;
3447
3448 }
3449
3450
3451
3452 DllExport void * SWIGSTDCALL Ada_LLVMConstUDiv (
3453   void * jarg1
3454   ,
3455
3456   void * jarg2
3457   )
3458 {
3459   void * jresult ;
3460   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
3461   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
3462   LLVMValueRef result;
3463
3464   arg1 = (LLVMValueRef)jarg1;
3465
3466   arg2 = (LLVMValueRef)jarg2;
3467
3468   result = (LLVMValueRef)LLVMConstUDiv(arg1,arg2);
3469   jresult = (void *) result;
3470
3471
3472
3473   return jresult;
3474
3475 }
3476
3477
3478
3479 DllExport void * SWIGSTDCALL Ada_LLVMConstSDiv (
3480   void * jarg1
3481   ,
3482
3483   void * jarg2
3484   )
3485 {
3486   void * jresult ;
3487   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
3488   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
3489   LLVMValueRef result;
3490
3491   arg1 = (LLVMValueRef)jarg1;
3492
3493   arg2 = (LLVMValueRef)jarg2;
3494
3495   result = (LLVMValueRef)LLVMConstSDiv(arg1,arg2);
3496   jresult = (void *) result;
3497
3498
3499
3500   return jresult;
3501
3502 }
3503
3504
3505
3506 DllExport void * SWIGSTDCALL Ada_LLVMConstFDiv (
3507   void * jarg1
3508   ,
3509
3510   void * jarg2
3511   )
3512 {
3513   void * jresult ;
3514   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
3515   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
3516   LLVMValueRef result;
3517
3518   arg1 = (LLVMValueRef)jarg1;
3519
3520   arg2 = (LLVMValueRef)jarg2;
3521
3522   result = (LLVMValueRef)LLVMConstFDiv(arg1,arg2);
3523   jresult = (void *) result;
3524
3525
3526
3527   return jresult;
3528
3529 }
3530
3531
3532
3533 DllExport void * SWIGSTDCALL Ada_LLVMConstURem (
3534   void * jarg1
3535   ,
3536
3537   void * jarg2
3538   )
3539 {
3540   void * jresult ;
3541   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
3542   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
3543   LLVMValueRef result;
3544
3545   arg1 = (LLVMValueRef)jarg1;
3546
3547   arg2 = (LLVMValueRef)jarg2;
3548
3549   result = (LLVMValueRef)LLVMConstURem(arg1,arg2);
3550   jresult = (void *) result;
3551
3552
3553
3554   return jresult;
3555
3556 }
3557
3558
3559
3560 DllExport void * SWIGSTDCALL Ada_LLVMConstSRem (
3561   void * jarg1
3562   ,
3563
3564   void * jarg2
3565   )
3566 {
3567   void * jresult ;
3568   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
3569   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
3570   LLVMValueRef result;
3571
3572   arg1 = (LLVMValueRef)jarg1;
3573
3574   arg2 = (LLVMValueRef)jarg2;
3575
3576   result = (LLVMValueRef)LLVMConstSRem(arg1,arg2);
3577   jresult = (void *) result;
3578
3579
3580
3581   return jresult;
3582
3583 }
3584
3585
3586
3587 DllExport void * SWIGSTDCALL Ada_LLVMConstFRem (
3588   void * jarg1
3589   ,
3590
3591   void * jarg2
3592   )
3593 {
3594   void * jresult ;
3595   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
3596   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
3597   LLVMValueRef result;
3598
3599   arg1 = (LLVMValueRef)jarg1;
3600
3601   arg2 = (LLVMValueRef)jarg2;
3602
3603   result = (LLVMValueRef)LLVMConstFRem(arg1,arg2);
3604   jresult = (void *) result;
3605
3606
3607
3608   return jresult;
3609
3610 }
3611
3612
3613
3614 DllExport void * SWIGSTDCALL Ada_LLVMConstAnd (
3615   void * jarg1
3616   ,
3617
3618   void * jarg2
3619   )
3620 {
3621   void * jresult ;
3622   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
3623   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
3624   LLVMValueRef result;
3625
3626   arg1 = (LLVMValueRef)jarg1;
3627
3628   arg2 = (LLVMValueRef)jarg2;
3629
3630   result = (LLVMValueRef)LLVMConstAnd(arg1,arg2);
3631   jresult = (void *) result;
3632
3633
3634
3635   return jresult;
3636
3637 }
3638
3639
3640
3641 DllExport void * SWIGSTDCALL Ada_LLVMConstOr (
3642   void * jarg1
3643   ,
3644
3645   void * jarg2
3646   )
3647 {
3648   void * jresult ;
3649   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
3650   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
3651   LLVMValueRef result;
3652
3653   arg1 = (LLVMValueRef)jarg1;
3654
3655   arg2 = (LLVMValueRef)jarg2;
3656
3657   result = (LLVMValueRef)LLVMConstOr(arg1,arg2);
3658   jresult = (void *) result;
3659
3660
3661
3662   return jresult;
3663
3664 }
3665
3666
3667
3668 DllExport void * SWIGSTDCALL Ada_LLVMConstXor (
3669   void * jarg1
3670   ,
3671
3672   void * jarg2
3673   )
3674 {
3675   void * jresult ;
3676   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
3677   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
3678   LLVMValueRef result;
3679
3680   arg1 = (LLVMValueRef)jarg1;
3681
3682   arg2 = (LLVMValueRef)jarg2;
3683
3684   result = (LLVMValueRef)LLVMConstXor(arg1,arg2);
3685   jresult = (void *) result;
3686
3687
3688
3689   return jresult;
3690
3691 }
3692
3693
3694
3695 DllExport void * SWIGSTDCALL Ada_LLVMConstICmp (
3696   int jarg1
3697   ,
3698
3699   void * jarg2
3700   ,
3701
3702   void * jarg3
3703   )
3704 {
3705   void * jresult ;
3706   LLVMIntPredicate arg1 ;
3707   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
3708   LLVMValueRef arg3 = (LLVMValueRef) 0 ;
3709   LLVMValueRef result;
3710
3711   arg1 = (LLVMIntPredicate) jarg1;
3712
3713   arg2 = (LLVMValueRef)jarg2;
3714
3715   arg3 = (LLVMValueRef)jarg3;
3716
3717   result = (LLVMValueRef)LLVMConstICmp(arg1,arg2,arg3);
3718   jresult = (void *) result;
3719
3720
3721
3722   return jresult;
3723
3724 }
3725
3726
3727
3728 DllExport void * SWIGSTDCALL Ada_LLVMConstFCmp (
3729   int jarg1
3730   ,
3731
3732   void * jarg2
3733   ,
3734
3735   void * jarg3
3736   )
3737 {
3738   void * jresult ;
3739   LLVMRealPredicate arg1 ;
3740   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
3741   LLVMValueRef arg3 = (LLVMValueRef) 0 ;
3742   LLVMValueRef result;
3743
3744   arg1 = (LLVMRealPredicate) jarg1;
3745
3746   arg2 = (LLVMValueRef)jarg2;
3747
3748   arg3 = (LLVMValueRef)jarg3;
3749
3750   result = (LLVMValueRef)LLVMConstFCmp(arg1,arg2,arg3);
3751   jresult = (void *) result;
3752
3753
3754
3755   return jresult;
3756
3757 }
3758
3759
3760
3761 DllExport void * SWIGSTDCALL Ada_LLVMConstShl (
3762   void * jarg1
3763   ,
3764
3765   void * jarg2
3766   )
3767 {
3768   void * jresult ;
3769   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
3770   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
3771   LLVMValueRef result;
3772
3773   arg1 = (LLVMValueRef)jarg1;
3774
3775   arg2 = (LLVMValueRef)jarg2;
3776
3777   result = (LLVMValueRef)LLVMConstShl(arg1,arg2);
3778   jresult = (void *) result;
3779
3780
3781
3782   return jresult;
3783
3784 }
3785
3786
3787
3788 DllExport void * SWIGSTDCALL Ada_LLVMConstLShr (
3789   void * jarg1
3790   ,
3791
3792   void * jarg2
3793   )
3794 {
3795   void * jresult ;
3796   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
3797   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
3798   LLVMValueRef result;
3799
3800   arg1 = (LLVMValueRef)jarg1;
3801
3802   arg2 = (LLVMValueRef)jarg2;
3803
3804   result = (LLVMValueRef)LLVMConstLShr(arg1,arg2);
3805   jresult = (void *) result;
3806
3807
3808
3809   return jresult;
3810
3811 }
3812
3813
3814
3815 DllExport void * SWIGSTDCALL Ada_LLVMConstAShr (
3816   void * jarg1
3817   ,
3818
3819   void * jarg2
3820   )
3821 {
3822   void * jresult ;
3823   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
3824   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
3825   LLVMValueRef result;
3826
3827   arg1 = (LLVMValueRef)jarg1;
3828
3829   arg2 = (LLVMValueRef)jarg2;
3830
3831   result = (LLVMValueRef)LLVMConstAShr(arg1,arg2);
3832   jresult = (void *) result;
3833
3834
3835
3836   return jresult;
3837
3838 }
3839
3840
3841
3842 DllExport void * SWIGSTDCALL Ada_LLVMConstGEP (
3843   void * jarg1
3844   ,
3845
3846   void * jarg2
3847   ,
3848
3849   unsigned int jarg3
3850   )
3851 {
3852   void * jresult ;
3853   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
3854   LLVMValueRef *arg2 = (LLVMValueRef *) 0 ;
3855   unsigned int arg3 ;
3856   LLVMValueRef result;
3857
3858   arg1 = (LLVMValueRef)jarg1;
3859
3860   arg2 = (LLVMValueRef *)jarg2;
3861
3862
3863   arg3 = (unsigned int) jarg3;
3864
3865
3866   result = (LLVMValueRef)LLVMConstGEP(arg1,arg2,arg3);
3867   jresult = (void *) result;
3868
3869
3870
3871   return jresult;
3872
3873 }
3874
3875
3876
3877 DllExport void * SWIGSTDCALL Ada_LLVMConstTrunc (
3878   void * jarg1
3879   ,
3880
3881   void * jarg2
3882   )
3883 {
3884   void * jresult ;
3885   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
3886   LLVMTypeRef arg2 = (LLVMTypeRef) 0 ;
3887   LLVMValueRef result;
3888
3889   arg1 = (LLVMValueRef)jarg1;
3890
3891   arg2 = (LLVMTypeRef)jarg2;
3892
3893   result = (LLVMValueRef)LLVMConstTrunc(arg1,arg2);
3894   jresult = (void *) result;
3895
3896
3897
3898   return jresult;
3899
3900 }
3901
3902
3903
3904 DllExport void * SWIGSTDCALL Ada_LLVMConstSExt (
3905   void * jarg1
3906   ,
3907
3908   void * jarg2
3909   )
3910 {
3911   void * jresult ;
3912   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
3913   LLVMTypeRef arg2 = (LLVMTypeRef) 0 ;
3914   LLVMValueRef result;
3915
3916   arg1 = (LLVMValueRef)jarg1;
3917
3918   arg2 = (LLVMTypeRef)jarg2;
3919
3920   result = (LLVMValueRef)LLVMConstSExt(arg1,arg2);
3921   jresult = (void *) result;
3922
3923
3924
3925   return jresult;
3926
3927 }
3928
3929
3930
3931 DllExport void * SWIGSTDCALL Ada_LLVMConstZExt (
3932   void * jarg1
3933   ,
3934
3935   void * jarg2
3936   )
3937 {
3938   void * jresult ;
3939   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
3940   LLVMTypeRef arg2 = (LLVMTypeRef) 0 ;
3941   LLVMValueRef result;
3942
3943   arg1 = (LLVMValueRef)jarg1;
3944
3945   arg2 = (LLVMTypeRef)jarg2;
3946
3947   result = (LLVMValueRef)LLVMConstZExt(arg1,arg2);
3948   jresult = (void *) result;
3949
3950
3951
3952   return jresult;
3953
3954 }
3955
3956
3957
3958 DllExport void * SWIGSTDCALL Ada_LLVMConstFPTrunc (
3959   void * jarg1
3960   ,
3961
3962   void * jarg2
3963   )
3964 {
3965   void * jresult ;
3966   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
3967   LLVMTypeRef arg2 = (LLVMTypeRef) 0 ;
3968   LLVMValueRef result;
3969
3970   arg1 = (LLVMValueRef)jarg1;
3971
3972   arg2 = (LLVMTypeRef)jarg2;
3973
3974   result = (LLVMValueRef)LLVMConstFPTrunc(arg1,arg2);
3975   jresult = (void *) result;
3976
3977
3978
3979   return jresult;
3980
3981 }
3982
3983
3984
3985 DllExport void * SWIGSTDCALL Ada_LLVMConstFPExt (
3986   void * jarg1
3987   ,
3988
3989   void * jarg2
3990   )
3991 {
3992   void * jresult ;
3993   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
3994   LLVMTypeRef arg2 = (LLVMTypeRef) 0 ;
3995   LLVMValueRef result;
3996
3997   arg1 = (LLVMValueRef)jarg1;
3998
3999   arg2 = (LLVMTypeRef)jarg2;
4000
4001   result = (LLVMValueRef)LLVMConstFPExt(arg1,arg2);
4002   jresult = (void *) result;
4003
4004
4005
4006   return jresult;
4007
4008 }
4009
4010
4011
4012 DllExport void * SWIGSTDCALL Ada_LLVMConstUIToFP (
4013   void * jarg1
4014   ,
4015
4016   void * jarg2
4017   )
4018 {
4019   void * jresult ;
4020   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
4021   LLVMTypeRef arg2 = (LLVMTypeRef) 0 ;
4022   LLVMValueRef result;
4023
4024   arg1 = (LLVMValueRef)jarg1;
4025
4026   arg2 = (LLVMTypeRef)jarg2;
4027
4028   result = (LLVMValueRef)LLVMConstUIToFP(arg1,arg2);
4029   jresult = (void *) result;
4030
4031
4032
4033   return jresult;
4034
4035 }
4036
4037
4038
4039 DllExport void * SWIGSTDCALL Ada_LLVMConstSIToFP (
4040   void * jarg1
4041   ,
4042
4043   void * jarg2
4044   )
4045 {
4046   void * jresult ;
4047   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
4048   LLVMTypeRef arg2 = (LLVMTypeRef) 0 ;
4049   LLVMValueRef result;
4050
4051   arg1 = (LLVMValueRef)jarg1;
4052
4053   arg2 = (LLVMTypeRef)jarg2;
4054
4055   result = (LLVMValueRef)LLVMConstSIToFP(arg1,arg2);
4056   jresult = (void *) result;
4057
4058
4059
4060   return jresult;
4061
4062 }
4063
4064
4065
4066 DllExport void * SWIGSTDCALL Ada_LLVMConstFPToUI (
4067   void * jarg1
4068   ,
4069
4070   void * jarg2
4071   )
4072 {
4073   void * jresult ;
4074   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
4075   LLVMTypeRef arg2 = (LLVMTypeRef) 0 ;
4076   LLVMValueRef result;
4077
4078   arg1 = (LLVMValueRef)jarg1;
4079
4080   arg2 = (LLVMTypeRef)jarg2;
4081
4082   result = (LLVMValueRef)LLVMConstFPToUI(arg1,arg2);
4083   jresult = (void *) result;
4084
4085
4086
4087   return jresult;
4088
4089 }
4090
4091
4092
4093 DllExport void * SWIGSTDCALL Ada_LLVMConstFPToSI (
4094   void * jarg1
4095   ,
4096
4097   void * jarg2
4098   )
4099 {
4100   void * jresult ;
4101   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
4102   LLVMTypeRef arg2 = (LLVMTypeRef) 0 ;
4103   LLVMValueRef result;
4104
4105   arg1 = (LLVMValueRef)jarg1;
4106
4107   arg2 = (LLVMTypeRef)jarg2;
4108
4109   result = (LLVMValueRef)LLVMConstFPToSI(arg1,arg2);
4110   jresult = (void *) result;
4111
4112
4113
4114   return jresult;
4115
4116 }
4117
4118
4119
4120 DllExport void * SWIGSTDCALL Ada_LLVMConstPtrToInt (
4121   void * jarg1
4122   ,
4123
4124   void * jarg2
4125   )
4126 {
4127   void * jresult ;
4128   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
4129   LLVMTypeRef arg2 = (LLVMTypeRef) 0 ;
4130   LLVMValueRef result;
4131
4132   arg1 = (LLVMValueRef)jarg1;
4133
4134   arg2 = (LLVMTypeRef)jarg2;
4135
4136   result = (LLVMValueRef)LLVMConstPtrToInt(arg1,arg2);
4137   jresult = (void *) result;
4138
4139
4140
4141   return jresult;
4142
4143 }
4144
4145
4146
4147 DllExport void * SWIGSTDCALL Ada_LLVMConstIntToPtr (
4148   void * jarg1
4149   ,
4150
4151   void * jarg2
4152   )
4153 {
4154   void * jresult ;
4155   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
4156   LLVMTypeRef arg2 = (LLVMTypeRef) 0 ;
4157   LLVMValueRef result;
4158
4159   arg1 = (LLVMValueRef)jarg1;
4160
4161   arg2 = (LLVMTypeRef)jarg2;
4162
4163   result = (LLVMValueRef)LLVMConstIntToPtr(arg1,arg2);
4164   jresult = (void *) result;
4165
4166
4167
4168   return jresult;
4169
4170 }
4171
4172
4173
4174 DllExport void * SWIGSTDCALL Ada_LLVMConstBitCast (
4175   void * jarg1
4176   ,
4177
4178   void * jarg2
4179   )
4180 {
4181   void * jresult ;
4182   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
4183   LLVMTypeRef arg2 = (LLVMTypeRef) 0 ;
4184   LLVMValueRef result;
4185
4186   arg1 = (LLVMValueRef)jarg1;
4187
4188   arg2 = (LLVMTypeRef)jarg2;
4189
4190   result = (LLVMValueRef)LLVMConstBitCast(arg1,arg2);
4191   jresult = (void *) result;
4192
4193
4194
4195   return jresult;
4196
4197 }
4198
4199
4200
4201 DllExport void * SWIGSTDCALL Ada_LLVMConstSelect (
4202   void * jarg1
4203   ,
4204
4205   void * jarg2
4206   ,
4207
4208   void * jarg3
4209   )
4210 {
4211   void * jresult ;
4212   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
4213   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
4214   LLVMValueRef arg3 = (LLVMValueRef) 0 ;
4215   LLVMValueRef result;
4216
4217   arg1 = (LLVMValueRef)jarg1;
4218
4219   arg2 = (LLVMValueRef)jarg2;
4220
4221   arg3 = (LLVMValueRef)jarg3;
4222
4223   result = (LLVMValueRef)LLVMConstSelect(arg1,arg2,arg3);
4224   jresult = (void *) result;
4225
4226
4227
4228   return jresult;
4229
4230 }
4231
4232
4233
4234 DllExport void * SWIGSTDCALL Ada_LLVMConstExtractElement (
4235   void * jarg1
4236   ,
4237
4238   void * jarg2
4239   )
4240 {
4241   void * jresult ;
4242   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
4243   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
4244   LLVMValueRef result;
4245
4246   arg1 = (LLVMValueRef)jarg1;
4247
4248   arg2 = (LLVMValueRef)jarg2;
4249
4250   result = (LLVMValueRef)LLVMConstExtractElement(arg1,arg2);
4251   jresult = (void *) result;
4252
4253
4254
4255   return jresult;
4256
4257 }
4258
4259
4260
4261 DllExport void * SWIGSTDCALL Ada_LLVMConstInsertElement (
4262   void * jarg1
4263   ,
4264
4265   void * jarg2
4266   ,
4267
4268   void * jarg3
4269   )
4270 {
4271   void * jresult ;
4272   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
4273   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
4274   LLVMValueRef arg3 = (LLVMValueRef) 0 ;
4275   LLVMValueRef result;
4276
4277   arg1 = (LLVMValueRef)jarg1;
4278
4279   arg2 = (LLVMValueRef)jarg2;
4280
4281   arg3 = (LLVMValueRef)jarg3;
4282
4283   result = (LLVMValueRef)LLVMConstInsertElement(arg1,arg2,arg3);
4284   jresult = (void *) result;
4285
4286
4287
4288   return jresult;
4289
4290 }
4291
4292
4293
4294 DllExport void * SWIGSTDCALL Ada_LLVMConstShuffleVector (
4295   void * jarg1
4296   ,
4297
4298   void * jarg2
4299   ,
4300
4301   void * jarg3
4302   )
4303 {
4304   void * jresult ;
4305   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
4306   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
4307   LLVMValueRef arg3 = (LLVMValueRef) 0 ;
4308   LLVMValueRef result;
4309
4310   arg1 = (LLVMValueRef)jarg1;
4311
4312   arg2 = (LLVMValueRef)jarg2;
4313
4314   arg3 = (LLVMValueRef)jarg3;
4315
4316   result = (LLVMValueRef)LLVMConstShuffleVector(arg1,arg2,arg3);
4317   jresult = (void *) result;
4318
4319
4320
4321   return jresult;
4322
4323 }
4324
4325
4326
4327 DllExport void * SWIGSTDCALL Ada_LLVMConstExtractValue (
4328   void * jarg1
4329   ,
4330
4331   unsigned int* jarg2
4332   ,
4333
4334   unsigned int jarg3
4335   )
4336 {
4337   void * jresult ;
4338   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
4339   unsigned int *arg2 = (unsigned int *) 0 ;
4340   unsigned int arg3 ;
4341   LLVMValueRef result;
4342
4343   arg1 = (LLVMValueRef)jarg1;
4344
4345
4346   arg2 = (unsigned int *) jarg2;
4347
4348
4349
4350   arg3 = (unsigned int) jarg3;
4351
4352
4353   result = (LLVMValueRef)LLVMConstExtractValue(arg1,arg2,arg3);
4354   jresult = (void *) result;
4355
4356
4357
4358   return jresult;
4359
4360 }
4361
4362
4363
4364 DllExport void * SWIGSTDCALL Ada_LLVMConstInsertValue (
4365   void * jarg1
4366   ,
4367
4368   void * jarg2
4369   ,
4370
4371   unsigned int* jarg3
4372   ,
4373
4374   unsigned int jarg4
4375   )
4376 {
4377   void * jresult ;
4378   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
4379   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
4380   unsigned int *arg3 = (unsigned int *) 0 ;
4381   unsigned int arg4 ;
4382   LLVMValueRef result;
4383
4384   arg1 = (LLVMValueRef)jarg1;
4385
4386   arg2 = (LLVMValueRef)jarg2;
4387
4388
4389   arg3 = (unsigned int *) jarg3;
4390
4391
4392
4393   arg4 = (unsigned int) jarg4;
4394
4395
4396   result = (LLVMValueRef)LLVMConstInsertValue(arg1,arg2,arg3,arg4);
4397   jresult = (void *) result;
4398
4399
4400
4401   return jresult;
4402
4403 }
4404
4405
4406
4407 DllExport void * SWIGSTDCALL Ada_LLVMConstInlineAsm (
4408   void * jarg1
4409   ,
4410
4411   char * jarg2
4412   ,
4413
4414   char * jarg3
4415   ,
4416
4417   int jarg4
4418   )
4419 {
4420   void * jresult ;
4421   LLVMTypeRef arg1 = (LLVMTypeRef) 0 ;
4422   char *arg2 = (char *) 0 ;
4423   char *arg3 = (char *) 0 ;
4424   int arg4 ;
4425   LLVMValueRef result;
4426
4427   arg1 = (LLVMTypeRef)jarg1;
4428
4429   arg2 = jarg2;
4430
4431   arg3 = jarg3;
4432
4433
4434   arg4 = (int) jarg4;
4435
4436
4437   result = (LLVMValueRef)LLVMConstInlineAsm(arg1,(char const *)arg2,(char const *)arg3,arg4);
4438   jresult = (void *) result;
4439
4440
4441
4442   return jresult;
4443
4444 }
4445
4446
4447
4448 DllExport void * SWIGSTDCALL Ada_LLVMGetGlobalParent (
4449   void * jarg1
4450   )
4451 {
4452   void * jresult ;
4453   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
4454   LLVMModuleRef result;
4455
4456   arg1 = (LLVMValueRef)jarg1;
4457
4458   result = (LLVMModuleRef)LLVMGetGlobalParent(arg1);
4459   jresult = (void *) result;
4460
4461
4462
4463   return jresult;
4464
4465 }
4466
4467
4468
4469 DllExport int SWIGSTDCALL Ada_LLVMIsDeclaration (
4470   void * jarg1
4471   )
4472 {
4473   int jresult ;
4474   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
4475   int result;
4476
4477   arg1 = (LLVMValueRef)jarg1;
4478
4479   result = (int)LLVMIsDeclaration(arg1);
4480   jresult = result;
4481
4482
4483
4484   return jresult;
4485
4486 }
4487
4488
4489
4490 DllExport int SWIGSTDCALL Ada_LLVMGetLinkage (
4491   void * jarg1
4492   )
4493 {
4494   int jresult ;
4495   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
4496   LLVMLinkage result;
4497
4498   arg1 = (LLVMValueRef)jarg1;
4499
4500   result = (LLVMLinkage)LLVMGetLinkage(arg1);
4501   jresult = result;
4502
4503
4504
4505   return jresult;
4506
4507 }
4508
4509
4510
4511 DllExport void SWIGSTDCALL Ada_LLVMSetLinkage (
4512   void * jarg1
4513   ,
4514
4515   int jarg2
4516   )
4517 {
4518   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
4519   LLVMLinkage arg2 ;
4520
4521   arg1 = (LLVMValueRef)jarg1;
4522
4523   arg2 = (LLVMLinkage) jarg2;
4524
4525   LLVMSetLinkage(arg1,arg2);
4526
4527
4528 }
4529
4530
4531
4532 DllExport char * SWIGSTDCALL Ada_LLVMGetSection (
4533   void * jarg1
4534   )
4535 {
4536   char * jresult ;
4537   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
4538   char *result = 0 ;
4539
4540   arg1 = (LLVMValueRef)jarg1;
4541
4542   result = (char *)LLVMGetSection(arg1);
4543   jresult = result;
4544
4545
4546
4547   return jresult;
4548
4549 }
4550
4551
4552
4553 DllExport void SWIGSTDCALL Ada_LLVMSetSection (
4554   void * jarg1
4555   ,
4556
4557   char * jarg2
4558   )
4559 {
4560   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
4561   char *arg2 = (char *) 0 ;
4562
4563   arg1 = (LLVMValueRef)jarg1;
4564
4565   arg2 = jarg2;
4566
4567   LLVMSetSection(arg1,(char const *)arg2);
4568
4569
4570 }
4571
4572
4573
4574 DllExport int SWIGSTDCALL Ada_LLVMGetVisibility (
4575   void * jarg1
4576   )
4577 {
4578   int jresult ;
4579   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
4580   LLVMVisibility result;
4581
4582   arg1 = (LLVMValueRef)jarg1;
4583
4584   result = (LLVMVisibility)LLVMGetVisibility(arg1);
4585   jresult = result;
4586
4587
4588
4589   return jresult;
4590
4591 }
4592
4593
4594
4595 DllExport void SWIGSTDCALL Ada_LLVMSetVisibility (
4596   void * jarg1
4597   ,
4598
4599   int jarg2
4600   )
4601 {
4602   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
4603   LLVMVisibility arg2 ;
4604
4605   arg1 = (LLVMValueRef)jarg1;
4606
4607   arg2 = (LLVMVisibility) jarg2;
4608
4609   LLVMSetVisibility(arg1,arg2);
4610
4611
4612 }
4613
4614
4615
4616 DllExport unsigned int SWIGSTDCALL Ada_LLVMGetAlignment (
4617   void * jarg1
4618   )
4619 {
4620   unsigned int jresult ;
4621   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
4622   unsigned int result;
4623
4624   arg1 = (LLVMValueRef)jarg1;
4625
4626   result = (unsigned int)LLVMGetAlignment(arg1);
4627   jresult = result;
4628
4629
4630
4631   return jresult;
4632
4633 }
4634
4635
4636
4637 DllExport void SWIGSTDCALL Ada_LLVMSetAlignment (
4638   void * jarg1
4639   ,
4640
4641   unsigned int jarg2
4642   )
4643 {
4644   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
4645   unsigned int arg2 ;
4646
4647   arg1 = (LLVMValueRef)jarg1;
4648
4649
4650   arg2 = (unsigned int) jarg2;
4651
4652
4653   LLVMSetAlignment(arg1,arg2);
4654
4655
4656 }
4657
4658
4659
4660 DllExport void * SWIGSTDCALL Ada_LLVMAddGlobal (
4661   void * jarg1
4662   ,
4663
4664   void * jarg2
4665   ,
4666
4667   char * jarg3
4668   )
4669 {
4670   void * jresult ;
4671   LLVMModuleRef arg1 = (LLVMModuleRef) 0 ;
4672   LLVMTypeRef arg2 = (LLVMTypeRef) 0 ;
4673   char *arg3 = (char *) 0 ;
4674   LLVMValueRef result;
4675
4676   arg1 = (LLVMModuleRef)jarg1;
4677
4678   arg2 = (LLVMTypeRef)jarg2;
4679
4680   arg3 = jarg3;
4681
4682   result = (LLVMValueRef)LLVMAddGlobal(arg1,arg2,(char const *)arg3);
4683   jresult = (void *) result;
4684
4685
4686
4687   return jresult;
4688
4689 }
4690
4691
4692
4693 DllExport void * SWIGSTDCALL Ada_LLVMGetNamedGlobal (
4694   void * jarg1
4695   ,
4696
4697   char * jarg2
4698   )
4699 {
4700   void * jresult ;
4701   LLVMModuleRef arg1 = (LLVMModuleRef) 0 ;
4702   char *arg2 = (char *) 0 ;
4703   LLVMValueRef result;
4704
4705   arg1 = (LLVMModuleRef)jarg1;
4706
4707   arg2 = jarg2;
4708
4709   result = (LLVMValueRef)LLVMGetNamedGlobal(arg1,(char const *)arg2);
4710   jresult = (void *) result;
4711
4712
4713
4714   return jresult;
4715
4716 }
4717
4718
4719
4720 DllExport void * SWIGSTDCALL Ada_LLVMGetFirstGlobal (
4721   void * jarg1
4722   )
4723 {
4724   void * jresult ;
4725   LLVMModuleRef arg1 = (LLVMModuleRef) 0 ;
4726   LLVMValueRef result;
4727
4728   arg1 = (LLVMModuleRef)jarg1;
4729
4730   result = (LLVMValueRef)LLVMGetFirstGlobal(arg1);
4731   jresult = (void *) result;
4732
4733
4734
4735   return jresult;
4736
4737 }
4738
4739
4740
4741 DllExport void * SWIGSTDCALL Ada_LLVMGetLastGlobal (
4742   void * jarg1
4743   )
4744 {
4745   void * jresult ;
4746   LLVMModuleRef arg1 = (LLVMModuleRef) 0 ;
4747   LLVMValueRef result;
4748
4749   arg1 = (LLVMModuleRef)jarg1;
4750
4751   result = (LLVMValueRef)LLVMGetLastGlobal(arg1);
4752   jresult = (void *) result;
4753
4754
4755
4756   return jresult;
4757
4758 }
4759
4760
4761
4762 DllExport void * SWIGSTDCALL Ada_LLVMGetNextGlobal (
4763   void * jarg1
4764   )
4765 {
4766   void * jresult ;
4767   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
4768   LLVMValueRef result;
4769
4770   arg1 = (LLVMValueRef)jarg1;
4771
4772   result = (LLVMValueRef)LLVMGetNextGlobal(arg1);
4773   jresult = (void *) result;
4774
4775
4776
4777   return jresult;
4778
4779 }
4780
4781
4782
4783 DllExport void * SWIGSTDCALL Ada_LLVMGetPreviousGlobal (
4784   void * jarg1
4785   )
4786 {
4787   void * jresult ;
4788   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
4789   LLVMValueRef result;
4790
4791   arg1 = (LLVMValueRef)jarg1;
4792
4793   result = (LLVMValueRef)LLVMGetPreviousGlobal(arg1);
4794   jresult = (void *) result;
4795
4796
4797
4798   return jresult;
4799
4800 }
4801
4802
4803
4804 DllExport void SWIGSTDCALL Ada_LLVMDeleteGlobal (
4805   void * jarg1
4806   )
4807 {
4808   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
4809
4810   arg1 = (LLVMValueRef)jarg1;
4811
4812   LLVMDeleteGlobal(arg1);
4813
4814
4815 }
4816
4817
4818
4819 DllExport void * SWIGSTDCALL Ada_LLVMGetInitializer (
4820   void * jarg1
4821   )
4822 {
4823   void * jresult ;
4824   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
4825   LLVMValueRef result;
4826
4827   arg1 = (LLVMValueRef)jarg1;
4828
4829   result = (LLVMValueRef)LLVMGetInitializer(arg1);
4830   jresult = (void *) result;
4831
4832
4833
4834   return jresult;
4835
4836 }
4837
4838
4839
4840 DllExport void SWIGSTDCALL Ada_LLVMSetInitializer (
4841   void * jarg1
4842   ,
4843
4844   void * jarg2
4845   )
4846 {
4847   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
4848   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
4849
4850   arg1 = (LLVMValueRef)jarg1;
4851
4852   arg2 = (LLVMValueRef)jarg2;
4853
4854   LLVMSetInitializer(arg1,arg2);
4855
4856
4857 }
4858
4859
4860
4861 DllExport int SWIGSTDCALL Ada_LLVMIsThreadLocal (
4862   void * jarg1
4863   )
4864 {
4865   int jresult ;
4866   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
4867   int result;
4868
4869   arg1 = (LLVMValueRef)jarg1;
4870
4871   result = (int)LLVMIsThreadLocal(arg1);
4872   jresult = result;
4873
4874
4875
4876   return jresult;
4877
4878 }
4879
4880
4881
4882 DllExport void SWIGSTDCALL Ada_LLVMSetThreadLocal (
4883   void * jarg1
4884   ,
4885
4886   int jarg2
4887   )
4888 {
4889   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
4890   int arg2 ;
4891
4892   arg1 = (LLVMValueRef)jarg1;
4893
4894
4895   arg2 = (int) jarg2;
4896
4897
4898   LLVMSetThreadLocal(arg1,arg2);
4899
4900
4901 }
4902
4903
4904
4905 DllExport int SWIGSTDCALL Ada_LLVMIsGlobalConstant (
4906   void * jarg1
4907   )
4908 {
4909   int jresult ;
4910   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
4911   int result;
4912
4913   arg1 = (LLVMValueRef)jarg1;
4914
4915   result = (int)LLVMIsGlobalConstant(arg1);
4916   jresult = result;
4917
4918
4919
4920   return jresult;
4921
4922 }
4923
4924
4925
4926 DllExport void SWIGSTDCALL Ada_LLVMSetGlobalConstant (
4927   void * jarg1
4928   ,
4929
4930   int jarg2
4931   )
4932 {
4933   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
4934   int arg2 ;
4935
4936   arg1 = (LLVMValueRef)jarg1;
4937
4938
4939   arg2 = (int) jarg2;
4940
4941
4942   LLVMSetGlobalConstant(arg1,arg2);
4943
4944
4945 }
4946
4947
4948
4949 DllExport void * SWIGSTDCALL Ada_LLVMAddAlias (
4950   void * jarg1
4951   ,
4952
4953   void * jarg2
4954   ,
4955
4956   void * jarg3
4957   ,
4958
4959   char * jarg4
4960   )
4961 {
4962   void * jresult ;
4963   LLVMModuleRef arg1 = (LLVMModuleRef) 0 ;
4964   LLVMTypeRef arg2 = (LLVMTypeRef) 0 ;
4965   LLVMValueRef arg3 = (LLVMValueRef) 0 ;
4966   char *arg4 = (char *) 0 ;
4967   LLVMValueRef result;
4968
4969   arg1 = (LLVMModuleRef)jarg1;
4970
4971   arg2 = (LLVMTypeRef)jarg2;
4972
4973   arg3 = (LLVMValueRef)jarg3;
4974
4975   arg4 = jarg4;
4976
4977   result = (LLVMValueRef)LLVMAddAlias(arg1,arg2,arg3,(char const *)arg4);
4978   jresult = (void *) result;
4979
4980
4981
4982   return jresult;
4983
4984 }
4985
4986
4987
4988 DllExport void * SWIGSTDCALL Ada_LLVMAddFunction (
4989   void * jarg1
4990   ,
4991
4992   char * jarg2
4993   ,
4994
4995   void * jarg3
4996   )
4997 {
4998   void * jresult ;
4999   LLVMModuleRef arg1 = (LLVMModuleRef) 0 ;
5000   char *arg2 = (char *) 0 ;
5001   LLVMTypeRef arg3 = (LLVMTypeRef) 0 ;
5002   LLVMValueRef result;
5003
5004   arg1 = (LLVMModuleRef)jarg1;
5005
5006   arg2 = jarg2;
5007
5008   arg3 = (LLVMTypeRef)jarg3;
5009
5010   result = (LLVMValueRef)LLVMAddFunction(arg1,(char const *)arg2,arg3);
5011   jresult = (void *) result;
5012
5013
5014
5015   return jresult;
5016
5017 }
5018
5019
5020
5021 DllExport void * SWIGSTDCALL Ada_LLVMGetNamedFunction (
5022   void * jarg1
5023   ,
5024
5025   char * jarg2
5026   )
5027 {
5028   void * jresult ;
5029   LLVMModuleRef arg1 = (LLVMModuleRef) 0 ;
5030   char *arg2 = (char *) 0 ;
5031   LLVMValueRef result;
5032
5033   arg1 = (LLVMModuleRef)jarg1;
5034
5035   arg2 = jarg2;
5036
5037   result = (LLVMValueRef)LLVMGetNamedFunction(arg1,(char const *)arg2);
5038   jresult = (void *) result;
5039
5040
5041
5042   return jresult;
5043
5044 }
5045
5046
5047
5048 DllExport void * SWIGSTDCALL Ada_LLVMGetFirstFunction (
5049   void * jarg1
5050   )
5051 {
5052   void * jresult ;
5053   LLVMModuleRef arg1 = (LLVMModuleRef) 0 ;
5054   LLVMValueRef result;
5055
5056   arg1 = (LLVMModuleRef)jarg1;
5057
5058   result = (LLVMValueRef)LLVMGetFirstFunction(arg1);
5059   jresult = (void *) result;
5060
5061
5062
5063   return jresult;
5064
5065 }
5066
5067
5068
5069 DllExport void * SWIGSTDCALL Ada_LLVMGetLastFunction (
5070   void * jarg1
5071   )
5072 {
5073   void * jresult ;
5074   LLVMModuleRef arg1 = (LLVMModuleRef) 0 ;
5075   LLVMValueRef result;
5076
5077   arg1 = (LLVMModuleRef)jarg1;
5078
5079   result = (LLVMValueRef)LLVMGetLastFunction(arg1);
5080   jresult = (void *) result;
5081
5082
5083
5084   return jresult;
5085
5086 }
5087
5088
5089
5090 DllExport void * SWIGSTDCALL Ada_LLVMGetNextFunction (
5091   void * jarg1
5092   )
5093 {
5094   void * jresult ;
5095   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
5096   LLVMValueRef result;
5097
5098   arg1 = (LLVMValueRef)jarg1;
5099
5100   result = (LLVMValueRef)LLVMGetNextFunction(arg1);
5101   jresult = (void *) result;
5102
5103
5104
5105   return jresult;
5106
5107 }
5108
5109
5110
5111 DllExport void * SWIGSTDCALL Ada_LLVMGetPreviousFunction (
5112   void * jarg1
5113   )
5114 {
5115   void * jresult ;
5116   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
5117   LLVMValueRef result;
5118
5119   arg1 = (LLVMValueRef)jarg1;
5120
5121   result = (LLVMValueRef)LLVMGetPreviousFunction(arg1);
5122   jresult = (void *) result;
5123
5124
5125
5126   return jresult;
5127
5128 }
5129
5130
5131
5132 DllExport void SWIGSTDCALL Ada_LLVMDeleteFunction (
5133   void * jarg1
5134   )
5135 {
5136   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
5137
5138   arg1 = (LLVMValueRef)jarg1;
5139
5140   LLVMDeleteFunction(arg1);
5141
5142
5143 }
5144
5145
5146
5147 DllExport unsigned int SWIGSTDCALL Ada_LLVMGetIntrinsicID (
5148   void * jarg1
5149   )
5150 {
5151   unsigned int jresult ;
5152   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
5153   unsigned int result;
5154
5155   arg1 = (LLVMValueRef)jarg1;
5156
5157   result = (unsigned int)LLVMGetIntrinsicID(arg1);
5158   jresult = result;
5159
5160
5161
5162   return jresult;
5163
5164 }
5165
5166
5167
5168 DllExport unsigned int SWIGSTDCALL Ada_LLVMGetFunctionCallConv (
5169   void * jarg1
5170   )
5171 {
5172   unsigned int jresult ;
5173   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
5174   unsigned int result;
5175
5176   arg1 = (LLVMValueRef)jarg1;
5177
5178   result = (unsigned int)LLVMGetFunctionCallConv(arg1);
5179   jresult = result;
5180
5181
5182
5183   return jresult;
5184
5185 }
5186
5187
5188
5189 DllExport void SWIGSTDCALL Ada_LLVMSetFunctionCallConv (
5190   void * jarg1
5191   ,
5192
5193   unsigned int jarg2
5194   )
5195 {
5196   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
5197   unsigned int arg2 ;
5198
5199   arg1 = (LLVMValueRef)jarg1;
5200
5201
5202   arg2 = (unsigned int) jarg2;
5203
5204
5205   LLVMSetFunctionCallConv(arg1,arg2);
5206
5207
5208 }
5209
5210
5211
5212 DllExport char * SWIGSTDCALL Ada_LLVMGetGC (
5213   void * jarg1
5214   )
5215 {
5216   char * jresult ;
5217   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
5218   char *result = 0 ;
5219
5220   arg1 = (LLVMValueRef)jarg1;
5221
5222   result = (char *)LLVMGetGC(arg1);
5223   jresult = result;
5224
5225
5226
5227   return jresult;
5228
5229 }
5230
5231
5232
5233 DllExport void SWIGSTDCALL Ada_LLVMSetGC (
5234   void * jarg1
5235   ,
5236
5237   char * jarg2
5238   )
5239 {
5240   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
5241   char *arg2 = (char *) 0 ;
5242
5243   arg1 = (LLVMValueRef)jarg1;
5244
5245   arg2 = jarg2;
5246
5247   LLVMSetGC(arg1,(char const *)arg2);
5248
5249
5250 }
5251
5252
5253
5254 DllExport void SWIGSTDCALL Ada_LLVMAddFunctionAttr (
5255   void * jarg1
5256   ,
5257
5258   int jarg2
5259   )
5260 {
5261   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
5262   LLVMAttribute arg2 ;
5263
5264   arg1 = (LLVMValueRef)jarg1;
5265
5266   arg2 = (LLVMAttribute) jarg2;
5267
5268   LLVMAddFunctionAttr(arg1,arg2);
5269
5270
5271 }
5272
5273
5274
5275 DllExport void SWIGSTDCALL Ada_LLVMRemoveFunctionAttr (
5276   void * jarg1
5277   ,
5278
5279   int jarg2
5280   )
5281 {
5282   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
5283   LLVMAttribute arg2 ;
5284
5285   arg1 = (LLVMValueRef)jarg1;
5286
5287   arg2 = (LLVMAttribute) jarg2;
5288
5289   LLVMRemoveFunctionAttr(arg1,arg2);
5290
5291
5292 }
5293
5294
5295
5296 DllExport unsigned int SWIGSTDCALL Ada_LLVMCountParams (
5297   void * jarg1
5298   )
5299 {
5300   unsigned int jresult ;
5301   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
5302   unsigned int result;
5303
5304   arg1 = (LLVMValueRef)jarg1;
5305
5306   result = (unsigned int)LLVMCountParams(arg1);
5307   jresult = result;
5308
5309
5310
5311   return jresult;
5312
5313 }
5314
5315
5316
5317 DllExport void SWIGSTDCALL Ada_LLVMGetParams (
5318   void * jarg1
5319   ,
5320
5321   void * jarg2
5322   )
5323 {
5324   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
5325   LLVMValueRef *arg2 = (LLVMValueRef *) 0 ;
5326
5327   arg1 = (LLVMValueRef)jarg1;
5328
5329   arg2 = (LLVMValueRef *)jarg2;
5330
5331   LLVMGetParams(arg1,arg2);
5332
5333
5334 }
5335
5336
5337
5338 DllExport void * SWIGSTDCALL Ada_LLVMGetParam (
5339   void * jarg1
5340   ,
5341
5342   unsigned int jarg2
5343   )
5344 {
5345   void * jresult ;
5346   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
5347   unsigned int arg2 ;
5348   LLVMValueRef result;
5349
5350   arg1 = (LLVMValueRef)jarg1;
5351
5352
5353   arg2 = (unsigned int) jarg2;
5354
5355
5356   result = (LLVMValueRef)LLVMGetParam(arg1,arg2);
5357   jresult = (void *) result;
5358
5359
5360
5361   return jresult;
5362
5363 }
5364
5365
5366
5367 DllExport void * SWIGSTDCALL Ada_LLVMGetParamParent (
5368   void * jarg1
5369   )
5370 {
5371   void * jresult ;
5372   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
5373   LLVMValueRef result;
5374
5375   arg1 = (LLVMValueRef)jarg1;
5376
5377   result = (LLVMValueRef)LLVMGetParamParent(arg1);
5378   jresult = (void *) result;
5379
5380
5381
5382   return jresult;
5383
5384 }
5385
5386
5387
5388 DllExport void * SWIGSTDCALL Ada_LLVMGetFirstParam (
5389   void * jarg1
5390   )
5391 {
5392   void * jresult ;
5393   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
5394   LLVMValueRef result;
5395
5396   arg1 = (LLVMValueRef)jarg1;
5397
5398   result = (LLVMValueRef)LLVMGetFirstParam(arg1);
5399   jresult = (void *) result;
5400
5401
5402
5403   return jresult;
5404
5405 }
5406
5407
5408
5409 DllExport void * SWIGSTDCALL Ada_LLVMGetLastParam (
5410   void * jarg1
5411   )
5412 {
5413   void * jresult ;
5414   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
5415   LLVMValueRef result;
5416
5417   arg1 = (LLVMValueRef)jarg1;
5418
5419   result = (LLVMValueRef)LLVMGetLastParam(arg1);
5420   jresult = (void *) result;
5421
5422
5423
5424   return jresult;
5425
5426 }
5427
5428
5429
5430 DllExport void * SWIGSTDCALL Ada_LLVMGetNextParam (
5431   void * jarg1
5432   )
5433 {
5434   void * jresult ;
5435   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
5436   LLVMValueRef result;
5437
5438   arg1 = (LLVMValueRef)jarg1;
5439
5440   result = (LLVMValueRef)LLVMGetNextParam(arg1);
5441   jresult = (void *) result;
5442
5443
5444
5445   return jresult;
5446
5447 }
5448
5449
5450
5451 DllExport void * SWIGSTDCALL Ada_LLVMGetPreviousParam (
5452   void * jarg1
5453   )
5454 {
5455   void * jresult ;
5456   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
5457   LLVMValueRef result;
5458
5459   arg1 = (LLVMValueRef)jarg1;
5460
5461   result = (LLVMValueRef)LLVMGetPreviousParam(arg1);
5462   jresult = (void *) result;
5463
5464
5465
5466   return jresult;
5467
5468 }
5469
5470
5471
5472 DllExport void SWIGSTDCALL Ada_LLVMAddAttribute (
5473   void * jarg1
5474   ,
5475
5476   int jarg2
5477   )
5478 {
5479   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
5480   LLVMAttribute arg2 ;
5481
5482   arg1 = (LLVMValueRef)jarg1;
5483
5484   arg2 = (LLVMAttribute) jarg2;
5485
5486   LLVMAddAttribute(arg1,arg2);
5487
5488
5489 }
5490
5491
5492
5493 DllExport void SWIGSTDCALL Ada_LLVMRemoveAttribute (
5494   void * jarg1
5495   ,
5496
5497   int jarg2
5498   )
5499 {
5500   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
5501   LLVMAttribute arg2 ;
5502
5503   arg1 = (LLVMValueRef)jarg1;
5504
5505   arg2 = (LLVMAttribute) jarg2;
5506
5507   LLVMRemoveAttribute(arg1,arg2);
5508
5509
5510 }
5511
5512
5513
5514 DllExport void SWIGSTDCALL Ada_LLVMSetParamAlignment (
5515   void * jarg1
5516   ,
5517
5518   unsigned int jarg2
5519   )
5520 {
5521   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
5522   unsigned int arg2 ;
5523
5524   arg1 = (LLVMValueRef)jarg1;
5525
5526
5527   arg2 = (unsigned int) jarg2;
5528
5529
5530   LLVMSetParamAlignment(arg1,arg2);
5531
5532
5533 }
5534
5535
5536
5537 DllExport void * SWIGSTDCALL Ada_LLVMBasicBlockAsValue (
5538   void * jarg1
5539   )
5540 {
5541   void * jresult ;
5542   LLVMBasicBlockRef arg1 = (LLVMBasicBlockRef) 0 ;
5543   LLVMValueRef result;
5544
5545   arg1 = (LLVMBasicBlockRef)jarg1;
5546
5547   result = (LLVMValueRef)LLVMBasicBlockAsValue(arg1);
5548   jresult = (void *) result;
5549
5550
5551
5552   return jresult;
5553
5554 }
5555
5556
5557
5558 DllExport int SWIGSTDCALL Ada_LLVMValueIsBasicBlock (
5559   void * jarg1
5560   )
5561 {
5562   int jresult ;
5563   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
5564   int result;
5565
5566   arg1 = (LLVMValueRef)jarg1;
5567
5568   result = (int)LLVMValueIsBasicBlock(arg1);
5569   jresult = result;
5570
5571
5572
5573   return jresult;
5574
5575 }
5576
5577
5578
5579 DllExport void * SWIGSTDCALL Ada_LLVMValueAsBasicBlock (
5580   void * jarg1
5581   )
5582 {
5583   void * jresult ;
5584   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
5585   LLVMBasicBlockRef result;
5586
5587   arg1 = (LLVMValueRef)jarg1;
5588
5589   result = (LLVMBasicBlockRef)LLVMValueAsBasicBlock(arg1);
5590   jresult = (void *) result;
5591
5592
5593
5594   return jresult;
5595
5596 }
5597
5598
5599
5600 DllExport void * SWIGSTDCALL Ada_LLVMGetBasicBlockParent (
5601   void * jarg1
5602   )
5603 {
5604   void * jresult ;
5605   LLVMBasicBlockRef arg1 = (LLVMBasicBlockRef) 0 ;
5606   LLVMValueRef result;
5607
5608   arg1 = (LLVMBasicBlockRef)jarg1;
5609
5610   result = (LLVMValueRef)LLVMGetBasicBlockParent(arg1);
5611   jresult = (void *) result;
5612
5613
5614
5615   return jresult;
5616
5617 }
5618
5619
5620
5621 DllExport unsigned int SWIGSTDCALL Ada_LLVMCountBasicBlocks (
5622   void * jarg1
5623   )
5624 {
5625   unsigned int jresult ;
5626   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
5627   unsigned int result;
5628
5629   arg1 = (LLVMValueRef)jarg1;
5630
5631   result = (unsigned int)LLVMCountBasicBlocks(arg1);
5632   jresult = result;
5633
5634
5635
5636   return jresult;
5637
5638 }
5639
5640
5641
5642 DllExport void SWIGSTDCALL Ada_LLVMGetBasicBlocks (
5643   void * jarg1
5644   ,
5645
5646   void * jarg2
5647   )
5648 {
5649   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
5650   LLVMBasicBlockRef *arg2 = (LLVMBasicBlockRef *) 0 ;
5651
5652   arg1 = (LLVMValueRef)jarg1;
5653
5654   arg2 = (LLVMBasicBlockRef *)jarg2;
5655
5656   LLVMGetBasicBlocks(arg1,arg2);
5657
5658
5659 }
5660
5661
5662
5663 DllExport void * SWIGSTDCALL Ada_LLVMGetFirstBasicBlock (
5664   void * jarg1
5665   )
5666 {
5667   void * jresult ;
5668   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
5669   LLVMBasicBlockRef result;
5670
5671   arg1 = (LLVMValueRef)jarg1;
5672
5673   result = (LLVMBasicBlockRef)LLVMGetFirstBasicBlock(arg1);
5674   jresult = (void *) result;
5675
5676
5677
5678   return jresult;
5679
5680 }
5681
5682
5683
5684 DllExport void * SWIGSTDCALL Ada_LLVMGetLastBasicBlock (
5685   void * jarg1
5686   )
5687 {
5688   void * jresult ;
5689   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
5690   LLVMBasicBlockRef result;
5691
5692   arg1 = (LLVMValueRef)jarg1;
5693
5694   result = (LLVMBasicBlockRef)LLVMGetLastBasicBlock(arg1);
5695   jresult = (void *) result;
5696
5697
5698
5699   return jresult;
5700
5701 }
5702
5703
5704
5705 DllExport void * SWIGSTDCALL Ada_LLVMGetNextBasicBlock (
5706   void * jarg1
5707   )
5708 {
5709   void * jresult ;
5710   LLVMBasicBlockRef arg1 = (LLVMBasicBlockRef) 0 ;
5711   LLVMBasicBlockRef result;
5712
5713   arg1 = (LLVMBasicBlockRef)jarg1;
5714
5715   result = (LLVMBasicBlockRef)LLVMGetNextBasicBlock(arg1);
5716   jresult = (void *) result;
5717
5718
5719
5720   return jresult;
5721
5722 }
5723
5724
5725
5726 DllExport void * SWIGSTDCALL Ada_LLVMGetPreviousBasicBlock (
5727   void * jarg1
5728   )
5729 {
5730   void * jresult ;
5731   LLVMBasicBlockRef arg1 = (LLVMBasicBlockRef) 0 ;
5732   LLVMBasicBlockRef result;
5733
5734   arg1 = (LLVMBasicBlockRef)jarg1;
5735
5736   result = (LLVMBasicBlockRef)LLVMGetPreviousBasicBlock(arg1);
5737   jresult = (void *) result;
5738
5739
5740
5741   return jresult;
5742
5743 }
5744
5745
5746
5747 DllExport void * SWIGSTDCALL Ada_LLVMGetEntryBasicBlock (
5748   void * jarg1
5749   )
5750 {
5751   void * jresult ;
5752   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
5753   LLVMBasicBlockRef result;
5754
5755   arg1 = (LLVMValueRef)jarg1;
5756
5757   result = (LLVMBasicBlockRef)LLVMGetEntryBasicBlock(arg1);
5758   jresult = (void *) result;
5759
5760
5761
5762   return jresult;
5763
5764 }
5765
5766
5767
5768 DllExport void * SWIGSTDCALL Ada_LLVMAppendBasicBlock (
5769   void * jarg1
5770   ,
5771
5772   char * jarg2
5773   )
5774 {
5775   void * jresult ;
5776   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
5777   char *arg2 = (char *) 0 ;
5778   LLVMBasicBlockRef result;
5779
5780   arg1 = (LLVMValueRef)jarg1;
5781
5782   arg2 = jarg2;
5783
5784   result = (LLVMBasicBlockRef)LLVMAppendBasicBlock(arg1,(char const *)arg2);
5785   jresult = (void *) result;
5786
5787
5788
5789   return jresult;
5790
5791 }
5792
5793
5794
5795 DllExport void * SWIGSTDCALL Ada_LLVMInsertBasicBlock (
5796   void * jarg1
5797   ,
5798
5799   char * jarg2
5800   )
5801 {
5802   void * jresult ;
5803   LLVMBasicBlockRef arg1 = (LLVMBasicBlockRef) 0 ;
5804   char *arg2 = (char *) 0 ;
5805   LLVMBasicBlockRef result;
5806
5807   arg1 = (LLVMBasicBlockRef)jarg1;
5808
5809   arg2 = jarg2;
5810
5811   result = (LLVMBasicBlockRef)LLVMInsertBasicBlock(arg1,(char const *)arg2);
5812   jresult = (void *) result;
5813
5814
5815
5816   return jresult;
5817
5818 }
5819
5820
5821
5822 DllExport void SWIGSTDCALL Ada_LLVMDeleteBasicBlock (
5823   void * jarg1
5824   )
5825 {
5826   LLVMBasicBlockRef arg1 = (LLVMBasicBlockRef) 0 ;
5827
5828   arg1 = (LLVMBasicBlockRef)jarg1;
5829
5830   LLVMDeleteBasicBlock(arg1);
5831
5832
5833 }
5834
5835
5836
5837 DllExport void * SWIGSTDCALL Ada_LLVMGetInstructionParent (
5838   void * jarg1
5839   )
5840 {
5841   void * jresult ;
5842   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
5843   LLVMBasicBlockRef result;
5844
5845   arg1 = (LLVMValueRef)jarg1;
5846
5847   result = (LLVMBasicBlockRef)LLVMGetInstructionParent(arg1);
5848   jresult = (void *) result;
5849
5850
5851
5852   return jresult;
5853
5854 }
5855
5856
5857
5858 DllExport void * SWIGSTDCALL Ada_LLVMGetFirstInstruction (
5859   void * jarg1
5860   )
5861 {
5862   void * jresult ;
5863   LLVMBasicBlockRef arg1 = (LLVMBasicBlockRef) 0 ;
5864   LLVMValueRef result;
5865
5866   arg1 = (LLVMBasicBlockRef)jarg1;
5867
5868   result = (LLVMValueRef)LLVMGetFirstInstruction(arg1);
5869   jresult = (void *) result;
5870
5871
5872
5873   return jresult;
5874
5875 }
5876
5877
5878
5879 DllExport void * SWIGSTDCALL Ada_LLVMGetLastInstruction (
5880   void * jarg1
5881   )
5882 {
5883   void * jresult ;
5884   LLVMBasicBlockRef arg1 = (LLVMBasicBlockRef) 0 ;
5885   LLVMValueRef result;
5886
5887   arg1 = (LLVMBasicBlockRef)jarg1;
5888
5889   result = (LLVMValueRef)LLVMGetLastInstruction(arg1);
5890   jresult = (void *) result;
5891
5892
5893
5894   return jresult;
5895
5896 }
5897
5898
5899
5900 DllExport void * SWIGSTDCALL Ada_LLVMGetNextInstruction (
5901   void * jarg1
5902   )
5903 {
5904   void * jresult ;
5905   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
5906   LLVMValueRef result;
5907
5908   arg1 = (LLVMValueRef)jarg1;
5909
5910   result = (LLVMValueRef)LLVMGetNextInstruction(arg1);
5911   jresult = (void *) result;
5912
5913
5914
5915   return jresult;
5916
5917 }
5918
5919
5920
5921 DllExport void * SWIGSTDCALL Ada_LLVMGetPreviousInstruction (
5922   void * jarg1
5923   )
5924 {
5925   void * jresult ;
5926   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
5927   LLVMValueRef result;
5928
5929   arg1 = (LLVMValueRef)jarg1;
5930
5931   result = (LLVMValueRef)LLVMGetPreviousInstruction(arg1);
5932   jresult = (void *) result;
5933
5934
5935
5936   return jresult;
5937
5938 }
5939
5940
5941
5942 DllExport void SWIGSTDCALL Ada_LLVMSetInstructionCallConv (
5943   void * jarg1
5944   ,
5945
5946   unsigned int jarg2
5947   )
5948 {
5949   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
5950   unsigned int arg2 ;
5951
5952   arg1 = (LLVMValueRef)jarg1;
5953
5954
5955   arg2 = (unsigned int) jarg2;
5956
5957
5958   LLVMSetInstructionCallConv(arg1,arg2);
5959
5960
5961 }
5962
5963
5964
5965 DllExport unsigned int SWIGSTDCALL Ada_LLVMGetInstructionCallConv (
5966   void * jarg1
5967   )
5968 {
5969   unsigned int jresult ;
5970   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
5971   unsigned int result;
5972
5973   arg1 = (LLVMValueRef)jarg1;
5974
5975   result = (unsigned int)LLVMGetInstructionCallConv(arg1);
5976   jresult = result;
5977
5978
5979
5980   return jresult;
5981
5982 }
5983
5984
5985
5986 DllExport void SWIGSTDCALL Ada_LLVMAddInstrAttribute (
5987   void * jarg1
5988   ,
5989
5990   unsigned int jarg2
5991   ,
5992
5993   int jarg3
5994   )
5995 {
5996   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
5997   unsigned int arg2 ;
5998   LLVMAttribute arg3 ;
5999
6000   arg1 = (LLVMValueRef)jarg1;
6001
6002
6003   arg2 = (unsigned int) jarg2;
6004
6005
6006   arg3 = (LLVMAttribute) jarg3;
6007
6008   LLVMAddInstrAttribute(arg1,arg2,arg3);
6009
6010
6011 }
6012
6013
6014
6015 DllExport void SWIGSTDCALL Ada_LLVMRemoveInstrAttribute (
6016   void * jarg1
6017   ,
6018
6019   unsigned int jarg2
6020   ,
6021
6022   int jarg3
6023   )
6024 {
6025   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
6026   unsigned int arg2 ;
6027   LLVMAttribute arg3 ;
6028
6029   arg1 = (LLVMValueRef)jarg1;
6030
6031
6032   arg2 = (unsigned int) jarg2;
6033
6034
6035   arg3 = (LLVMAttribute) jarg3;
6036
6037   LLVMRemoveInstrAttribute(arg1,arg2,arg3);
6038
6039
6040 }
6041
6042
6043
6044 DllExport void SWIGSTDCALL Ada_LLVMSetInstrParamAlignment (
6045   void * jarg1
6046   ,
6047
6048   unsigned int jarg2
6049   ,
6050
6051   unsigned int jarg3
6052   )
6053 {
6054   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
6055   unsigned int arg2 ;
6056   unsigned int arg3 ;
6057
6058   arg1 = (LLVMValueRef)jarg1;
6059
6060
6061   arg2 = (unsigned int) jarg2;
6062
6063
6064
6065   arg3 = (unsigned int) jarg3;
6066
6067
6068   LLVMSetInstrParamAlignment(arg1,arg2,arg3);
6069
6070
6071 }
6072
6073
6074
6075 DllExport int SWIGSTDCALL Ada_LLVMIsTailCall (
6076   void * jarg1
6077   )
6078 {
6079   int jresult ;
6080   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
6081   int result;
6082
6083   arg1 = (LLVMValueRef)jarg1;
6084
6085   result = (int)LLVMIsTailCall(arg1);
6086   jresult = result;
6087
6088
6089
6090   return jresult;
6091
6092 }
6093
6094
6095
6096 DllExport void SWIGSTDCALL Ada_LLVMSetTailCall (
6097   void * jarg1
6098   ,
6099
6100   int jarg2
6101   )
6102 {
6103   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
6104   int arg2 ;
6105
6106   arg1 = (LLVMValueRef)jarg1;
6107
6108
6109   arg2 = (int) jarg2;
6110
6111
6112   LLVMSetTailCall(arg1,arg2);
6113
6114
6115 }
6116
6117
6118
6119 DllExport void SWIGSTDCALL Ada_LLVMAddIncoming (
6120   void * jarg1
6121   ,
6122
6123   void * jarg2
6124   ,
6125
6126   void * jarg3
6127   ,
6128
6129   unsigned int jarg4
6130   )
6131 {
6132   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
6133   LLVMValueRef *arg2 = (LLVMValueRef *) 0 ;
6134   LLVMBasicBlockRef *arg3 = (LLVMBasicBlockRef *) 0 ;
6135   unsigned int arg4 ;
6136
6137   arg1 = (LLVMValueRef)jarg1;
6138
6139   arg2 = (LLVMValueRef *)jarg2;
6140
6141   arg3 = (LLVMBasicBlockRef *)jarg3;
6142
6143
6144   arg4 = (unsigned int) jarg4;
6145
6146
6147   LLVMAddIncoming(arg1,arg2,arg3,arg4);
6148
6149
6150 }
6151
6152
6153
6154 DllExport unsigned int SWIGSTDCALL Ada_LLVMCountIncoming (
6155   void * jarg1
6156   )
6157 {
6158   unsigned int jresult ;
6159   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
6160   unsigned int result;
6161
6162   arg1 = (LLVMValueRef)jarg1;
6163
6164   result = (unsigned int)LLVMCountIncoming(arg1);
6165   jresult = result;
6166
6167
6168
6169   return jresult;
6170
6171 }
6172
6173
6174
6175 DllExport void * SWIGSTDCALL Ada_LLVMGetIncomingValue (
6176   void * jarg1
6177   ,
6178
6179   unsigned int jarg2
6180   )
6181 {
6182   void * jresult ;
6183   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
6184   unsigned int arg2 ;
6185   LLVMValueRef result;
6186
6187   arg1 = (LLVMValueRef)jarg1;
6188
6189
6190   arg2 = (unsigned int) jarg2;
6191
6192
6193   result = (LLVMValueRef)LLVMGetIncomingValue(arg1,arg2);
6194   jresult = (void *) result;
6195
6196
6197
6198   return jresult;
6199
6200 }
6201
6202
6203
6204 DllExport void * SWIGSTDCALL Ada_LLVMGetIncomingBlock (
6205   void * jarg1
6206   ,
6207
6208   unsigned int jarg2
6209   )
6210 {
6211   void * jresult ;
6212   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
6213   unsigned int arg2 ;
6214   LLVMBasicBlockRef result;
6215
6216   arg1 = (LLVMValueRef)jarg1;
6217
6218
6219   arg2 = (unsigned int) jarg2;
6220
6221
6222   result = (LLVMBasicBlockRef)LLVMGetIncomingBlock(arg1,arg2);
6223   jresult = (void *) result;
6224
6225
6226
6227   return jresult;
6228
6229 }
6230
6231
6232
6233 DllExport void * SWIGSTDCALL Ada_LLVMCreateBuilder (
6234   )
6235 {
6236   void * jresult ;
6237   LLVMBuilderRef result;
6238
6239   result = (LLVMBuilderRef)LLVMCreateBuilder();
6240   jresult = (void *) result;
6241
6242
6243
6244   return jresult;
6245
6246 }
6247
6248
6249
6250 DllExport void SWIGSTDCALL Ada_LLVMPositionBuilder (
6251   void * jarg1
6252   ,
6253
6254   void * jarg2
6255   ,
6256
6257   void * jarg3
6258   )
6259 {
6260   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
6261   LLVMBasicBlockRef arg2 = (LLVMBasicBlockRef) 0 ;
6262   LLVMValueRef arg3 = (LLVMValueRef) 0 ;
6263
6264   arg1 = (LLVMBuilderRef)jarg1;
6265
6266   arg2 = (LLVMBasicBlockRef)jarg2;
6267
6268   arg3 = (LLVMValueRef)jarg3;
6269
6270   LLVMPositionBuilder(arg1,arg2,arg3);
6271
6272
6273 }
6274
6275
6276
6277 DllExport void SWIGSTDCALL Ada_LLVMPositionBuilderBefore (
6278   void * jarg1
6279   ,
6280
6281   void * jarg2
6282   )
6283 {
6284   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
6285   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
6286
6287   arg1 = (LLVMBuilderRef)jarg1;
6288
6289   arg2 = (LLVMValueRef)jarg2;
6290
6291   LLVMPositionBuilderBefore(arg1,arg2);
6292
6293
6294 }
6295
6296
6297
6298 DllExport void SWIGSTDCALL Ada_LLVMPositionBuilderAtEnd (
6299   void * jarg1
6300   ,
6301
6302   void * jarg2
6303   )
6304 {
6305   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
6306   LLVMBasicBlockRef arg2 = (LLVMBasicBlockRef) 0 ;
6307
6308   arg1 = (LLVMBuilderRef)jarg1;
6309
6310   arg2 = (LLVMBasicBlockRef)jarg2;
6311
6312   LLVMPositionBuilderAtEnd(arg1,arg2);
6313
6314
6315 }
6316
6317
6318
6319 DllExport void * SWIGSTDCALL Ada_LLVMGetInsertBlock (
6320   void * jarg1
6321   )
6322 {
6323   void * jresult ;
6324   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
6325   LLVMBasicBlockRef result;
6326
6327   arg1 = (LLVMBuilderRef)jarg1;
6328
6329   result = (LLVMBasicBlockRef)LLVMGetInsertBlock(arg1);
6330   jresult = (void *) result;
6331
6332
6333
6334   return jresult;
6335
6336 }
6337
6338
6339
6340 DllExport void SWIGSTDCALL Ada_LLVMClearInsertionPosition (
6341   void * jarg1
6342   )
6343 {
6344   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
6345
6346   arg1 = (LLVMBuilderRef)jarg1;
6347
6348   LLVMClearInsertionPosition(arg1);
6349
6350
6351 }
6352
6353
6354
6355 DllExport void SWIGSTDCALL Ada_LLVMInsertIntoBuilder (
6356   void * jarg1
6357   ,
6358
6359   void * jarg2
6360   )
6361 {
6362   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
6363   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
6364
6365   arg1 = (LLVMBuilderRef)jarg1;
6366
6367   arg2 = (LLVMValueRef)jarg2;
6368
6369   LLVMInsertIntoBuilder(arg1,arg2);
6370
6371
6372 }
6373
6374
6375
6376 DllExport void SWIGSTDCALL Ada_LLVMDisposeBuilder (
6377   void * jarg1
6378   )
6379 {
6380   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
6381
6382   arg1 = (LLVMBuilderRef)jarg1;
6383
6384   LLVMDisposeBuilder(arg1);
6385
6386
6387 }
6388
6389
6390
6391 DllExport void * SWIGSTDCALL Ada_LLVMBuildRetVoid (
6392   void * jarg1
6393   )
6394 {
6395   void * jresult ;
6396   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
6397   LLVMValueRef result;
6398
6399   arg1 = (LLVMBuilderRef)jarg1;
6400
6401   result = (LLVMValueRef)LLVMBuildRetVoid(arg1);
6402   jresult = (void *) result;
6403
6404
6405
6406   return jresult;
6407
6408 }
6409
6410
6411
6412 DllExport void * SWIGSTDCALL Ada_LLVMBuildRet (
6413   void * jarg1
6414   ,
6415
6416   void * jarg2
6417   )
6418 {
6419   void * jresult ;
6420   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
6421   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
6422   LLVMValueRef result;
6423
6424   arg1 = (LLVMBuilderRef)jarg1;
6425
6426   arg2 = (LLVMValueRef)jarg2;
6427
6428   result = (LLVMValueRef)LLVMBuildRet(arg1,arg2);
6429   jresult = (void *) result;
6430
6431
6432
6433   return jresult;
6434
6435 }
6436
6437
6438
6439 DllExport void * SWIGSTDCALL Ada_LLVMBuildBr (
6440   void * jarg1
6441   ,
6442
6443   void * jarg2
6444   )
6445 {
6446   void * jresult ;
6447   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
6448   LLVMBasicBlockRef arg2 = (LLVMBasicBlockRef) 0 ;
6449   LLVMValueRef result;
6450
6451   arg1 = (LLVMBuilderRef)jarg1;
6452
6453   arg2 = (LLVMBasicBlockRef)jarg2;
6454
6455   result = (LLVMValueRef)LLVMBuildBr(arg1,arg2);
6456   jresult = (void *) result;
6457
6458
6459
6460   return jresult;
6461
6462 }
6463
6464
6465
6466 DllExport void * SWIGSTDCALL Ada_LLVMBuildCondBr (
6467   void * jarg1
6468   ,
6469
6470   void * jarg2
6471   ,
6472
6473   void * jarg3
6474   ,
6475
6476   void * jarg4
6477   )
6478 {
6479   void * jresult ;
6480   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
6481   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
6482   LLVMBasicBlockRef arg3 = (LLVMBasicBlockRef) 0 ;
6483   LLVMBasicBlockRef arg4 = (LLVMBasicBlockRef) 0 ;
6484   LLVMValueRef result;
6485
6486   arg1 = (LLVMBuilderRef)jarg1;
6487
6488   arg2 = (LLVMValueRef)jarg2;
6489
6490   arg3 = (LLVMBasicBlockRef)jarg3;
6491
6492   arg4 = (LLVMBasicBlockRef)jarg4;
6493
6494   result = (LLVMValueRef)LLVMBuildCondBr(arg1,arg2,arg3,arg4);
6495   jresult = (void *) result;
6496
6497
6498
6499   return jresult;
6500
6501 }
6502
6503
6504
6505 DllExport void * SWIGSTDCALL Ada_LLVMBuildSwitch (
6506   void * jarg1
6507   ,
6508
6509   void * jarg2
6510   ,
6511
6512   void * jarg3
6513   ,
6514
6515   unsigned int jarg4
6516   )
6517 {
6518   void * jresult ;
6519   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
6520   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
6521   LLVMBasicBlockRef arg3 = (LLVMBasicBlockRef) 0 ;
6522   unsigned int arg4 ;
6523   LLVMValueRef result;
6524
6525   arg1 = (LLVMBuilderRef)jarg1;
6526
6527   arg2 = (LLVMValueRef)jarg2;
6528
6529   arg3 = (LLVMBasicBlockRef)jarg3;
6530
6531
6532   arg4 = (unsigned int) jarg4;
6533
6534
6535   result = (LLVMValueRef)LLVMBuildSwitch(arg1,arg2,arg3,arg4);
6536   jresult = (void *) result;
6537
6538
6539
6540   return jresult;
6541
6542 }
6543
6544
6545
6546 DllExport void * SWIGSTDCALL Ada_LLVMBuildInvoke (
6547   void * jarg1
6548   ,
6549
6550   void * jarg2
6551   ,
6552
6553   void * jarg3
6554   ,
6555
6556   unsigned int jarg4
6557   ,
6558
6559   void * jarg5
6560   ,
6561
6562   void * jarg6
6563   ,
6564
6565   char * jarg7
6566   )
6567 {
6568   void * jresult ;
6569   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
6570   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
6571   LLVMValueRef *arg3 = (LLVMValueRef *) 0 ;
6572   unsigned int arg4 ;
6573   LLVMBasicBlockRef arg5 = (LLVMBasicBlockRef) 0 ;
6574   LLVMBasicBlockRef arg6 = (LLVMBasicBlockRef) 0 ;
6575   char *arg7 = (char *) 0 ;
6576   LLVMValueRef result;
6577
6578   arg1 = (LLVMBuilderRef)jarg1;
6579
6580   arg2 = (LLVMValueRef)jarg2;
6581
6582   arg3 = (LLVMValueRef *)jarg3;
6583
6584
6585   arg4 = (unsigned int) jarg4;
6586
6587
6588   arg5 = (LLVMBasicBlockRef)jarg5;
6589
6590   arg6 = (LLVMBasicBlockRef)jarg6;
6591
6592   arg7 = jarg7;
6593
6594   result = (LLVMValueRef)LLVMBuildInvoke(arg1,arg2,arg3,arg4,arg5,arg6,(char const *)arg7);
6595   jresult = (void *) result;
6596
6597
6598
6599   return jresult;
6600
6601 }
6602
6603
6604
6605 DllExport void * SWIGSTDCALL Ada_LLVMBuildUnwind (
6606   void * jarg1
6607   )
6608 {
6609   void * jresult ;
6610   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
6611   LLVMValueRef result;
6612
6613   arg1 = (LLVMBuilderRef)jarg1;
6614
6615   result = (LLVMValueRef)LLVMBuildUnwind(arg1);
6616   jresult = (void *) result;
6617
6618
6619
6620   return jresult;
6621
6622 }
6623
6624
6625
6626 DllExport void * SWIGSTDCALL Ada_LLVMBuildUnreachable (
6627   void * jarg1
6628   )
6629 {
6630   void * jresult ;
6631   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
6632   LLVMValueRef result;
6633
6634   arg1 = (LLVMBuilderRef)jarg1;
6635
6636   result = (LLVMValueRef)LLVMBuildUnreachable(arg1);
6637   jresult = (void *) result;
6638
6639
6640
6641   return jresult;
6642
6643 }
6644
6645
6646
6647 DllExport void SWIGSTDCALL Ada_LLVMAddCase (
6648   void * jarg1
6649   ,
6650
6651   void * jarg2
6652   ,
6653
6654   void * jarg3
6655   )
6656 {
6657   LLVMValueRef arg1 = (LLVMValueRef) 0 ;
6658   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
6659   LLVMBasicBlockRef arg3 = (LLVMBasicBlockRef) 0 ;
6660
6661   arg1 = (LLVMValueRef)jarg1;
6662
6663   arg2 = (LLVMValueRef)jarg2;
6664
6665   arg3 = (LLVMBasicBlockRef)jarg3;
6666
6667   LLVMAddCase(arg1,arg2,arg3);
6668
6669
6670 }
6671
6672
6673
6674 DllExport void * SWIGSTDCALL Ada_LLVMBuildAdd (
6675   void * jarg1
6676   ,
6677
6678   void * jarg2
6679   ,
6680
6681   void * jarg3
6682   ,
6683
6684   char * jarg4
6685   )
6686 {
6687   void * jresult ;
6688   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
6689   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
6690   LLVMValueRef arg3 = (LLVMValueRef) 0 ;
6691   char *arg4 = (char *) 0 ;
6692   LLVMValueRef result;
6693
6694   arg1 = (LLVMBuilderRef)jarg1;
6695
6696   arg2 = (LLVMValueRef)jarg2;
6697
6698   arg3 = (LLVMValueRef)jarg3;
6699
6700   arg4 = jarg4;
6701
6702   result = (LLVMValueRef)LLVMBuildAdd(arg1,arg2,arg3,(char const *)arg4);
6703   jresult = (void *) result;
6704
6705
6706
6707   return jresult;
6708
6709 }
6710
6711
6712
6713 DllExport void * SWIGSTDCALL Ada_LLVMBuildSub (
6714   void * jarg1
6715   ,
6716
6717   void * jarg2
6718   ,
6719
6720   void * jarg3
6721   ,
6722
6723   char * jarg4
6724   )
6725 {
6726   void * jresult ;
6727   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
6728   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
6729   LLVMValueRef arg3 = (LLVMValueRef) 0 ;
6730   char *arg4 = (char *) 0 ;
6731   LLVMValueRef result;
6732
6733   arg1 = (LLVMBuilderRef)jarg1;
6734
6735   arg2 = (LLVMValueRef)jarg2;
6736
6737   arg3 = (LLVMValueRef)jarg3;
6738
6739   arg4 = jarg4;
6740
6741   result = (LLVMValueRef)LLVMBuildSub(arg1,arg2,arg3,(char const *)arg4);
6742   jresult = (void *) result;
6743
6744
6745
6746   return jresult;
6747
6748 }
6749
6750
6751
6752 DllExport void * SWIGSTDCALL Ada_LLVMBuildMul (
6753   void * jarg1
6754   ,
6755
6756   void * jarg2
6757   ,
6758
6759   void * jarg3
6760   ,
6761
6762   char * jarg4
6763   )
6764 {
6765   void * jresult ;
6766   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
6767   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
6768   LLVMValueRef arg3 = (LLVMValueRef) 0 ;
6769   char *arg4 = (char *) 0 ;
6770   LLVMValueRef result;
6771
6772   arg1 = (LLVMBuilderRef)jarg1;
6773
6774   arg2 = (LLVMValueRef)jarg2;
6775
6776   arg3 = (LLVMValueRef)jarg3;
6777
6778   arg4 = jarg4;
6779
6780   result = (LLVMValueRef)LLVMBuildMul(arg1,arg2,arg3,(char const *)arg4);
6781   jresult = (void *) result;
6782
6783
6784
6785   return jresult;
6786
6787 }
6788
6789
6790
6791 DllExport void * SWIGSTDCALL Ada_LLVMBuildUDiv (
6792   void * jarg1
6793   ,
6794
6795   void * jarg2
6796   ,
6797
6798   void * jarg3
6799   ,
6800
6801   char * jarg4
6802   )
6803 {
6804   void * jresult ;
6805   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
6806   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
6807   LLVMValueRef arg3 = (LLVMValueRef) 0 ;
6808   char *arg4 = (char *) 0 ;
6809   LLVMValueRef result;
6810
6811   arg1 = (LLVMBuilderRef)jarg1;
6812
6813   arg2 = (LLVMValueRef)jarg2;
6814
6815   arg3 = (LLVMValueRef)jarg3;
6816
6817   arg4 = jarg4;
6818
6819   result = (LLVMValueRef)LLVMBuildUDiv(arg1,arg2,arg3,(char const *)arg4);
6820   jresult = (void *) result;
6821
6822
6823
6824   return jresult;
6825
6826 }
6827
6828
6829
6830 DllExport void * SWIGSTDCALL Ada_LLVMBuildSDiv (
6831   void * jarg1
6832   ,
6833
6834   void * jarg2
6835   ,
6836
6837   void * jarg3
6838   ,
6839
6840   char * jarg4
6841   )
6842 {
6843   void * jresult ;
6844   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
6845   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
6846   LLVMValueRef arg3 = (LLVMValueRef) 0 ;
6847   char *arg4 = (char *) 0 ;
6848   LLVMValueRef result;
6849
6850   arg1 = (LLVMBuilderRef)jarg1;
6851
6852   arg2 = (LLVMValueRef)jarg2;
6853
6854   arg3 = (LLVMValueRef)jarg3;
6855
6856   arg4 = jarg4;
6857
6858   result = (LLVMValueRef)LLVMBuildSDiv(arg1,arg2,arg3,(char const *)arg4);
6859   jresult = (void *) result;
6860
6861
6862
6863   return jresult;
6864
6865 }
6866
6867
6868
6869 DllExport void * SWIGSTDCALL Ada_LLVMBuildFDiv (
6870   void * jarg1
6871   ,
6872
6873   void * jarg2
6874   ,
6875
6876   void * jarg3
6877   ,
6878
6879   char * jarg4
6880   )
6881 {
6882   void * jresult ;
6883   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
6884   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
6885   LLVMValueRef arg3 = (LLVMValueRef) 0 ;
6886   char *arg4 = (char *) 0 ;
6887   LLVMValueRef result;
6888
6889   arg1 = (LLVMBuilderRef)jarg1;
6890
6891   arg2 = (LLVMValueRef)jarg2;
6892
6893   arg3 = (LLVMValueRef)jarg3;
6894
6895   arg4 = jarg4;
6896
6897   result = (LLVMValueRef)LLVMBuildFDiv(arg1,arg2,arg3,(char const *)arg4);
6898   jresult = (void *) result;
6899
6900
6901
6902   return jresult;
6903
6904 }
6905
6906
6907
6908 DllExport void * SWIGSTDCALL Ada_LLVMBuildURem (
6909   void * jarg1
6910   ,
6911
6912   void * jarg2
6913   ,
6914
6915   void * jarg3
6916   ,
6917
6918   char * jarg4
6919   )
6920 {
6921   void * jresult ;
6922   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
6923   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
6924   LLVMValueRef arg3 = (LLVMValueRef) 0 ;
6925   char *arg4 = (char *) 0 ;
6926   LLVMValueRef result;
6927
6928   arg1 = (LLVMBuilderRef)jarg1;
6929
6930   arg2 = (LLVMValueRef)jarg2;
6931
6932   arg3 = (LLVMValueRef)jarg3;
6933
6934   arg4 = jarg4;
6935
6936   result = (LLVMValueRef)LLVMBuildURem(arg1,arg2,arg3,(char const *)arg4);
6937   jresult = (void *) result;
6938
6939
6940
6941   return jresult;
6942
6943 }
6944
6945
6946
6947 DllExport void * SWIGSTDCALL Ada_LLVMBuildSRem (
6948   void * jarg1
6949   ,
6950
6951   void * jarg2
6952   ,
6953
6954   void * jarg3
6955   ,
6956
6957   char * jarg4
6958   )
6959 {
6960   void * jresult ;
6961   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
6962   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
6963   LLVMValueRef arg3 = (LLVMValueRef) 0 ;
6964   char *arg4 = (char *) 0 ;
6965   LLVMValueRef result;
6966
6967   arg1 = (LLVMBuilderRef)jarg1;
6968
6969   arg2 = (LLVMValueRef)jarg2;
6970
6971   arg3 = (LLVMValueRef)jarg3;
6972
6973   arg4 = jarg4;
6974
6975   result = (LLVMValueRef)LLVMBuildSRem(arg1,arg2,arg3,(char const *)arg4);
6976   jresult = (void *) result;
6977
6978
6979
6980   return jresult;
6981
6982 }
6983
6984
6985
6986 DllExport void * SWIGSTDCALL Ada_LLVMBuildFRem (
6987   void * jarg1
6988   ,
6989
6990   void * jarg2
6991   ,
6992
6993   void * jarg3
6994   ,
6995
6996   char * jarg4
6997   )
6998 {
6999   void * jresult ;
7000   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
7001   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
7002   LLVMValueRef arg3 = (LLVMValueRef) 0 ;
7003   char *arg4 = (char *) 0 ;
7004   LLVMValueRef result;
7005
7006   arg1 = (LLVMBuilderRef)jarg1;
7007
7008   arg2 = (LLVMValueRef)jarg2;
7009
7010   arg3 = (LLVMValueRef)jarg3;
7011
7012   arg4 = jarg4;
7013
7014   result = (LLVMValueRef)LLVMBuildFRem(arg1,arg2,arg3,(char const *)arg4);
7015   jresult = (void *) result;
7016
7017
7018
7019   return jresult;
7020
7021 }
7022
7023
7024
7025 DllExport void * SWIGSTDCALL Ada_LLVMBuildShl (
7026   void * jarg1
7027   ,
7028
7029   void * jarg2
7030   ,
7031
7032   void * jarg3
7033   ,
7034
7035   char * jarg4
7036   )
7037 {
7038   void * jresult ;
7039   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
7040   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
7041   LLVMValueRef arg3 = (LLVMValueRef) 0 ;
7042   char *arg4 = (char *) 0 ;
7043   LLVMValueRef result;
7044
7045   arg1 = (LLVMBuilderRef)jarg1;
7046
7047   arg2 = (LLVMValueRef)jarg2;
7048
7049   arg3 = (LLVMValueRef)jarg3;
7050
7051   arg4 = jarg4;
7052
7053   result = (LLVMValueRef)LLVMBuildShl(arg1,arg2,arg3,(char const *)arg4);
7054   jresult = (void *) result;
7055
7056
7057
7058   return jresult;
7059
7060 }
7061
7062
7063
7064 DllExport void * SWIGSTDCALL Ada_LLVMBuildLShr (
7065   void * jarg1
7066   ,
7067
7068   void * jarg2
7069   ,
7070
7071   void * jarg3
7072   ,
7073
7074   char * jarg4
7075   )
7076 {
7077   void * jresult ;
7078   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
7079   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
7080   LLVMValueRef arg3 = (LLVMValueRef) 0 ;
7081   char *arg4 = (char *) 0 ;
7082   LLVMValueRef result;
7083
7084   arg1 = (LLVMBuilderRef)jarg1;
7085
7086   arg2 = (LLVMValueRef)jarg2;
7087
7088   arg3 = (LLVMValueRef)jarg3;
7089
7090   arg4 = jarg4;
7091
7092   result = (LLVMValueRef)LLVMBuildLShr(arg1,arg2,arg3,(char const *)arg4);
7093   jresult = (void *) result;
7094
7095
7096
7097   return jresult;
7098
7099 }
7100
7101
7102
7103 DllExport void * SWIGSTDCALL Ada_LLVMBuildAShr (
7104   void * jarg1
7105   ,
7106
7107   void * jarg2
7108   ,
7109
7110   void * jarg3
7111   ,
7112
7113   char * jarg4
7114   )
7115 {
7116   void * jresult ;
7117   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
7118   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
7119   LLVMValueRef arg3 = (LLVMValueRef) 0 ;
7120   char *arg4 = (char *) 0 ;
7121   LLVMValueRef result;
7122
7123   arg1 = (LLVMBuilderRef)jarg1;
7124
7125   arg2 = (LLVMValueRef)jarg2;
7126
7127   arg3 = (LLVMValueRef)jarg3;
7128
7129   arg4 = jarg4;
7130
7131   result = (LLVMValueRef)LLVMBuildAShr(arg1,arg2,arg3,(char const *)arg4);
7132   jresult = (void *) result;
7133
7134
7135
7136   return jresult;
7137
7138 }
7139
7140
7141
7142 DllExport void * SWIGSTDCALL Ada_LLVMBuildAnd (
7143   void * jarg1
7144   ,
7145
7146   void * jarg2
7147   ,
7148
7149   void * jarg3
7150   ,
7151
7152   char * jarg4
7153   )
7154 {
7155   void * jresult ;
7156   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
7157   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
7158   LLVMValueRef arg3 = (LLVMValueRef) 0 ;
7159   char *arg4 = (char *) 0 ;
7160   LLVMValueRef result;
7161
7162   arg1 = (LLVMBuilderRef)jarg1;
7163
7164   arg2 = (LLVMValueRef)jarg2;
7165
7166   arg3 = (LLVMValueRef)jarg3;
7167
7168   arg4 = jarg4;
7169
7170   result = (LLVMValueRef)LLVMBuildAnd(arg1,arg2,arg3,(char const *)arg4);
7171   jresult = (void *) result;
7172
7173
7174
7175   return jresult;
7176
7177 }
7178
7179
7180
7181 DllExport void * SWIGSTDCALL Ada_LLVMBuildOr (
7182   void * jarg1
7183   ,
7184
7185   void * jarg2
7186   ,
7187
7188   void * jarg3
7189   ,
7190
7191   char * jarg4
7192   )
7193 {
7194   void * jresult ;
7195   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
7196   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
7197   LLVMValueRef arg3 = (LLVMValueRef) 0 ;
7198   char *arg4 = (char *) 0 ;
7199   LLVMValueRef result;
7200
7201   arg1 = (LLVMBuilderRef)jarg1;
7202
7203   arg2 = (LLVMValueRef)jarg2;
7204
7205   arg3 = (LLVMValueRef)jarg3;
7206
7207   arg4 = jarg4;
7208
7209   result = (LLVMValueRef)LLVMBuildOr(arg1,arg2,arg3,(char const *)arg4);
7210   jresult = (void *) result;
7211
7212
7213
7214   return jresult;
7215
7216 }
7217
7218
7219
7220 DllExport void * SWIGSTDCALL Ada_LLVMBuildXor (
7221   void * jarg1
7222   ,
7223
7224   void * jarg2
7225   ,
7226
7227   void * jarg3
7228   ,
7229
7230   char * jarg4
7231   )
7232 {
7233   void * jresult ;
7234   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
7235   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
7236   LLVMValueRef arg3 = (LLVMValueRef) 0 ;
7237   char *arg4 = (char *) 0 ;
7238   LLVMValueRef result;
7239
7240   arg1 = (LLVMBuilderRef)jarg1;
7241
7242   arg2 = (LLVMValueRef)jarg2;
7243
7244   arg3 = (LLVMValueRef)jarg3;
7245
7246   arg4 = jarg4;
7247
7248   result = (LLVMValueRef)LLVMBuildXor(arg1,arg2,arg3,(char const *)arg4);
7249   jresult = (void *) result;
7250
7251
7252
7253   return jresult;
7254
7255 }
7256
7257
7258
7259 DllExport void * SWIGSTDCALL Ada_LLVMBuildNeg (
7260   void * jarg1
7261   ,
7262
7263   void * jarg2
7264   ,
7265
7266   char * jarg3
7267   )
7268 {
7269   void * jresult ;
7270   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
7271   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
7272   char *arg3 = (char *) 0 ;
7273   LLVMValueRef result;
7274
7275   arg1 = (LLVMBuilderRef)jarg1;
7276
7277   arg2 = (LLVMValueRef)jarg2;
7278
7279   arg3 = jarg3;
7280
7281   result = (LLVMValueRef)LLVMBuildNeg(arg1,arg2,(char const *)arg3);
7282   jresult = (void *) result;
7283
7284
7285
7286   return jresult;
7287
7288 }
7289
7290
7291
7292 DllExport void * SWIGSTDCALL Ada_LLVMBuildNot (
7293   void * jarg1
7294   ,
7295
7296   void * jarg2
7297   ,
7298
7299   char * jarg3
7300   )
7301 {
7302   void * jresult ;
7303   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
7304   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
7305   char *arg3 = (char *) 0 ;
7306   LLVMValueRef result;
7307
7308   arg1 = (LLVMBuilderRef)jarg1;
7309
7310   arg2 = (LLVMValueRef)jarg2;
7311
7312   arg3 = jarg3;
7313
7314   result = (LLVMValueRef)LLVMBuildNot(arg1,arg2,(char const *)arg3);
7315   jresult = (void *) result;
7316
7317
7318
7319   return jresult;
7320
7321 }
7322
7323
7324
7325 DllExport void * SWIGSTDCALL Ada_LLVMBuildMalloc (
7326   void * jarg1
7327   ,
7328
7329   void * jarg2
7330   ,
7331
7332   char * jarg3
7333   )
7334 {
7335   void * jresult ;
7336   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
7337   LLVMTypeRef arg2 = (LLVMTypeRef) 0 ;
7338   char *arg3 = (char *) 0 ;
7339   LLVMValueRef result;
7340
7341   arg1 = (LLVMBuilderRef)jarg1;
7342
7343   arg2 = (LLVMTypeRef)jarg2;
7344
7345   arg3 = jarg3;
7346
7347   result = (LLVMValueRef)LLVMBuildMalloc(arg1,arg2,(char const *)arg3);
7348   jresult = (void *) result;
7349
7350
7351
7352   return jresult;
7353
7354 }
7355
7356
7357
7358 DllExport void * SWIGSTDCALL Ada_LLVMBuildArrayMalloc (
7359   void * jarg1
7360   ,
7361
7362   void * jarg2
7363   ,
7364
7365   void * jarg3
7366   ,
7367
7368   char * jarg4
7369   )
7370 {
7371   void * jresult ;
7372   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
7373   LLVMTypeRef arg2 = (LLVMTypeRef) 0 ;
7374   LLVMValueRef arg3 = (LLVMValueRef) 0 ;
7375   char *arg4 = (char *) 0 ;
7376   LLVMValueRef result;
7377
7378   arg1 = (LLVMBuilderRef)jarg1;
7379
7380   arg2 = (LLVMTypeRef)jarg2;
7381
7382   arg3 = (LLVMValueRef)jarg3;
7383
7384   arg4 = jarg4;
7385
7386   result = (LLVMValueRef)LLVMBuildArrayMalloc(arg1,arg2,arg3,(char const *)arg4);
7387   jresult = (void *) result;
7388
7389
7390
7391   return jresult;
7392
7393 }
7394
7395
7396
7397 DllExport void * SWIGSTDCALL Ada_LLVMBuildAlloca (
7398   void * jarg1
7399   ,
7400
7401   void * jarg2
7402   ,
7403
7404   char * jarg3
7405   )
7406 {
7407   void * jresult ;
7408   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
7409   LLVMTypeRef arg2 = (LLVMTypeRef) 0 ;
7410   char *arg3 = (char *) 0 ;
7411   LLVMValueRef result;
7412
7413   arg1 = (LLVMBuilderRef)jarg1;
7414
7415   arg2 = (LLVMTypeRef)jarg2;
7416
7417   arg3 = jarg3;
7418
7419   result = (LLVMValueRef)LLVMBuildAlloca(arg1,arg2,(char const *)arg3);
7420   jresult = (void *) result;
7421
7422
7423
7424   return jresult;
7425
7426 }
7427
7428
7429
7430 DllExport void * SWIGSTDCALL Ada_LLVMBuildArrayAlloca (
7431   void * jarg1
7432   ,
7433
7434   void * jarg2
7435   ,
7436
7437   void * jarg3
7438   ,
7439
7440   char * jarg4
7441   )
7442 {
7443   void * jresult ;
7444   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
7445   LLVMTypeRef arg2 = (LLVMTypeRef) 0 ;
7446   LLVMValueRef arg3 = (LLVMValueRef) 0 ;
7447   char *arg4 = (char *) 0 ;
7448   LLVMValueRef result;
7449
7450   arg1 = (LLVMBuilderRef)jarg1;
7451
7452   arg2 = (LLVMTypeRef)jarg2;
7453
7454   arg3 = (LLVMValueRef)jarg3;
7455
7456   arg4 = jarg4;
7457
7458   result = (LLVMValueRef)LLVMBuildArrayAlloca(arg1,arg2,arg3,(char const *)arg4);
7459   jresult = (void *) result;
7460
7461
7462
7463   return jresult;
7464
7465 }
7466
7467
7468
7469 DllExport void * SWIGSTDCALL Ada_LLVMBuildFree (
7470   void * jarg1
7471   ,
7472
7473   void * jarg2
7474   )
7475 {
7476   void * jresult ;
7477   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
7478   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
7479   LLVMValueRef result;
7480
7481   arg1 = (LLVMBuilderRef)jarg1;
7482
7483   arg2 = (LLVMValueRef)jarg2;
7484
7485   result = (LLVMValueRef)LLVMBuildFree(arg1,arg2);
7486   jresult = (void *) result;
7487
7488
7489
7490   return jresult;
7491
7492 }
7493
7494
7495
7496 DllExport void * SWIGSTDCALL Ada_LLVMBuildLoad (
7497   void * jarg1
7498   ,
7499
7500   void * jarg2
7501   ,
7502
7503   char * jarg3
7504   )
7505 {
7506   void * jresult ;
7507   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
7508   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
7509   char *arg3 = (char *) 0 ;
7510   LLVMValueRef result;
7511
7512   arg1 = (LLVMBuilderRef)jarg1;
7513
7514   arg2 = (LLVMValueRef)jarg2;
7515
7516   arg3 = jarg3;
7517
7518   result = (LLVMValueRef)LLVMBuildLoad(arg1,arg2,(char const *)arg3);
7519   jresult = (void *) result;
7520
7521
7522
7523   return jresult;
7524
7525 }
7526
7527
7528
7529 DllExport void * SWIGSTDCALL Ada_LLVMBuildStore (
7530   void * jarg1
7531   ,
7532
7533   void * jarg2
7534   ,
7535
7536   void * jarg3
7537   )
7538 {
7539   void * jresult ;
7540   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
7541   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
7542   LLVMValueRef arg3 = (LLVMValueRef) 0 ;
7543   LLVMValueRef result;
7544
7545   arg1 = (LLVMBuilderRef)jarg1;
7546
7547   arg2 = (LLVMValueRef)jarg2;
7548
7549   arg3 = (LLVMValueRef)jarg3;
7550
7551   result = (LLVMValueRef)LLVMBuildStore(arg1,arg2,arg3);
7552   jresult = (void *) result;
7553
7554
7555
7556   return jresult;
7557
7558 }
7559
7560
7561
7562 DllExport void * SWIGSTDCALL Ada_LLVMBuildGEP (
7563   void * jarg1
7564   ,
7565
7566   void * jarg2
7567   ,
7568
7569   void * jarg3
7570   ,
7571
7572   unsigned int jarg4
7573   ,
7574
7575   char * jarg5
7576   )
7577 {
7578   void * jresult ;
7579   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
7580   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
7581   LLVMValueRef *arg3 = (LLVMValueRef *) 0 ;
7582   unsigned int arg4 ;
7583   char *arg5 = (char *) 0 ;
7584   LLVMValueRef result;
7585
7586   arg1 = (LLVMBuilderRef)jarg1;
7587
7588   arg2 = (LLVMValueRef)jarg2;
7589
7590   arg3 = (LLVMValueRef *)jarg3;
7591
7592
7593   arg4 = (unsigned int) jarg4;
7594
7595
7596   arg5 = jarg5;
7597
7598   result = (LLVMValueRef)LLVMBuildGEP(arg1,arg2,arg3,arg4,(char const *)arg5);
7599   jresult = (void *) result;
7600
7601
7602
7603   return jresult;
7604
7605 }
7606
7607
7608
7609 DllExport void * SWIGSTDCALL Ada_LLVMBuildTrunc (
7610   void * jarg1
7611   ,
7612
7613   void * jarg2
7614   ,
7615
7616   void * jarg3
7617   ,
7618
7619   char * jarg4
7620   )
7621 {
7622   void * jresult ;
7623   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
7624   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
7625   LLVMTypeRef arg3 = (LLVMTypeRef) 0 ;
7626   char *arg4 = (char *) 0 ;
7627   LLVMValueRef result;
7628
7629   arg1 = (LLVMBuilderRef)jarg1;
7630
7631   arg2 = (LLVMValueRef)jarg2;
7632
7633   arg3 = (LLVMTypeRef)jarg3;
7634
7635   arg4 = jarg4;
7636
7637   result = (LLVMValueRef)LLVMBuildTrunc(arg1,arg2,arg3,(char const *)arg4);
7638   jresult = (void *) result;
7639
7640
7641
7642   return jresult;
7643
7644 }
7645
7646
7647
7648 DllExport void * SWIGSTDCALL Ada_LLVMBuildZExt (
7649   void * jarg1
7650   ,
7651
7652   void * jarg2
7653   ,
7654
7655   void * jarg3
7656   ,
7657
7658   char * jarg4
7659   )
7660 {
7661   void * jresult ;
7662   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
7663   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
7664   LLVMTypeRef arg3 = (LLVMTypeRef) 0 ;
7665   char *arg4 = (char *) 0 ;
7666   LLVMValueRef result;
7667
7668   arg1 = (LLVMBuilderRef)jarg1;
7669
7670   arg2 = (LLVMValueRef)jarg2;
7671
7672   arg3 = (LLVMTypeRef)jarg3;
7673
7674   arg4 = jarg4;
7675
7676   result = (LLVMValueRef)LLVMBuildZExt(arg1,arg2,arg3,(char const *)arg4);
7677   jresult = (void *) result;
7678
7679
7680
7681   return jresult;
7682
7683 }
7684
7685
7686
7687 DllExport void * SWIGSTDCALL Ada_LLVMBuildSExt (
7688   void * jarg1
7689   ,
7690
7691   void * jarg2
7692   ,
7693
7694   void * jarg3
7695   ,
7696
7697   char * jarg4
7698   )
7699 {
7700   void * jresult ;
7701   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
7702   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
7703   LLVMTypeRef arg3 = (LLVMTypeRef) 0 ;
7704   char *arg4 = (char *) 0 ;
7705   LLVMValueRef result;
7706
7707   arg1 = (LLVMBuilderRef)jarg1;
7708
7709   arg2 = (LLVMValueRef)jarg2;
7710
7711   arg3 = (LLVMTypeRef)jarg3;
7712
7713   arg4 = jarg4;
7714
7715   result = (LLVMValueRef)LLVMBuildSExt(arg1,arg2,arg3,(char const *)arg4);
7716   jresult = (void *) result;
7717
7718
7719
7720   return jresult;
7721
7722 }
7723
7724
7725
7726 DllExport void * SWIGSTDCALL Ada_LLVMBuildFPToUI (
7727   void * jarg1
7728   ,
7729
7730   void * jarg2
7731   ,
7732
7733   void * jarg3
7734   ,
7735
7736   char * jarg4
7737   )
7738 {
7739   void * jresult ;
7740   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
7741   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
7742   LLVMTypeRef arg3 = (LLVMTypeRef) 0 ;
7743   char *arg4 = (char *) 0 ;
7744   LLVMValueRef result;
7745
7746   arg1 = (LLVMBuilderRef)jarg1;
7747
7748   arg2 = (LLVMValueRef)jarg2;
7749
7750   arg3 = (LLVMTypeRef)jarg3;
7751
7752   arg4 = jarg4;
7753
7754   result = (LLVMValueRef)LLVMBuildFPToUI(arg1,arg2,arg3,(char const *)arg4);
7755   jresult = (void *) result;
7756
7757
7758
7759   return jresult;
7760
7761 }
7762
7763
7764
7765 DllExport void * SWIGSTDCALL Ada_LLVMBuildFPToSI (
7766   void * jarg1
7767   ,
7768
7769   void * jarg2
7770   ,
7771
7772   void * jarg3
7773   ,
7774
7775   char * jarg4
7776   )
7777 {
7778   void * jresult ;
7779   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
7780   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
7781   LLVMTypeRef arg3 = (LLVMTypeRef) 0 ;
7782   char *arg4 = (char *) 0 ;
7783   LLVMValueRef result;
7784
7785   arg1 = (LLVMBuilderRef)jarg1;
7786
7787   arg2 = (LLVMValueRef)jarg2;
7788
7789   arg3 = (LLVMTypeRef)jarg3;
7790
7791   arg4 = jarg4;
7792
7793   result = (LLVMValueRef)LLVMBuildFPToSI(arg1,arg2,arg3,(char const *)arg4);
7794   jresult = (void *) result;
7795
7796
7797
7798   return jresult;
7799
7800 }
7801
7802
7803
7804 DllExport void * SWIGSTDCALL Ada_LLVMBuildUIToFP (
7805   void * jarg1
7806   ,
7807
7808   void * jarg2
7809   ,
7810
7811   void * jarg3
7812   ,
7813
7814   char * jarg4
7815   )
7816 {
7817   void * jresult ;
7818   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
7819   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
7820   LLVMTypeRef arg3 = (LLVMTypeRef) 0 ;
7821   char *arg4 = (char *) 0 ;
7822   LLVMValueRef result;
7823
7824   arg1 = (LLVMBuilderRef)jarg1;
7825
7826   arg2 = (LLVMValueRef)jarg2;
7827
7828   arg3 = (LLVMTypeRef)jarg3;
7829
7830   arg4 = jarg4;
7831
7832   result = (LLVMValueRef)LLVMBuildUIToFP(arg1,arg2,arg3,(char const *)arg4);
7833   jresult = (void *) result;
7834
7835
7836
7837   return jresult;
7838
7839 }
7840
7841
7842
7843 DllExport void * SWIGSTDCALL Ada_LLVMBuildSIToFP (
7844   void * jarg1
7845   ,
7846
7847   void * jarg2
7848   ,
7849
7850   void * jarg3
7851   ,
7852
7853   char * jarg4
7854   )
7855 {
7856   void * jresult ;
7857   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
7858   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
7859   LLVMTypeRef arg3 = (LLVMTypeRef) 0 ;
7860   char *arg4 = (char *) 0 ;
7861   LLVMValueRef result;
7862
7863   arg1 = (LLVMBuilderRef)jarg1;
7864
7865   arg2 = (LLVMValueRef)jarg2;
7866
7867   arg3 = (LLVMTypeRef)jarg3;
7868
7869   arg4 = jarg4;
7870
7871   result = (LLVMValueRef)LLVMBuildSIToFP(arg1,arg2,arg3,(char const *)arg4);
7872   jresult = (void *) result;
7873
7874
7875
7876   return jresult;
7877
7878 }
7879
7880
7881
7882 DllExport void * SWIGSTDCALL Ada_LLVMBuildFPTrunc (
7883   void * jarg1
7884   ,
7885
7886   void * jarg2
7887   ,
7888
7889   void * jarg3
7890   ,
7891
7892   char * jarg4
7893   )
7894 {
7895   void * jresult ;
7896   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
7897   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
7898   LLVMTypeRef arg3 = (LLVMTypeRef) 0 ;
7899   char *arg4 = (char *) 0 ;
7900   LLVMValueRef result;
7901
7902   arg1 = (LLVMBuilderRef)jarg1;
7903
7904   arg2 = (LLVMValueRef)jarg2;
7905
7906   arg3 = (LLVMTypeRef)jarg3;
7907
7908   arg4 = jarg4;
7909
7910   result = (LLVMValueRef)LLVMBuildFPTrunc(arg1,arg2,arg3,(char const *)arg4);
7911   jresult = (void *) result;
7912
7913
7914
7915   return jresult;
7916
7917 }
7918
7919
7920
7921 DllExport void * SWIGSTDCALL Ada_LLVMBuildFPExt (
7922   void * jarg1
7923   ,
7924
7925   void * jarg2
7926   ,
7927
7928   void * jarg3
7929   ,
7930
7931   char * jarg4
7932   )
7933 {
7934   void * jresult ;
7935   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
7936   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
7937   LLVMTypeRef arg3 = (LLVMTypeRef) 0 ;
7938   char *arg4 = (char *) 0 ;
7939   LLVMValueRef result;
7940
7941   arg1 = (LLVMBuilderRef)jarg1;
7942
7943   arg2 = (LLVMValueRef)jarg2;
7944
7945   arg3 = (LLVMTypeRef)jarg3;
7946
7947   arg4 = jarg4;
7948
7949   result = (LLVMValueRef)LLVMBuildFPExt(arg1,arg2,arg3,(char const *)arg4);
7950   jresult = (void *) result;
7951
7952
7953
7954   return jresult;
7955
7956 }
7957
7958
7959
7960 DllExport void * SWIGSTDCALL Ada_LLVMBuildPtrToInt (
7961   void * jarg1
7962   ,
7963
7964   void * jarg2
7965   ,
7966
7967   void * jarg3
7968   ,
7969
7970   char * jarg4
7971   )
7972 {
7973   void * jresult ;
7974   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
7975   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
7976   LLVMTypeRef arg3 = (LLVMTypeRef) 0 ;
7977   char *arg4 = (char *) 0 ;
7978   LLVMValueRef result;
7979
7980   arg1 = (LLVMBuilderRef)jarg1;
7981
7982   arg2 = (LLVMValueRef)jarg2;
7983
7984   arg3 = (LLVMTypeRef)jarg3;
7985
7986   arg4 = jarg4;
7987
7988   result = (LLVMValueRef)LLVMBuildPtrToInt(arg1,arg2,arg3,(char const *)arg4);
7989   jresult = (void *) result;
7990
7991
7992
7993   return jresult;
7994
7995 }
7996
7997
7998
7999 DllExport void * SWIGSTDCALL Ada_LLVMBuildIntToPtr (
8000   void * jarg1
8001   ,
8002
8003   void * jarg2
8004   ,
8005
8006   void * jarg3
8007   ,
8008
8009   char * jarg4
8010   )
8011 {
8012   void * jresult ;
8013   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
8014   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
8015   LLVMTypeRef arg3 = (LLVMTypeRef) 0 ;
8016   char *arg4 = (char *) 0 ;
8017   LLVMValueRef result;
8018
8019   arg1 = (LLVMBuilderRef)jarg1;
8020
8021   arg2 = (LLVMValueRef)jarg2;
8022
8023   arg3 = (LLVMTypeRef)jarg3;
8024
8025   arg4 = jarg4;
8026
8027   result = (LLVMValueRef)LLVMBuildIntToPtr(arg1,arg2,arg3,(char const *)arg4);
8028   jresult = (void *) result;
8029
8030
8031
8032   return jresult;
8033
8034 }
8035
8036
8037
8038 DllExport void * SWIGSTDCALL Ada_LLVMBuildBitCast (
8039   void * jarg1
8040   ,
8041
8042   void * jarg2
8043   ,
8044
8045   void * jarg3
8046   ,
8047
8048   char * jarg4
8049   )
8050 {
8051   void * jresult ;
8052   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
8053   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
8054   LLVMTypeRef arg3 = (LLVMTypeRef) 0 ;
8055   char *arg4 = (char *) 0 ;
8056   LLVMValueRef result;
8057
8058   arg1 = (LLVMBuilderRef)jarg1;
8059
8060   arg2 = (LLVMValueRef)jarg2;
8061
8062   arg3 = (LLVMTypeRef)jarg3;
8063
8064   arg4 = jarg4;
8065
8066   result = (LLVMValueRef)LLVMBuildBitCast(arg1,arg2,arg3,(char const *)arg4);
8067   jresult = (void *) result;
8068
8069
8070
8071   return jresult;
8072
8073 }
8074
8075
8076
8077 DllExport void * SWIGSTDCALL Ada_LLVMBuildICmp (
8078   void * jarg1
8079   ,
8080
8081   int jarg2
8082   ,
8083
8084   void * jarg3
8085   ,
8086
8087   void * jarg4
8088   ,
8089
8090   char * jarg5
8091   )
8092 {
8093   void * jresult ;
8094   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
8095   LLVMIntPredicate arg2 ;
8096   LLVMValueRef arg3 = (LLVMValueRef) 0 ;
8097   LLVMValueRef arg4 = (LLVMValueRef) 0 ;
8098   char *arg5 = (char *) 0 ;
8099   LLVMValueRef result;
8100
8101   arg1 = (LLVMBuilderRef)jarg1;
8102
8103   arg2 = (LLVMIntPredicate) jarg2;
8104
8105   arg3 = (LLVMValueRef)jarg3;
8106
8107   arg4 = (LLVMValueRef)jarg4;
8108
8109   arg5 = jarg5;
8110
8111   result = (LLVMValueRef)LLVMBuildICmp(arg1,arg2,arg3,arg4,(char const *)arg5);
8112   jresult = (void *) result;
8113
8114
8115
8116   return jresult;
8117
8118 }
8119
8120
8121
8122 DllExport void * SWIGSTDCALL Ada_LLVMBuildFCmp (
8123   void * jarg1
8124   ,
8125
8126   int jarg2
8127   ,
8128
8129   void * jarg3
8130   ,
8131
8132   void * jarg4
8133   ,
8134
8135   char * jarg5
8136   )
8137 {
8138   void * jresult ;
8139   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
8140   LLVMRealPredicate arg2 ;
8141   LLVMValueRef arg3 = (LLVMValueRef) 0 ;
8142   LLVMValueRef arg4 = (LLVMValueRef) 0 ;
8143   char *arg5 = (char *) 0 ;
8144   LLVMValueRef result;
8145
8146   arg1 = (LLVMBuilderRef)jarg1;
8147
8148   arg2 = (LLVMRealPredicate) jarg2;
8149
8150   arg3 = (LLVMValueRef)jarg3;
8151
8152   arg4 = (LLVMValueRef)jarg4;
8153
8154   arg5 = jarg5;
8155
8156   result = (LLVMValueRef)LLVMBuildFCmp(arg1,arg2,arg3,arg4,(char const *)arg5);
8157   jresult = (void *) result;
8158
8159
8160
8161   return jresult;
8162
8163 }
8164
8165
8166
8167 DllExport void * SWIGSTDCALL Ada_LLVMBuildPhi (
8168   void * jarg1
8169   ,
8170
8171   void * jarg2
8172   ,
8173
8174   char * jarg3
8175   )
8176 {
8177   void * jresult ;
8178   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
8179   LLVMTypeRef arg2 = (LLVMTypeRef) 0 ;
8180   char *arg3 = (char *) 0 ;
8181   LLVMValueRef result;
8182
8183   arg1 = (LLVMBuilderRef)jarg1;
8184
8185   arg2 = (LLVMTypeRef)jarg2;
8186
8187   arg3 = jarg3;
8188
8189   result = (LLVMValueRef)LLVMBuildPhi(arg1,arg2,(char const *)arg3);
8190   jresult = (void *) result;
8191
8192
8193
8194   return jresult;
8195
8196 }
8197
8198
8199
8200 DllExport void * SWIGSTDCALL Ada_LLVMBuildCall (
8201   void * jarg1
8202   ,
8203
8204   void * jarg2
8205   ,
8206
8207   void * jarg3
8208   ,
8209
8210   unsigned int jarg4
8211   ,
8212
8213   char * jarg5
8214   )
8215 {
8216   void * jresult ;
8217   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
8218   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
8219   LLVMValueRef *arg3 = (LLVMValueRef *) 0 ;
8220   unsigned int arg4 ;
8221   char *arg5 = (char *) 0 ;
8222   LLVMValueRef result;
8223
8224   arg1 = (LLVMBuilderRef)jarg1;
8225
8226   arg2 = (LLVMValueRef)jarg2;
8227
8228   arg3 = (LLVMValueRef *)jarg3;
8229
8230
8231   arg4 = (unsigned int) jarg4;
8232
8233
8234   arg5 = jarg5;
8235
8236   result = (LLVMValueRef)LLVMBuildCall(arg1,arg2,arg3,arg4,(char const *)arg5);
8237   jresult = (void *) result;
8238
8239
8240
8241   return jresult;
8242
8243 }
8244
8245
8246
8247 DllExport void * SWIGSTDCALL Ada_LLVMBuildSelect (
8248   void * jarg1
8249   ,
8250
8251   void * jarg2
8252   ,
8253
8254   void * jarg3
8255   ,
8256
8257   void * jarg4
8258   ,
8259
8260   char * jarg5
8261   )
8262 {
8263   void * jresult ;
8264   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
8265   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
8266   LLVMValueRef arg3 = (LLVMValueRef) 0 ;
8267   LLVMValueRef arg4 = (LLVMValueRef) 0 ;
8268   char *arg5 = (char *) 0 ;
8269   LLVMValueRef result;
8270
8271   arg1 = (LLVMBuilderRef)jarg1;
8272
8273   arg2 = (LLVMValueRef)jarg2;
8274
8275   arg3 = (LLVMValueRef)jarg3;
8276
8277   arg4 = (LLVMValueRef)jarg4;
8278
8279   arg5 = jarg5;
8280
8281   result = (LLVMValueRef)LLVMBuildSelect(arg1,arg2,arg3,arg4,(char const *)arg5);
8282   jresult = (void *) result;
8283
8284
8285
8286   return jresult;
8287
8288 }
8289
8290
8291
8292 DllExport void * SWIGSTDCALL Ada_LLVMBuildVAArg (
8293   void * jarg1
8294   ,
8295
8296   void * jarg2
8297   ,
8298
8299   void * jarg3
8300   ,
8301
8302   char * jarg4
8303   )
8304 {
8305   void * jresult ;
8306   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
8307   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
8308   LLVMTypeRef arg3 = (LLVMTypeRef) 0 ;
8309   char *arg4 = (char *) 0 ;
8310   LLVMValueRef result;
8311
8312   arg1 = (LLVMBuilderRef)jarg1;
8313
8314   arg2 = (LLVMValueRef)jarg2;
8315
8316   arg3 = (LLVMTypeRef)jarg3;
8317
8318   arg4 = jarg4;
8319
8320   result = (LLVMValueRef)LLVMBuildVAArg(arg1,arg2,arg3,(char const *)arg4);
8321   jresult = (void *) result;
8322
8323
8324
8325   return jresult;
8326
8327 }
8328
8329
8330
8331 DllExport void * SWIGSTDCALL Ada_LLVMBuildExtractElement (
8332   void * jarg1
8333   ,
8334
8335   void * jarg2
8336   ,
8337
8338   void * jarg3
8339   ,
8340
8341   char * jarg4
8342   )
8343 {
8344   void * jresult ;
8345   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
8346   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
8347   LLVMValueRef arg3 = (LLVMValueRef) 0 ;
8348   char *arg4 = (char *) 0 ;
8349   LLVMValueRef result;
8350
8351   arg1 = (LLVMBuilderRef)jarg1;
8352
8353   arg2 = (LLVMValueRef)jarg2;
8354
8355   arg3 = (LLVMValueRef)jarg3;
8356
8357   arg4 = jarg4;
8358
8359   result = (LLVMValueRef)LLVMBuildExtractElement(arg1,arg2,arg3,(char const *)arg4);
8360   jresult = (void *) result;
8361
8362
8363
8364   return jresult;
8365
8366 }
8367
8368
8369
8370 DllExport void * SWIGSTDCALL Ada_LLVMBuildInsertElement (
8371   void * jarg1
8372   ,
8373
8374   void * jarg2
8375   ,
8376
8377   void * jarg3
8378   ,
8379
8380   void * jarg4
8381   ,
8382
8383   char * jarg5
8384   )
8385 {
8386   void * jresult ;
8387   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
8388   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
8389   LLVMValueRef arg3 = (LLVMValueRef) 0 ;
8390   LLVMValueRef arg4 = (LLVMValueRef) 0 ;
8391   char *arg5 = (char *) 0 ;
8392   LLVMValueRef result;
8393
8394   arg1 = (LLVMBuilderRef)jarg1;
8395
8396   arg2 = (LLVMValueRef)jarg2;
8397
8398   arg3 = (LLVMValueRef)jarg3;
8399
8400   arg4 = (LLVMValueRef)jarg4;
8401
8402   arg5 = jarg5;
8403
8404   result = (LLVMValueRef)LLVMBuildInsertElement(arg1,arg2,arg3,arg4,(char const *)arg5);
8405   jresult = (void *) result;
8406
8407
8408
8409   return jresult;
8410
8411 }
8412
8413
8414
8415 DllExport void * SWIGSTDCALL Ada_LLVMBuildShuffleVector (
8416   void * jarg1
8417   ,
8418
8419   void * jarg2
8420   ,
8421
8422   void * jarg3
8423   ,
8424
8425   void * jarg4
8426   ,
8427
8428   char * jarg5
8429   )
8430 {
8431   void * jresult ;
8432   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
8433   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
8434   LLVMValueRef arg3 = (LLVMValueRef) 0 ;
8435   LLVMValueRef arg4 = (LLVMValueRef) 0 ;
8436   char *arg5 = (char *) 0 ;
8437   LLVMValueRef result;
8438
8439   arg1 = (LLVMBuilderRef)jarg1;
8440
8441   arg2 = (LLVMValueRef)jarg2;
8442
8443   arg3 = (LLVMValueRef)jarg3;
8444
8445   arg4 = (LLVMValueRef)jarg4;
8446
8447   arg5 = jarg5;
8448
8449   result = (LLVMValueRef)LLVMBuildShuffleVector(arg1,arg2,arg3,arg4,(char const *)arg5);
8450   jresult = (void *) result;
8451
8452
8453
8454   return jresult;
8455
8456 }
8457
8458
8459
8460 DllExport void * SWIGSTDCALL Ada_LLVMBuildExtractValue (
8461   void * jarg1
8462   ,
8463
8464   void * jarg2
8465   ,
8466
8467   unsigned int jarg3
8468   ,
8469
8470   char * jarg4
8471   )
8472 {
8473   void * jresult ;
8474   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
8475   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
8476   unsigned int arg3 ;
8477   char *arg4 = (char *) 0 ;
8478   LLVMValueRef result;
8479
8480   arg1 = (LLVMBuilderRef)jarg1;
8481
8482   arg2 = (LLVMValueRef)jarg2;
8483
8484
8485   arg3 = (unsigned int) jarg3;
8486
8487
8488   arg4 = jarg4;
8489
8490   result = (LLVMValueRef)LLVMBuildExtractValue(arg1,arg2,arg3,(char const *)arg4);
8491   jresult = (void *) result;
8492
8493
8494
8495   return jresult;
8496
8497 }
8498
8499
8500
8501 DllExport void * SWIGSTDCALL Ada_LLVMBuildInsertValue (
8502   void * jarg1
8503   ,
8504
8505   void * jarg2
8506   ,
8507
8508   void * jarg3
8509   ,
8510
8511   unsigned int jarg4
8512   ,
8513
8514   char * jarg5
8515   )
8516 {
8517   void * jresult ;
8518   LLVMBuilderRef arg1 = (LLVMBuilderRef) 0 ;
8519   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
8520   LLVMValueRef arg3 = (LLVMValueRef) 0 ;
8521   unsigned int arg4 ;
8522   char *arg5 = (char *) 0 ;
8523   LLVMValueRef result;
8524
8525   arg1 = (LLVMBuilderRef)jarg1;
8526
8527   arg2 = (LLVMValueRef)jarg2;
8528
8529   arg3 = (LLVMValueRef)jarg3;
8530
8531
8532   arg4 = (unsigned int) jarg4;
8533
8534
8535   arg5 = jarg5;
8536
8537   result = (LLVMValueRef)LLVMBuildInsertValue(arg1,arg2,arg3,arg4,(char const *)arg5);
8538   jresult = (void *) result;
8539
8540
8541
8542   return jresult;
8543
8544 }
8545
8546
8547
8548 DllExport void * SWIGSTDCALL Ada_LLVMCreateModuleProviderForExistingModule (
8549   void * jarg1
8550   )
8551 {
8552   void * jresult ;
8553   LLVMModuleRef arg1 = (LLVMModuleRef) 0 ;
8554   LLVMModuleProviderRef result;
8555
8556   arg1 = (LLVMModuleRef)jarg1;
8557
8558   result = (LLVMModuleProviderRef)LLVMCreateModuleProviderForExistingModule(arg1);
8559   jresult = (void *) result;
8560
8561
8562
8563   return jresult;
8564
8565 }
8566
8567
8568
8569 DllExport void SWIGSTDCALL Ada_LLVMDisposeModuleProvider (
8570   void * jarg1
8571   )
8572 {
8573   LLVMModuleProviderRef arg1 = (LLVMModuleProviderRef) 0 ;
8574
8575   arg1 = (LLVMModuleProviderRef)jarg1;
8576
8577   LLVMDisposeModuleProvider(arg1);
8578
8579
8580 }
8581
8582
8583
8584 DllExport int SWIGSTDCALL Ada_LLVMCreateMemoryBufferWithContentsOfFile (
8585   char * jarg1
8586   ,
8587
8588   void * jarg2
8589   ,
8590
8591   void * jarg3
8592   )
8593 {
8594   int jresult ;
8595   char *arg1 = (char *) 0 ;
8596   LLVMMemoryBufferRef *arg2 = (LLVMMemoryBufferRef *) 0 ;
8597   char **arg3 = (char **) 0 ;
8598   int result;
8599
8600   arg1 = jarg1;
8601
8602   arg2 = (LLVMMemoryBufferRef *)jarg2;
8603
8604   arg3 = (char **)jarg3;
8605
8606   result = (int)LLVMCreateMemoryBufferWithContentsOfFile((char const *)arg1,arg2,arg3);
8607   jresult = result;
8608
8609
8610
8611   return jresult;
8612
8613 }
8614
8615
8616
8617 DllExport int SWIGSTDCALL Ada_LLVMCreateMemoryBufferWithSTDIN (
8618   void * jarg1
8619   ,
8620
8621   void * jarg2
8622   )
8623 {
8624   int jresult ;
8625   LLVMMemoryBufferRef *arg1 = (LLVMMemoryBufferRef *) 0 ;
8626   char **arg2 = (char **) 0 ;
8627   int result;
8628
8629   arg1 = (LLVMMemoryBufferRef *)jarg1;
8630
8631   arg2 = (char **)jarg2;
8632
8633   result = (int)LLVMCreateMemoryBufferWithSTDIN(arg1,arg2);
8634   jresult = result;
8635
8636
8637
8638   return jresult;
8639
8640 }
8641
8642
8643
8644 DllExport void SWIGSTDCALL Ada_LLVMDisposeMemoryBuffer (
8645   void * jarg1
8646   )
8647 {
8648   LLVMMemoryBufferRef arg1 = (LLVMMemoryBufferRef) 0 ;
8649
8650   arg1 = (LLVMMemoryBufferRef)jarg1;
8651
8652   LLVMDisposeMemoryBuffer(arg1);
8653
8654
8655 }
8656
8657
8658
8659 DllExport void * SWIGSTDCALL Ada_LLVMCreatePassManager (
8660   )
8661 {
8662   void * jresult ;
8663   LLVMPassManagerRef result;
8664
8665   result = (LLVMPassManagerRef)LLVMCreatePassManager();
8666   jresult = (void *) result;
8667
8668
8669
8670   return jresult;
8671
8672 }
8673
8674
8675
8676 DllExport void * SWIGSTDCALL Ada_LLVMCreateFunctionPassManager (
8677   void * jarg1
8678   )
8679 {
8680   void * jresult ;
8681   LLVMModuleProviderRef arg1 = (LLVMModuleProviderRef) 0 ;
8682   LLVMPassManagerRef result;
8683
8684   arg1 = (LLVMModuleProviderRef)jarg1;
8685
8686   result = (LLVMPassManagerRef)LLVMCreateFunctionPassManager(arg1);
8687   jresult = (void *) result;
8688
8689
8690
8691   return jresult;
8692
8693 }
8694
8695
8696
8697 DllExport int SWIGSTDCALL Ada_LLVMRunPassManager (
8698   void * jarg1
8699   ,
8700
8701   void * jarg2
8702   )
8703 {
8704   int jresult ;
8705   LLVMPassManagerRef arg1 = (LLVMPassManagerRef) 0 ;
8706   LLVMModuleRef arg2 = (LLVMModuleRef) 0 ;
8707   int result;
8708
8709   arg1 = (LLVMPassManagerRef)jarg1;
8710
8711   arg2 = (LLVMModuleRef)jarg2;
8712
8713   result = (int)LLVMRunPassManager(arg1,arg2);
8714   jresult = result;
8715
8716
8717
8718   return jresult;
8719
8720 }
8721
8722
8723
8724 DllExport int SWIGSTDCALL Ada_LLVMInitializeFunctionPassManager (
8725   void * jarg1
8726   )
8727 {
8728   int jresult ;
8729   LLVMPassManagerRef arg1 = (LLVMPassManagerRef) 0 ;
8730   int result;
8731
8732   arg1 = (LLVMPassManagerRef)jarg1;
8733
8734   result = (int)LLVMInitializeFunctionPassManager(arg1);
8735   jresult = result;
8736
8737
8738
8739   return jresult;
8740
8741 }
8742
8743
8744
8745 DllExport int SWIGSTDCALL Ada_LLVMRunFunctionPassManager (
8746   void * jarg1
8747   ,
8748
8749   void * jarg2
8750   )
8751 {
8752   int jresult ;
8753   LLVMPassManagerRef arg1 = (LLVMPassManagerRef) 0 ;
8754   LLVMValueRef arg2 = (LLVMValueRef) 0 ;
8755   int result;
8756
8757   arg1 = (LLVMPassManagerRef)jarg1;
8758
8759   arg2 = (LLVMValueRef)jarg2;
8760
8761   result = (int)LLVMRunFunctionPassManager(arg1,arg2);
8762   jresult = result;
8763
8764
8765
8766   return jresult;
8767
8768 }
8769
8770
8771
8772 DllExport int SWIGSTDCALL Ada_LLVMFinalizeFunctionPassManager (
8773   void * jarg1
8774   )
8775 {
8776   int jresult ;
8777   LLVMPassManagerRef arg1 = (LLVMPassManagerRef) 0 ;
8778   int result;
8779
8780   arg1 = (LLVMPassManagerRef)jarg1;
8781
8782   result = (int)LLVMFinalizeFunctionPassManager(arg1);
8783   jresult = result;
8784
8785
8786
8787   return jresult;
8788
8789 }
8790
8791
8792
8793 DllExport void SWIGSTDCALL Ada_LLVMDisposePassManager (
8794   void * jarg1
8795   )
8796 {
8797   LLVMPassManagerRef arg1 = (LLVMPassManagerRef) 0 ;
8798
8799   arg1 = (LLVMPassManagerRef)jarg1;
8800
8801   LLVMDisposePassManager(arg1);
8802
8803
8804 }
8805
8806
8807
8808 #ifdef __cplusplus
8809 }
8810 #endif
8811 #ifdef __cplusplus
8812 extern "C" {
8813 #endif
8814 #ifdef __cplusplus
8815 }
8816 #endif
8817