Skip to content

Commit 1c1b8c2

Browse files
pfusikpfusik
authored
[ELFAttributeParser][NFC] Make string arrays const (#101460)
1 parent 4b6f4ef commit 1c1b8c2

File tree

4 files changed

+103
-73
lines changed

4 files changed

+103
-73
lines changed

‎llvm/lib/Support/ARMAttributeParser.cpp

Lines changed: 86 additions & 60 deletions
Original file line numberDiff line numberDiff line change
@@ -84,12 +84,29 @@ Error ARMAttributeParser::stringAttribute(AttrType tag) {
8484
return Error::success();
8585
}
8686

87-
static const char *CPU_arch_strings[] = {
88-
"Pre-v4", "ARM v4", "ARM v4T", "ARM v5T", "ARM v5TE", "ARM v5TEJ",
89-
"ARM v6", "ARM v6KZ", "ARM v6T2", "ARM v6K", "ARM v7", "ARM v6-M",
90-
"ARM v6S-M", "ARM v7E-M", "ARM v8-A", "ARM v8-R", "ARM v8-M Baseline",
91-
"ARM v8-M Mainline", nullptr, nullptr, nullptr, "ARM v8.1-M Mainline",
92-
"ARM v9-A"};
87+
static const char *const CPU_arch_strings[] = {"Pre-v4",
88+
"ARM v4",
89+
"ARM v4T",
90+
"ARM v5T",
91+
"ARM v5TE",
92+
"ARM v5TEJ",
93+
"ARM v6",
94+
"ARM v6KZ",
95+
"ARM v6T2",
96+
"ARM v6K",
97+
"ARM v7",
98+
"ARM v6-M",
99+
"ARM v6S-M",
100+
"ARM v7E-M",
101+
"ARM v8-A",
102+
"ARM v8-R",
103+
"ARM v8-M Baseline",
104+
"ARM v8-M Mainline",
105+
nullptr,
106+
nullptr,
107+
nullptr,
108+
"ARM v8.1-M Mainline",
109+
"ARM v9-A"};
93110

94111
Error ARMAttributeParser::CPU_arch(AttrType tag) {
95112
return parseStringAttribute("CPU_arch", tag, ArrayRef(CPU_arch_strings));
@@ -113,101 +130,109 @@ Error ARMAttributeParser::CPU_arch_profile(AttrType tag) {
113130
}
114131

115132
Error ARMAttributeParser::ARM_ISA_use(AttrType tag) {
116-
static const char *strings[] = {"Not Permitted", "Permitted"};
133+
static const char *const strings[] = {"Not Permitted", "Permitted"};
117134
return parseStringAttribute("ARM_ISA_use", tag, ArrayRef(strings));
118135
}
119136

120137
Error ARMAttributeParser::THUMB_ISA_use(AttrType tag) {
121-
static const char *strings[] = {"Not Permitted", "Thumb-1", "Thumb-2", "Permitted"};
138+
static const char *const strings[] = {"Not Permitted", "Thumb-1", "Thumb-2",
139+
"Permitted"};
122140
return parseStringAttribute("THUMB_ISA_use", tag, ArrayRef(strings));
123141
}
124142

125143
Error ARMAttributeParser::FP_arch(AttrType tag) {
126-
static const char *strings[] = {
144+
static const char *const strings[] = {
127145
"Not Permitted", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16",
128146
"VFPv4", "VFPv4-D16", "ARMv8-a FP", "ARMv8-a FP-D16"};
129147
return parseStringAttribute("FP_arch", tag, ArrayRef(strings));
130148
}
131149

132150
Error ARMAttributeParser::WMMX_arch(AttrType tag) {
133-
static const char *strings[] = {"Not Permitted", "WMMXv1", "WMMXv2"};
151+
static const char *const strings[] = {"Not Permitted", "WMMXv1", "WMMXv2"};
134152
return parseStringAttribute("WMMX_arch", tag, ArrayRef(strings));
135153
}
136154

137155
Error ARMAttributeParser::Advanced_SIMD_arch(AttrType tag) {
138-
static const char *strings[] = {"Not Permitted", "NEONv1", "NEONv2+FMA",
139-
"ARMv8-a NEON", "ARMv8.1-a NEON"};
156+
static const char *const strings[] = {"Not Permitted", "NEONv1", "NEONv2+FMA",
157+
"ARMv8-a NEON", "ARMv8.1-a NEON"};
140158
return parseStringAttribute("Advanced_SIMD_arch", tag, ArrayRef(strings));
141159
}
142160

143161
Error ARMAttributeParser::MVE_arch(AttrType tag) {
144-
static const char *strings[] = {"Not Permitted", "MVE integer",
145-
"MVE integer and float"};
162+
static const char *const strings[] = {"Not Permitted", "MVE integer",
163+
"MVE integer and float"};
146164
return parseStringAttribute("MVE_arch", tag, ArrayRef(strings));
147165
}
148166

149167
Error ARMAttributeParser::PCS_config(AttrType tag) {
150-
static const char *strings[] = {
151-
"None", "Bare Platform", "Linux Application", "Linux DSO", "Palm OS 2004",
152-
"Reserved (Palm OS)", "Symbian OS 2004", "Reserved (Symbian OS)"};
168+
static const char *const strings[] = {"None",
169+
"Bare Platform",
170+
"Linux Application",
171+
"Linux DSO",
172+
"Palm OS 2004",
173+
"Reserved (Palm OS)",
174+
"Symbian OS 2004",
175+
"Reserved (Symbian OS)"};
153176
return parseStringAttribute("PCS_config", tag, ArrayRef(strings));
154177
}
155178

156179
Error ARMAttributeParser::ABI_PCS_R9_use(AttrType tag) {
157-
static const char *strings[] = {"v6", "Static Base", "TLS", "Unused"};
180+
static const char *const strings[] = {"v6", "Static Base", "TLS", "Unused"};
158181
return parseStringAttribute("ABI_PCS_R9_use", tag, ArrayRef(strings));
159182
}
160183

161184
Error ARMAttributeParser::ABI_PCS_RW_data(AttrType tag) {
162-
static const char *strings[] = {"Absolute", "PC-relative", "SB-relative",
163-
"Not Permitted"};
185+
static const char *const strings[] = {"Absolute", "PC-relative",
186+
"SB-relative", "Not Permitted"};
164187
return parseStringAttribute("ABI_PCS_RW_data", tag, ArrayRef(strings));
165188
}
166189

167190
Error ARMAttributeParser::ABI_PCS_RO_data(AttrType tag) {
168-
static const char *strings[] = {"Absolute", "PC-relative", "Not Permitted"};
191+
static const char *const strings[] = {"Absolute", "PC-relative",
192+
"Not Permitted"};
169193
return parseStringAttribute("ABI_PCS_RO_data", tag, ArrayRef(strings));
170194
}
171195

172196
Error ARMAttributeParser::ABI_PCS_GOT_use(AttrType tag) {
173-
static const char *strings[] = {"Not Permitted", "Direct", "GOT-Indirect"};
197+
static const char *const strings[] = {"Not Permitted", "Direct",
198+
"GOT-Indirect"};
174199
return parseStringAttribute("ABI_PCS_GOT_use", tag, ArrayRef(strings));
175200
}
176201

177202
Error ARMAttributeParser::ABI_PCS_wchar_t(AttrType tag) {
178-
static const char *strings[] = {"Not Permitted", "Unknown", "2-byte",
179-
"Unknown", "4-byte"};
203+
static const char *const strings[] = {"Not Permitted", "Unknown", "2-byte",
204+
"Unknown", "4-byte"};
180205
return parseStringAttribute("ABI_PCS_wchar_t", tag, ArrayRef(strings));
181206
}
182207

183208
Error ARMAttributeParser::ABI_FP_rounding(AttrType tag) {
184-
static const char *strings[] = {"IEEE-754", "Runtime"};
209+
static const char *const strings[] = {"IEEE-754", "Runtime"};
185210
return parseStringAttribute("ABI_FP_rounding", tag, ArrayRef(strings));
186211
}
187212

188213
Error ARMAttributeParser::ABI_FP_denormal(AttrType tag) {
189-
static const char *strings[] = {"Unsupported", "IEEE-754", "Sign Only"};
214+
static const char *const strings[] = {"Unsupported", "IEEE-754", "Sign Only"};
190215
return parseStringAttribute("ABI_FP_denormal", tag, ArrayRef(strings));
191216
}
192217

193218
Error ARMAttributeParser::ABI_FP_exceptions(AttrType tag) {
194-
static const char *strings[] = {"Not Permitted", "IEEE-754"};
219+
static const char *const strings[] = {"Not Permitted", "IEEE-754"};
195220
return parseStringAttribute("ABI_FP_exceptions", tag, ArrayRef(strings));
196221
}
197222
Error ARMAttributeParser::ABI_FP_user_exceptions(AttrType tag) {
198-
static const char *strings[] = {"Not Permitted", "IEEE-754"};
223+
static const char *const strings[] = {"Not Permitted", "IEEE-754"};
199224
return parseStringAttribute("ABI_FP_user_exceptions", tag, ArrayRef(strings));
200225
}
201226

202227
Error ARMAttributeParser::ABI_FP_number_model(AttrType tag) {
203-
static const char *strings[] = {"Not Permitted", "Finite Only", "RTABI",
204-
"IEEE-754"};
228+
static const char *const strings[] = {"Not Permitted", "Finite Only", "RTABI",
229+
"IEEE-754"};
205230
return parseStringAttribute("ABI_FP_number_model", tag, ArrayRef(strings));
206231
}
207232

208233
Error ARMAttributeParser::ABI_align_needed(AttrType tag) {
209-
static const char *strings[] = {"Not Permitted", "8-byte alignment",
210-
"4-byte alignment", "Reserved"};
234+
static const char *const strings[] = {"Not Permitted", "8-byte alignment",
235+
"4-byte alignment", "Reserved"};
211236

212237
uint64_t value = de.getULEB128(cursor);
213238

@@ -244,38 +269,38 @@ Error ARMAttributeParser::ABI_align_preserved(AttrType tag) {
244269
}
245270

246271
Error ARMAttributeParser::ABI_enum_size(AttrType tag) {
247-
static const char *strings[] = {"Not Permitted", "Packed", "Int32",
248-
"External Int32"};
272+
static const char *const strings[] = {"Not Permitted", "Packed", "Int32",
273+
"External Int32"};
249274
return parseStringAttribute("ABI_enum_size", tag, ArrayRef(strings));
250275
}
251276

252277
Error ARMAttributeParser::ABI_HardFP_use(AttrType tag) {
253-
static const char *strings[] = {"Tag_FP_arch", "Single-Precision", "Reserved",
254-
"Tag_FP_arch (deprecated)"};
278+
static const char *const strings[] = {"Tag_FP_arch", "Single-Precision",
279+
"Reserved", "Tag_FP_arch (deprecated)"};
255280
return parseStringAttribute("ABI_HardFP_use", tag, ArrayRef(strings));
256281
}
257282

258283
Error ARMAttributeParser::ABI_VFP_args(AttrType tag) {
259-
static const char *strings[] = {"AAPCS", "AAPCS VFP", "Custom",
260-
"Not Permitted"};
284+
static const char *const strings[] = {"AAPCS", "AAPCS VFP", "Custom",
285+
"Not Permitted"};
261286
return parseStringAttribute("ABI_VFP_args", tag, ArrayRef(strings));
262287
}
263288

264289
Error ARMAttributeParser::ABI_WMMX_args(AttrType tag) {
265-
static const char *strings[] = {"AAPCS", "iWMMX", "Custom"};
290+
static const char *const strings[] = {"AAPCS", "iWMMX", "Custom"};
266291
return parseStringAttribute("ABI_WMMX_args", tag, ArrayRef(strings));
267292
}
268293

269294
Error ARMAttributeParser::ABI_optimization_goals(AttrType tag) {
270-
static const char *strings[] = {
271-
"None", "Speed", "Aggressive Speed", "Size", "Aggressive Size", "Debugging",
272-
"Best Debugging"
273-
};
295+
static const char *const strings[] = {
296+
"None", "Speed", "Aggressive Speed",
297+
"Size", "Aggressive Size", "Debugging",
298+
"Best Debugging"};
274299
return parseStringAttribute("ABI_optimization_goals", tag, ArrayRef(strings));
275300
}
276301

277302
Error ARMAttributeParser::ABI_FP_optimization_goals(AttrType tag) {
278-
static const char *strings[] = {
303+
static const char *const strings[] = {
279304
"None", "Speed", "Aggressive Speed", "Size", "Aggressive Size",
280305
"Accuracy", "Best Accuracy"};
281306
return parseStringAttribute("ABI_FP_optimization_goals", tag,
@@ -309,66 +334,67 @@ Error ARMAttributeParser::compatibility(AttrType tag) {
309334
}
310335

311336
Error ARMAttributeParser::CPU_unaligned_access(AttrType tag) {
312-
static const char *strings[] = {"Not Permitted", "v6-style"};
337+
static const char *const strings[] = {"Not Permitted", "v6-style"};
313338
return parseStringAttribute("CPU_unaligned_access", tag, ArrayRef(strings));
314339
}
315340

316341
Error ARMAttributeParser::FP_HP_extension(AttrType tag) {
317-
static const char *strings[] = {"If Available", "Permitted"};
342+
static const char *const strings[] = {"If Available", "Permitted"};
318343
return parseStringAttribute("FP_HP_extension", tag, ArrayRef(strings));
319344
}
320345

321346
Error ARMAttributeParser::ABI_FP_16bit_format(AttrType tag) {
322-
static const char *strings[] = {"Not Permitted", "IEEE-754", "VFPv3"};
347+
static const char *const strings[] = {"Not Permitted", "IEEE-754", "VFPv3"};
323348
return parseStringAttribute("ABI_FP_16bit_format", tag, ArrayRef(strings));
324349
}
325350

326351
Error ARMAttributeParser::MPextension_use(AttrType tag) {
327-
static const char *strings[] = {"Not Permitted", "Permitted"};
352+
static const char *const strings[] = {"Not Permitted", "Permitted"};
328353
return parseStringAttribute("MPextension_use", tag, ArrayRef(strings));
329354
}
330355

331356
Error ARMAttributeParser::DIV_use(AttrType tag) {
332-
static const char *strings[] = {"If Available", "Not Permitted", "Permitted"};
357+
static const char *const strings[] = {"If Available", "Not Permitted",
358+
"Permitted"};
333359
return parseStringAttribute("DIV_use", tag, ArrayRef(strings));
334360
}
335361

336362
Error ARMAttributeParser::DSP_extension(AttrType tag) {
337-
static const char *strings[] = {"Not Permitted", "Permitted"};
363+
static const char *const strings[] = {"Not Permitted", "Permitted"};
338364
return parseStringAttribute("DSP_extension", tag, ArrayRef(strings));
339365
}
340366

341367
Error ARMAttributeParser::T2EE_use(AttrType tag) {
342-
static const char *strings[] = {"Not Permitted", "Permitted"};
368+
static const char *const strings[] = {"Not Permitted", "Permitted"};
343369
return parseStringAttribute("T2EE_use", tag, ArrayRef(strings));
344370
}
345371

346372
Error ARMAttributeParser::Virtualization_use(AttrType tag) {
347-
static const char *strings[] = {"Not Permitted", "TrustZone",
348-
"Virtualization Extensions",
349-
"TrustZone + Virtualization Extensions"};
373+
static const char *const strings[] = {
374+
"Not Permitted", "TrustZone", "Virtualization Extensions",
375+
"TrustZone + Virtualization Extensions"};
350376
return parseStringAttribute("Virtualization_use", tag, ArrayRef(strings));
351377
}
352378

353379
Error ARMAttributeParser::PAC_extension(ARMBuildAttrs::AttrType tag) {
354-
static const char *strings[] = {"Not Permitted", "Permitted in NOP space",
355-
"Permitted"};
380+
static const char *const strings[] = {"Not Permitted",
381+
"Permitted in NOP space", "Permitted"};
356382
return parseStringAttribute("PAC_extension", tag, ArrayRef(strings));
357383
}
358384

359385
Error ARMAttributeParser::BTI_extension(ARMBuildAttrs::AttrType tag) {
360-
static const char *strings[] = {"Not Permitted", "Permitted in NOP space",
361-
"Permitted"};
386+
static const char *const strings[] = {"Not Permitted",
387+
"Permitted in NOP space", "Permitted"};
362388
return parseStringAttribute("BTI_extension", tag, ArrayRef(strings));
363389
}
364390

365391
Error ARMAttributeParser::PACRET_use(ARMBuildAttrs::AttrType tag) {
366-
static const char *strings[] = {"Not Used", "Used"};
392+
static const char *const strings[] = {"Not Used", "Used"};
367393
return parseStringAttribute("PACRET_use", tag, ArrayRef(strings));
368394
}
369395

370396
Error ARMAttributeParser::BTI_use(ARMBuildAttrs::AttrType tag) {
371-
static const char *strings[] = {"Not Used", "Used"};
397+
static const char *const strings[] = {"Not Used", "Used"};
372398
return parseStringAttribute("BTI_use", tag, ArrayRef(strings));
373399
}
374400

‎llvm/lib/Support/CSKYAttributeParser.cpp

Lines changed: 9 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -82,38 +82,39 @@ Error CSKYAttributeParser::handler(uint64_t tag, bool &handled) {
8282
}
8383

8484
Error CSKYAttributeParser::dspVersion(unsigned tag) {
85-
static const char *strings[] = {"Error", "DSP Extension", "DSP 2.0"};
85+
static const char *const strings[] = {"Error", "DSP Extension", "DSP 2.0"};
8686
return parseStringAttribute("Tag_CSKY_DSP_VERSION", tag, ArrayRef(strings));
8787
}
8888

8989
Error CSKYAttributeParser::vdspVersion(unsigned tag) {
90-
static const char *strings[] = {"Error", "VDSP Version 1", "VDSP Version 2"};
90+
static const char *const strings[] = {"Error", "VDSP Version 1",
91+
"VDSP Version 2"};
9192
return parseStringAttribute("Tag_CSKY_VDSP_VERSION", tag, ArrayRef(strings));
9293
}
9394

9495
Error CSKYAttributeParser::fpuVersion(unsigned tag) {
95-
static const char *strings[] = {"Error", "FPU Version 1", "FPU Version 2",
96-
"FPU Version 3"};
96+
static const char *const strings[] = {"Error", "FPU Version 1",
97+
"FPU Version 2", "FPU Version 3"};
9798
return parseStringAttribute("Tag_CSKY_FPU_VERSION", tag, ArrayRef(strings));
9899
}
99100

100101
Error CSKYAttributeParser::fpuABI(unsigned tag) {
101-
static const char *strings[] = {"Error", "Soft", "SoftFP", "Hard"};
102+
static const char *const strings[] = {"Error", "Soft", "SoftFP", "Hard"};
102103
return parseStringAttribute("Tag_CSKY_FPU_ABI", tag, ArrayRef(strings));
103104
}
104105

105106
Error CSKYAttributeParser::fpuRounding(unsigned tag) {
106-
static const char *strings[] = {"None", "Needed"};
107+
static const char *const strings[] = {"None", "Needed"};
107108
return parseStringAttribute("Tag_CSKY_FPU_ROUNDING", tag, ArrayRef(strings));
108109
}
109110

110111
Error CSKYAttributeParser::fpuDenormal(unsigned tag) {
111-
static const char *strings[] = {"None", "Needed"};
112+
static const char *const strings[] = {"None", "Needed"};
112113
return parseStringAttribute("Tag_CSKY_FPU_DENORMAL", tag, ArrayRef(strings));
113114
}
114115

115116
Error CSKYAttributeParser::fpuException(unsigned tag) {
116-
static const char *strings[] = {"None", "Needed"};
117+
static const char *const strings[] = {"None", "Needed"};
117118
return parseStringAttribute("Tag_CSKY_FPU_EXCEPTION", tag, ArrayRef(strings));
118119
}
119120

‎llvm/lib/Support/MSP430AttributeParser.cpp

Lines changed: 6 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -21,22 +21,24 @@ constexpr std::array<MSP430AttributeParser::DisplayHandler, 4>
2121
{MSP430Attrs::TagEnumSize, &MSP430AttributeParser::parseEnumSize}}};
2222

2323
Error MSP430AttributeParser::parseISA(AttrType Tag) {
24-
static const char *StringVals[] = {"None", "MSP430", "MSP430X"};
24+
static const char *const StringVals[] = {"None", "MSP430", "MSP430X"};
2525
return parseStringAttribute("ISA", Tag, ArrayRef(StringVals));
2626
}
2727

2828
Error MSP430AttributeParser::parseCodeModel(AttrType Tag) {
29-
static const char *StringVals[] = {"None", "Small", "Large"};
29+
static const char *const StringVals[] = {"None", "Small", "Large"};
3030
return parseStringAttribute("Code Model", Tag, ArrayRef(StringVals));
3131
}
3232

3333
Error MSP430AttributeParser::parseDataModel(AttrType Tag) {
34-
static const char *StringVals[] = {"None", "Small", "Large", "Restricted"};
34+
static const char *const StringVals[] = {"None", "Small", "Large",
35+
"Restricted"};
3536
return parseStringAttribute("Data Model", Tag, ArrayRef(StringVals));
3637
}
3738

3839
Error MSP430AttributeParser::parseEnumSize(AttrType Tag) {
39-
static const char *StringVals[] = {"None", "Small", "Integer", "Don't Care"};
40+
static const char *const StringVals[] = {"None", "Small", "Integer",
41+
"Don't Care"};
4042
return parseStringAttribute("Enum Size", Tag, ArrayRef(StringVals));
4143
}
4244

‎llvm/lib/Support/RISCVAttributeParser.cpp

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -50,7 +50,8 @@ Error RISCVAttributeParser::atomicAbi(unsigned Tag) {
5050
}
5151

5252
Error RISCVAttributeParser::unalignedAccess(unsigned tag) {
53-
static const char *strings[] = {"No unaligned access", "Unaligned access"};
53+
static const char *const strings[] = {"No unaligned access",
54+
"Unaligned access"};
5455
return parseStringAttribute("Unaligned_access", tag, ArrayRef(strings));
5556
}
5657

0 commit comments

Comments
 (0)