source: parabix-LLVM/mkValueTypes.py @ 3845

Last change on this file since 3845 was 3845, checked in by cameron, 5 years ago

Scripts for generated MachineValueType?.h and ValueTypes?.td

File size: 8.8 KB
Line 
1#
2# Generate MachineValueType.h and ValueTypes.td
3#
4# Rob Cameron   May 16, 2014
5
6
7from string import Template
8import re, os, shutil
9
10
11def calculateTypeData(maxwidth=256):
12    enumTypeLine =    "\t%s\t\t%s,\n"
13    defTypeLine = "def %s\t: ValueType<%s , %s>;\n"
14    fw = 1
15    fws = []
16    while (fw <= maxwidth): fws.append(fw); fw = fw * 2
17    enumVal = 0
18    VectorSizeMap = {}
19    for f in fws: VectorSizeMap[f] = []
20    VectorFieldSizeMap = {}
21    for f in fws: VectorFieldSizeMap[f] = []
22    VTmap = {}
23    VTmap['integer_type_lines'] = ''
24    VTmap['int_value_type_defs'] = ''
25    intTypes = ""
26    intVecTypes = ""
27    for fw in fws:
28        enumVal += 1
29        iType = "i%s" % fw
30        VTmap['integer_type_lines'] += enumTypeLine % (iType, enumVal)
31        VTmap['int_value_type_defs'] += defTypeLine % (iType, fw, enumVal)
32    VTmap['first_integer_type'] = 'i%s' % fws[0]
33    VTmap['last_integer_type'] = 'i%s' % fws[-1]
34    VTmap['f16'] = enumVal + 1
35    VTmap['f32'] = VTmap['f16'] + 1
36    VTmap['f64'] = VTmap['f32'] + 1
37    VTmap['f80'] = VTmap['f64'] + 1
38    VTmap['f128'] = VTmap['f80'] + 1
39    VTmap['ppcf128'] = VTmap['f128'] + 1
40   
41    enumVal = enumVal + 6
42    VTmap['integer_vector_type_lines'] = ''
43    VTmap['int_vector_value_type_defs'] = ''
44    for fw in fws:
45        for fieldcount in [f for f in fws if f * fw <= maxwidth]:
46            enumVal += 1
47            vType = "v%si%s" % (fieldcount, fw)
48            VTmap['integer_vector_type_lines'] += enumTypeLine % (vType, enumVal)
49            VTmap['int_vector_value_type_defs'] += defTypeLine % (vType, fieldcount * fw, enumVal)
50            VectorSizeMap[fw * fieldcount].append(vType)
51            VectorFieldSizeMap[fw].append(vType)
52    VTmap['first_integer_vector_type'] = "v%si%s" % (fws[0], fws[0])
53    VTmap['last_integer_vector_type'] = vType
54    VTmap['float_vector_type_lines'] = ''
55    VTmap['float_vector_value_type_defs'] = ''
56    for fpfw in [16,32,64]:
57        for fieldcount in [f for f in fws if f > 1 and f * fpfw <= maxwidth]:
58            enumVal += 1
59            vType = "v%sf%s" % (fieldcount, fpfw)
60            VTmap['float_vector_type_lines'] += enumTypeLine % (vType, enumVal)
61            VTmap['float_vector_value_type_defs'] += defTypeLine % (vType, fieldcount * fpfw, enumVal)
62            VectorSizeMap[fpfw * fieldcount].append(vType)
63            VectorFieldSizeMap[fpfw].append(vType)
64    VTmap['first_float_vector_type'] = "v%sf%s" % (2, 16)
65    VTmap['last_float_vector_type'] = vType
66    VTmap['x86mmx'] = enumVal + 1
67    VTmap['Glue'] = VTmap['x86mmx'] + 1
68    VTmap['isVoid'] = VTmap['Glue'] + 1
69    VTmap['Untyped'] = VTmap['isVoid'] + 1
70    VTmap['last_value_type'] = VTmap['Untyped'] + 1
71    VTmap['max_value_type'] = ((VTmap['last_value_type'] - 1)/32 + 1)*32
72    return (VTmap, VectorSizeMap, VectorFieldSizeMap)
73
74
75isXXXBitVectorTemplate = r"""
76    /// is${width}BitVector - Return true if this is a ${width}-bit vector type.
77    bool is${width}BitVector() const {
78    return (${typetest});
79    }
80"""
81
82def make_isXXXBitFunctions(VectorSizeMap):
83    fns = ""
84    for s in sorted(VectorSizeMap.keys()):
85        tests = ["SimpleTy == MVT::%s" % t for t in VectorSizeMap[s]]
86        fns += Template(isXXXBitVectorTemplate).substitute(width = repr(s), typetest = " ||\n\t\t".join(tests))
87    return fns
88
89getVectorElementTypeTemplate = r"""
90    MVT getVectorElementType() const {
91        switch (SimpleTy) {
92        default:
93            llvm_unreachable("Not a vector MVT!");
94${vector_element_type_cases}
95      }
96    }
97   
98"""
99
100def make_getVectorElementType(VectorFieldSizeMap):
101    tCases = ""
102    for s in sorted(VectorFieldSizeMap.keys()):
103        fCases = ["case %s: " % t for t in VectorFieldSizeMap[s] if t[-3] == 'f']
104        iCases = ["case %s: " % t  for t in VectorFieldSizeMap[s] if t[-3] != 'f']
105        if fCases != []:
106            tCases += "\t%s return f%s;\n" % (" ".join(fCases), s)
107        if iCases != []:
108            tCases += "\t%s return i%s;\n" % (" ".join(iCases), s)
109    return Template(getVectorElementTypeTemplate).substitute(vector_element_type_cases = tCases)
110
111getVectorElementNumElementsTemplate = r"""
112    unsigned getVectorNumElements() const {
113      switch (SimpleTy) {
114      default:
115        llvm_unreachable("Not a vector MVT!");
116${vector_element_num_cases}
117      }
118    }
119   
120    """
121vecNumRe =  re.compile("v([0-9]+)[if][0-9]+")
122
123def make_getVectorNumElements(VectorSizeMap):
124    nCases = ""
125    byElemCount = {}
126    for s in sorted(VectorSizeMap.keys()):
127        for t in VectorSizeMap[s]:
128            m = vecNumRe.match(t)
129            e = m.group(1)
130            if not byElemCount.has_key(e): byElemCount[e] = ""
131            byElemCount[e] += "case %s: " % t
132    for e in sorted(byElemCount.keys()):
133        nCases += "      %s return %s;\n" % (byElemCount[e], e)
134    return Template(getVectorElementNumElementsTemplate).substitute(vector_element_num_cases = nCases)
135
136getSizeInBitsTemplate = r"""
137    unsigned getSizeInBits() const {
138    switch (SimpleTy) {
139      default:
140        llvm_unreachable("getSizeInBits called on extended MVT.");
141      case Other:
142        llvm_unreachable("Value type is non-standard value, Other.");
143      case iPTR:
144        llvm_unreachable("Value type size is target-dependent. Ask TLI.");
145      case iPTRAny:
146      case iAny:
147      case fAny:
148      case vAny:
149        llvm_unreachable("Value type is overloaded.");
150      case Metadata:
151        llvm_unreachable("Value type is metadata.");
152${size_in_bits_cases}
153      case x86mmx: return 64;
154      case f80 :  return 80;
155      case f128:
156      case ppcf128: return 128;
157      }
158    }
159   
160"""
161def make_getSizeInBits(VectorSizeMap):
162    sCases = ""
163    for s in sorted(VectorSizeMap.keys()):
164        vCases = ["case %s:" % v for v in VectorSizeMap[s]]
165        sCases += "      case i%s: " % s
166        if s in [16,32,64]: sCases += "case f%s: " % s
167        sCases += " ".join(vCases)
168        sCases += " return %s;\n" % s
169    return Template(getSizeInBitsTemplate).substitute(size_in_bits_cases = sCases)
170
171getIntegerVTTemplate = r"""
172    static MVT getIntegerVT(unsigned BitWidth) {
173      switch (BitWidth) {
174      default:
175        return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE);
176${integer_VT_cases}
177      }
178    }
179"""
180
181def make_getIntegerVT(VectorFieldSizeMap):
182    iCases = ""
183    for s in sorted(VectorFieldSizeMap.keys()):
184        iCases += "      case %s:\n        return MVT::i%s;\n" % (s, s)
185    return Template(getIntegerVTTemplate).substitute(integer_VT_cases = iCases)
186   
187
188
189getVectorVTTemplate = r"""
190    static MVT getVectorVT(MVT VT, unsigned NumElements) {
191      switch (VT.SimpleTy) {
192      default:
193        break;
194${vector_VT_cases}
195      }
196      return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE);
197    }
198"""
199
200def make_getVectorVT(VectorFieldSizeMap):
201    iCases = ""
202    fCases = ""
203    for s in sorted(VectorFieldSizeMap.keys()):
204        iCases += "      case MVT::i%s:\n" % s
205        for t in VectorFieldSizeMap[s]:
206            if t[-3] != 'f':
207                # integer case
208                m = vecNumRe.match(t)
209                e = m.group(1)
210                iCases += "        if (NumElements == %s)  return MVT::%s;\n" % (e, t)
211        iCases += "        break;\n"
212    for s in [16, 32, 64]:
213        fCases += "      case MVT::f%s:\n" % s
214        for t in VectorFieldSizeMap[s]:
215            if t[-3] == 'f':
216                # float case
217                m = vecNumRe.match(t)
218                e = m.group(1)
219                fCases += "        if (NumElements == %s)  return MVT::%s;\n" % (e, t)
220        fCases += "        break;\n"
221    return Template(getVectorVTTemplate).substitute(vector_VT_cases = iCases+fCases)
222
223
224def makeMachineValueType_h(maxwidth):
225    f = open('MachineValueType.h.pytemplate')
226    t = Template(f.read())
227    f.close()
228    (VTmap, VectorSizeMap, VectorFieldSizeMap) = calculateTypeData(maxwidth)
229    VTmap['isXXXBitFunctions'] = make_isXXXBitFunctions(VectorSizeMap)
230    VTmap['getVectorElementType'] = make_getVectorElementType(VectorFieldSizeMap)
231    VTmap['getVectorNumElements'] = make_getVectorNumElements(VectorSizeMap)
232    VTmap['getSizeInBits'] = make_getSizeInBits(VectorSizeMap)
233    VTmap['getIntegerVT'] = make_getIntegerVT(VectorFieldSizeMap)
234    VTmap['getVectorVT'] = make_getVectorVT(VectorFieldSizeMap)
235    content = t.substitute(VTmap)
236    if not os.path.exists("MachineValueType.h.bak"):
237                shutil.move("MachineValueType.h", "MachineValueType.h.bak")
238    f = open("MachineValueType.h", "w")
239    f.write(content)
240    f.close()
241
242def makeValueTypes_td(maxwidth):
243    f = open('ValueTypes.td.pytemplate')
244    t = Template(f.read())
245    f.close()
246    (VTmap, VectorSizeMap, VectorFieldSizeMap) = calculateTypeData(maxwidth)
247    content = t.substitute(VTmap)
248    if not os.path.exists("ValueTypes.td.bak"):
249                shutil.move("ValueTypes.td", "ValueTypes.td.bak")
250    f = open("ValueTypes.td", "w")
251    f.write(content)
252    f.close()
253
254if __name__ == '__main__':
255    makeMachineValueType_h(512)
256    makeValueTypes_td(512)
Note: See TracBrowser for help on using the repository browser.