llvm-project

1
//===-- JSONExporter.cpp  - Export Scops as JSON  -------------------------===//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8
//
9
// Export the Scops build by ScopInfo pass as a JSON file.
10
//
11
//===----------------------------------------------------------------------===//
12

13
#include "polly/JSONExporter.h"
14
#include "polly/DependenceInfo.h"
15
#include "polly/LinkAllPasses.h"
16
#include "polly/Options.h"
17
#include "polly/ScopInfo.h"
18
#include "polly/ScopPass.h"
19
#include "polly/Support/ISLTools.h"
20
#include "polly/Support/ScopLocation.h"
21
#include "llvm/ADT/Statistic.h"
22
#include "llvm/IR/Module.h"
23
#include "llvm/Support/FileSystem.h"
24
#include "llvm/Support/JSON.h"
25
#include "llvm/Support/MemoryBuffer.h"
26
#include "llvm/Support/ToolOutputFile.h"
27
#include "llvm/Support/raw_ostream.h"
28
#include "isl/map.h"
29
#include "isl/set.h"
30
#include <memory>
31
#include <string>
32
#include <system_error>
33

34
using namespace llvm;
35
using namespace polly;
36

37
#define DEBUG_TYPE "polly-import-jscop"
38

39
STATISTIC(NewAccessMapFound, "Number of updated access functions");
40

41
namespace {
42
static cl::opt<std::string>
43
    ImportDir("polly-import-jscop-dir",
44
              cl::desc("The directory to import the .jscop files from."),
45
              cl::Hidden, cl::value_desc("Directory path"), cl::ValueRequired,
46
              cl::init("."), cl::cat(PollyCategory));
47

48
static cl::opt<std::string>
49
    ImportPostfix("polly-import-jscop-postfix",
50
                  cl::desc("Postfix to append to the import .jsop files."),
51
                  cl::Hidden, cl::value_desc("File postfix"), cl::ValueRequired,
52
                  cl::init(""), cl::cat(PollyCategory));
53

54
class JSONExporter : public ScopPass {
55
public:
56
  static char ID;
57
  explicit JSONExporter() : ScopPass(ID) {}
58

59
  /// Export the SCoP @p S to a JSON file.
60
  bool runOnScop(Scop &S) override;
61

62
  /// Print the SCoP @p S as it is exported.
63
  void printScop(raw_ostream &OS, Scop &S) const override;
64

65
  /// Register all analyses and transformation required.
66
  void getAnalysisUsage(AnalysisUsage &AU) const override;
67
};
68

69
class JSONImporter : public ScopPass {
70
public:
71
  static char ID;
72
  std::vector<std::string> NewAccessStrings;
73
  explicit JSONImporter() : ScopPass(ID) {}
74
  /// Import new access functions for SCoP @p S from a JSON file.
75
  bool runOnScop(Scop &S) override;
76

77
  /// Print the SCoP @p S and the imported access functions.
78
  void printScop(raw_ostream &OS, Scop &S) const override;
79

80
  /// Register all analyses and transformation required.
81
  void getAnalysisUsage(AnalysisUsage &AU) const override;
82
};
83
} // namespace
84

85
static std::string getFileName(Scop &S, StringRef Suffix = "") {
86
  std::string FunctionName = S.getFunction().getName().str();
87
  std::string FileName = FunctionName + "___" + S.getNameStr() + ".jscop";
88

89
  if (Suffix != "")
90
    FileName += "." + Suffix.str();
91

92
  return FileName;
93
}
94

95
/// Export all arrays from the Scop.
96
///
97
/// @param S The Scop containing the arrays.
98
///
99
/// @returns Json::Value containing the arrays.
100
static json::Array exportArrays(const Scop &S) {
101
  json::Array Arrays;
102
  std::string Buffer;
103
  llvm::raw_string_ostream RawStringOstream(Buffer);
104

105
  for (auto &SAI : S.arrays()) {
106
    if (!SAI->isArrayKind())
107
      continue;
108

109
    json::Object Array;
110
    json::Array Sizes;
111
    Array["name"] = SAI->getName();
112
    unsigned i = 0;
113
    if (!SAI->getDimensionSize(i)) {
114
      Sizes.push_back("*");
115
      i++;
116
    }
117
    for (; i < SAI->getNumberOfDimensions(); i++) {
118
      SAI->getDimensionSize(i)->print(RawStringOstream);
119
      Sizes.push_back(RawStringOstream.str());
120
      Buffer.clear();
121
    }
122
    Array["sizes"] = std::move(Sizes);
123
    SAI->getElementType()->print(RawStringOstream);
124
    Array["type"] = RawStringOstream.str();
125
    Buffer.clear();
126
    Arrays.push_back(std::move(Array));
127
  }
128
  return Arrays;
129
}
130

