LCOV - code coverage report
Current view: top level - build-llvm/lib/IR - AttributesCompatFunc.inc (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 32 89 36.0 %
Date: 2017-09-14 15:23:50 Functions: 4 5 80.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : #ifdef GET_ATTR_ENUM
       2             : #undef GET_ATTR_ENUM
       3             : Alignment,
       4             : AllocSize,
       5             : AlwaysInline,
       6             : ArgMemOnly,
       7             : Builtin,
       8             : ByVal,
       9             : Cold,
      10             : Convergent,
      11             : Dereferenceable,
      12             : DereferenceableOrNull,
      13             : InAlloca,
      14             : InReg,
      15             : InaccessibleMemOnly,
      16             : InaccessibleMemOrArgMemOnly,
      17             : InlineHint,
      18             : JumpTable,
      19             : MinSize,
      20             : Naked,
      21             : Nest,
      22             : NoAlias,
      23             : NoBuiltin,
      24             : NoCapture,
      25             : NoDuplicate,
      26             : NoImplicitFloat,
      27             : NoInline,
      28             : NoRecurse,
      29             : NoRedZone,
      30             : NoReturn,
      31             : NoUnwind,
      32             : NonLazyBind,
      33             : NonNull,
      34             : OptimizeForSize,
      35             : OptimizeNone,
      36             : ReadNone,
      37             : ReadOnly,
      38             : Returned,
      39             : ReturnsTwice,
      40             : SExt,
      41             : SafeStack,
      42             : SanitizeAddress,
      43             : SanitizeMemory,
      44             : SanitizeThread,
      45             : Speculatable,
      46             : StackAlignment,
      47             : StackProtect,
      48             : StackProtectReq,
      49             : StackProtectStrong,
      50             : StrictFP,
      51             : StructRet,
      52             : SwiftError,
      53             : SwiftSelf,
      54             : UWTable,
      55             : WriteOnly,
      56             : ZExt,
      57             : #endif
      58             : #ifdef GET_ATTR_KIND_FROM_NAME
      59             : #undef GET_ATTR_KIND_FROM_NAME
      60           0 : static Attribute::AttrKind getAttrKindFromName(StringRef AttrName) {
      61           0 :   return StringSwitch<Attribute::AttrKind>(AttrName)
      62           0 :     .Case("align", Attribute::Alignment)
      63           0 :     .Case("allocsize", Attribute::AllocSize)
      64           0 :     .Case("alwaysinline", Attribute::AlwaysInline)
      65           0 :     .Case("argmemonly", Attribute::ArgMemOnly)
      66           0 :     .Case("builtin", Attribute::Builtin)
      67           0 :     .Case("byval", Attribute::ByVal)
      68           0 :     .Case("cold", Attribute::Cold)
      69           0 :     .Case("convergent", Attribute::Convergent)
      70           0 :     .Case("dereferenceable", Attribute::Dereferenceable)
      71           0 :     .Case("dereferenceable_or_null", Attribute::DereferenceableOrNull)
      72           0 :     .Case("inalloca", Attribute::InAlloca)
      73           0 :     .Case("inreg", Attribute::InReg)
      74           0 :     .Case("inaccessiblememonly", Attribute::InaccessibleMemOnly)
      75           0 :     .Case("inaccessiblemem_or_argmemonly", Attribute::InaccessibleMemOrArgMemOnly)
      76           0 :     .Case("inlinehint", Attribute::InlineHint)
      77           0 :     .Case("jumptable", Attribute::JumpTable)
      78           0 :     .Case("minsize", Attribute::MinSize)
      79           0 :     .Case("naked", Attribute::Naked)
      80           0 :     .Case("nest", Attribute::Nest)
      81           0 :     .Case("noalias", Attribute::NoAlias)
      82           0 :     .Case("nobuiltin", Attribute::NoBuiltin)
      83           0 :     .Case("nocapture", Attribute::NoCapture)
      84           0 :     .Case("noduplicate", Attribute::NoDuplicate)
      85           0 :     .Case("noimplicitfloat", Attribute::NoImplicitFloat)
      86           0 :     .Case("noinline", Attribute::NoInline)
      87           0 :     .Case("norecurse", Attribute::NoRecurse)
      88           0 :     .Case("noredzone", Attribute::NoRedZone)
      89           0 :     .Case("noreturn", Attribute::NoReturn)
      90           0 :     .Case("nounwind", Attribute::NoUnwind)
      91           0 :     .Case("nonlazybind", Attribute::NonLazyBind)
      92           0 :     .Case("nonnull", Attribute::NonNull)
      93           0 :     .Case("optsize", Attribute::OptimizeForSize)
      94           0 :     .Case("optnone", Attribute::OptimizeNone)
      95           0 :     .Case("readnone", Attribute::ReadNone)
      96           0 :     .Case("readonly", Attribute::ReadOnly)
      97           0 :     .Case("returned", Attribute::Returned)
      98           0 :     .Case("returns_twice", Attribute::ReturnsTwice)
      99           0 :     .Case("signext", Attribute::SExt)
     100           0 :     .Case("safestack", Attribute::SafeStack)
     101           0 :     .Case("sanitize_address", Attribute::SanitizeAddress)
     102           0 :     .Case("sanitize_memory", Attribute::SanitizeMemory)
     103           0 :     .Case("sanitize_thread", Attribute::SanitizeThread)
     104           0 :     .Case("speculatable", Attribute::Speculatable)
     105           0 :     .Case("alignstack", Attribute::StackAlignment)
     106           0 :     .Case("ssp", Attribute::StackProtect)
     107           0 :     .Case("sspreq", Attribute::StackProtectReq)
     108           0 :     .Case("sspstrong", Attribute::StackProtectStrong)
     109           0 :     .Case("strictfp", Attribute::StrictFP)
     110           0 :     .Case("sret", Attribute::StructRet)
     111           0 :     .Case("swifterror", Attribute::SwiftError)
     112           0 :     .Case("swiftself", Attribute::SwiftSelf)
     113           0 :     .Case("uwtable", Attribute::UWTable)
     114           0 :     .Case("writeonly", Attribute::WriteOnly)
     115           0 :     .Case("zeroext", Attribute::ZExt)
     116           0 :     .Default(Attribute::None);
     117             : }
     118             : 
     119             : #endif
     120             : #ifdef GET_ATTR_COMPAT_FUNC
     121             : #undef GET_ATTR_COMPAT_FUNC
     122             : struct EnumAttr {
     123             :   static bool isSet(const Function &Fn,
     124             :                     Attribute::AttrKind Kind) {
     125      175717 :     return Fn.hasFnAttribute(Kind);
     126             :   }
     127             : 
     128             :   static void set(Function &Fn,
     129             :                   Attribute::AttrKind Kind, bool Val) {
     130             :     if (Val)
     131             :       Fn.addFnAttr(Kind);
     132             :     else
     133             :       Fn.removeFnAttr(Kind);
     134             :   }
     135             : };
     136             : 
     137             : struct StrBoolAttr {
     138      702888 :   static bool isSet(const Function &Fn,
     139             :                     StringRef Kind) {
     140      702888 :     auto A = Fn.getFnAttribute(Kind);
     141     1405776 :     return A.getValueAsString().equals("true");
     142             :   }
     143             : 
     144           4 :   static void set(Function &Fn,
     145             :                   StringRef Kind, bool Val) {
     146           8 :     Fn.addFnAttr(Kind, Val ? "true" : "false");
     147           4 :   }
     148             : };
     149             : 
     150             : // EnumAttr classes
     151             : struct AlignmentAttr : EnumAttr {
     152             :   static enum Attribute::AttrKind getKind() {
     153             :     return llvm::Attribute::Alignment;
     154             :   }
     155             : };
     156             : struct AllocSizeAttr : EnumAttr {
     157             :   static enum Attribute::AttrKind getKind() {
     158             :     return llvm::Attribute::AllocSize;
     159             :   }
     160             : };
     161             : struct AlwaysInlineAttr : EnumAttr {
     162             :   static enum Attribute::AttrKind getKind() {
     163             :     return llvm::Attribute::AlwaysInline;
     164             :   }
     165             : };
     166             : struct ArgMemOnlyAttr : EnumAttr {
     167             :   static enum Attribute::AttrKind getKind() {
     168             :     return llvm::Attribute::ArgMemOnly;
     169             :   }
     170             : };
     171             : struct BuiltinAttr : EnumAttr {
     172             :   static enum Attribute::AttrKind getKind() {
     173             :     return llvm::Attribute::Builtin;
     174             :   }
     175             : };
     176             : struct ByValAttr : EnumAttr {
     177             :   static enum Attribute::AttrKind getKind() {
     178             :     return llvm::Attribute::ByVal;
     179             :   }
     180             : };
     181             : struct ColdAttr : EnumAttr {
     182             :   static enum Attribute::AttrKind getKind() {
     183             :     return llvm::Attribute::Cold;
     184             :   }
     185             : };
     186             : struct ConvergentAttr : EnumAttr {
     187             :   static enum Attribute::AttrKind getKind() {
     188             :     return llvm::Attribute::Convergent;
     189             :   }
     190             : };
     191             : struct DereferenceableAttr : EnumAttr {
     192             :   static enum Attribute::AttrKind getKind() {
     193             :     return llvm::Attribute::Dereferenceable;
     194             :   }
     195             : };
     196             : struct DereferenceableOrNullAttr : EnumAttr {
     197             :   static enum Attribute::AttrKind getKind() {
     198             :     return llvm::Attribute::DereferenceableOrNull;
     199             :   }
     200             : };
     201             : struct InAllocaAttr : EnumAttr {
     202             :   static enum Attribute::AttrKind getKind() {
     203             :     return llvm::Attribute::InAlloca;
     204             :   }
     205             : };
     206             : struct InRegAttr : EnumAttr {
     207             :   static enum Attribute::AttrKind getKind() {
     208             :     return llvm::Attribute::InReg;
     209             :   }
     210             : };
     211             : struct InaccessibleMemOnlyAttr : EnumAttr {
     212             :   static enum Attribute::AttrKind getKind() {
     213             :     return llvm::Attribute::InaccessibleMemOnly;
     214             :   }
     215             : };
     216             : struct InaccessibleMemOrArgMemOnlyAttr : EnumAttr {
     217             :   static enum Attribute::AttrKind getKind() {
     218             :     return llvm::Attribute::InaccessibleMemOrArgMemOnly;
     219             :   }
     220             : };
     221             : struct InlineHintAttr : EnumAttr {
     222             :   static enum Attribute::AttrKind getKind() {
     223             :     return llvm::Attribute::InlineHint;
     224             :   }
     225             : };
     226             : struct JumpTableAttr : EnumAttr {
     227             :   static enum Attribute::AttrKind getKind() {
     228             :     return llvm::Attribute::JumpTable;
     229             :   }
     230             : };
     231             : struct MinSizeAttr : EnumAttr {
     232             :   static enum Attribute::AttrKind getKind() {
     233             :     return llvm::Attribute::MinSize;
     234             :   }
     235             : };
     236             : struct NakedAttr : EnumAttr {
     237             :   static enum Attribute::AttrKind getKind() {
     238             :     return llvm::Attribute::Naked;
     239             :   }
     240             : };
     241             : struct NestAttr : EnumAttr {
     242             :   static enum Attribute::AttrKind getKind() {
     243             :     return llvm::Attribute::Nest;
     244             :   }
     245             : };
     246             : struct NoAliasAttr : EnumAttr {
     247             :   static enum Attribute::AttrKind getKind() {
     248             :     return llvm::Attribute::NoAlias;
     249             :   }
     250             : };
     251             : struct NoBuiltinAttr : EnumAttr {
     252             :   static enum Attribute::AttrKind getKind() {
     253             :     return llvm::Attribute::NoBuiltin;
     254             :   }
     255             : };
     256             : struct NoCaptureAttr : EnumAttr {
     257             :   static enum Attribute::AttrKind getKind() {
     258             :     return llvm::Attribute::NoCapture;
     259             :   }
     260             : };
     261             : struct NoDuplicateAttr : EnumAttr {
     262             :   static enum Attribute::AttrKind getKind() {
     263             :     return llvm::Attribute::NoDuplicate;
     264             :   }
     265             : };
     266             : struct NoImplicitFloatAttr : EnumAttr {
     267             :   static enum Attribute::AttrKind getKind() {
     268             :     return llvm::Attribute::NoImplicitFloat;
     269             :   }
     270             : };
     271             : struct NoInlineAttr : EnumAttr {
     272             :   static enum Attribute::AttrKind getKind() {
     273             :     return llvm::Attribute::NoInline;
     274             :   }
     275             : };
     276             : struct NoRecurseAttr : EnumAttr {
     277             :   static enum Attribute::AttrKind getKind() {
     278             :     return llvm::Attribute::NoRecurse;
     279             :   }
     280             : };
     281             : struct NoRedZoneAttr : EnumAttr {
     282             :   static enum Attribute::AttrKind getKind() {
     283             :     return llvm::Attribute::NoRedZone;
     284             :   }
     285             : };
     286             : struct NoReturnAttr : EnumAttr {
     287             :   static enum Attribute::AttrKind getKind() {
     288             :     return llvm::Attribute::NoReturn;
     289             :   }
     290             : };
     291             : struct NoUnwindAttr : EnumAttr {
     292             :   static enum Attribute::AttrKind getKind() {
     293             :     return llvm::Attribute::NoUnwind;
     294             :   }
     295             : };
     296             : struct NonLazyBindAttr : EnumAttr {
     297             :   static enum Attribute::AttrKind getKind() {
     298             :     return llvm::Attribute::NonLazyBind;
     299             :   }
     300             : };
     301             : struct NonNullAttr : EnumAttr {
     302             :   static enum Attribute::AttrKind getKind() {
     303             :     return llvm::Attribute::NonNull;
     304             :   }
     305             : };
     306             : struct OptimizeForSizeAttr : EnumAttr {
     307             :   static enum Attribute::AttrKind getKind() {
     308             :     return llvm::Attribute::OptimizeForSize;
     309             :   }
     310             : };
     311             : struct OptimizeNoneAttr : EnumAttr {
     312             :   static enum Attribute::AttrKind getKind() {
     313             :     return llvm::Attribute::OptimizeNone;
     314             :   }
     315             : };
     316             : struct ReadNoneAttr : EnumAttr {
     317             :   static enum Attribute::AttrKind getKind() {
     318             :     return llvm::Attribute::ReadNone;
     319             :   }
     320             : };
     321             : struct ReadOnlyAttr : EnumAttr {
     322             :   static enum Attribute::AttrKind getKind() {
     323             :     return llvm::Attribute::ReadOnly;
     324             :   }
     325             : };
     326             : struct ReturnedAttr : EnumAttr {
     327             :   static enum Attribute::AttrKind getKind() {
     328             :     return llvm::Attribute::Returned;
     329             :   }
     330             : };
     331             : struct ReturnsTwiceAttr : EnumAttr {
     332             :   static enum Attribute::AttrKind getKind() {
     333             :     return llvm::Attribute::ReturnsTwice;
     334             :   }
     335             : };
     336             : struct SExtAttr : EnumAttr {
     337             :   static enum Attribute::AttrKind getKind() {
     338             :     return llvm::Attribute::SExt;
     339             :   }
     340             : };
     341             : struct SafeStackAttr : EnumAttr {
     342             :   static enum Attribute::AttrKind getKind() {
     343             :     return llvm::Attribute::SafeStack;
     344             :   }
     345             : };
     346             : struct SanitizeAddressAttr : EnumAttr {
     347             :   static enum Attribute::AttrKind getKind() {
     348             :     return llvm::Attribute::SanitizeAddress;
     349             :   }
     350             : };
     351             : struct SanitizeMemoryAttr : EnumAttr {
     352             :   static enum Attribute::AttrKind getKind() {
     353             :     return llvm::Attribute::SanitizeMemory;
     354             :   }
     355             : };
     356             : struct SanitizeThreadAttr : EnumAttr {
     357             :   static enum Attribute::AttrKind getKind() {
     358             :     return llvm::Attribute::SanitizeThread;
     359             :   }
     360             : };
     361             : struct SpeculatableAttr : EnumAttr {
     362             :   static enum Attribute::AttrKind getKind() {
     363             :     return llvm::Attribute::Speculatable;
     364             :   }
     365             : };
     366             : struct StackAlignmentAttr : EnumAttr {
     367             :   static enum Attribute::AttrKind getKind() {
     368             :     return llvm::Attribute::StackAlignment;
     369             :   }
     370             : };
     371             : struct StackProtectAttr : EnumAttr {
     372             :   static enum Attribute::AttrKind getKind() {
     373             :     return llvm::Attribute::StackProtect;
     374             :   }
     375             : };
     376             : struct StackProtectReqAttr : EnumAttr {
     377             :   static enum Attribute::AttrKind getKind() {
     378             :     return llvm::Attribute::StackProtectReq;
     379             :   }
     380             : };
     381             : struct StackProtectStrongAttr : EnumAttr {
     382             :   static enum Attribute::AttrKind getKind() {
     383             :     return llvm::Attribute::StackProtectStrong;
     384             :   }
     385             : };
     386             : struct StrictFPAttr : EnumAttr {
     387             :   static enum Attribute::AttrKind getKind() {
     388             :     return llvm::Attribute::StrictFP;
     389             :   }
     390             : };
     391             : struct StructRetAttr : EnumAttr {
     392             :   static enum Attribute::AttrKind getKind() {
     393             :     return llvm::Attribute::StructRet;
     394             :   }
     395             : };
     396             : struct SwiftErrorAttr : EnumAttr {
     397             :   static enum Attribute::AttrKind getKind() {
     398             :     return llvm::Attribute::SwiftError;
     399             :   }
     400             : };
     401             : struct SwiftSelfAttr : EnumAttr {
     402             :   static enum Attribute::AttrKind getKind() {
     403             :     return llvm::Attribute::SwiftSelf;
     404             :   }
     405             : };
     406             : struct UWTableAttr : EnumAttr {
     407             :   static enum Attribute::AttrKind getKind() {
     408             :     return llvm::Attribute::UWTable;
     409             :   }
     410             : };
     411             : struct WriteOnlyAttr : EnumAttr {
     412             :   static enum Attribute::AttrKind getKind() {
     413             :     return llvm::Attribute::WriteOnly;
     414             :   }
     415             : };
     416             : struct ZExtAttr : EnumAttr {
     417             :   static enum Attribute::AttrKind getKind() {
     418             :     return llvm::Attribute::ZExt;
     419             :   }
     420             : };
     421             : 
     422             : // StrBoolAttr classes
     423             : struct LessPreciseFPMADAttr : StrBoolAttr {
     424             :   static StringRef getKind() {
     425       87867 :     return "less-precise-fpmad";
     426             :   }
     427             : };
     428             : struct NoInfsFPMathAttr : StrBoolAttr {
     429             :   static StringRef getKind() {
     430       87861 :     return "no-infs-fp-math";
     431             :   }
     432             : };
     433             : struct NoJumpTablesAttr : StrBoolAttr {
     434             :   static StringRef getKind() {
     435      175720 :     return "no-jump-tables";
     436             :   }
     437             : };
     438             : struct NoNansFPMathAttr : StrBoolAttr {
     439             :   static StringRef getKind() {
     440       87861 :     return "no-nans-fp-math";
     441             :   }
     442             : };
     443             : struct ProfileSampleAccurateAttr : StrBoolAttr {
     444             :   static StringRef getKind() {
     445      175722 :     return "profile-sample-accurate";
     446             :   }
     447             : };
     448             : struct UnsafeFPMathAttr : StrBoolAttr {
     449             :   static StringRef getKind() {
     450       87861 :     return "unsafe-fp-math";
     451             :   }
     452             : };
     453             : 
     454      353222 : static inline bool hasCompatibleFnAttrs(const Function &Caller,
     455             :                                         const Function &Callee) {
     456      353222 :   bool Ret = true;
     457             : 
     458      353222 :   Ret &= isEqual<SanitizeAddressAttr>(Caller, Callee);
     459      353222 :   Ret &= isEqual<SanitizeThreadAttr>(Caller, Callee);
     460      353222 :   Ret &= isEqual<SanitizeMemoryAttr>(Caller, Callee);
     461      353222 :   Ret &= isEqual<SafeStackAttr>(Caller, Callee);
     462             : 
     463      353222 :   return Ret;
     464             : }
     465             : 
     466       87861 : static inline void mergeFnAttrs(Function &Caller,
     467             :                                 const Function &Callee) {
     468       87861 :   setOR<ProfileSampleAccurateAttr>(Caller, Callee);
     469       87861 :   adjustCallerSSPLevel(Caller, Callee);
     470       87861 :   adjustCallerStackProbes(Caller, Callee);
     471       87861 :   adjustCallerStackProbeSize(Caller, Callee);
     472       87861 :   setAND<LessPreciseFPMADAttr>(Caller, Callee);
     473       87861 :   setAND<NoInfsFPMathAttr>(Caller, Callee);
     474       87861 :   setAND<NoNansFPMathAttr>(Caller, Callee);
     475       87861 :   setAND<UnsafeFPMathAttr>(Caller, Callee);
     476       87861 :   setOR<NoImplicitFloatAttr>(Caller, Callee);
     477       87861 :   setOR<NoJumpTablesAttr>(Caller, Callee);
     478       87861 : }
     479             : 
     480             : #endif

Generated by: LCOV version 1.13