bindings/ada/llvm/llvm_linktimeoptimizer_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_link_time_Optimizer (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_link_time_Optimizer(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/lto.h"
 252 #include "llvm-c/LinkTimeOptimizer.h"
 253
 254
 255
 256 //  struct LLVMCtxt;
 257
 258
 259 #undef protected
 260 #undef private
 261 #ifdef __cplusplus
 262 extern "C" {
 263 #endif
 264 DllExport char * SWIGSTDCALL Ada_lto_get_version (
 265   )
 266 {
 267   char * jresult ;
 268   char *result = 0 ;
 269
 270   result = (char *)lto_get_version();
 271   jresult = result;
 272
 273
 274
 275   return jresult;
 276
 277 }
 278
 279
 280
 281 DllExport char * SWIGSTDCALL Ada_lto_get_error_message (
 282   )
 283 {
 284   char * jresult ;
 285   char *result = 0 ;
 286
 287   result = (char *)lto_get_error_message();
 288   jresult = result;
 289
 290
 291
 292   return jresult;
 293
 294 }
 295
 296
 297
 298 DllExport unsigned int SWIGSTDCALL Ada_lto_module_is_object_file (
 299   char * jarg1
 300   )
 301 {
 302   unsigned int jresult ;
 303   char *arg1 = (char *) 0 ;
 304   bool result;
 305
 306   arg1 = jarg1;
 307
 308   result = (bool)lto_module_is_object_file((char const *)arg1);
 309   jresult = result;
 310
 311
 312
 313   return jresult;
 314
 315 }
 316
 317
 318
 319 DllExport unsigned int SWIGSTDCALL Ada_lto_module_is_object_file_for_target (
 320   char * jarg1
 321   ,
 322
 323   char * jarg2
 324   )
 325 {
 326   unsigned int jresult ;
 327   char *arg1 = (char *) 0 ;
 328   char *arg2 = (char *) 0 ;
 329   bool result;
 330
 331   arg1 = jarg1;
 332
 333   arg2 = jarg2;
 334
 335   result = (bool)lto_module_is_object_file_for_target((char const *)arg1,(char const *)arg2);
 336   jresult = result;
 337
 338
 339
 340   return jresult;
 341
 342 }
 343
 344
 345
 346 DllExport unsigned int SWIGSTDCALL Ada_lto_module_is_object_file_in_memory (
 347   void* jarg1
 348   ,
 349
 350   size_t jarg2
 351   )
 352 {
 353   unsigned int jresult ;
 354   void *arg1 = (void *) 0 ;
 355   size_t arg2 ;
 356   bool result;
 357
 358   arg1 = (void *)jarg1;
 359
 360
 361   arg2 = (size_t) jarg2;
 362
 363
 364   result = (bool)lto_module_is_object_file_in_memory((void const *)arg1,arg2);
 365   jresult = result;
 366
 367
 368
 369   return jresult;
 370
 371 }
 372
 373
 374
 375 DllExport unsigned int SWIGSTDCALL Ada_lto_module_is_object_file_in_memory_for_target (
 376   void* jarg1
 377   ,
 378
 379   size_t jarg2
 380   ,
 381
 382   char * jarg3
 383   )
 384 {
 385   unsigned int jresult ;
 386   void *arg1 = (void *) 0 ;
 387   size_t arg2 ;
 388   char *arg3 = (char *) 0 ;
 389   bool result;
 390
 391   arg1 = (void *)jarg1;
 392
 393
 394   arg2 = (size_t) jarg2;
 395
 396
 397   arg3 = jarg3;
 398
 399   result = (bool)lto_module_is_object_file_in_memory_for_target((void const *)arg1,arg2,(char const *)arg3);
 400   jresult = result;
 401
 402
 403
 404   return jresult;
 405
 406 }
 407
 408
 409
 410 DllExport void * SWIGSTDCALL Ada_lto_module_create (
 411   char * jarg1
 412   )
 413 {
 414   void * jresult ;
 415   char *arg1 = (char *) 0 ;
 416   lto_module_t result;
 417
 418   arg1 = jarg1;
 419
 420   result = (lto_module_t)lto_module_create((char const *)arg1);
 421   jresult = (void *) result;
 422
 423
 424
 425   return jresult;
 426
 427 }
 428
 429
 430
 431 DllExport void * SWIGSTDCALL Ada_lto_module_create_from_memory (
 432   void* jarg1
 433   ,
 434
 435   size_t jarg2
 436   )
 437 {
 438   void * jresult ;
 439   void *arg1 = (void *) 0 ;
 440   size_t arg2 ;
 441   lto_module_t result;
 442
 443   arg1 = (void *)jarg1;
 444
 445
 446   arg2 = (size_t) jarg2;
 447
 448
 449   result = (lto_module_t)lto_module_create_from_memory((void const *)arg1,arg2);
 450   jresult = (void *) result;
 451
 452
 453
 454   return jresult;
 455
 456 }
 457
 458
 459
 460 DllExport void SWIGSTDCALL Ada_lto_module_dispose (
 461   void * jarg1
 462   )
 463 {
 464   lto_module_t arg1 = (lto_module_t) 0 ;
 465
 466   arg1 = (lto_module_t)jarg1;
 467
 468   lto_module_dispose(arg1);
 469
 470
 471 }
 472
 473
 474
 475 DllExport char * SWIGSTDCALL Ada_lto_module_get_target_triple (
 476   void * jarg1
 477   )
 478 {
 479   char * jresult ;
 480   lto_module_t arg1 = (lto_module_t) 0 ;
 481   char *result = 0 ;
 482
 483   arg1 = (lto_module_t)jarg1;
 484
 485   result = (char *)lto_module_get_target_triple(arg1);
 486   jresult = result;
 487
 488
 489
 490   return jresult;
 491
 492 }
 493
 494
 495
 496 DllExport unsigned int SWIGSTDCALL Ada_lto_module_get_num_symbols (
 497   void * jarg1
 498   )
 499 {
 500   unsigned int jresult ;
 501   lto_module_t arg1 = (lto_module_t) 0 ;
 502   unsigned int result;
 503
 504   arg1 = (lto_module_t)jarg1;
 505
 506   result = (unsigned int)lto_module_get_num_symbols(arg1);
 507   jresult = result;
 508
 509
 510
 511   return jresult;
 512
 513 }
 514
 515
 516
 517 DllExport char * SWIGSTDCALL Ada_lto_module_get_symbol_name (
 518   void * jarg1
 519   ,
 520
 521   unsigned int jarg2
 522   )
 523 {
 524   char * jresult ;
 525   lto_module_t arg1 = (lto_module_t) 0 ;
 526   unsigned int arg2 ;
 527   char *result = 0 ;
 528
 529   arg1 = (lto_module_t)jarg1;
 530
 531
 532   arg2 = (unsigned int) jarg2;
 533
 534
 535   result = (char *)lto_module_get_symbol_name(arg1,arg2);
 536   jresult = result;
 537
 538
 539
 540   return jresult;
 541
 542 }
 543
 544
 545
 546 DllExport int SWIGSTDCALL Ada_lto_module_get_symbol_attribute (
 547   void * jarg1
 548   ,
 549
 550   unsigned int jarg2
 551   )
 552 {
 553   int jresult ;
 554   lto_module_t arg1 = (lto_module_t) 0 ;
 555   unsigned int arg2 ;
 556   lto_symbol_attributes result;
 557
 558   arg1 = (lto_module_t)jarg1;
 559
 560
 561   arg2 = (unsigned int) jarg2;
 562
 563
 564   result = (lto_symbol_attributes)lto_module_get_symbol_attribute(arg1,arg2);
 565   jresult = result;
 566
 567
 568
 569   return jresult;
 570
 571 }
 572
 573
 574
 575 DllExport void * SWIGSTDCALL Ada_lto_codegen_create (
 576   )
 577 {
 578   void * jresult ;
 579   lto_code_gen_t result;
 580
 581   result = (lto_code_gen_t)lto_codegen_create();
 582   jresult = (void *) result;
 583
 584
 585
 586   return jresult;
 587
 588 }
 589
 590
 591
 592 DllExport void SWIGSTDCALL Ada_lto_codegen_dispose (
 593   void * jarg1
 594   )
 595 {
 596   lto_code_gen_t arg1 = (lto_code_gen_t) 0 ;
 597
 598   arg1 = (lto_code_gen_t)jarg1;
 599
 600   lto_codegen_dispose(arg1);
 601
 602
 603 }
 604
 605
 606
 607 DllExport unsigned int SWIGSTDCALL Ada_lto_codegen_add_module (
 608   void * jarg1
 609   ,
 610
 611   void * jarg2
 612   )
 613 {
 614   unsigned int jresult ;
 615   lto_code_gen_t arg1 = (lto_code_gen_t) 0 ;
 616   lto_module_t arg2 = (lto_module_t) 0 ;
 617   bool result;
 618
 619   arg1 = (lto_code_gen_t)jarg1;
 620
 621   arg2 = (lto_module_t)jarg2;
 622
 623   result = (bool)lto_codegen_add_module(arg1,arg2);
 624   jresult = result;
 625
 626
 627
 628   return jresult;
 629
 630 }
 631
 632
 633
 634 DllExport unsigned int SWIGSTDCALL Ada_lto_codegen_set_debug_model (
 635   void * jarg1
 636   ,
 637
 638   int jarg2
 639   )
 640 {
 641   unsigned int jresult ;
 642   lto_code_gen_t arg1 = (lto_code_gen_t) 0 ;
 643   lto_debug_model arg2 ;
 644   bool result;
 645
 646   arg1 = (lto_code_gen_t)jarg1;
 647
 648   arg2 = (lto_debug_model) jarg2;
 649
 650   result = (bool)lto_codegen_set_debug_model(arg1,arg2);
 651   jresult = result;
 652
 653
 654
 655   return jresult;
 656
 657 }
 658
 659
 660
 661 DllExport unsigned int SWIGSTDCALL Ada_lto_codegen_set_pic_model (
 662   void * jarg1
 663   ,
 664
 665   int jarg2
 666   )
 667 {
 668   unsigned int jresult ;
 669   lto_code_gen_t arg1 = (lto_code_gen_t) 0 ;
 670   lto_codegen_model arg2 ;
 671   bool result;
 672
 673   arg1 = (lto_code_gen_t)jarg1;
 674
 675   arg2 = (lto_codegen_model) jarg2;
 676
 677   result = (bool)lto_codegen_set_pic_model(arg1,arg2);
 678   jresult = result;
 679
 680
 681
 682   return jresult;
 683
 684 }
 685
 686
 687
 688 DllExport void SWIGSTDCALL Ada_lto_codegen_set_gcc_path (
 689   void * jarg1
 690   ,
 691
 692   char * jarg2
 693   )
 694 {
 695   lto_code_gen_t arg1 = (lto_code_gen_t) 0 ;
 696   char *arg2 = (char *) 0 ;
 697
 698   arg1 = (lto_code_gen_t)jarg1;
 699
 700   arg2 = jarg2;
 701
 702   lto_codegen_set_gcc_path(arg1,(char const *)arg2);
 703
 704
 705 }
 706
 707
 708
 709 DllExport void SWIGSTDCALL Ada_lto_codegen_set_assembler_path (
 710   void * jarg1
 711   ,
 712
 713   char * jarg2
 714   )
 715 {
 716   lto_code_gen_t arg1 = (lto_code_gen_t) 0 ;
 717   char *arg2 = (char *) 0 ;
 718
 719   arg1 = (lto_code_gen_t)jarg1;
 720
 721   arg2 = jarg2;
 722
 723   lto_codegen_set_assembler_path(arg1,(char const *)arg2);
 724
 725
 726 }
 727
 728
 729
 730 DllExport void SWIGSTDCALL Ada_lto_codegen_add_must_preserve_symbol (
 731   void * jarg1
 732   ,
 733
 734   char * jarg2
 735   )
 736 {
 737   lto_code_gen_t arg1 = (lto_code_gen_t) 0 ;
 738   char *arg2 = (char *) 0 ;
 739
 740   arg1 = (lto_code_gen_t)jarg1;
 741
 742   arg2 = jarg2;
 743
 744   lto_codegen_add_must_preserve_symbol(arg1,(char const *)arg2);
 745
 746
 747 }
 748
 749
 750
 751 DllExport unsigned int SWIGSTDCALL Ada_lto_codegen_write_merged_modules (
 752   void * jarg1
 753   ,
 754
 755   char * jarg2
 756   )
 757 {
 758   unsigned int jresult ;
 759   lto_code_gen_t arg1 = (lto_code_gen_t) 0 ;
 760   char *arg2 = (char *) 0 ;
 761   bool result;
 762
 763   arg1 = (lto_code_gen_t)jarg1;
 764
 765   arg2 = jarg2;
 766
 767   result = (bool)lto_codegen_write_merged_modules(arg1,(char const *)arg2);
 768   jresult = result;
 769
 770
 771
 772   return jresult;
 773
 774 }
 775
 776
 777
 778 DllExport void* SWIGSTDCALL Ada_lto_codegen_compile (
 779   void * jarg1
 780   ,
 781
 782   size_t* jarg2
 783   )
 784 {
 785   void* jresult ;
 786   lto_code_gen_t arg1 = (lto_code_gen_t) 0 ;
 787   size_t *arg2 = (size_t *) 0 ;
 788   void *result = 0 ;
 789
 790   arg1 = (lto_code_gen_t)jarg1;
 791
 792
 793   arg2 = (size_t *) jarg2;
 794
 795
 796   result = (void *)lto_codegen_compile(arg1,arg2);
 797   jresult = (void *) result;
 798
 799
 800
 801   return jresult;
 802
 803 }
 804
 805
 806
 807 DllExport void SWIGSTDCALL Ada_lto_codegen_debug_options (
 808   void * jarg1
 809   ,
 810
 811   char * jarg2
 812   )
 813 {
 814   lto_code_gen_t arg1 = (lto_code_gen_t) 0 ;
 815   char *arg2 = (char *) 0 ;
 816
 817   arg1 = (lto_code_gen_t)jarg1;
 818
 819   arg2 = jarg2;
 820
 821   lto_codegen_debug_options(arg1,(char const *)arg2);
 822
 823
 824 }
 825
 826
 827
 828 DllExport void* SWIGSTDCALL Ada_llvm_create_optimizer (
 829   )
 830 {
 831   void* jresult ;
 832   llvm_lto_t result;
 833
 834   result = (llvm_lto_t)llvm_create_optimizer();
 835   jresult = (void *) result;
 836
 837
 838
 839   return jresult;
 840
 841 }
 842
 843
 844
 845 DllExport void SWIGSTDCALL Ada_llvm_destroy_optimizer (
 846   void* jarg1
 847   )
 848 {
 849   llvm_lto_t arg1 = (llvm_lto_t) 0 ;
 850
 851   arg1 = (llvm_lto_t)jarg1;
 852
 853   llvm_destroy_optimizer(arg1);
 854
 855
 856 }
 857
 858
 859
 860 DllExport int SWIGSTDCALL Ada_llvm_read_object_file (
 861   void* jarg1
 862   ,
 863
 864   char * jarg2
 865   )
 866 {
 867   int jresult ;
 868   llvm_lto_t arg1 = (llvm_lto_t) 0 ;
 869   char *arg2 = (char *) 0 ;
 870   llvm_lto_status_t result;
 871
 872   arg1 = (llvm_lto_t)jarg1;
 873
 874   arg2 = jarg2;
 875
 876   result = (llvm_lto_status_t)llvm_read_object_file(arg1,(char const *)arg2);
 877   jresult = result;
 878
 879
 880
 881   return jresult;
 882
 883 }
 884
 885
 886
 887 DllExport int SWIGSTDCALL Ada_llvm_optimize_modules (
 888   void* jarg1
 889   ,
 890
 891   char * jarg2
 892   )
 893 {
 894   int jresult ;
 895   llvm_lto_t arg1 = (llvm_lto_t) 0 ;
 896   char *arg2 = (char *) 0 ;
 897   llvm_lto_status_t result;
 898
 899   arg1 = (llvm_lto_t)jarg1;
 900
 901   arg2 = jarg2;
 902
 903   result = (llvm_lto_status_t)llvm_optimize_modules(arg1,(char const *)arg2);
 904   jresult = result;
 905
 906
 907
 908   return jresult;
 909
 910 }
 911
 912
 913
 914 #ifdef __cplusplus
 915 }
 916 #endif
 917 #ifdef __cplusplus
 918 extern "C" {
 919 #endif
 920 #ifdef __cplusplus
 921 }
 922 #endif
 923