131
static json::Value getJSON(Scop &S) {
132
  json::Object root;
133
  unsigned LineBegin, LineEnd;
134
  std::string FileName;
135

136
  getDebugLocation(&S.getRegion(), LineBegin, LineEnd, FileName);
137
  std::string Location;
138
  if (LineBegin != (unsigned)-1)
139
    Location = FileName + ":" + std::to_string(LineBegin) + "-" +
140
               std::to_string(LineEnd);
141

142
  root["name"] = S.getNameStr();
143
  root["context"] = S.getContextStr();
144
  if (LineBegin != (unsigned)-1)
145
    root["location"] = Location;
146

147
  root["arrays"] = exportArrays(S);
148

149
  root["statements"];
150

151
  json::Array Statements;
152
  for (ScopStmt &Stmt : S) {
153
    json::Object statement;
154

155
    statement["name"] = Stmt.getBaseName();
156
    statement["domain"] = Stmt.getDomainStr();
157
    statement["schedule"] = Stmt.getScheduleStr();
158

159
    json::Array Accesses;
160
    for (MemoryAccess *MA : Stmt) {
161
      json::Object access;
162

163
      access["kind"] = MA->isRead() ? "read" : "write";
164
      access["relation"] = MA->getAccessRelationStr();
165

166
      Accesses.push_back(std::move(access));
167
    }
168
    statement["accesses"] = std::move(Accesses);
169

170
    Statements.push_back(std::move(statement));
171
  }
172

173
  root["statements"] = std::move(Statements);
174
  return json::Value(std::move(root));
175
}
176

177
static void exportScop(Scop &S) {
178
  std::string FileName = ImportDir + "/" + getFileName(S);
179

180
  json::Value jscop = getJSON(S);
181

182
  // Write to file.
183
  std::error_code EC;
184
  ToolOutputFile F(FileName, EC, llvm::sys::fs::OF_TextWithCRLF);
185

186
  std::string FunctionName = S.getFunction().getName().str();
187
  errs() << "Writing JScop '" << S.getNameStr() << "' in function '"
188
         << FunctionName << "' to '" << FileName << "'.\n";
189

190
  if (!EC) {
191
    F.os() << formatv("{0:3}", jscop);
192
    F.os().close();
193
    if (!F.os().has_error()) {
194
      errs() << "\n";
195
      F.keep();
196
      return;
197
    }
198
  }
199

200
  errs() << "  error opening file for writing!\n";
201
  F.os().clear_error();
202
}
203

204
typedef Dependences::StatementToIslMapTy StatementToIslMapTy;
205

206
/// Import a new context from JScop.
207
///
208
/// @param S The scop to update.
209
/// @param JScop The JScop file describing the new schedule.
210
///
211
/// @returns True if the import succeeded, otherwise False.
212
static bool importContext(Scop &S, const json::Object &JScop) {
213
  isl::set OldContext = S.getContext();
214

215
  // Check if key 'context' is present.
216
  if (!JScop.get("context")) {
217
    errs() << "JScop file has no key named 'context'.\n";
218
    return false;
219
  }
220

221
  isl::set NewContext =
222
      isl::set{S.getIslCtx().get(), JScop.getString("context").value().str()};
223

224
  // Check whether the context was parsed successfully.
225
  if (NewContext.is_null()) {
226
    errs() << "The context was not parsed successfully by ISL.\n";
227
    return false;
228
  }
229

230
  // Check if the isl_set is a parameter set.
231
  if (!NewContext.is_params()) {
232
    errs() << "The isl_set is not a parameter set.\n";
233
    return false;
234
  }
235

236
  unsigned OldContextDim = unsignedFromIslSize(OldContext.dim(isl::dim::param));
237
  unsigned NewContextDim = unsignedFromIslSize(NewContext.dim(isl::dim::param));
238

239
  // Check if the imported context has the right number of parameters.
240
  if (OldContextDim != NewContextDim) {
241
    errs() << "Imported context has the wrong number of parameters : "
242
           << "Found " << NewContextDim << " Expected " << OldContextDim
243
           << "\n";
244
    return false;
245
  }
246

247
  for (unsigned i = 0; i < OldContextDim; i++) {
248
    isl::id Id = OldContext.get_dim_id(isl::dim::param, i);
249
    NewContext = NewContext.set_dim_id(isl::dim::param, i, Id);
250
  }
251

252
  S.setContext(NewContext);
253
  return true;
254
}
255

