1 //===- ARMELFAttributeData.h ----------------------------------------------===//
2 //
3 //                     The MCLinker Project
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 #include "ARMELFAttributeData.h"
10 
11 #include "mcld/LinkerConfig.h"
12 #include "mcld/MC/Input.h"
13 #include "mcld/Support/LEB128.h"
14 #include "mcld/Support/MsgHandling.h"
15 #include <llvm/ADT/STLExtras.h>
16 
17 namespace mcld {
18 
getAttributeValue(TagType pTag) const19 const ELFAttributeValue* ARMELFAttributeData::getAttributeValue(
20     TagType pTag) const {
21   if (pTag <= Tag_Max) {
22     const ELFAttributeValue& attr_value = m_Attrs[pTag];
23 
24     if (attr_value.isInitialized()) {
25       return &attr_value;
26     } else {
27       // Don't return uninitialized attribute value.
28       return NULL;
29     }
30   } else {
31     UnknownAttrsMap::const_iterator attr_it = m_UnknownAttrs.find(pTag);
32 
33     if (attr_it == m_UnknownAttrs.end()) {
34       return NULL;
35     } else {
36       return &attr_it->second;
37     }
38   }
39 }
40 
41 std::pair<ELFAttributeValue*, bool>
getOrCreateAttributeValue(TagType pTag)42 ARMELFAttributeData::getOrCreateAttributeValue(TagType pTag) {
43   ELFAttributeValue* attr_value = NULL;
44 
45   if (pTag <= Tag_Max) {
46     attr_value = &m_Attrs[pTag];
47   } else {
48     // An unknown tag encounterred.
49     attr_value = &m_UnknownAttrs[pTag];
50   }
51 
52   assert(attr_value != NULL);
53 
54   // Setup the value type.
55   if (!attr_value->isUninitialized()) {
56     return std::make_pair(attr_value, false);
57   } else {
58     attr_value->setType(GetAttributeValueType(pTag));
59     return std::make_pair(attr_value, true);
60   }
61 }
62 
GetAttributeValueType(TagType pTag)63 unsigned int ARMELFAttributeData::GetAttributeValueType(TagType pTag) {
64   // See ARM [ABI-addenda], 2.2.6.
65   switch (pTag) {
66     case Tag_compatibility: {
67       return (ELFAttributeValue::Int | ELFAttributeValue::String);
68     }
69     case Tag_nodefaults: {
70       return (ELFAttributeValue::Int | ELFAttributeValue::NoDefault);
71     }
72     case Tag_CPU_raw_name:
73     case Tag_CPU_name: {
74       return ELFAttributeValue::String;
75     }
76     default: {
77       if (pTag < 32)
78         return ELFAttributeValue::Int;
79       else
80         return ((pTag & 1) ? ELFAttributeValue::String
81                            : ELFAttributeValue::Int);
82     }
83   }
84   // unreachable
85 }
86 
87 //===--------------------------------------------------------------------===//
88 // Helper Functions for merge()
89 //===--------------------------------------------------------------------===//
90 
91 namespace {
92 
93 /*
94  * Helper function to decode value in Tag_also_compatible_with.
95  *
96  * @ref ARM [ABI-addenda], 2.3.7.3
97  */
decode_secondary_compatibility_attribute(const ELFAttributeValue & pValue)98 static int decode_secondary_compatibility_attribute(
99     const ELFAttributeValue& pValue) {
100   // The encoding of Tag_also_compatible_with is:
101   //
102   // Tag_also_compatible_with (=65), NTSB: data
103   //
104   // The data can be either an ULEB128-encoded number followed by a NULL byte or
105   // a NULL-terminated string. Currently, only the following byte sequence in
106   // data are currently defined:
107   //
108   // Tag_CPU_arch (=6) [The arch] 0
109   assert((pValue.type() == ELFAttributeValue::String) &&
110          "Value of Tag_also_compatible_with must be a string!");
111 
112   const std::string& data = pValue.getStringValue();
113 
114   // Though the integer is in LEB128 format, but they occupy only 1 byte in
115   // currently defined value.
116   if (data.length() < 2)
117     // Must have a byte for Tag_CPU_arch (=6)
118     //           a byte for specifying the CPU architecture (CPU_Arch_ARM_*)
119     //
120     // Currently, the 2nd byte can only be v4T (=2) or v6-M (=11).
121     return -1;
122 
123   if ((static_cast<uint8_t>(data[0]) == ARMELFAttributeData::Tag_CPU_arch) &&
124       ((data[1] == ARMELFAttributeData::CPU_Arch_ARM_V4T) ||
125        (data[1] == ARMELFAttributeData::CPU_Arch_ARM_V6_M)))
126     return static_cast<uint32_t>(data[1]);
127 
128   // Tag_also_compatible_with can be safely ignored.
129   return -1;
130 }
131 
132 /*
133  * This helper array keeps the ordering of the values in attributes such as
134  * Tag_ABI_align_needed which are sored as 1 > 2 > 0.
135  */
136 static const int value_ordering_120[] = {0, 2, 1};
137 
138 }  // anonymous namespace
139 
140 //===--------------------------------------------------------------------===//
141 // End Helper Functions for merge()
142 //===--------------------------------------------------------------------===//
143 
merge(const LinkerConfig & pConfig,const Input & pInput,TagType pTag,const ELFAttributeValue & pInAttr)144 bool ARMELFAttributeData::merge(const LinkerConfig& pConfig,
145                                 const Input& pInput,
146                                 TagType pTag,
147                                 const ELFAttributeValue& pInAttr) {
148   // Pre-condition
149   //  1. The out_attr must be initailized and has value of the same type as
150   //     pInAttr.
151   //  2. The value helf by out_attr and pInAttr must be different.
152   ELFAttributeValue& out_attr = m_Attrs[pTag];
153 
154   // Attribute in the output must have value assigned.
155   assert(out_attr.isInitialized() && "No output attribute to be merged!");
156 
157   switch (pTag) {
158     case Tag_CPU_arch: {
159       // Need value of Tag_also_compatible_with in the input for merge.
160       if (pInAttr.getIntValue() <= CPU_Arch_Max) {
161         m_CPUArch = pInAttr.getIntValue();
162       } else {
163         error(diag::error_unknown_cpu_arch) << pInput.name();
164         return false;
165       }
166       break;
167     }
168     case Tag_CPU_name: {
169       // need value of Tag_CPU_arch in the input for merge
170       m_CPUName = pInAttr.getStringValue();
171       break;
172     }
173     case Tag_CPU_raw_name: {
174       // need value of Tag_CPU_arch in the input for merge
175       m_CPURawName = pInAttr.getStringValue();
176       break;
177     }
178     case Tag_FP_arch: {
179       // need value of Tag_HardFP_use in the input for merge
180       m_FPArch = pInAttr.getIntValue();
181       break;
182     }
183     case Tag_ABI_HardFP_use: {
184       // need value of Tag_FP_arch in the input for merge
185       m_HardFPUse = pInAttr.getIntValue();
186       break;
187     }
188     case Tag_also_compatible_with: {
189       // need value of Tag_CPU_arch in the input for merge
190       m_SecondaryCPUArch = decode_secondary_compatibility_attribute(pInAttr);
191       break;
192     }
193     case Tag_ABI_VFP_args: {
194       // need value of Tag_ABI_FP_number_model in the input for merge
195       m_VFPArgs = pInAttr.getIntValue();
196       break;
197     }
198     // The value of these tags are integers and after merge, only the greatest
199     // value held by pInAttr and out_attr goes into output.
200     case Tag_ARM_ISA_use:
201     case Tag_THUMB_ISA_use:
202     case Tag_WMMX_arch:
203     case Tag_Advanced_SIMD_arch:
204     case Tag_ABI_FP_rounding:
205     case Tag_ABI_FP_exceptions:
206     case Tag_ABI_FP_user_exceptions:
207     case Tag_ABI_FP_number_model:
208     case Tag_FP_HP_extension:
209     case Tag_CPU_unaligned_access:
210     case Tag_T2EE_use: {
211       assert((out_attr.type() == ELFAttributeValue::Int) &&
212              (pInAttr.type() == ELFAttributeValue::Int) &&
213              "should have integer parameeter!");
214       if (pInAttr.getIntValue() > out_attr.getIntValue())
215         out_attr.setIntValue(pInAttr.getIntValue());
216       break;
217     }
218     // The value of these tags are integers and after merge, only the smallest
219     // value held by pInAttr and out_attr goes into output.
220     case Tag_ABI_align_preserved:
221     case Tag_ABI_PCS_RO_data: {
222       assert((out_attr.type() == ELFAttributeValue::Int) &&
223              (pInAttr.type() == ELFAttributeValue::Int) &&
224              "should have integer parameeter!");
225       if (pInAttr.getIntValue() < out_attr.getIntValue())
226         out_attr.setIntValue(pInAttr.getIntValue());
227       break;
228     }
229     // The values of these attributes are sorted as 1 > 2 > 0. And the greater
230     // value becomes output.
231     case Tag_ABI_align_needed:
232     case Tag_ABI_FP_denormal:
233     case Tag_ABI_PCS_GOT_use: {
234       const int in_val = pInAttr.getIntValue();
235       const int out_val = out_attr.getIntValue();
236 
237       if (in_val <= 2) {
238         if (out_val <= 2) {
239           // Use value_ordering_120 to determine the ordering.
240           if (value_ordering_120[in_val] > value_ordering_120[out_val]) {
241             out_attr.setIntValue(in_val);
242           }
243         }
244       } else {
245         // input value > 2, for future-proofing
246         if (in_val > out_val) {
247           out_attr.setIntValue(in_val);
248         }
249       }
250       break;
251     }
252     // These tags use the first value ever seen.
253     case Tag_ABI_optimization_goals:
254     case Tag_ABI_FP_optimization_goals: {
255       break;
256     }
257     // Tag_CPU_arch_profile
258     case Tag_CPU_arch_profile: {
259       if (pInAttr.getIntValue() == Arch_Profile_None)
260         return true;
261 
262       switch (out_attr.getIntValue()) {
263         case Arch_Profile_None: {
264           out_attr.setIntValue(pInAttr.getIntValue());
265           break;
266         }
267         case Arch_Profile_RealOrApp: {
268           if (pInAttr.getIntValue() != Arch_Profile_Microcontroller)
269             out_attr.setIntValue(pInAttr.getIntValue());
270           else
271             warning(diag::warn_mismatch_cpu_arch_profile)
272                 << pInAttr.getIntValue() << pInput.name();
273           break;
274         }
275         default: {
276           // out_attr is Arch_Profile_Application or Arch_Profile_Realtime or
277           // Arch_Profile_Microcontroller.
278           if ((pInAttr.getIntValue() == Arch_Profile_RealOrApp) &&
279               (out_attr.getIntValue() != Arch_Profile_Microcontroller)) {
280             // do nothing
281           } else {
282             if (pConfig.options().warnMismatch())
283               warning(diag::warn_mismatch_cpu_arch_profile)
284                   << pInAttr.getIntValue() << pInput.name();
285           }
286           break;
287         }
288       }
289       break;
290     }
291     // Tag_MPextension_use and Tag_MPextension_use_legacy
292     case Tag_MPextension_use:
293     case Tag_MPextension_use_legacy: {
294       if (m_MPextensionUse < 0) {
295         m_MPextensionUse = pInAttr.getIntValue();
296       } else {
297         if (static_cast<unsigned>(m_MPextensionUse) != pInAttr.getIntValue()) {
298           warning(diag::error_mismatch_mpextension_use) << pInput.name();
299         }
300       }
301       break;
302     }
303     // Tag_DIV_use
304     case Tag_DIV_use: {
305       if (pInAttr.getIntValue() == 2) {
306         // 2 means the code was permitted to use SDIV/UDIV in anyway.
307         out_attr.setIntValue(2);
308       } else {
309         // Merge until settling down Tag_CPU_arch.
310         m_DIVUse = pInAttr.getIntValue();
311       }
312       break;
313     }
314     // Tag_ABI_enum_size
315     case Tag_ABI_enum_size: {
316       if ((out_attr.getIntValue() == Enum_Unused) ||
317           (out_attr.getIntValue() == Enum_Containerized_As_Possible))
318         out_attr.setIntValue(pInAttr.getIntValue());
319       else if (pInAttr.getIntValue() != Enum_Containerized_As_Possible &&
320                pConfig.options().warnMismatch())
321         warning(diag::warn_mismatch_enum_size)
322             << pInput.name() << pInAttr.getIntValue() << out_attr.getIntValue();
323       break;
324     }
325     // Tag_ABI_FP_16bit_format
326     case Tag_ABI_FP_16bit_format: {
327       // 0: doesn't use any 16-bit FP number
328       // 1: use IEEE 754 format 16-bit FP number
329       // 2: use VFPv3/Advanced SIMD "alternative format" 16-bit FP number
330       if (pInAttr.getIntValue() != 0) {
331         if (out_attr.getIntValue() == 0) {
332           out_attr.setIntValue(pInAttr.getIntValue());
333         } else {
334           if (pConfig.options().warnMismatch())
335             warning(diag::warn_mismatch_fp16_format) << pInput.name();
336         }
337       }
338       break;
339     }
340     // Tag_nodefaults
341     case Tag_nodefaults: {
342       // There's nothing to do for this tag. It doesn't have an actual value.
343       break;
344     }
345     // Tag_conformance
346     case Tag_conformance: {
347       // Throw away the value if the attribute value doesn't match.
348       if (out_attr.getStringValue() != pInAttr.getStringValue())
349         out_attr.setStringValue("");
350       break;
351     }
352     // Tag_Virtualization_use
353     case Tag_Virtualization_use: {
354       // 0: No use of any virtualization extension
355       // 1: TrustZone
356       // 2: Virtualization extension such as HVC and ERET
357       // 3: TrustZone and virtualization extension are permitted
358       if (pInAttr.getIntValue() != 0) {
359         if (out_attr.getIntValue() == 0) {
360           out_attr.setIntValue(pInAttr.getIntValue());
361         } else {
362           if ((out_attr.getIntValue() <= 3) && (pInAttr.getIntValue() <= 3)) {
363             // Promote to 3
364             out_attr.setIntValue(3);
365           } else {
366             warning(diag::warn_unrecognized_virtualization_use)
367                 << pInput.name() << pInAttr.getIntValue();
368           }
369         }
370       }
371       break;
372     }
373     // Tag_ABI_WMMX_args
374     case Tag_ABI_WMMX_args: {
375       // There's no way to merge this value (i.e., objects contain different
376       // value in this tag are definitely incompatible.)
377       if (pConfig.options().warnMismatch())
378         warning(diag::warn_mismatch_abi_wmmx_args) << pInput.name();
379       break;
380     }
381     // Tag_PCS_config
382     case Tag_PCS_config: {
383       // 0 means no standard configuration used or no information recorded.
384       if (pInAttr.getIntValue() != 0) {
385         if (out_attr.getIntValue() == 0)
386           out_attr.setIntValue(pInAttr.getIntValue());
387         else {
388           // Different values in these attribute are conflict
389           if (pConfig.options().warnMismatch())
390             warning(diag::warn_mismatch_pcs_config) << pInput.name();
391         }
392       }
393       break;
394     }
395     // Tag_ABI_PCS_R9_use
396     case Tag_ABI_PCS_R9_use: {
397       if (pInAttr.getIntValue() != R9_Unused) {
398         if (out_attr.getIntValue() == R9_Unused)
399           out_attr.setIntValue(pInAttr.getIntValue());
400         else {
401           if (pConfig.options().warnMismatch())
402             warning(diag::warn_mismatch_r9_use) << pInput.name();
403         }
404       }
405       break;
406     }
407     // Tag_ABI_PCS_RW_data
408     case Tag_ABI_PCS_RW_data: {
409       if (pInAttr.getIntValue() == RW_data_SB_Relative) {
410         // Require using R9 as SB (global Static Base register).
411         if ((out_attr.getIntValue() != R9_Unused) &&
412             (out_attr.getIntValue() != R9_SB) &&
413             pConfig.options().warnMismatch())
414           warning(diag::warn_mismatch_r9_use) << pInput.name();
415       }
416       // Choose the smaller value
417       if (pInAttr.getIntValue() < out_attr.getIntValue())
418         out_attr.setIntValue(pInAttr.getIntValue());
419       break;
420     }
421     // Tag_ABI_PCS_wchar_t
422     case Tag_ABI_PCS_wchar_t: {
423       // 0: no use of wchar_t
424       // 2: sizeof(wchar_t) = 2
425       // 4: sizeof(wchar_t) = 4
426       if (pInAttr.getIntValue() != 0) {
427         if (out_attr.getIntValue() == 0)
428           out_attr.setIntValue(pInAttr.getIntValue());
429         else {
430           if (pConfig.options().warnMismatch())
431             warning(diag::warn_mismatch_wchar_size) << pInput.name()
432                                                     << pInAttr.getIntValue()
433                                                     << out_attr.getIntValue();
434         }
435       }
436       break;
437     }
438     default: {
439       // Handle unknown attributes:
440       //
441       // Since we don't know how to merge the value of unknown attribute, we
442       // have to ignore it. There're two rules related to the processing (See
443       // ARM [ABI-addenda] 2.2.6, Coding extensibility and compatibility.):
444       //
445       // 1. For tag N where N >= 128, tag N has the same properties as
446       //    tag N % 128.
447       // 2. Tag 64-127 can be safely ignored.
448       // 3. Tag 0-63 must be comprehended, therefore we cannot ignore.
449       if (pConfig.options().warnMismatch()) {
450         if ((pTag & 127) < 64) {
451           warning(diag::warn_unknown_mandatory_attribute) << pTag
452                                                           << pInput.name();
453         } else {
454           warning(diag::warn_unknown_attribute) << pTag << pInput.name();
455         }
456       }
457       break;
458     }
459   }
460   return true;
461 }
462 
463 //===--------------------------------------------------------------------===//
464 // Helper Functions for postMerge()
465 //===--------------------------------------------------------------------===//
466 
467 namespace {
468 
469 /*
470  * Helper function to encode value in Tag_also_compatible_with.
471  *
472  * @ref ARM [ABI-addenda], 2.3.7.3
473  */
encode_secondary_compatibility_attribute(ELFAttributeValue & pValue,int pArch)474 static void encode_secondary_compatibility_attribute(ELFAttributeValue& pValue,
475                                                      int pArch) {
476   if ((pArch < 0) || (pArch > ARMELFAttributeData::CPU_Arch_Max)) {
477     pValue.setStringValue("");
478   } else {
479     char new_value[] = {
480         ARMELFAttributeData::Tag_CPU_arch, static_cast<char>(pArch), 0};
481     pValue.setStringValue(std::string(new_value, sizeof(new_value)));
482   }
483   return;
484 }
485 
486 /*
487  * Combine the main and secondary CPU arch value
488  */
calculate_cpu_arch(int cpu_arch,int secondary_arch)489 static int calculate_cpu_arch(int cpu_arch, int secondary_arch) {
490   // short-circuit
491   if ((secondary_arch < 0) ||
492       ((cpu_arch + secondary_arch) != (ARMELFAttributeData::CPU_Arch_ARM_V4T +
493                                        ARMELFAttributeData::CPU_Arch_ARM_V6_M)))
494     return cpu_arch;
495 
496   if ((cpu_arch == ARMELFAttributeData::CPU_Arch_ARM_V4T) &&
497       (secondary_arch == ARMELFAttributeData::CPU_Arch_ARM_V6_M))
498     return ARMELFAttributeData::CPU_Arch_ARM_V4T_Plus_V6_M;
499   else if ((cpu_arch == ARMELFAttributeData::CPU_Arch_ARM_V6_M) &&
500            (secondary_arch == ARMELFAttributeData::CPU_Arch_ARM_V4T))
501     return ARMELFAttributeData::CPU_Arch_ARM_V4T_Plus_V6_M;
502   else
503     return cpu_arch;
504 }
505 
506 /*
507  * Given a CPU arch X and a CPU arch Y in which Y is newer than X, the value in
508  * cpu_compatibility_table[X][Y] is the CPU arch required to run ISA both from X
509  * and Y. 0 in the table means unreachable and -1 means conflict architecture
510  * profile.
511  */
512 #define CPU(C)  ARMELFAttributeData::CPU_Arch_ARM_ ## C
513 static const int cpu_compatibility_table[][CPU(V4T_Plus_V6_M) + 1] = {
514     /* old\new          ARM v6T2    ARM v6K   ARM v7   ARM v6-M   ARM v6S-M   ARM v7E-M    ARMv8, ARM v4t + v6-M     */  // NOLINT
515     /* Pre v4     */ { CPU(V6T2),  CPU(V6K), CPU(V7),        -1,         -1,         -1,      -1,       -1           },  // NOLINT
516     /* ARM v4     */ { CPU(V6T2),  CPU(V6K), CPU(V7),        -1,         -1,         -1,      -1,       -1           },  // NOLINT
517     /* ARM v4T    */ { CPU(V6T2),  CPU(V6K), CPU(V7),  CPU(V6K),   CPU(V6K), CPU(V7E_M), CPU(V8), CPU(V4T)           },  // NOLINT
518     /* ARM v5T    */ { CPU(V6T2),  CPU(V6K), CPU(V7),  CPU(V6K),   CPU(V6K), CPU(V7E_M), CPU(V8), CPU(V5T)           },  // NOLINT
519     /* ARM v5TE   */ { CPU(V6T2),  CPU(V6K), CPU(V7),  CPU(V6K),   CPU(V6K), CPU(V7E_M), CPU(V8), CPU(V5TE)          },  // NOLINT
520     /* ARM v5TEJ  */ { CPU(V6T2),  CPU(V6K), CPU(V7),  CPU(V6K),   CPU(V6K), CPU(V7E_M), CPU(V8), CPU(V5TEJ)         },  // NOLINT
521     /* ARM v6     */ { CPU(V6T2),  CPU(V6K), CPU(V7),  CPU(V6K),   CPU(V6K), CPU(V7E_M), CPU(V8), CPU(V6)            },  // NOLINT
522     /* ARM v6KZ   */ {   CPU(V7), CPU(V6KZ), CPU(V7), CPU(V6KZ),  CPU(V6KZ), CPU(V7E_M), CPU(V8), CPU(V6KZ)          },  // NOLINT
523     /* ARM v6T2   */ { CPU(V6T2),   CPU(V7), CPU(V7),   CPU(V7),    CPU(V7), CPU(V7E_M), CPU(V8), CPU(V6T2)          },  // NOLINT
524     /* ARM v6K    */ {         0,  CPU(V6K), CPU(V7),  CPU(V6K),   CPU(V6K), CPU(V7E_M), CPU(V8), CPU(V6K)           },  // NOLINT
525     /* ARM v7     */ {         0,         0, CPU(V7),   CPU(V7),    CPU(V7), CPU(V7E_M), CPU(V8), CPU(V7)            },  // NOLINT
526     /* ARM v6-M   */ {         0,         0,       0, CPU(V6_M), CPU(V6S_M), CPU(V7E_M), CPU(V8), CPU(V6_M)          },  // NOLINT
527     /* ARM v6S-M  */ {         0,         0,       0,         0, CPU(V6S_M), CPU(V7E_M), CPU(V8), CPU(V6S_M)         },  // NOLINT
528     /* ARM v7E-M  */ {         0,         0,       0,         0,          0, CPU(V7E_M), CPU(V8), CPU(V7E_M)         },  // NOLINT
529     /* ARM v8     */ {         0,         0,       0,         0,          0,          0, CPU(V8), CPU(V8)            },  // NOLINT
530     /* v4T + v6-M */ {         0,         0,       0,         0,          0,          0,       0, CPU(V4T_Plus_V6_M) }   // NOLINT
531 };
532 
533 /*
534  * Helper function to determine the merge of two different CPU arch.
535  */
merge_cpu_arch(int out_cpu_arch,int in_cpu_arch)536 static int merge_cpu_arch(int out_cpu_arch, int in_cpu_arch) {
537   if (out_cpu_arch > CPU(V4T_Plus_V6_M))
538     return in_cpu_arch;
539 
540   int new_cpu_arch, old_cpu_arch;
541   if (out_cpu_arch > in_cpu_arch) {
542     new_cpu_arch = out_cpu_arch;
543     old_cpu_arch = in_cpu_arch;
544   } else {
545     new_cpu_arch = in_cpu_arch;
546     old_cpu_arch = out_cpu_arch;
547   }
548 
549   // No need to check the compatibility since the CPU architectures before
550   // V6KZ add features monotonically.
551   if (new_cpu_arch <= CPU(V6KZ))
552     return new_cpu_arch;
553 
554   return cpu_compatibility_table[old_cpu_arch][new_cpu_arch - CPU(V6T2)];
555 }
556 #undef CPU
557 
558 /*
559  * Generic CPU name is used when Tag_CPU_name is unable to guess during the
560  * merge of Tag_CPU_arch.
561  */
562 static const char* generic_cpu_name_table[] = {
563     /* Pre v4    */ "Pre v4",
564     /* Pre v4    */ "ARM v4",
565     /* ARM v4T   */ "ARM v4T",
566     /* ARM v5T   */ "ARM v5T",
567     /* ARM v5TE  */ "ARM v5TE",
568     /* ARM v5TEJ */ "ARM v5TEJ",
569     /* ARM v6    */ "ARM v6",
570     /* ARM v6KZ  */ "ARM v6KZ",
571     /* ARM v6T2  */ "ARM v6T2",
572     /* ARM v6K   */ "ARM v6K",
573     /* ARM v7    */ "ARM v7",
574     /* ARM v6-M  */ "ARM v6-M",
575     /* ARM v6S-M */ "ARM v6S-M",
576     /* ARM v7E-M */ "ARM v7E-M",
577     /* ARM v8    */ "ARM v8",
578 };
579 
get_generic_cpu_name(int cpu_arch)580 static const char* get_generic_cpu_name(int cpu_arch) {
581   assert(static_cast<size_t>(cpu_arch) <
582          (sizeof(generic_cpu_name_table) / sizeof(generic_cpu_name_table[0])));
583   return generic_cpu_name_table[cpu_arch];
584 }
585 
586 /*
587  * Helper functions & data used in the merge of two different FP arch.
588  */
589 static const struct fp_config_data {
590   int version;
591   int regs;
592 } fp_configs[] = {
593       {0, 0},
594       {1, 16},
595       {2, 16},
596       {3, 32},
597       {3, 16},
598       {4, 32},
599       {4, 16},
600       {8, 32},
601       {8, 16},
602 };
603 
604 static const size_t num_fp_configs =
605     sizeof(fp_configs) / sizeof(fp_config_data);
606 
607 // Given h(x, y) = (x * (y >> 4) + (y >> 5))
608 //
609 // fp_config_hash_table[ h(0, 0)  =  0 ] = 0
610 // fp_config_hash_table[ h(1, 16) =  1 ] = 1
611 // fp_config_hash_table[ h(2, 16) =  2 ] = 2
612 // fp_config_hash_table[ h(3, 32) =  7 ] = 3
613 // fp_config_hash_table[ h(3, 16) =  3 ] = 4
614 // fp_config_hash_table[ h(4, 32) =  9 ] = 5
615 // fp_config_hash_table[ h(4, 16) =  4 ] = 6
616 // fp_config_hash_table[ h(8, 32) = 17 ] = 7
617 // fp_config_hash_table[ h(8, 16) =  8 ] = 8
618 //
619 // h(0, 0) = 0
620 static const uint8_t fp_config_hash_table[] = {
621 #define UND static_cast<uint8_t>(-1)
622     /*  0 */ 0,
623     /*  1 */ 1,
624     /*  2 */ 2,
625     /*  3 */ 4,
626     /*  4 */ 6,
627     /*  5 */ UND,
628     /*  6 */ UND,
629     /*  7 */ 3,
630     /*  8 */ 8,
631     /*  9 */ 5,
632     /* 10 */ UND,
633     /* 11 */ UND,
634     /* 12 */ UND,
635     /* 13 */ UND,
636     /* 14 */ UND,
637     /* 15 */ UND,
638     /* 16 */ UND,
639     /* 17 */ 7,
640 #undef UND
641 };
642 
calculate_fp_config_hash(const struct fp_config_data & pConfig)643 static int calculate_fp_config_hash(const struct fp_config_data& pConfig) {
644   int x = pConfig.version;
645   int y = pConfig.regs;
646   return (x * (y >> 4) + (y >> 5));
647 }
648 
get_fp_arch_of_config(const struct fp_config_data & pConfig)649 static int get_fp_arch_of_config(const struct fp_config_data& pConfig) {
650   int hash = calculate_fp_config_hash(pConfig);
651   assert(static_cast<size_t>(hash) <
652          llvm::array_lengthof(fp_config_hash_table));
653   return fp_config_hash_table[hash];
654 }
655 
is_allowed_use_of_div(int cpu_arch,int cpu_arch_profile,int div_use)656 static bool is_allowed_use_of_div(int cpu_arch,
657                                   int cpu_arch_profile,
658                                   int div_use) {
659   // 0: The code was permitted to use SDIV and UDIV in the Thumb ISA on v7-R or
660   //    v7-M.
661   // 1: The code was not permitted to use SDIV and UDIV.
662   // 2: The code was explicitly permitted to use SDIV and UDIV.
663   switch (div_use) {
664     case 0: {
665       if ((cpu_arch == ARMELFAttributeData::CPU_Arch_ARM_V7) &&
666           ((cpu_arch_profile == 'R') || (cpu_arch_profile == 'M'))) {
667         return true;
668       } else {
669         return (cpu_arch >= ARMELFAttributeData::CPU_Arch_ARM_V7E_M);
670       }
671     }
672     case 1: {
673       return false;
674     }
675     case 2:
676     // For future proofing
677     default: { return true; }
678   }
679 }
680 
681 }  // anonymous namespace
682 
683 //===--------------------------------------------------------------------===//
684 // End Helper Functions for postMerge()
685 //===--------------------------------------------------------------------===//
686 
postMerge(const LinkerConfig & pConfig,const Input & pInput)687 bool ARMELFAttributeData::postMerge(const LinkerConfig& pConfig,
688                                     const Input& pInput) {
689   // Process Tag_CPU_arch, Tag_CPU_name, Tag_CPU_raw_name, and
690   // Tag_also_compatible_with.
691   ELFAttributeValue& out_cpu_arch_attr = m_Attrs[Tag_CPU_arch];
692   ELFAttributeValue& out_secondary_compatibility_attr =
693       m_Attrs[Tag_also_compatible_with];
694 
695   if ((m_CurrentCPUArch < 0) && out_cpu_arch_attr.isInitialized()) {
696     // Current input initializes the value of Tag_CPU_arch. Validate it.
697     int out_cpu_arch = out_cpu_arch_attr.getIntValue();
698 
699     if (out_cpu_arch > CPU_Arch_Max) {
700       error(diag::error_unknown_cpu_arch) << pInput.name();
701       return false;
702     }
703 
704     // Initialize m_CurrentCPUArch.
705     int out_secondary_arch = -1;
706     if (out_secondary_compatibility_attr.isInitialized())
707       out_secondary_arch = decode_secondary_compatibility_attribute(
708           out_secondary_compatibility_attr);
709 
710     m_CurrentCPUArch = calculate_cpu_arch(out_cpu_arch, out_secondary_arch);
711   }
712 
713   if (m_CPUArch >= 0) {
714     assert(out_cpu_arch_attr.isInitialized() && "CPU arch has never set!");
715     assert(m_CurrentCPUArch >= 0);
716 
717     int in_cpu_arch = calculate_cpu_arch(m_CPUArch, m_SecondaryCPUArch);
718     int result_cpu_arch = merge_cpu_arch(m_CurrentCPUArch, in_cpu_arch);
719 
720     if (result_cpu_arch < 0) {
721       warning(diag::warn_mismatch_cpu_arch_profile) << in_cpu_arch
722                                                     << pInput.name();
723     } else {
724       if (result_cpu_arch != m_CurrentCPUArch) {
725         // Value of Tag_CPU_arch are going to changea.
726         m_CurrentCPUArch = result_cpu_arch;
727 
728         // Write the result value to the output.
729         if (result_cpu_arch == CPU_Arch_ARM_V4T_Plus_V6_M) {
730           out_cpu_arch_attr.setIntValue(CPU_Arch_ARM_V4T);
731           encode_secondary_compatibility_attribute(
732               out_secondary_compatibility_attr, CPU_Arch_ARM_V6_M);
733         } else {
734           out_cpu_arch_attr.setIntValue(result_cpu_arch);
735           encode_secondary_compatibility_attribute(
736               out_secondary_compatibility_attr, -1);
737         }
738 
739         ELFAttributeValue& out_cpu_name = m_Attrs[Tag_CPU_name];
740         ELFAttributeValue& out_cpu_raw_name = m_Attrs[Tag_CPU_raw_name];
741 
742         if (m_CurrentCPUArch != in_cpu_arch) {
743           // Unable to guess the Tag_CPU_name. Use the generic name.
744           if (out_cpu_name.isInitialized()) {
745             out_cpu_name.setStringValue(get_generic_cpu_name(m_CurrentCPUArch));
746           }
747 
748           // Tag_CPU_raw_name becomes unknown. Set to default value to disable
749           // it.
750           out_cpu_raw_name.setStringValue("");
751         } else {
752           // Use the value of Tag_CPU_name and Tag_CPU_raw_name from the input.
753           if (!m_CPUName.empty()) {
754             ELFAttributeValue& out_cpu_name = m_Attrs[Tag_CPU_name];
755             assert(out_cpu_name.isInitialized() && "CPU name has never set!");
756             out_cpu_name.setStringValue(m_CPUName);
757           }
758 
759           if (!m_CPURawName.empty()) {
760             ELFAttributeValue& out_cpu_raw_name = m_Attrs[Tag_CPU_raw_name];
761             assert(out_cpu_raw_name.isInitialized() &&
762                    "CPU raw name has never set!");
763             out_cpu_raw_name.setStringValue(m_CPURawName);
764           }
765         }
766       }
767     }
768   }  // (m_CPUArch >= 0)
769 
770   // Process Tag_ABI_VFP_args.
771   if (m_VFPArgs >= 0) {
772     ELFAttributeValue& out_attr = m_Attrs[Tag_ABI_VFP_args];
773     ELFAttributeValue& out_float_number_model_attr =
774         m_Attrs[Tag_ABI_FP_number_model];
775 
776     assert(out_attr.isInitialized() && "VFP args has never set!");
777 
778     // If the output is not permitted to use floating number, this attribute
779     // is ignored (migrate the value from input directly.)
780     if (out_float_number_model_attr.isUninitialized() ||
781         (out_float_number_model_attr.getIntValue() == 0)) {
782       // Inherit requirement from input.
783       out_attr.setIntValue(m_VFPArgs);
784     } else {
785       if (pConfig.options().warnMismatch())
786         warning(diag::warn_mismatch_vfp_args) << pInput.name();
787     }
788   }
789 
790   // Process Tag_FP_arch.
791   ELFAttributeValue& out_fp_arch_attr = m_Attrs[Tag_FP_arch];
792   if (m_FPArch >= 0) {
793     assert(out_fp_arch_attr.isInitialized() && "FP arch has never set!");
794 
795     // Tag_FP_arch
796     //  0: instructions requiring FP hardware are not permitted
797     //  1: VFP1
798     //  2: VFP2
799     //  3: VFP3 D32
800     //  4: VFP3 D16
801     //  5: VFP4 D32
802     //  6: VFP4 D16
803     //  7: ARM v8-A D32
804     //  8: ARM v8-A D16
805     if (out_fp_arch_attr.getIntValue() == 0) {
806       // Output has no constraints on FP hardware. Copy the requirement from
807       // input.
808       out_fp_arch_attr.setIntValue(m_FPArch);
809     } else if (m_FPArch == 0) {
810       // Input has no constraints on FP hardware. Do nothing.
811     } else {
812       // If here, both output and input contain non-zero value of Tag_FP_arch.
813 
814       // Version greater than num_fp_configs is not defined. Choose the greater
815       // one for future-proofing.
816       if (static_cast<unsigned>(m_FPArch) > num_fp_configs) {
817         if (static_cast<unsigned>(m_FPArch) > out_fp_arch_attr.getIntValue()) {
818           out_fp_arch_attr.setIntValue(m_FPArch);
819         }
820       } else {
821         if (out_fp_arch_attr.getIntValue() < num_fp_configs) {
822           const struct fp_config_data& input_fp_config = fp_configs[m_FPArch];
823 
824           const struct fp_config_data& output_fp_config =
825               fp_configs[out_fp_arch_attr.getIntValue()];
826 
827           const struct fp_config_data result_fp_config = {
828               /*version*/ ((output_fp_config.version > input_fp_config.version)
829                                ? output_fp_config.version
830                                : input_fp_config.version),
831               /* regs */ ((output_fp_config.regs > input_fp_config.regs)
832                               ? output_fp_config.regs
833                               : input_fp_config.regs),
834           };
835           // Find the attribute value corresponding the result_fp_config
836           out_fp_arch_attr.setIntValue(get_fp_arch_of_config(result_fp_config));
837         }
838       }
839     }
840   }  // (m_FPArch >= 0)
841 
842   // Process Tag_ABI_HardFP_use.
843   ELFAttributeValue& out_hardfp_use_attr = m_Attrs[Tag_ABI_HardFP_use];
844 
845   if (!m_HardFPUseInitialized && out_hardfp_use_attr.isInitialized()) {
846     m_HardFPUse = out_hardfp_use_attr.getIntValue();
847     m_HardFPUseInitialized = true;
848   }
849 
850   if (m_HardFPUse >= 0) {
851     // Tag_ABI_HardFP_use depends on the meaning of Tag_FP_arch when it's 0.
852     assert(out_hardfp_use_attr.isInitialized() && "HardFP use has never set!");
853 
854     if (out_fp_arch_attr.isUninitialized() ||
855         (out_fp_arch_attr.getIntValue() == 0)) {
856       // Has no constraints on FP hardware.
857       out_hardfp_use_attr.setIntValue(m_HardFPUse);
858     } else {
859       // Both output and input contain non-zero value of Tag_FP_arch and we have
860       // different Tag_ABI_HaedFP_Use settings other than 0.
861       if ((out_fp_arch_attr.getIntValue() > 0) && (m_HardFPUse > 0))
862         // Promote to 3 (The user permitted this entity to use both SP and DP
863         // VFP instruction.)
864         out_hardfp_use_attr.setIntValue(3);
865     }
866   }
867 
868   // Move the value of Tag_MPextension_use_legacy to Tag_MPextension_use.
869   ELFAttributeValue& out_mpextension_use_legacy =
870       m_Attrs[Tag_MPextension_use_legacy];
871 
872   ELFAttributeValue& out_mpextension_use = m_Attrs[Tag_MPextension_use];
873 
874   // If Tag_MPextension_use_legacy has value, it must be introduced by current
875   // input since it is reset every time after the merge completed.
876   if (out_mpextension_use_legacy.isInitialized()) {
877     if (out_mpextension_use.isInitialized()) {
878       if (m_MPextensionUse < 0) {
879         // The value of Tag_MPextension_use is introduced by the current input.
880         // Check whether it is consistent with the one set in legacy.
881         m_MPextensionUse = out_mpextension_use.getIntValue();
882       } else {
883         // Current input introduces value of Tag_MPextension_use in
884         // m_MPextensionUse.
885       }
886 
887       // Check the consistency between m_MPextensionUse and the value of
888       // Tag_MPextension_use_legacy.
889       if (static_cast<unsigned>(m_MPextensionUse) !=
890           out_mpextension_use_legacy.getIntValue()) {
891         error(diag::error_mismatch_mpextension_use) << pInput.name();
892         return false;
893       }
894     } else {
895       if (m_MPextensionUse < 0) {
896         // Tag_MPextension_use is not set. Initialize it and move the value.
897         out_mpextension_use.setType(ELFAttributeValue::Int);
898         out_mpextension_use.setIntValue(out_mpextension_use.getIntValue());
899       } else {
900         // Unreachable case since the value to unitialized attribute is directly
901         // assigned in ELFAttribute::Subsection::merge().
902         assert(false && "Tag_MPextension_use is uninitialized but have value?");
903       }
904     }
905 
906     // Reset the attribute to uninitialized so it won't be included in the
907     // output.
908     out_mpextension_use_legacy.setType(ELFAttributeValue::Uninitialized);
909   }
910 
911   // Process Tag_MPextension_use.
912   if (m_MPextensionUse > 0) {
913     assert(out_mpextension_use.isInitialized());
914 
915     if (static_cast<unsigned>(m_MPextensionUse) >
916         out_mpextension_use.getIntValue()) {
917       out_mpextension_use.setIntValue(m_MPextensionUse);
918     }
919   }
920 
921   // Process Tag_DIV_use.
922   ELFAttributeValue& out_div_use_attr = m_Attrs[Tag_DIV_use];
923 
924   if (!m_DIVUseInitialized && out_div_use_attr.isInitialized()) {
925     // Perform the merge by reverting value of Tag_DIV_use and setup m_DIVUse.
926     m_DIVUse = out_div_use_attr.getIntValue();
927     out_div_use_attr.setIntValue(0);
928     m_DIVUseInitialized = true;
929   }
930 
931   if (m_DIVUse >= 0) {
932     assert(out_div_use_attr.isInitialized());
933 
934     const ELFAttributeValue& out_cpu_arch_profile_attr =
935         m_Attrs[Tag_CPU_arch_profile];
936 
937     int out_cpu_arch_profile = Arch_Profile_None;
938     if (out_cpu_arch_profile_attr.isInitialized()) {
939       out_cpu_arch_profile = out_cpu_arch_profile_attr.getIntValue();
940     }
941 
942     if (m_DIVUse == 1) {
943       // Input (=1) was not permitted to use SDIV and UDIV. See whether current
944       // output was explicitly permitted the use.
945       if (!is_allowed_use_of_div(m_CurrentCPUArch,
946                                  out_cpu_arch_profile,
947                                  out_div_use_attr.getIntValue())) {
948         out_div_use_attr.setIntValue(1);
949       }
950     } else {
951       if (out_div_use_attr.getIntValue() != 1) {
952         // Output does not explicitly forbid the use of SDIV/UDIV. See whether
953         // the input attribute can allow it under current CPU architecture
954         // profile.
955         if (is_allowed_use_of_div(
956                 m_CurrentCPUArch, out_cpu_arch_profile, m_DIVUse)) {
957           out_div_use_attr.setIntValue(m_DIVUse);
958         }
959       }
960     }
961   }
962 
963   return true;
964 }
965 
sizeOutput() const966 size_t ARMELFAttributeData::sizeOutput() const {
967   size_t result = 0;
968 
969   // Size contributed by known attributes
970   for (unsigned i = 0; i <= Tag_Max; ++i) {
971     TagType tag = static_cast<TagType>(i);
972     const ELFAttributeValue& value = m_Attrs[tag];
973 
974     if (value.shouldEmit()) {
975       result += leb128::size(static_cast<uint32_t>(tag));
976       result += value.getSize();
977     }
978   }
979 
980   // Size contributed by unknown attributes
981   for (UnknownAttrsMap::const_iterator unknown_attr_it = m_UnknownAttrs.begin(),
982                                        unknown_attr_end = m_UnknownAttrs.end();
983        unknown_attr_it != unknown_attr_end;
984        ++unknown_attr_it) {
985     TagType tag = unknown_attr_it->first;
986     const ELFAttributeValue& value = unknown_attr_it->second;
987 
988     if (value.shouldEmit()) {
989       result += leb128::size(static_cast<uint32_t>(tag));
990       result += value.getSize();
991     }
992   }
993 
994   return result;
995 }
996 
emit(char * pBuf) const997 size_t ARMELFAttributeData::emit(char* pBuf) const {
998   char* buffer = pBuf;
999 
1000   // Tag_conformance "should be emitted first in a file-scope sub-subsection of
1001   // the first public subsection of the attribute section."
1002   //
1003   // See ARM [ABI-addenda], 2.3.7.4 Conformance tag
1004   const ELFAttributeValue& attr_conformance = m_Attrs[Tag_conformance];
1005 
1006   if (attr_conformance.shouldEmit()) {
1007     if (!ELFAttributeData::WriteAttribute(
1008             Tag_conformance, attr_conformance, buffer)) {
1009       return 0;
1010     }
1011   }
1012 
1013   // Tag_nodefaults "should be emitted before any other tag in an attribute
1014   // subsection other that the conformance tag"
1015   //
1016   // See ARM [ABI-addenda], 2.3.7.5 No defaults tag
1017   const ELFAttributeValue& attr_nodefaults = m_Attrs[Tag_nodefaults];
1018 
1019   if (attr_nodefaults.shouldEmit()) {
1020     if (!ELFAttributeData::WriteAttribute(
1021             Tag_nodefaults, attr_nodefaults, buffer)) {
1022       return 0;
1023     }
1024   }
1025 
1026   // Tag_conformance (=67)
1027   // Tag_nodefaults (=64)
1028   for (unsigned i = 0; i < Tag_nodefaults; ++i) {
1029     TagType tag = static_cast<TagType>(i);
1030     const ELFAttributeValue& value = m_Attrs[tag];
1031 
1032     if (value.shouldEmit() &&
1033         !ELFAttributeData::WriteAttribute(tag, value, buffer)) {
1034       return 0;
1035     }
1036   }
1037 
1038   for (unsigned i = (Tag_nodefaults + 1); i <= Tag_Max; ++i) {
1039     TagType tag = static_cast<TagType>(i);
1040     const ELFAttributeValue& value = m_Attrs[tag];
1041 
1042     if (value.shouldEmit() && (i != Tag_conformance) &&
1043         !ELFAttributeData::WriteAttribute(tag, value, buffer)) {
1044       return 0;
1045     }
1046   }
1047 
1048   for (UnknownAttrsMap::const_iterator unknown_attr_it = m_UnknownAttrs.begin(),
1049                                        unknown_attr_end = m_UnknownAttrs.end();
1050        unknown_attr_it != unknown_attr_end;
1051        ++unknown_attr_it) {
1052     TagType tag = unknown_attr_it->first;
1053     const ELFAttributeValue& value = unknown_attr_it->second;
1054 
1055     if (value.shouldEmit() &&
1056         !ELFAttributeData::WriteAttribute(tag, value, buffer)) {
1057       return 0;
1058     }
1059   }
1060 
1061   return (buffer - pBuf);
1062 }
1063 
usingThumb() const1064 bool ARMELFAttributeData::usingThumb() const {
1065   int arch = m_Attrs[Tag_CPU_arch].getIntValue();
1066   if ((arch == CPU_Arch_ARM_V6_M) || (arch == CPU_Arch_ARM_V6S_M))
1067     return true;
1068   if ((arch != CPU_Arch_ARM_V7) && (arch != CPU_Arch_ARM_V7E_M))
1069     return false;
1070 
1071   arch = m_Attrs[Tag_CPU_arch_profile].getIntValue();
1072   return arch == Arch_Profile_Microcontroller;
1073 }
1074 
usingThumb2() const1075 bool ARMELFAttributeData::usingThumb2() const {
1076   int arch = m_Attrs[Tag_CPU_arch].getIntValue();
1077   return (arch == CPU_Arch_ARM_V6T2) || (arch == CPU_Arch_ARM_V7);
1078 }
1079 
1080 }  // namespace mcld
1081