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