256
/// Import a new schedule from JScop.
257
///
258
/// ... and verify that the new schedule does preserve existing data
259
/// dependences.
260
///
261
/// @param S The scop to update.
262
/// @param JScop The JScop file describing the new schedule.
263
/// @param D The data dependences of the @p S.
264
///
265
/// @returns True if the import succeeded, otherwise False.
266
static bool importSchedule(Scop &S, const json::Object &JScop,
267
                           const Dependences &D) {
268
  StatementToIslMapTy NewSchedule;
269

270
  // Check if key 'statements' is present.
271
  if (!JScop.get("statements")) {
272
    errs() << "JScop file has no key name 'statements'.\n";
273
    return false;
274
  }
275

276
  const json::Array &statements = *JScop.getArray("statements");
277

278
  // Check whether the number of indices equals the number of statements
279
  if (statements.size() != S.getSize()) {
280
    errs() << "The number of indices and the number of statements differ.\n";
281
    return false;
282
  }
283

284
  int Index = 0;
285
  for (ScopStmt &Stmt : S) {
286
    // Check if key 'schedule' is present.
287
    if (!statements[Index].getAsObject()->get("schedule")) {
288
      errs() << "Statement " << Index << " has no 'schedule' key.\n";
289
      return false;
290
    }
291
    std::optional<StringRef> Schedule =
292
        statements[Index].getAsObject()->getString("schedule");
293
    assert(Schedule.has_value() &&
294
           "Schedules that contain extension nodes require special handling.");
295
    isl_map *Map = isl_map_read_from_str(S.getIslCtx().get(),
296
                                         Schedule.value().str().c_str());
297

298
    // Check whether the schedule was parsed successfully
299
    if (!Map) {
300
      errs() << "The schedule was not parsed successfully (index = " << Index
301
             << ").\n";
302
      return false;
303
    }
304

305
    isl_space *Space = Stmt.getDomainSpace().release();
306

307
    // Copy the old tuple id. This is necessary to retain the user pointer,
308
    // that stores the reference to the ScopStmt this schedule belongs to.
309
    Map = isl_map_set_tuple_id(Map, isl_dim_in,
310
                               isl_space_get_tuple_id(Space, isl_dim_set));
311
    for (isl_size i = 0; i < isl_space_dim(Space, isl_dim_param); i++) {
312
      isl_id *Id = isl_space_get_dim_id(Space, isl_dim_param, i);
313
      Map = isl_map_set_dim_id(Map, isl_dim_param, i, Id);
314
    }
315
    isl_space_free(Space);
316
    NewSchedule[&Stmt] = isl::manage(Map);
317
    Index++;
318
  }
319

320
  // Check whether the new schedule is valid or not.
321
  if (!D.isValidSchedule(S, NewSchedule)) {
322
    errs() << "JScop file contains a schedule that changes the "
323
           << "dependences. Use -disable-polly-legality to continue anyways\n";
324
    return false;
325
  }
326

327
  auto ScheduleMap = isl::union_map::empty(S.getIslCtx());
328
  for (ScopStmt &Stmt : S) {
329
    if (NewSchedule.contains(&Stmt))
330
      ScheduleMap = ScheduleMap.unite(NewSchedule[&Stmt]);
331
    else
332
      ScheduleMap = ScheduleMap.unite(Stmt.getSchedule());
333
  }
334

335
  S.setSchedule(ScheduleMap);
336

337
  return true;
338
}
339

