Coverage Report

Created: 2017-08-21 19:50

/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/tools/polly/lib/External/isl/isl_id.c
Line
Count
Source (jump to first uncovered line)
1
/*
2
 * Copyright 2008-2009 Katholieke Universiteit Leuven
3
 *
4
 * Use of this software is governed by the MIT license
5
 *
6
 * Written by Sven Verdoolaege, K.U.Leuven, Departement
7
 * Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium
8
 */
9
10
#include <string.h>
11
#include <isl_ctx_private.h>
12
#include <isl_id_private.h>
13
14
#undef BASE
15
#define BASE id
16
17
#include <isl_list_templ.c>
18
19
/* A special, static isl_id to use as domains (and ranges)
20
 * of sets and parameters domains.
21
 * The user should never get a hold on this isl_id.
22
 */
23
isl_id isl_id_none = {
24
  .ref = -1,
25
  .ctx = NULL,
26
  .name = "#none",
27
  .user = NULL
28
};
29
30
isl_ctx *isl_id_get_ctx(__isl_keep isl_id *id)
31
20.1k
{
32
20.1k
  return id ? id->ctx : NULL;
33
20.1k
}
34
35
void *isl_id_get_user(__isl_keep isl_id *id)
36
29.8k
{
37
29.8k
  return id ? id->user : NULL;
38
29.8k
}
39
40
const char *isl_id_get_name(__isl_keep isl_id *id)
41
11.6k
{
42
11.6k
  return id ? id->name : NULL;
43
11.6k
}
44
45
static __isl_give isl_id *id_alloc(isl_ctx *ctx, const char *name, void *user)
46
68.7k
{
47
67.1k
  const char *copy = name ? strdup(name) : NULL;
48
68.7k
  isl_id *id;
49
68.7k
50
68.7k
  if (
name && 68.7k
!copy67.1k
)
51
0
    return NULL;
52
68.7k
  
id = 68.7k
isl_calloc_type68.7k
(ctx, struct isl_id);
53
68.7k
  if (!id)
54
1
    goto error;
55
68.7k
56
68.7k
  id->ctx = ctx;
57
68.7k
  isl_ctx_ref(id->ctx);
58
68.7k
  id->ref = 1;
59
68.7k
  id->name = copy;
60
68.7k
  id->user = user;
61
68.7k
62
68.7k
  id->hash = isl_hash_init();
63
68.7k
  if (name)
64
67.1k
    id->hash = isl_hash_string(id->hash, name);
65
68.7k
  else
66
1.57k
    
id->hash = 1.57k
isl_hash_builtin1.57k
(id->hash, user);
67
68.7k
68
68.7k
  return id;
69
68.7k
error:
70
1
  free((char *)copy);
71
68.7k
  return NULL;
72
68.7k
}
73
74
uint32_t isl_id_get_hash(__isl_keep isl_id *id)
75
1.01k
{
76
1.01k
  return id ? 
id->hash1.01k
:
00
;
77
1.01k
}
78
79
struct isl_name_and_user {
80
  const char *name;
81
  void *user;
82
};
83
84
static int isl_id_has_name_and_user(const void *entry, const void *val)
85
91.8k
{
86
91.8k
  isl_id *id = (isl_id *)entry;
87
91.8k
  struct isl_name_and_user *nu = (struct isl_name_and_user *) val;
88
91.8k
89
91.8k
  if (id->user != nu->user)
90
84.4k
    return 0;
91
7.37k
  
if (7.37k
id->name == nu->name7.37k
)
92
697
    return 1;
93
6.67k
  
if (6.67k
!id->name || 6.67k
!nu->name6.67k
)
94
0
    return 0;
95
6.67k
96
6.67k
  return !strcmp(id->name, nu->name);
97
91.8k
}
98
99
__isl_give isl_id *isl_id_alloc(isl_ctx *ctx, const char *name, void *user)
100
76.0k
{
101
76.0k
  struct isl_hash_table_entry *entry;
102
76.0k
  uint32_t id_hash;
103
76.0k
  struct isl_name_and_user nu = { name, user };
104
76.0k
105
76.0k
  if (!ctx)
106
0
    return NULL;
107
76.0k
108
76.0k
  
id_hash = 76.0k
isl_hash_init76.0k
();
109
76.0k
  if (name)
110
73.8k
    id_hash = isl_hash_string(id_hash, name);
111
76.0k
  else
112
2.27k
    
id_hash = 2.27k
isl_hash_builtin2.27k
(id_hash, user);
113
76.0k
  entry = isl_hash_table_find(ctx, &ctx->id_table, id_hash,
114
76.0k
          isl_id_has_name_and_user, &nu, 1);
115
76.0k
  if (!entry)
116
0
    return NULL;
117
76.0k
  
if (76.0k
entry->data76.0k
)
118
7.37k
    return isl_id_copy(entry->data);
119
76.0k
  entry->data = id_alloc(ctx, name, user);
120
68.7k
  if (!entry->data)
121
1
    ctx->id_table.n--;
122
76.0k
  return entry->data;
123
76.0k
}
124
125
/* If the id has a negative refcount, then it is a static isl_id
126
 * which should not be changed.
127
 */
