id.cc

   1 /*
   2  * Copyright 2011      Leiden University. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   8  *    1. Redistributions of source code must retain the above copyright
   9  *       notice, this list of conditions and the following disclaimer.
  10  *
  11  *    2. Redistributions in binary form must reproduce the above
  12  *       copyright notice, this list of conditions and the following
  13  *       disclaimer in the documentation and/or other materials provided
  14  *       with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY LEIDEN UNIVERSITY ''AS IS'' AND ANY
  17  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  19  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL LEIDEN UNIVERSITY OR
  20  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  21  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  22  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
  23  * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  *
  28  * The views and conclusions contained in the software and documentation
  29  * are those of the authors and should not be interpreted as
  30  * representing official policies, either expressed or implied, of
  31  * Leiden University.
  32  */
  33
  34 #include <string.h>
  35
  36 #include "clang_compatibility.h"
  37 #include "id.h"
  38
  39 using namespace clang;
  40
  41 /* Create an isl_id that refers to the variable declarator "decl".
  42  */
  43 __isl_give isl_id *pet_id_from_decl(isl_ctx *ctx, ValueDecl *decl)
  44 {
  45         return isl_id_alloc(ctx, decl->getName().str().c_str(), decl);
  46 }
  47
  48 /* Create an isl_id that refers to the variable declarator "decl", but
  49  * has name "name".
  50  */
  51 __isl_give isl_id *pet_id_from_name_and_decl(isl_ctx *ctx, const char *name,
  52         ValueDecl *decl)
  53 {
  54         return isl_id_alloc(ctx, name, decl);
  55 }
  56
  57 /* Create an isl_id with name specified by "name_template" and "n" and
  58  * associated type "qt".
  59  */
  60 static __isl_give isl_id *pet_id_from_type(isl_ctx *ctx,
  61         const char *name_template, int n, QualType qt)
  62 {
  63         char name[50];
  64         const Type *type = qt.getTypePtr();
  65
  66         snprintf(name, sizeof(name), name_template, n);
  67         return isl_id_alloc(ctx, name, const_cast<Type *>(type));
  68 }
  69
  70 /* Create an isl_id with name "__pet_arg_<n>" and associated type "qt".
  71  */
  72 __isl_give isl_id *pet_id_arg_from_type(isl_ctx *ctx, int n, QualType qt)
  73 {
  74         return pet_id_from_type(ctx, "__pet_arg_%d", n, qt);
  75 }
  76
  77 /* Create an isl_id with name "__pet_ret_<n>" and associated type "qt".
  78  */
  79 __isl_give isl_id *pet_id_ret_from_type(isl_ctx *ctx, int n, QualType qt)
  80 {
  81         return pet_id_from_type(ctx, "__pet_ret_%d", n, qt);
  82 }
  83
  84 /* Compare the prefix of "s" to "prefix" up to the length of "prefix".
  85  */
  86 static int prefixcmp(const char *s, const char *prefix)
  87 {
  88         return strncmp(s, prefix, strlen(prefix));
  89 }
  90
  91 /* Is "id" an identifier created by pet_id_arg_from_type or
  92  * pet_id_ret_from_type?
  93  */
  94 static int pet_id_is_arg_or_ret(__isl_keep isl_id *id)
  95 {
  96         const char *name;
  97
  98         if (!id)
  99                 return -1;
 100         name = isl_id_get_name(id);
 101         if (!name)
 102                 return 0;
 103         return !prefixcmp(name, "__pet_arg") || !prefixcmp(name, "__pet_ret");
 104 }
 105
 106 /* Extract the ValueDecl that was associated to "id"
 107  * in pet_id_from_decl.
 108  *
 109  * If "id" was create by pet_id_arg_from_type or pet_id_ret_from_type,
 110  * then there is no ValueDecl associated to it, so return NULL instead.
 111  */
 112 ValueDecl *pet_id_get_decl(__isl_keep isl_id *id)
 113 {
 114         if (pet_id_is_arg_or_ret(id))
 115                 return NULL;
 116
 117         return (ValueDecl *) isl_id_get_user(id);
 118 }
 119
 120 /* Construct a pet_expr representing an index expression for an access
 121  * to the variable represented by "id".
 122  */
 123 __isl_give pet_expr *pet_id_create_index_expr(__isl_take isl_id *id)
 124 {
 125         isl_space *space;
 126
 127         if (!id)
 128                 return NULL;
 129
 130         space = isl_space_alloc(isl_id_get_ctx(id), 0, 0, 0);
 131         space = isl_space_set_tuple_id(space, isl_dim_out, id);
 132
 133         return pet_expr_from_index(isl_multi_pw_aff_zero(space));
 134 }
 135
 136 /* Is "T" the type of a variable length array with static size?
 137  */
 138 static bool is_vla_with_static_size(QualType T)
 139 {
 140         const VariableArrayType *vlatype;
 141
 142         if (!T->isVariableArrayType())
 143                 return false;
 144         vlatype = cast<VariableArrayType>(T);
 145         return vlatype->getSizeModifier() == ArraySizeModifier::Static;
 146 }
 147
 148 /* Return the type of the variable represented by "id" as an array.
 149  *
 150  * In particular, if the declaration associated to "id" is a parameter
 151  * declaration that is a variable length array with a static size, then
 152  * return the original type (i.e., the variable length array).
 153  * Otherwise, return the type of decl.
 154  *
 155  * If "id" was created by pet_id_arg_from_type or pet_id_ret_from_type,
 156  * then it has a type associated to it, so return that type instead.
 157  */
 158 QualType pet_id_get_array_type(__isl_keep isl_id *id)
 159 {
 160         ValueDecl *decl;
 161         ParmVarDecl *parm;
 162         QualType T;
 163
 164         if (pet_id_is_arg_or_ret(id)) {
 165                 const Type *type;
 166                 type = (const Type *) isl_id_get_user(id);
 167                 return QualType(type, 0);
 168         }
 169
 170         decl = pet_id_get_decl(id);
 171
 172         parm = dyn_cast<ParmVarDecl>(decl);
 173         if (!parm)
 174                 return decl->getType();
 175
 176         T = parm->getOriginalType();
 177         if (!is_vla_with_static_size(T))
 178                 return decl->getType();
 179         return T;
 180 }