340
/// Import new memory accesses from JScop.
341
///
342
/// @param S The scop to update.
343
/// @param JScop The JScop file describing the new schedule.
344
/// @param DL The data layout to assume.
345
/// @param NewAccessStrings optionally record the imported access strings
346
///
347
/// @returns True if the import succeeded, otherwise False.
348
static bool
349
importAccesses(Scop &S, const json::Object &JScop, const DataLayout &DL,
350
               std::vector<std::string> *NewAccessStrings = nullptr) {
351
  int StatementIdx = 0;
352

353
  // Check if key 'statements' is present.
354
  if (!JScop.get("statements")) {
355
    errs() << "JScop file has no key name 'statements'.\n";
356
    return false;
357
  }
358
  const json::Array &statements = *JScop.getArray("statements");
359

360
  // Check whether the number of indices equals the number of statements
361
  if (statements.size() != S.getSize()) {
362
    errs() << "The number of indices and the number of statements differ.\n";
363
    return false;
364
  }
365

366
  for (ScopStmt &Stmt : S) {
367
    int MemoryAccessIdx = 0;
368
    const json::Object *Statement = statements[StatementIdx].getAsObject();
369
    assert(Statement);
370

371
    // Check if key 'accesses' is present.
372
    if (!Statement->get("accesses")) {
373
      errs()
374
          << "Statement from JScop file has no key name 'accesses' for index "
375
          << StatementIdx << ".\n";
376
      return false;
377
    }
378
    const json::Array &JsonAccesses = *Statement->getArray("accesses");
379

380
    // Check whether the number of indices equals the number of memory
381
    // accesses
382
    if (Stmt.size() != JsonAccesses.size()) {
383
      errs() << "The number of memory accesses in the JSop file and the number "
384
                "of memory accesses differ for index "
385
             << StatementIdx << ".\n";
386
      return false;
387
    }
388

389
    for (MemoryAccess *MA : Stmt) {
390
      // Check if key 'relation' is present.
391
      const json::Object *JsonMemoryAccess =
392
          JsonAccesses[MemoryAccessIdx].getAsObject();
393
      assert(JsonMemoryAccess);
394
      if (!JsonMemoryAccess->get("relation")) {
395
        errs() << "Memory access number " << MemoryAccessIdx
396
               << " has no key name 'relation' for statement number "
397
               << StatementIdx << ".\n";
398
        return false;
399
      }
400
      StringRef Accesses = *JsonMemoryAccess->getString("relation");
401
      isl_map *NewAccessMap =
402
          isl_map_read_from_str(S.getIslCtx().get(), Accesses.str().c_str());
403

404
      // Check whether the access was parsed successfully
405
      if (!NewAccessMap) {
406
        errs() << "The access was not parsed successfully by ISL.\n";
407
        return false;
408
      }
409
      isl_map *CurrentAccessMap = MA->getAccessRelation().release();
410

411
      // Check if the number of parameter change
412
      if (isl_map_dim(NewAccessMap, isl_dim_param) !=
413
          isl_map_dim(CurrentAccessMap, isl_dim_param)) {
414
        errs() << "JScop file changes the number of parameter dimensions.\n";
415
        isl_map_free(CurrentAccessMap);
416
        isl_map_free(NewAccessMap);
417
        return false;
418
      }
419

420
      isl_id *NewOutId;
421

422
      // If the NewAccessMap has zero dimensions, it is the scalar access; it
423
      // must be the same as before.
424
      // If it has at least one dimension, it's an array access; search for
425
      // its ScopArrayInfo.
426
      if (isl_map_dim(NewAccessMap, isl_dim_out) >= 1) {
427
        NewOutId = isl_map_get_tuple_id(NewAccessMap, isl_dim_out);
428
        auto *SAI = S.getArrayInfoByName(isl_id_get_name(NewOutId));
429
        isl_id *OutId = isl_map_get_tuple_id(CurrentAccessMap, isl_dim_out);
430
        auto *OutSAI = ScopArrayInfo::getFromId(isl::manage(OutId));
431
        if (!SAI || SAI->getElementType() != OutSAI->getElementType()) {
432
          errs() << "JScop file contains access function with undeclared "
433
                    "ScopArrayInfo\n";
434
          isl_map_free(CurrentAccessMap);
435
          isl_map_free(NewAccessMap);
436
          isl_id_free(NewOutId);
437
          return false;
438
        }
439
        isl_id_free(NewOutId);
440
        NewOutId = SAI->getBasePtrId().release();
441
      } else {
442
        NewOutId = isl_map_get_tuple_id(CurrentAccessMap, isl_dim_out);
443
      }
444

445
      NewAccessMap = isl_map_set_tuple_id(NewAccessMap, isl_dim_out, NewOutId);
446

447
      if (MA->isArrayKind()) {
448
        // We keep the old alignment, thus we cannot allow accesses to memory
449
        // locations that were not accessed before if the alignment of the
450
        // access is not the default alignment.
451
        bool SpecialAlignment = true;
452
        if (LoadInst *LoadI = dyn_cast<LoadInst>(MA->getAccessInstruction())) {
453
          SpecialAlignment =
454
              DL.getABITypeAlign(LoadI->getType()) != LoadI->getAlign();
455
        } else if (StoreInst *StoreI =
456
                       dyn_cast<StoreInst>(MA->getAccessInstruction())) {
457
          SpecialAlignment =
458
              DL.getABITypeAlign(StoreI->getValueOperand()->getType()) !=
459
              StoreI->getAlign();
460
        }
461

462
        if (SpecialAlignment) {
463
          isl_set *NewAccessSet = isl_map_range(isl_map_copy(NewAccessMap));
464
          isl_set *CurrentAccessSet =
465
              isl_map_range(isl_map_copy(CurrentAccessMap));
466
          bool IsSubset = isl_set_is_subset(NewAccessSet, CurrentAccessSet);
467
          isl_set_free(NewAccessSet);
468
          isl_set_free(CurrentAccessSet);
469

470
          // Check if the JScop file changes the accessed memory.
471
          if (!IsSubset) {
472
            errs() << "JScop file changes the accessed memory\n";
473
            isl_map_free(CurrentAccessMap);
474
            isl_map_free(NewAccessMap);
475
            return false;
476
          }
477
        }
478
      }
479

480
      // We need to copy the isl_ids for the parameter dimensions to the new
481
      // map. Without doing this the current map would have different
482
      // ids then the new one, even though both are named identically.
483
      for (isl_size i = 0; i < isl_map_dim(CurrentAccessMap, isl_dim_param);
484
           i++) {
485
        isl_id *Id = isl_map_get_dim_id(CurrentAccessMap, isl_dim_param, i);
486
        NewAccessMap = isl_map_set_dim_id(NewAccessMap, isl_dim_param, i, Id);
487
      }
488

489
      // Copy the old tuple id. This is necessary to retain the user pointer,
490
      // that stores the reference to the ScopStmt this access belongs to.
491
      isl_id *Id = isl_map_get_tuple_id(CurrentAccessMap, isl_dim_in);
492
      NewAccessMap = isl_map_set_tuple_id(NewAccessMap, isl_dim_in, Id);
493

494
      auto NewAccessDomain = isl_map_domain(isl_map_copy(NewAccessMap));
495
      auto CurrentAccessDomain = isl_map_domain(isl_map_copy(CurrentAccessMap));
496

497
      if (!isl_set_has_equal_space(NewAccessDomain, CurrentAccessDomain)) {
498
        errs() << "JScop file contains access function with incompatible "
499
               << "dimensions\n";
500
        isl_map_free(CurrentAccessMap);
501
        isl_map_free(NewAccessMap);
502
        isl_set_free(NewAccessDomain);
503
        isl_set_free(CurrentAccessDomain);
504
        return false;
505
      }
506

507
      NewAccessDomain =
508
          isl_set_intersect_params(NewAccessDomain, S.getContext().release());
509
      CurrentAccessDomain = isl_set_intersect_params(CurrentAccessDomain,
510
                                                     S.getContext().release());
511
      CurrentAccessDomain =
512
          isl_set_intersect(CurrentAccessDomain, Stmt.getDomain().release());
513

514
      if (MA->isRead() &&
515
          isl_set_is_subset(CurrentAccessDomain, NewAccessDomain) ==
516
              isl_bool_false) {
517
        errs() << "Mapping not defined for all iteration domain elements\n";
518
        isl_set_free(CurrentAccessDomain);
519
        isl_set_free(NewAccessDomain);
520
        isl_map_free(CurrentAccessMap);
521
        isl_map_free(NewAccessMap);
522
        return false;
523
      }
524

525
      isl_set_free(CurrentAccessDomain);
526
      isl_set_free(NewAccessDomain);
527

528
      if (!isl_map_is_equal(NewAccessMap, CurrentAccessMap)) {
529
        // Statistics.
530
        ++NewAccessMapFound;
531
        if (NewAccessStrings)
532
          NewAccessStrings->push_back(Accesses.str());
533
        MA->setNewAccessRelation(isl::manage(NewAccessMap));
534
      } else {
535
        isl_map_free(NewAccessMap);
536
      }
537
      isl_map_free(CurrentAccessMap);
538
      MemoryAccessIdx++;
539
    }
540
    StatementIdx++;
541
  }
542

543
  return true;
544
}
545

