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 "id.h"
  37
  38 using namespace clang;
  39
  40 /* Create an isl_id that refers to the variable declarator "decl".
  41  */
  42 __isl_give isl_id *pet_id_from_decl(isl_ctx *ctx, ValueDecl *decl)
  43 {
  44         return isl_id_alloc(ctx, decl->getName().str().c_str(), decl);
  45 }
  46
  47 /* Create an isl_id that refers to the variable declarator "decl", but
  48  * has name "name".
  49  */
  50 __isl_give isl_id *pet_id_from_name_and_decl(isl_ctx *ctx, const char *name,
  51         ValueDecl *decl)
  52 {
  53         return isl_id_alloc(ctx, name, decl);
  54 }
  55
  56 /* Create an isl_id with name "__pet_arg_<n>" and associated type "qt".
  57  */
  58 __isl_give isl_id *pet_id_arg_from_type(isl_ctx *ctx, int n, QualType qt)
  59 {
  60         char name[50];
  61         const Type *type = qt.getTypePtr();
  62
  63         snprintf(name, sizeof(name), "__pet_arg_%d", n);
  64         return isl_id_alloc(ctx, name, const_cast<Type *>(type));
  65 }
  66
  67 /* Compare the prefix of "s" to "prefix" up to the length of "prefix".
  68  */
  69 static int prefixcmp(const char *s, const char *prefix)
  70 {
  71         return strncmp(s, prefix, strlen(prefix));
  72 }
  73
  74 /* Is "id" an identifier created by pet_id_arg_from_type?
  75  */
  76 static int pet_id_is_arg(__isl_keep isl_id *id)
  77 {
  78         const char *name;
  79
  80         if (!id)
  81                 return -1;
  82         name = isl_id_get_name(id);
  83         if (!name)
  84                 return 0;
  85         return !prefixcmp(name, "__pet_arg");
  86 }
  87
  88 /* Extract the ValueDecl that was associated to "id"
  89  * in pet_id_from_decl.
  90  *
  91  * If "id" was create by pet_id_arg_from_type, then there is no
  92  * ValueDecl associated to it, so return NULL instead.
  93  */
  94 ValueDecl *pet_id_get_decl(__isl_keep isl_id *id)
  95 {
  96         if (pet_id_is_arg(id))
  97                 return NULL;
  98
  99         return (ValueDecl *) isl_id_get_user(id);
 100 }
 101
 102 /* Construct a pet_expr representing an index expression for an access
 103  * to the variable represented by "id".
 104  */
 105 __isl_give pet_expr *pet_id_create_index_expr(__isl_take isl_id *id)
 106 {
 107         isl_space *space;
 108
 109         if (!id)
 110                 return NULL;
 111
 112         space = isl_space_alloc(isl_id_get_ctx(id), 0, 0, 0);
 113         space = isl_space_set_tuple_id(space, isl_dim_out, id);
 114
 115         return pet_expr_from_index(isl_multi_pw_aff_zero(space));
 116 }
 117
 118 /* Is "T" the type of a variable length array with static size?
 119  */
 120 static bool is_vla_with_static_size(QualType T)
 121 {
 122         const VariableArrayType *vlatype;
 123
 124         if (!T->isVariableArrayType())
 125                 return false;
 126         vlatype = cast<VariableArrayType>(T);
 127         return vlatype->getSizeModifier() == VariableArrayType::Static;
 128 }
 129
 130 /* Return the type of the variable represented by "id" as an array.
 131  *
 132  * In particular, if the declaration associated to "id" is a parameter
 133  * declaration that is a variable length array with a static size, then
 134  * return the original type (i.e., the variable length array).
 135  * Otherwise, return the type of decl.
 136  *
 137  * If "id" was created by pet_id_arg_from_type, then it has
 138  * a type associated to it, so return that type instead.
 139  */
 140 QualType pet_id_get_array_type(__isl_keep isl_id *id)
 141 {
 142         ValueDecl *decl;
 143         ParmVarDecl *parm;
 144         QualType T;
 145
 146         if (pet_id_is_arg(id)) {
 147                 const Type *type;
 148                 type = (const Type *) isl_id_get_user(id);
 149                 return QualType(type, 0);
 150         }
 151
 152         decl = pet_id_get_decl(id);
 153
 154         parm = dyn_cast<ParmVarDecl>(decl);
 155         if (!parm)
 156                 return decl->getType();
 157
 158         T = parm->getOriginalType();
 159         if (!is_vla_with_static_size(T))
 160                 return decl->getType();
 161         return T;
 162 }