1 //===--- AVR.h - Declare AVR target feature support -------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file declares AVR TargetInfo objects. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #ifndef LLVM_CLANG_LIB_BASIC_TARGETS_AVR_H 14 #define LLVM_CLANG_LIB_BASIC_TARGETS_AVR_H 15 16 #include "clang/Basic/TargetInfo.h" 17 #include "clang/Basic/TargetOptions.h" 18 #include "llvm/ADT/Triple.h" 19 #include "llvm/Support/Compiler.h" 20 21 namespace clang { 22 namespace targets { 23 24 // AVR Target 25 class LLVM_LIBRARY_VISIBILITY AVRTargetInfo : public TargetInfo { 26 public: 27 AVRTargetInfo(const llvm::Triple &Triple, const TargetOptions &) 28 : TargetInfo(Triple) { 29 TLSSupported = false; 30 PointerWidth = 16; 31 PointerAlign = 8; 32 IntWidth = 16; 33 IntAlign = 8; 34 LongWidth = 32; 35 LongAlign = 8; 36 LongLongWidth = 64; 37 LongLongAlign = 8; 38 SuitableAlign = 8; 39 DefaultAlignForAttributeAligned = 8; 40 HalfWidth = 16; 41 HalfAlign = 8; 42 FloatWidth = 32; 43 FloatAlign = 8; 44 DoubleWidth = 32; 45 DoubleAlign = 8; 46 DoubleFormat = &llvm::APFloat::IEEEsingle(); 47 LongDoubleWidth = 32; 48 LongDoubleAlign = 8; 49 LongDoubleFormat = &llvm::APFloat::IEEEsingle(); 50 SizeType = UnsignedInt; 51 PtrDiffType = SignedInt; 52 IntPtrType = SignedInt; 53 Char16Type = UnsignedInt; 54 WIntType = SignedInt; 55 Char32Type = UnsignedLong; 56 SigAtomicType = SignedChar; 57 resetDataLayout("e-P1-p:16:8-i8:8-i16:8-i32:8-i64:8-f32:8-f64:8-n8-a:8"); 58 } 59 60 void getTargetDefines(const LangOptions &Opts, 61 MacroBuilder &Builder) const override; 62 63 ArrayRef<Builtin::Info> getTargetBuiltins() const override { return None; } 64 65 BuiltinVaListKind getBuiltinVaListKind() const override { 66 return TargetInfo::VoidPtrBuiltinVaList; 67 } 68 69 const char *getClobbers() const override { return ""; } 70 71 ArrayRef<const char *> getGCCRegNames() const override { 72 static const char *const GCCRegNames[] = { 73 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", 74 "r10", "r11", "r12", "r13", "r14", "r15", "r16", "r17", "r18", "r19", 75 "r20", "r21", "r22", "r23", "r24", "r25", "X", "Y", "Z", "SP" 76 }; 77 return llvm::makeArrayRef(GCCRegNames); 78 } 79 80 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override { 81 return None; 82 } 83 84 ArrayRef<TargetInfo::AddlRegName> getGCCAddlRegNames() const override { 85 static const TargetInfo::AddlRegName AddlRegNames[] = { 86 {{"r26", "r27"}, 26}, 87 {{"r28", "r29"}, 27}, 88 {{"r30", "r31"}, 28}, 89 {{"SPL", "SPH"}, 29}, 90 }; 91 return llvm::makeArrayRef(AddlRegNames); 92 } 93 94 bool validateAsmConstraint(const char *&Name, 95 TargetInfo::ConstraintInfo &Info) const override { 96 // There aren't any multi-character AVR specific constraints. 97 if (StringRef(Name).size() > 1) 98 return false; 99 100 switch (*Name) { 101 default: 102 return false; 103 case 'a': // Simple upper registers 104 case 'b': // Base pointer registers pairs 105 case 'd': // Upper register 106 case 'l': // Lower registers 107 case 'e': // Pointer register pairs 108 case 'q': // Stack pointer register 109 case 'r': // Any register 110 case 'w': // Special upper register pairs 111 case 't': // Temporary register 112 case 'x': 113 case 'X': // Pointer register pair X 114 case 'y': 115 case 'Y': // Pointer register pair Y 116 case 'z': 117 case 'Z': // Pointer register pair Z 118 Info.setAllowsRegister(); 119 return true; 120 case 'I': // 6-bit positive integer constant 121 Info.setRequiresImmediate(0, 63); 122 return true; 123 case 'J': // 6-bit negative integer constant 124 Info.setRequiresImmediate(-63, 0); 125 return true; 126 case 'K': // Integer constant (Range: 2) 127 Info.setRequiresImmediate(2); 128 return true; 129 case 'L': // Integer constant (Range: 0) 130 Info.setRequiresImmediate(0); 131 return true; 132 case 'M': // 8-bit integer constant 133 Info.setRequiresImmediate(0, 0xff); 134 return true; 135 case 'N': // Integer constant (Range: -1) 136 Info.setRequiresImmediate(-1); 137 return true; 138 case 'O': // Integer constant (Range: 8, 16, 24) 139 Info.setRequiresImmediate({8, 16, 24}); 140 return true; 141 case 'P': // Integer constant (Range: 1) 142 Info.setRequiresImmediate(1); 143 return true; 144 case 'R': // Integer constant (Range: -6 to 5) 145 Info.setRequiresImmediate(-6, 5); 146 return true; 147 case 'G': // Floating point constant 148 case 'Q': // A memory address based on Y or Z pointer with displacement. 149 return true; 150 } 151 152 return false; 153 } 154 155 IntType getIntTypeByWidth(unsigned BitWidth, bool IsSigned) const final { 156 // AVR prefers int for 16-bit integers. 157 return BitWidth == 16 ? (IsSigned ? SignedInt : UnsignedInt) 158 : TargetInfo::getIntTypeByWidth(BitWidth, IsSigned); 159 } 160 161 IntType getLeastIntTypeByWidth(unsigned BitWidth, bool IsSigned) const final { 162 // AVR uses int for int_least16_t and int_fast16_t. 163 return BitWidth == 16 164 ? (IsSigned ? SignedInt : UnsignedInt) 165 : TargetInfo::getLeastIntTypeByWidth(BitWidth, IsSigned); 166 } 167 168 bool isValidCPUName(StringRef Name) const override; 169 void fillValidCPUList(SmallVectorImpl<StringRef> &Values) const override; 170 bool setCPU(const std::string &Name) override { 171 bool isValid = isValidCPUName(Name); 172 if (isValid) 173 CPU = Name; 174 return isValid; 175 } 176 177 protected: 178 std::string CPU; 179 }; 180 181 } // namespace targets 182 } // namespace clang 183 184 #endif // LLVM_CLANG_LIB_BASIC_TARGETS_AVR_H 185