546
/// Check whether @p SAI and @p Array represent the same array.
547
static bool areArraysEqual(ScopArrayInfo *SAI, const json::Object &Array) {
548
  std::string Buffer;
549
  llvm::raw_string_ostream RawStringOstream(Buffer);
550

551
  // Check if key 'type' is present.
552
  if (!Array.get("type")) {
553
    errs() << "Array has no key 'type'.\n";
554
    return false;
555
  }
556

557
  // Check if key 'sizes' is present.
558
  if (!Array.get("sizes")) {
559
    errs() << "Array has no key 'sizes'.\n";
560
    return false;
561
  }
562

563
  // Check if key 'name' is present.
564
  if (!Array.get("name")) {
565
    errs() << "Array has no key 'name'.\n";
566
    return false;
567
  }
568

569
  if (SAI->getName() != *Array.getString("name"))
570
    return false;
571

572
  if (SAI->getNumberOfDimensions() != Array.getArray("sizes")->size())
573
    return false;
574

575
  for (unsigned i = 1; i < Array.getArray("sizes")->size(); i++) {
576
    SAI->getDimensionSize(i)->print(RawStringOstream);
577
    const json::Array &SizesArray = *Array.getArray("sizes");
578
    if (RawStringOstream.str() != SizesArray[i].getAsString().value())
579
      return false;
580
    Buffer.clear();
581
  }
582

583
  // Check if key 'type' differs from the current one or is not valid.
584
  SAI->getElementType()->print(RawStringOstream);
585
  if (RawStringOstream.str() != Array.getString("type").value()) {
586
    errs() << "Array has not a valid type.\n";
587
    return false;
588
  }
589

590
  return true;
591
}
592

