1 /*
   2  * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 #include "jdk_tools_jaotc_jnilibelf_JNILibELFAPI.h"
  25 
  26 // For file open and close
  27 #include <fcntl.h>
  28 #include <unistd.h>
  29 #include <err.h>
  30 #include <sysexits.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33 
  34 #include <assert.h>
  35 
  36 // For libelf interfaces
  37 #include <libelf.h>
  38 #include <gelf.h>
  39 
  40 // Convenience macro to shut the compiler warnings
  41 #ifdef UNUSED
  42 #elif defined(__GNUC__)
  43 # define UNUSED(x) UNUSED_ ## x __attribute__((unused))
  44 #elif defined(__LCLINT__)
  45 # define UNUSED(x) /*@unused@*/ x
  46 #else
  47 # define UNUSED(x) x
  48 #endif
  49 
  50 /**
  51  * libelfshim version
  52  */
  53 #ifndef AOT_VERSION_STRING
  54   #error AOT_VERSION_STRING must be defined
  55 #endif
  56 
  57 JNIEXPORT jstring JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_elfshim_1version
  58 (JNIEnv* env, jclass UNUSED(c))  {
  59    const char* ver = AOT_VERSION_STRING;
  60    return (*env)->NewStringUTF(env, ver);
  61 }
  62 
  63 JNIEXPORT jint JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_elf_1version
  64 (JNIEnv* UNUSED(env), jclass UNUSED(c), jint v)  {
  65     return elf_version(v);
  66 }
  67 
  68 /**
  69  * Unbox the Pointer object the encapsulated native address.
  70  */
  71 
  72 static jlong getNativeAddress(JNIEnv* env, jobject ptrObj) {
  73    jclass ptrClass;
  74    jfieldID fidNumber;
  75    jlong nativeAddress = -1;
  76     assert (ptrObj != NULL);
  77    // Get a reference to ptr object's class
  78    ptrClass = (*env)->GetObjectClass(env, ptrObj);
  79 
  80    // Get the Field ID of the instance variables "address"
  81    fidNumber = (*env)->GetFieldID(env, ptrClass, "address", "J");
  82    if (fidNumber != NULL) {
  83        // Get the long given the Field ID
  84        nativeAddress = (*env)->GetLongField(env, ptrObj, fidNumber);
  85    }
  86    // fprintf(stderr, "Native address : %lx\n", nativeAddress);
  87    return nativeAddress;
  88 }
  89 
  90 /**
  91  * Box the nativeAddress as a Pointer object.
  92  */
  93 static jobject makePointerObject(JNIEnv* env, jlong nativeAddr) {
  94    jclass ptrClass = (*env)->FindClass(env, "jdk/tools/jaotc/jnilibelf/Pointer");
  95    // Call back constructor to allocate a Pointer object, with an int argument
  96    jmethodID constructorId = (*env)->GetMethodID(env, ptrClass, "<init>", "(J)V");
  97    jobject retObj = (*env)->NewObject(env, ptrClass, constructorId, nativeAddr);
  98    return retObj;
  99 }
 100 
 101 JNIEXPORT jobject JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_elf_1begin
 102 (JNIEnv* env, jclass UNUSED(class), jint filedes, jint cmd, jobject ptrObj) {
 103 
 104    Elf* elfPtr = NULL;
 105    jlong addr = getNativeAddress(env, ptrObj);
 106 
 107    if (addr != -1) {
 108        // Call libelf function
 109        if ((elfPtr = elf_begin(filedes, cmd, (Elf *) addr)) == NULL) {
 110            errx(EX_SOFTWARE, "elf_begin() failed: %s.", elf_errmsg(-1));
 111        }
 112    } else {
 113        fprintf(stderr, "Failed to get native address to call elf_begin()\n");
 114    }
 115 
 116    return makePointerObject(env, (jlong) elfPtr);
 117 }
 118 
 119 JNIEXPORT jint JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_elf_1end
 120 (JNIEnv* env, jclass UNUSED(class), jobject ptrObj) {
 121 
 122    jlong addr = getNativeAddress(env, ptrObj);
 123 
 124    if (addr != -1) {
 125        // Call libelf function
 126        return elf_end((Elf *) addr);
 127    } else {
 128        fprintf(stderr, "Failed to get native address to call elf_end()\n");
 129        return -1;
 130    }
 131 }
 132 
 133 JNIEXPORT jint JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_elf_1kind
 134 (JNIEnv* env, jclass UNUSED(c), jobject ptrObj) {
 135    jlong addr = getNativeAddress(env, ptrObj);
 136 
 137    if (addr != -1) {
 138        // Call libelf function
 139        return elf_kind((Elf *) addr);
 140    } else {
 141        fprintf(stderr, "Failed to get native address to call elf_kind()\n");
 142        return -1;
 143    }
 144 }
 145 JNIEXPORT jint JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_elf_1flagphdr
 146 (JNIEnv* env, jclass UNUSED(c), jobject ptrObj, jint cmd, jint flags) {
 147 
 148    jlong addr = getNativeAddress(env, ptrObj);
 149    unsigned int retVal = 0;
 150 
 151    if (addr != -1) {
 152        // Call libelf function
 153        if ((retVal = elf_flagphdr((Elf *) addr, cmd, flags)) == 0) {
 154            errx(EX_SOFTWARE, "elf_flagphdr() failed: %s.", elf_errmsg(-1));
 155        }
 156    } else {
 157        fprintf(stderr, "Failed to get native address to call elf_flagphdr()\n");
 158    }
 159    return retVal;
 160 }
 161 
 162 JNIEXPORT jobject JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_elf_1newscn
 163 (JNIEnv* env, jclass UNUSED(c), jobject ptrObj) {
 164 
 165    Elf_Scn* elfSecPtr = NULL;
 166    jlong addr = getNativeAddress(env, ptrObj);
 167 
 168    if (addr != -1) {
 169        // Call libelf function
 170        if ((elfSecPtr = elf_newscn((Elf *) addr)) == NULL) {
 171            errx(EX_SOFTWARE, "elf_newscn() failed: %s.", elf_errmsg(-1));
 172        }
 173    } else {
 174        fprintf(stderr, "Failed to get native address to call elf_newscn()\n");
 175    }
 176 
 177    return makePointerObject(env, (jlong) elfSecPtr);
 178 }
 179 
 180 JNIEXPORT jobject JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_elf_1newdata
 181 (JNIEnv* env, jclass UNUSED(c), jobject ptrObj) {
 182 
 183    Elf_Data* elfDataPtr = NULL;
 184    jlong addr = getNativeAddress(env, ptrObj);
 185 
 186    if (addr != -1) {
 187        // Call libelf function
 188        if ((elfDataPtr = elf_newdata((Elf_Scn *) addr)) == NULL) {
 189            errx(EX_SOFTWARE, "elf_newdata() failed: %s.", elf_errmsg(-1));
 190        }
 191    } else {
 192        fprintf(stderr, "Failed to get native address to call elf_newdata()\n");
 193    }
 194    return makePointerObject(env, (jlong) elfDataPtr);
 195 }
 196 
 197 JNIEXPORT jobject JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_elf64_1getshdr
 198 (JNIEnv* env, jclass UNUSED(c), jobject ptrObj) {
 199 
 200    Elf64_Shdr* elf64ShdrPtr = NULL;
 201    jlong addr = getNativeAddress(env, ptrObj);
 202 
 203    if (addr != -1) {
 204        // Call libelf function
 205        if ((elf64ShdrPtr = elf64_getshdr((Elf_Scn *) addr)) == NULL) {
 206            errx(EX_SOFTWARE, "elf64_getshdr() failed: %s.", elf_errmsg(-1));
 207        }
 208    } else {
 209        fprintf(stderr, "Failed to get native address to call elf_getshdr()\n");
 210    }
 211    return makePointerObject(env, (jlong) elf64ShdrPtr);
 212 }
 213 
 214 JNIEXPORT jlong JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_elf_1update
 215 (JNIEnv* env, jclass UNUSED(c), jobject ptrObj, jint cmd) {
 216 
 217    off_t size = -1;
 218    jlong addr = getNativeAddress(env, ptrObj);
 219 
 220    if (addr != -1) {
 221        // Call libelf function
 222        if ((size = elf_update((Elf*) addr, cmd)) == -1) {
 223            errx(EX_SOFTWARE, "elf_update() failed: %s size (%d) cmd (%d).", elf_errmsg(-1), (int)size, cmd);
 224        }
 225    } else {
 226        fprintf(stderr, "Failed to get native address to call elf_update()\n");
 227    }
 228    return size;
 229 }
 230 
 231 JNIEXPORT jstring JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_elf_1errmsg
 232 (JNIEnv* env, jclass UNUSED(c), jint errno) {
 233 
 234    const char * retPtr = NULL;
 235    // Call libelf function
 236    if ((retPtr = elf_errmsg(errno)) == NULL) {
 237        errx(EX_SOFTWARE, "elf_errmsg() failed: %s.", elf_errmsg(-1));
 238    }
 239    return (*env)->NewStringUTF(env, retPtr);
 240 }
 241 
 242 JNIEXPORT jint JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_elf_1ndxscn
 243 (JNIEnv* env, jclass UNUSED(c), jobject ptrObj) {
 244    jint secnum = SHN_UNDEF;
 245    jlong addr = getNativeAddress(env, ptrObj);
 246    if (addr != -1) {
 247        // Call libelf function
 248        secnum = elf_ndxscn((Elf_Scn*) addr);
 249    } else {
 250        fprintf(stderr, "Failed to get native address to call elf_ndxscn()\n");
 251    }
 252    return secnum;
 253 }
 254 
 255 JNIEXPORT jobject JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_gelf_1newehdr
 256 (JNIEnv* env, jclass UNUSED(c), jobject ptrObj, jint elfClass) {
 257    unsigned long int retPtr = 0;
 258    jlong addr = getNativeAddress(env, ptrObj);
 259    if (addr != -1) {
 260        // Call libelf function
 261        if ((retPtr = gelf_newehdr((Elf*) addr, elfClass)) == 0) {
 262            errx(EX_SOFTWARE, "gelf_newehdr() failed: %s.", elf_errmsg(-1));
 263        }
 264    } else {
 265        fprintf(stderr, "Failed to get native address to call elf_newehdr()\n");
 266    }
 267    return makePointerObject(env, (jlong) retPtr);
 268 }
 269 
 270 JNIEXPORT jobject JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_gelf_1newphdr
 271 (JNIEnv* env, jclass UNUSED(c), jobject ptrObj, jint phnum) {
 272    unsigned long int retPtr = 0;
 273    jlong addr = getNativeAddress(env, ptrObj);
 274    if (addr != -1) {
 275        // Call libelf function
 276        if ((retPtr = gelf_newphdr((Elf*) addr, phnum)) == 0) {
 277            errx(EX_SOFTWARE, "gelf_newphdr() failed: %s.", elf_errmsg(-1));
 278        }
 279    } else {
 280        fprintf(stderr, "Failed to get native address to call elf_newphdr()\n");
 281    }
 282    return makePointerObject(env, (jlong) retPtr);
 283 }
 284 
 285 
 286 /* File operations */
 287 
 288 JNIEXPORT jint JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_open_1rw
 289 (JNIEnv * env, jclass UNUSED(class), jstring jfileName)  {
 290     int flags = O_RDWR | O_CREAT | O_TRUNC;
 291     int mode  = 0666;
 292     int retVal;
 293     const char* cfileName = (*env)->GetStringUTFChars(env, jfileName, NULL);
 294     if (cfileName == NULL) {
 295         return -1;
 296     }
 297     retVal = open(cfileName, flags, mode);
 298     if (retVal < 0) {
 299        err(EX_NOINPUT, "open %s failed", cfileName);
 300     }
 301     (*env)->ReleaseStringUTFChars(env, jfileName, cfileName);
 302 
 303     return retVal;
 304 }
 305 
 306 JNIEXPORT jint JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_open__Ljava_lang_String_2I
 307 (JNIEnv * env, jclass UNUSED(class), jstring jfileName, jint flags)  {
 308     int retVal;
 309     const char* cfileName = (*env)->GetStringUTFChars(env, jfileName, NULL);
 310     if (cfileName == NULL) {
 311         return -1;
 312     }
 313     retVal = open(cfileName, flags);
 314     if (retVal < 0) {
 315        err(EX_NOINPUT, "open %s failed", cfileName);
 316     }
 317     (*env)->ReleaseStringUTFChars(env, jfileName, cfileName);
 318 
 319     return retVal;
 320 }
 321 
 322 JNIEXPORT jint JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_open__Ljava_lang_String_2II
 323 (JNIEnv * env, jclass UNUSED(class), jstring jfileName, jint flags, jint mode)  {
 324     int retVal;
 325     const char* cfileName = (*env)->GetStringUTFChars(env, jfileName, NULL);
 326     if (cfileName == NULL) {
 327         return -1;
 328     }
 329     retVal = open(cfileName, flags, mode);
 330     if (retVal < 0) {
 331        err(EX_NOINPUT, "open %s failed", cfileName);
 332     }
 333     (*env)->ReleaseStringUTFChars(env, jfileName, cfileName);
 334 
 335     return retVal;
 336 }
 337 
 338 
 339 JNIEXPORT jint JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_close
 340 (JNIEnv* UNUSED(env), jclass UNUSED(class), jint fd) {
 341     return close(fd);
 342 }
 343 
 344 /**
 345  * Miscellaneous ELF data structure peek-poke functions in
 346  * shim_functions.c. No corresponding .h file exists yet.
 347  * So each function needs to be declared as extern
 348  */
 349 
 350 extern int size_of_Sym(int elfclass);
 351 extern int size_of_Rel(int elfclass);
 352 extern int size_of_Rela(int elfclass);
 353 
 354 extern void ehdr_set_data_encoding(void * ehdr, int val);
 355 extern void set_Ehdr_e_machine(int elfclass, void * structPtr, int val);
 356 extern void set_Ehdr_e_type(int elfclass, void * structPtr, int val);
 357 extern void set_Ehdr_e_version(int elfclass, void * structPtr, int val);
 358 extern void set_Ehdr_e_shstrndx(int elfclass, void * structPtr, int val);
 359 
 360 extern void phdr_set_type_self(int elfclass, void * ehdr, void * phdr);
 361 extern void phdr_set_type_self(int elfclass, void * ehdr, void * phdr);
 362 
 363 extern void set_Shdr_sh_name(int elfclass, void* structPtr, int val);
 364 extern void set_Shdr_sh_type(int elfclass, void* structPtr, int val);
 365 extern void set_Shdr_sh_flags(int elfclass, void* structPtr, int val);
 366 extern void set_Shdr_sh_entsize(int elfclass, void* structPtr, int val);
 367 extern void set_Shdr_sh_link(int elfclass, void* structPtr, int val);
 368 extern void set_Shdr_sh_info(int elfclass, void* structPtr, int val);
 369 
 370 extern void set_Data_d_align(void* structPtr, int val);
 371 extern void set_Data_d_off(void* structPtr, int val);
 372 extern void set_Data_d_buf(void* structPtr, void* val);
 373 extern void set_Data_d_type(void* structPtr, int val);
 374 extern void set_Data_d_size(void* structPtr, int val);
 375 extern void set_Data_d_version(void* structPtr, int val);
 376 
 377 extern void* create_sym_entry(int elfclass, int index, int type, int bind,
 378                                int shndx, int size, int value);
 379 extern void * create_reloc_entry(int elfclass, int roffset, int symtabIdx,
 380                                  int relocType, int raddend, int reloca);
 381 
 382 JNIEXPORT jint JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_size_1of_1Sym
 383 (JNIEnv* UNUSED(env), jclass UNUSED(c), jint elfClass) {
 384     return size_of_Sym(elfClass);
 385 }
 386 
 387 JNIEXPORT jint JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_size_1of_1Rela
 388 (JNIEnv* UNUSED(env), jclass UNUSED(c), jint elfClass) {
 389     return size_of_Rela(elfClass);
 390 }
 391 
 392 JNIEXPORT jint JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_size_1of_1Rel
 393 (JNIEnv* UNUSED(env), jclass UNUSED(c), jint elfClass) {
 394     return size_of_Rel(elfClass);
 395 }
 396 
 397 JNIEXPORT void JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_ehdr_1set_1data_1encoding
 398 (JNIEnv* env, jclass UNUSED(c), jobject ptrObj, jint val) {
 399     void* ehdr = (void*) getNativeAddress(env, ptrObj);
 400     ehdr_set_data_encoding(ehdr, val);
 401 }
 402 
 403 JNIEXPORT void JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_set_1Ehdr_1e_1machine
 404 (JNIEnv* env, jclass UNUSED(c), jint elfClass, jobject ptrObj, jint val) {
 405     void* ehdr = (void*) getNativeAddress(env, ptrObj);
 406     set_Ehdr_e_machine(elfClass, ehdr, val);
 407 }
 408 
 409 JNIEXPORT void JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_set_1Ehdr_1e_1type
 410 (JNIEnv* env, jclass UNUSED(c), jint elfClass, jobject ptrObj, jint val) {
 411     void* ehdr = (void*) getNativeAddress(env, ptrObj);
 412     set_Ehdr_e_type(elfClass, ehdr, val);
 413 }
 414 
 415 JNIEXPORT void JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_set_1Ehdr_1e_1version
 416 (JNIEnv* env, jclass UNUSED(c), jint elfClass, jobject ptrObj, jint val) {
 417     void* ehdr = (void*) getNativeAddress(env, ptrObj);
 418     set_Ehdr_e_version(elfClass, ehdr, val);
 419 }
 420 JNIEXPORT void JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_set_1Ehdr_1e_1shstrndx
 421 (JNIEnv* env, jclass UNUSED(c), jint elfClass, jobject ptrObj, jint val) {
 422     void* shdr = (void*) getNativeAddress(env, ptrObj);
 423     set_Ehdr_e_shstrndx(elfClass, shdr, val);
 424 }
 425 
 426 JNIEXPORT void JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_phdr_1set_1type_1self
 427 (JNIEnv* env, jclass UNUSED(c), jint elfClass, jobject ehdrPtr, jobject phdrPtr) {
 428     void* ehdr = (void*) getNativeAddress(env, ehdrPtr);
 429     void* phdr = (void*) getNativeAddress(env, phdrPtr);
 430     phdr_set_type_self(elfClass, ehdr, phdr);
 431 }
 432 
 433 JNIEXPORT void JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_set_1Shdr_1sh_1name
 434 (JNIEnv* env, jclass UNUSED(c), jint elfClass, jobject ptrObj, jint val) {
 435     void* shdr = (void*) getNativeAddress(env, ptrObj);
 436     set_Shdr_sh_name(elfClass, shdr, val);
 437 }
 438 
 439 JNIEXPORT void JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_set_1Shdr_1sh_1type
 440 (JNIEnv* env, jclass UNUSED(c), jint elfClass, jobject ptrObj, jint val) {
 441     void* shdr = (void*) getNativeAddress(env, ptrObj);
 442     set_Shdr_sh_type(elfClass, shdr, val);
 443 }
 444 
 445 JNIEXPORT void JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_set_1Shdr_1sh_1flags
 446 (JNIEnv* env, jclass UNUSED(c), jint elfClass, jobject ptrObj, jint val) {
 447     void* shdr = (void*) getNativeAddress(env, ptrObj);
 448     set_Shdr_sh_flags(elfClass, shdr, val);
 449 }
 450 
 451 JNIEXPORT void JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_set_1Shdr_1sh_1entsize
 452 (JNIEnv* env, jclass UNUSED(c), jint elfClass, jobject ptrObj, jint val) {
 453     void* shdr = (void*) getNativeAddress(env, ptrObj);
 454     set_Shdr_sh_entsize(elfClass, shdr, val);
 455 }
 456 
 457 JNIEXPORT void JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_set_1Shdr_1sh_1info
 458 (JNIEnv* env, jclass UNUSED(c), jint elfClass, jobject ptrObj, jint val) {
 459     void* shdr = (void*) getNativeAddress(env, ptrObj);
 460     set_Shdr_sh_info(elfClass, shdr, val);
 461 }
 462 
 463 JNIEXPORT void JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_set_1Shdr_1sh_1link
 464 (JNIEnv* env, jclass UNUSED(c), jint elfClass, jobject ptrObj, jint val) {
 465     void* shdr = (void*) getNativeAddress(env, ptrObj);
 466     set_Shdr_sh_link(elfClass, shdr, val);
 467 }
 468 
 469 JNIEXPORT void JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_set_1Data_1d_1align
 470 (JNIEnv* env, jclass UNUSED(c), jobject ptrObj, jint val) {
 471     void* dptr = (void*) getNativeAddress(env, ptrObj);
 472     set_Data_d_align(dptr, val);
 473 }
 474 
 475 
 476 JNIEXPORT void JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_set_1Data_1d_1off
 477 (JNIEnv* env, jclass UNUSED(c), jobject ptrObj, jint val) {
 478     void* dptr = (void*) getNativeAddress(env, ptrObj);
 479     set_Data_d_off(dptr, val);
 480 }
 481 
 482 JNIEXPORT void JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_set_1Data_1d_1buf
 483 (JNIEnv* env, jclass UNUSED(c), jobject ptrObj, jobject bufPtr) {
 484     void* dptr = (void*) getNativeAddress(env, ptrObj);
 485     void* bptr = (void*) getNativeAddress(env, bufPtr);
 486     set_Data_d_buf(dptr, bptr);
 487 }
 488 
 489 JNIEXPORT void JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_set_1Data_1d_1type
 490 (JNIEnv* env, jclass UNUSED(c), jobject ptrObj, jint val) {
 491     void* dptr = (void*) getNativeAddress(env, ptrObj);
 492     set_Data_d_type(dptr, val);
 493 }
 494 
 495 JNIEXPORT void JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_set_1Data_1d_1size
 496 (JNIEnv* env, jclass UNUSED(c), jobject ptrObj, jint val) {
 497     void* dptr = (void*) getNativeAddress(env, ptrObj);
 498     set_Data_d_size(dptr, val);
 499 }
 500 
 501 JNIEXPORT void JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_set_1Data_1d_1version
 502 (JNIEnv* env, jclass UNUSED(c), jobject ptrObj, jint val) {
 503     void* dptr = (void*) getNativeAddress(env, ptrObj);
 504     set_Data_d_version(dptr, val);
 505 }
 506 
 507 JNIEXPORT jlong JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_create_1sym_1entry
 508 (JNIEnv* UNUSED(env), jclass UNUSED(c), jint elfClass, jint index, jint type,
 509  jint bind, jint shndx, jint size, jint value) {
 510    void * retVal = create_sym_entry(elfClass, index, type, bind,
 511                                     shndx, size, value);
 512    return (jlong)retVal;
 513 }
 514 
 515 JNIEXPORT jlong JNICALL Java_jdk_tools_jaotc_jnilibelf_JNILibELFAPI_create_1reloc_1entry
 516 (JNIEnv* UNUSED(env), jclass UNUSED(c), jint elfClass, jint roffset,
 517  jint symTabIdx, jint relocType, jint raddend, jint reloca) {
 518    void * retVal = create_reloc_entry(elfClass, roffset, symTabIdx,
 519                                       relocType, raddend, reloca);
 520    return (jlong)retVal;
 521 }
 522