Home | History | Annotate | Download | only in crosstest 
      1 //===- subzero/crosstest/test_global.cpp - Global variable access tests ---===//
      2 //
      3 //                        The Subzero Code Generator
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 //
     10 // Implementation for crosstesting global variable access operations.
     11 //
     12 //===----------------------------------------------------------------------===//
     13 
     14 #include <stdint.h>
     15 #include <cstdlib>
     16 
     17 #include "test_global.h"
     18 
     19 // Note: The following take advantage of the fact that external global
     20 // names are not mangled with the --prefix CL argument. Hence, they
     21 // should have the same relocation value for both llc and Subzero.
     22 extern uint8_t *ExternName1;
     23 extern uint8_t *ExternName2;
     24 extern uint8_t *ExternName3;
     25 extern uint8_t *ExternName4;
     26 extern uint8_t *ExternName5;
     27 
     28 // Partially initialized array
     29 int ArrayInitPartial[10] = {60, 70, 80, 90, 100};
     30 int ArrayInitFull[] = {10, 20, 30, 40, 50};
     31 const int ArrayConst[] = {-10, -20, -30};
     32 static double ArrayDouble[10] = {0.5, 1.5, 2.5, 3.5};
     33 
     34 static struct {
     35   int Array1[5];
     36   uint8_t *Pointer1;
     37   double Array2[3];
     38   uint8_t *Pointer2;
     39   struct {
     40     uint8_t *Pointer3;
     41     int Array1[3];
     42     uint8_t *Pointer4;
     43   } NestedStuff;
     44   uint8_t *Pointer5;
     45 } StructEx = {
     46     {10, 20, 30, 40, 50},
     47     ExternName1,
     48     {0.5, 1.5, 2.5},
     49     ExternName4,
     50     {ExternName3, {1000, 1010, 1020}, ExternName2},
     51     ExternName5,
     52 };
     53 
     54 #define ARRAY(a)                                                               \
     55   { (uint8_t *)(a), sizeof(a) }
     56 
     57 // Note: By embedding the array addresses in this table, we are indirectly
     58 // testing relocations (i.e. getArray would return the wrong address if
     59 // relocations are broken).
     60 struct {
     61   uint8_t *ArrayAddress;
     62   size_t ArraySizeInBytes;
     63 } Arrays[] = {
     64     ARRAY(ArrayInitPartial),
     65     ARRAY(ArrayInitFull),
     66     ARRAY(ArrayConst),
     67     ARRAY(ArrayDouble),
     68     {(uint8_t *)(ArrayInitPartial + 2),
     69      sizeof(ArrayInitPartial) - 2 * sizeof(int)},
     70     {(uint8_t *)(&StructEx), sizeof(StructEx)},
     71 };
     72 size_t NumArraysElements = sizeof(Arrays) / sizeof(*Arrays);
     73 
     74 size_t getNumArrays() { return NumArraysElements; }
     75 
     76 const uint8_t *getArray(size_t WhichArray, size_t &Len) {
     77   if (WhichArray >= NumArraysElements) {
     78     Len = -1;
     79     return NULL;
     80   }
     81   Len = Arrays[WhichArray].ArraySizeInBytes;
     82   return Arrays[WhichArray].ArrayAddress;
     83 }
     84