593
/// Get the accepted primitive type from its textual representation
594
///        @p TypeTextRepresentation.
595
///
596
/// @param TypeTextRepresentation The textual representation of the type.
597
/// @return The pointer to the primitive type, if this type is accepted
598
///         or nullptr otherwise.
599
static Type *parseTextType(const std::string &TypeTextRepresentation,
600
                           LLVMContext &LLVMContext) {
601
  std::map<std::string, Type *> MapStrToType = {
602
      {"void", Type::getVoidTy(LLVMContext)},
603
      {"half", Type::getHalfTy(LLVMContext)},
604
      {"float", Type::getFloatTy(LLVMContext)},
605
      {"double", Type::getDoubleTy(LLVMContext)},
606
      {"x86_fp80", Type::getX86_FP80Ty(LLVMContext)},
607
      {"fp128", Type::getFP128Ty(LLVMContext)},
608
      {"ppc_fp128", Type::getPPC_FP128Ty(LLVMContext)},
609
      {"i1", Type::getInt1Ty(LLVMContext)},
610
      {"i8", Type::getInt8Ty(LLVMContext)},
611
      {"i16", Type::getInt16Ty(LLVMContext)},
612
      {"i32", Type::getInt32Ty(LLVMContext)},
613
      {"i64", Type::getInt64Ty(LLVMContext)},
614
      {"i128", Type::getInt128Ty(LLVMContext)}};
615

616
  auto It = MapStrToType.find(TypeTextRepresentation);
617
  if (It != MapStrToType.end())
618
    return It->second;
619

620
  errs() << "Textual representation can not be parsed: "
621
         << TypeTextRepresentation << "\n";
622
  return nullptr;
623
}
624

625
/// Import new arrays from JScop.
626
///
627
/// @param S The scop to update.
628
/// @param JScop The JScop file describing new arrays.
629
///
630
/// @returns True if the import succeeded, otherwise False.
631
static bool importArrays(Scop &S, const json::Object &JScop) {
632
  if (!JScop.get("arrays"))
633
    return true;
634
  const json::Array &Arrays = *JScop.getArray("arrays");
635
  if (Arrays.size() == 0)
636
    return true;
637

638
  unsigned ArrayIdx = 0;
639
  for (auto &SAI : S.arrays()) {
640
    if (!SAI->isArrayKind())
641
      continue;
642
    if (ArrayIdx + 1 > Arrays.size()) {
643
      errs() << "Not enough array entries in JScop file.\n";
644
      return false;
645
    }
646
    if (!areArraysEqual(SAI, *Arrays[ArrayIdx].getAsObject())) {
647
      errs() << "No match for array '" << SAI->getName() << "' in JScop.\n";
648
      return false;
649
    }
650
    ArrayIdx++;
651
  }
652

653
  for (; ArrayIdx < Arrays.size(); ArrayIdx++) {
654
    const json::Object &Array = *Arrays[ArrayIdx].getAsObject();
655
    auto *ElementType =
656
        parseTextType(Array.get("type")->getAsString().value().str(),
657
                      S.getSE()->getContext());
658
    if (!ElementType) {
659
      errs() << "Error while parsing element type for new array.\n";
660
      return false;
661
    }
662
    const json::Array &SizesArray = *Array.getArray("sizes");
663
    std::vector<unsigned> DimSizes;
664
    for (unsigned i = 0; i < SizesArray.size(); i++) {
665
      auto Size = std::stoi(SizesArray[i].getAsString()->str());
666

667
      // Check if the size if positive.
668
      if (Size <= 0) {
669
        errs() << "The size at index " << i << " is =< 0.\n";
670
        return false;
671
      }
672

673
      DimSizes.push_back(Size);
674
    }
675

676
    auto NewSAI = S.createScopArrayInfo(
677
        ElementType, Array.getString("name").value().str(), DimSizes);
678

679
    if (Array.get("allocation")) {
680
      NewSAI->setIsOnHeap(Array.getString("allocation").value() == "heap");
681
    }
682
  }
683

684
  return true;
685
}
686

