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 Int16Type = SignedInt; 56 Char32Type = UnsignedLong; 57 SigAtomicType = SignedChar; 58 ProgramAddrSpace = 1; 59 resetDataLayout("e-P1-p:16:8-i8:8-i16:8-i32:8-i64:8-f32:8-f64:8-n8-a:8"); 60 } 61 62 void getTargetDefines(const LangOptions &Opts, 63 MacroBuilder &Builder) const override; 64 65 ArrayRef<Builtin::Info> getTargetBuiltins() const override { return None; } 66 67 BuiltinVaListKind getBuiltinVaListKind() const override { 68 return TargetInfo::VoidPtrBuiltinVaList; 69 } 70 71 const char *getClobbers() const override { return ""; } 72 73 ArrayRef<const char *> getGCCRegNames() const override { 74 static const char *const GCCRegNames[] = { 75 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", 76 "r10", "r11", "r12", "r13", "r14", "r15", "r16", "r17", "r18", "r19", 77 "r20", "r21", "r22", "r23", "r24", "r25", "X", "Y", "Z", "SP"}; 78 return llvm::makeArrayRef(GCCRegNames); 79 } 80 81 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override { 82 return None; 83 } 84 85 ArrayRef<TargetInfo::AddlRegName> getGCCAddlRegNames() const override { 86 static const TargetInfo::AddlRegName AddlRegNames[] = { 87 {{"r26", "r27"}, 26}, 88 {{"r28", "r29"}, 27}, 89 {{"r30", "r31"}, 28}, 90 {{"SPL", "SPH"}, 29}, 91 }; 92 return llvm::makeArrayRef(AddlRegNames); 93 } 94 95 bool validateAsmConstraint(const char *&Name, 96 TargetInfo::ConstraintInfo &Info) const override { 97 // There aren't any multi-character AVR specific constraints. 98 if (StringRef(Name).size() > 1) 99 return false; 100 101 switch (*Name) { 102 default: 103 return false; 104 case 'a': // Simple upper registers 105 case 'b': // Base pointer registers pairs 106 case 'd': // Upper register 107 case 'l': // Lower registers 108 case 'e': // Pointer register pairs 109 case 'q': // Stack pointer register 110 case 'r': // Any register 111 case 'w': // Special upper register pairs 112 case 't': // Temporary register 113 case 'x': 114 case 'X': // Pointer register pair X 115 case 'y': 116 case 'Y': // Pointer register pair Y 117 case 'z': 118 case 'Z': // Pointer register pair Z 119 Info.setAllowsRegister(); 120 return true; 121 case 'I': // 6-bit positive integer constant 122 Info.setRequiresImmediate(0, 63); 123 return true; 124 case 'J': // 6-bit negative integer constant 125 Info.setRequiresImmediate(-63, 0); 126 return true; 127 case 'K': // Integer constant (Range: 2) 128 Info.setRequiresImmediate(2); 129 return true; 130 case 'L': // Integer constant (Range: 0) 131 Info.setRequiresImmediate(0); 132 return true; 133 case 'M': // 8-bit integer constant 134 Info.setRequiresImmediate(0, 0xff); 135 return true; 136 case 'N': // Integer constant (Range: -1) 137 Info.setRequiresImmediate(-1); 138 return true; 139 case 'O': // Integer constant (Range: 8, 16, 24) 140 Info.setRequiresImmediate({8, 16, 24}); 141 return true; 142 case 'P': // Integer constant (Range: 1) 143 Info.setRequiresImmediate(1); 144 return true; 145 case 'R': // Integer constant (Range: -6 to 5) 146 Info.setRequiresImmediate(-6, 5); 147 return true; 148 case 'G': // Floating point constant 149 case 'Q': // A memory address based on Y or Z pointer with displacement. 150 return true; 151 } 152 153 return false; 154 } 155 156 IntType getIntTypeByWidth(unsigned BitWidth, bool IsSigned) const final { 157 // AVR prefers int for 16-bit integers. 158 return BitWidth == 16 ? (IsSigned ? SignedInt : UnsignedInt) 159 : TargetInfo::getIntTypeByWidth(BitWidth, IsSigned); 160 } 161 162 IntType getLeastIntTypeByWidth(unsigned BitWidth, bool IsSigned) const final { 163 // AVR uses int for int_least16_t and int_fast16_t. 164 return BitWidth == 16 165 ? (IsSigned ? SignedInt : UnsignedInt) 166 : TargetInfo::getLeastIntTypeByWidth(BitWidth, IsSigned); 167 } 168 169 bool isValidCPUName(StringRef Name) const override; 170 void fillValidCPUList(SmallVectorImpl<StringRef> &Values) const override; 171 bool setCPU(const std::string &Name) override; 172 StringRef getABI() const override { return ABI; } 173 174 protected: 175 std::string CPU; 176 StringRef ABI; 177 }; 178 179 } // namespace targets 180 } // namespace clang 181 182 #endif // LLVM_CLANG_LIB_BASIC_TARGETS_AVR_H 183