128
__isl_give isl_id *isl_id_copy(isl_id *id)
129
13.3M
{
130
13.3M
  if (!id)
131
10.4k
    return NULL;
132
13.3M
133
13.3M
  
if (13.3M
id->ref < 013.3M
)
134
1.50M
    return id;
135
13.3M
136
13.3M
  id->ref++;
137
13.3M
  return id;
138
13.3M
}
139
140
/* Compare two isl_ids.
141
 *
142
 * The order is fairly arbitrary.  We do keep the comparison of
143
 * the user pointers as a last resort since these pointer values
144
 * may not be stable across different systems or even different runs.
145
 */
146
int isl_id_cmp(__isl_keep isl_id *id1, __isl_keep isl_id *id2)
147
4.30M
{
148
4.30M
  if (id1 == id2)
149
4.30M
    return 0;
150
0
  
if (0
!id10
)
151
0
    return -1;
152
0
  
if (0
!id20
)
153
0
    return 1;
154
0
  
if (0
!id1->name != !id2->name0
)
155
0
    return !id1->name - !id2->name;
156
0
  
if (0
id1->name0
)
{0
157
0
    int cmp = strcmp(id1->name, id2->name);
158
0
    if (cmp != 0)
159
0
      return cmp;
160
0
  }
161
0
  
if (0
id1->user < id2->user0
)
162
0
    return -1;
163
0
  else
164
0
    return 1;
165
4.30M
}
166
167
static int isl_id_eq(const void *entry, const void *name)
168
72.3k
{
169
72.3k
  return entry == name;
170
72.3k
}
171
172
uint32_t isl_hash_id(uint32_t hash, __isl_keep isl_id *id)
173
1.89M
{
174
1.89M
  if (id)
175
1.40M
    isl_hash_hash(hash, id->hash);
176
1.89M
177
1.89M
  return hash;
178
1.89M
}
179
180
/* Replace the free_user callback by "free_user".
181
 */
182
__isl_give isl_id *isl_id_set_free_user(__isl_take isl_id *id,
183
  void (*free_user)(void *user))
184
1.84k
{
185
1.84k
  if (!id)
186
0
    return NULL;
187
1.84k
188
1.84k
  id->free_user = free_user;
189
1.84k
190
1.84k
  return id;
191
1.84k
}
192
193
/* If the id has a negative refcount, then it is a static isl_id
194
 * and should not be freed.
195
 */
196
__isl_null isl_id *isl_id_free(__isl_take isl_id *id)
197
25.6M
{
198
25.6M
  struct isl_hash_table_entry *entry;
199
25.6M
200
25.6M
  if (!id)
201
10.7M
    return NULL;
202
25.6M
203
14.8M
  
if (14.8M
id->ref < 014.8M
)
204
2.97M
    return NULL;
205
14.8M
206
11.8M
  
if (11.8M
--id->ref > 011.8M
)
207
11.8M
    return NULL;
208
11.8M
209
11.8M
  entry = isl_hash_table_find(id->ctx, &id->ctx->id_table, id->hash,
210
68.4k
          isl_id_eq, id, 0);
211
68.4k
  if (!entry)
212
0
    isl_die(id->ctx, isl_error_unknown,
213
68.4k
      "unable to find id", (void)0);
214
68.4k
  else
215
68.4k
    isl_hash_table_remove(id->ctx, &id->ctx->id_table, entry);
216
68.4k
217
68.4k
  if (id->free_user)
218
1.84k
    id->free_user(id->user);
219
68.4k
220
68.4k
  free((char *)id->name);
221
68.4k
  isl_ctx_deref(id->ctx);
222
68.4k
  free(id);
223
68.4k
224
11.8M
  return NULL;
225
25.6M
}
226
227
__isl_give isl_printer *isl_printer_print_id(__isl_take isl_printer *p,
228
  __isl_keep isl_id *id)
229
14
{
230
14
  if (!id)
231
0
    goto error;
232
14
233
14
  
if (14
id->name14
)
234
14
    p = isl_printer_print_str(p, id->name);
235
14
  if (
id->user14
)
{14
236
14
    char buffer[50];
237
14
    snprintf(buffer, sizeof(buffer), "@%p", id->user);
238
14
    p = isl_printer_print_str(p, buffer);
239
14
  }
240
14
  return p;
241
14
error:
242
0
  isl_printer_free(p);
243
14
  return NULL;
244
14
}