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

Generated by: LCOV version 1.13