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

Generated by: LCOV version 1.13