687
/// Import a Scop from a JSCOP file
688
/// @param S The scop to be modified
689
/// @param D Dependence Info
690
/// @param DL The DataLayout of the function
691
/// @param NewAccessStrings Optionally record the imported access strings
692
///
693
/// @returns true on success, false otherwise. Beware that if this returns
694
/// false, the Scop may still have been modified. In this case the Scop contains
695
/// invalid information.
696
static bool importScop(Scop &S, const Dependences &D, const DataLayout &DL,
697
                       std::vector<std::string> *NewAccessStrings = nullptr) {
698
  std::string FileName = ImportDir + "/" + getFileName(S, ImportPostfix);
699

700
  std::string FunctionName = S.getFunction().getName().str();
701
  errs() << "Reading JScop '" << S.getNameStr() << "' in function '"
702
         << FunctionName << "' from '" << FileName << "'.\n";
703
  ErrorOr<std::unique_ptr<MemoryBuffer>> result =
704
      MemoryBuffer::getFile(FileName);
705
  std::error_code ec = result.getError();
706

707
  if (ec) {
708
    errs() << "File could not be read: " << ec.message() << "\n";
709
    return false;
710
  }
711

712
  Expected<json::Value> ParseResult =
713
      json::parse(result.get().get()->getBuffer());
714

715
  if (Error E = ParseResult.takeError()) {
716
    errs() << "JSCoP file could not be parsed\n";
717
    errs() << E << "\n";
718
    consumeError(std::move(E));
719
    return false;
720
  }
721
  json::Object &jscop = *ParseResult.get().getAsObject();
722

723
  bool Success = importContext(S, jscop);
724

725
  if (!Success)
726
    return false;
727

728
  Success = importSchedule(S, jscop, D);
729

730
  if (!Success)
731
    return false;
732

733
  Success = importArrays(S, jscop);
734

735
  if (!Success)
736
    return false;
737

738
  Success = importAccesses(S, jscop, DL, NewAccessStrings);
739

740
  if (!Success)
741
    return false;
742
  return true;
743
}
744

745
char JSONExporter::ID = 0;
746
void JSONExporter::printScop(raw_ostream &OS, Scop &S) const { OS << S; }
747

748
bool JSONExporter::runOnScop(Scop &S) {
749
  exportScop(S);
750
  return false;
751
}
752

753
void JSONExporter::getAnalysisUsage(AnalysisUsage &AU) const {
754
  AU.setPreservesAll();
755
  AU.addRequired<ScopInfoRegionPass>();
756
}
757

758
Pass *polly::createJSONExporterPass() { return new JSONExporter(); }
759

760
PreservedAnalyses JSONExportPass::run(Scop &S, ScopAnalysisManager &SAM,
761
                                      ScopStandardAnalysisResults &SAR,
762
                                      SPMUpdater &) {
763
  exportScop(S);
764
  return PreservedAnalyses::all();
765
}
766

767
char JSONImporter::ID = 0;
768

769
void JSONImporter::printScop(raw_ostream &OS, Scop &S) const {
770
  OS << S;
771
  for (std::vector<std::string>::const_iterator I = NewAccessStrings.begin(),
772
                                                E = NewAccessStrings.end();
773
       I != E; I++)
774
    OS << "New access function '" << *I << "' detected in JSCOP file\n";
775
}
776

777
bool JSONImporter::runOnScop(Scop &S) {
778
  const Dependences &D =
779
      getAnalysis<DependenceInfo>().getDependences(Dependences::AL_Statement);
780
  const DataLayout &DL = S.getFunction().getParent()->getDataLayout();
781

782
  if (!importScop(S, D, DL, &NewAccessStrings))
783
    report_fatal_error("Tried to import a malformed jscop file.");
784

785
  return false;
786
}
787

