tblgen 0.8.0

Safe Rust bindings for TableGen.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

// Original work Copyright 2016 Alexander Stocko <as@coder.gg>.
// Modified work Copyright 2023 Daan Vanoverloop
// See the COPYRIGHT file at the top-level directory of this distribution.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

#include "TableGen.hpp"
#include "TableGen.h"
#include "Types.h"
#include <cstring>

using ctablegen::RecordMap;
using ctablegen::tableGenFromRecType;

RecordKeeper *ctablegen::TableGenParser::parse() {
  auto recordKeeper = std::unique_ptr<RecordKeeper>(new RecordKeeper);
  sourceMgr.setIncludeDirs(includeDirs);

  for (const auto &file : files) {
    std::string full_path;
    if (!sourceMgr.AddIncludeFile(file, SMLoc(), full_path)) {
      return nullptr;
    }
  }

  bool result = TableGenParseFile(sourceMgr, *recordKeeper);
  if (!result) {
    return recordKeeper.release();
  }
  return nullptr;
}

void ctablegen::TableGenParser::addIncludeDirectory(const StringRef include) {
  includeDirs.push_back(std::string(include));
}

bool ctablegen::TableGenParser::addSource(const char *source) {
  ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
      MemoryBuffer::getMemBuffer(source);

  if (std::error_code EC = FileOrErr.getError()) {
    return false;
  }

  sourceMgr.AddNewSourceBuffer(std::move(*FileOrErr), SMLoc());
  return true;
}

void ctablegen::TableGenParser::addSourceFile(const StringRef file) {
  files.push_back(std::string(file));
}

TableGenParserRef tableGenGet() {
  return wrap(new ctablegen::TableGenParser());
}

void tableGenFree(TableGenParserRef tg_ref) { delete unwrap(tg_ref); }

void tableGenAddSourceFile(TableGenParserRef tg_ref, TableGenStringRef source) {
  unwrap(tg_ref)->addSourceFile(StringRef(source.data, source.len));
}

TableGenBool tableGenAddSource(TableGenParserRef tg_ref, const char *source) {
  return unwrap(tg_ref)->addSource(source);
}

void tableGenAddIncludeDirectory(TableGenParserRef tg_ref,
                                 TableGenStringRef include) {
  return unwrap(tg_ref)->addIncludeDirectory(
      StringRef(include.data, include.len));
}

TableGenRecordKeeperRef tableGenParse(TableGenParserRef tg_ref) {
  return wrap(unwrap(tg_ref)->parse());
}

// LLVM ListType
TableGenRecTyKind tableGenListRecordGetType(TableGenRecordValRef rv_ref) {
  if (!rv_ref)
    return TableGenInvalidRecTyKind;
  auto rv = unwrap(rv_ref);

  if (rv->getType()->getRecTyKind() == RecTy::ListRecTyKind) {
    auto list = rv->getType()->getListTy();
    return tableGenFromRecType(list->getElementType());
  }

  return TableGenInvalidRecTyKind;
}

size_t tableGenListRecordNumElements(TableGenTypedInitRef rv_ref) {
  auto list = dyn_cast<ListInit>(unwrap(rv_ref));
  if (!list)
    return 0;
  return list->size();
}

TableGenTypedInitRef tableGenListRecordGet(TableGenTypedInitRef rv_ref,
                                           size_t index) {
  auto list = dyn_cast<ListInit>(unwrap(rv_ref));
  if (!list)
    return nullptr;
  if (index >= list->size())
    return nullptr;
  auto elem = dyn_cast<TypedInit>(list->getElement(index));
  if (!elem)
    return nullptr;
  return wrap(elem);
}

// LLVM DagType
TableGenTypedInitRef tableGenDagRecordGet(TableGenTypedInitRef rv_ref,
                                          size_t index) {
  auto dag = dyn_cast<DagInit>(unwrap(rv_ref));
  if (!dag)
    return nullptr;
  if (index >= dag->getNumArgs())
    return nullptr;
  auto arg = dyn_cast<TypedInit>(dag->getArg(index));
  if (!arg)
    return nullptr;
  return wrap(arg);
}

size_t tableGenDagRecordNumArgs(TableGenTypedInitRef rv_ref) {
  auto dag = dyn_cast<DagInit>(unwrap(rv_ref));
  if (!dag)
    return 0;
  return dag->getNumArgs();
}

TableGenRecordRef tableGenDagRecordOperator(TableGenTypedInitRef rv_ref) {
  auto dag = dyn_cast<DagInit>(unwrap(rv_ref));
  if (!dag)
    return 0;
  return wrap(dag->getOperatorAsDef(SMLoc()));
}

TableGenStringRef tableGenDagRecordArgName(TableGenTypedInitRef rv_ref,
                                           size_t index) {
  auto dag = dyn_cast<DagInit>(unwrap(rv_ref));
  if (!dag)
    return TableGenStringRef{.data = nullptr, .len = 0};
  if (index >= dag->getNumArgs())
    return TableGenStringRef{.data = nullptr, .len = 0};
  auto s = dag->getArgNameStr(index);
  return TableGenStringRef{.data = s.data(), .len = s.size()};
}

// Memory
void tableGenBitArrayFree(int8_t bit_array[]) { delete[] bit_array; }

void tableGenStringFree(const char *str) { delete str; }

void tableGenStringArrayFree(const char **str_array) { delete str_array; }