788
void JSONImporter::getAnalysisUsage(AnalysisUsage &AU) const {
789
  ScopPass::getAnalysisUsage(AU);
790
  AU.addRequired<DependenceInfo>();
791

792
  // TODO: JSONImporter should throw away DependenceInfo.
793
  AU.addPreserved<DependenceInfo>();
794
}
795

796
Pass *polly::createJSONImporterPass() { return new JSONImporter(); }
797

798
PreservedAnalyses JSONImportPass::run(Scop &S, ScopAnalysisManager &SAM,
799
                                      ScopStandardAnalysisResults &SAR,
800
                                      SPMUpdater &) {
801
  const Dependences &D =
802
      SAM.getResult<DependenceAnalysis>(S, SAR).getDependences(
803
          Dependences::AL_Statement);
804
  const DataLayout &DL = S.getFunction().getParent()->getDataLayout();
805

806
  if (!importScop(S, D, DL))
807
    report_fatal_error("Tried to import a malformed jscop file.");
808

809
  // This invalidates all analyses on Scop.
810
  PreservedAnalyses PA;
811
  PA.preserveSet<AllAnalysesOn<Module>>();
812
  PA.preserveSet<AllAnalysesOn<Function>>();
813
  PA.preserveSet<AllAnalysesOn<Loop>>();
814
  return PA;
815
}
816

817
INITIALIZE_PASS_BEGIN(JSONExporter, "polly-export-jscop",
818
                      "Polly - Export Scops as JSON"
819
                      " (Writes a .jscop file for each Scop)",
820
                      false, false);
821
INITIALIZE_PASS_DEPENDENCY(DependenceInfo)
822
INITIALIZE_PASS_END(JSONExporter, "polly-export-jscop",
823
                    "Polly - Export Scops as JSON"
824
                    " (Writes a .jscop file for each Scop)",
825
                    false, false)
826

827
INITIALIZE_PASS_BEGIN(JSONImporter, "polly-import-jscop",
828
                      "Polly - Import Scops from JSON"
829
                      " (Reads a .jscop file for each Scop)",
830
                      false, false);
831
INITIALIZE_PASS_DEPENDENCY(DependenceInfo)
832
INITIALIZE_PASS_END(JSONImporter, "polly-import-jscop",
833
                    "Polly - Import Scops from JSON"
834
                    " (Reads a .jscop file for each Scop)",
835
                    false, false)
836

837
//===----------------------------------------------------------------------===//
838

839
namespace {
840
/// Print result from JSONImporter.
841
class JSONImporterPrinterLegacyPass final : public ScopPass {
842
public:
843
  static char ID;
844

845
  JSONImporterPrinterLegacyPass() : JSONImporterPrinterLegacyPass(outs()) {}
846
  explicit JSONImporterPrinterLegacyPass(llvm::raw_ostream &OS)
847
      : ScopPass(ID), OS(OS) {}
848

849
  bool runOnScop(Scop &S) override {
850
    JSONImporter &P = getAnalysis<JSONImporter>();
851

852
    OS << "Printing analysis '" << P.getPassName() << "' for region: '"
853
       << S.getRegion().getNameStr() << "' in function '"
854
       << S.getFunction().getName() << "':\n";
855
    P.printScop(OS, S);
856

857
    return false;
858
  }
859

860
  void getAnalysisUsage(AnalysisUsage &AU) const override {
861
    ScopPass::getAnalysisUsage(AU);
862
    AU.addRequired<JSONImporter>();
863
    AU.setPreservesAll();
864
  }
865

866
private:
867
  llvm::raw_ostream &OS;
868
};
869

870
char JSONImporterPrinterLegacyPass::ID = 0;
871
} // namespace
872

873
Pass *polly::createJSONImporterPrinterLegacyPass(llvm::raw_ostream &OS) {
874
  return new JSONImporterPrinterLegacyPass(OS);
875
}
876

877
INITIALIZE_PASS_BEGIN(JSONImporterPrinterLegacyPass, "polly-print-import-jscop",
878
                      "Polly - Print Scop import result", false, false)
879
INITIALIZE_PASS_DEPENDENCY(JSONImporter)
880
INITIALIZE_PASS_END(JSONImporterPrinterLegacyPass, "polly-print-import-jscop",
881
                    "Polly - Print Scop import result", false, false)
882