reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

    1
    2
    3
    4
    5
    6
    7
    8
    9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93

// RUN: %clang_analyze_cc1 -analyzer-checker=core,osx.coreFoundation.CFRetainRelease,osx.cocoa.RetainCount -verify %s
// RUN: %clang_analyze_cc1 -analyzer-checker=core,osx.coreFoundation.CFRetainRelease,osx.cocoa.RetainCount -analyzer-inline-max-stack-depth=0 -verify %s

#pragma clang arc_cf_code_audited begin
typedef const void * CFTypeRef;
extern CFTypeRef CFRetain(CFTypeRef cf);
extern void CFRelease(CFTypeRef cf);
#pragma clang arc_cf_code_audited end

#define CF_RETURNS_RETAINED __attribute__((cf_returns_retained))
#define CF_CONSUMED __attribute__((cf_consumed))

extern CFTypeRef CFCreate() CF_RETURNS_RETAINED;

// A "safe" variant of CFRetain that doesn't crash when a null pointer is
// retained. This is often defined by users in a similar manner. The
// CF_RETURNS_RETAINED annotation is misleading here, because the function
// is not supposed to return an object with a +1 retain count. Instead, it
// is supposed to return an object with +(N+1) retain count, where N is
// the original retain count of 'cf'. However, there is no good annotation
// to use in this case, and it is pointless to provide such annotation
// because the only use cases would be CFRetain and SafeCFRetain.
// So instead we teach the analyzer to be able to accept such code
// and ignore the misplaced annotation.
CFTypeRef SafeCFRetain(CFTypeRef cf) CF_RETURNS_RETAINED {
  if (cf) {
    return CFRetain(cf);
  }
  return cf;
}

// A "safe" variant of CFRelease that doesn't crash when a null pointer is
// released. The CF_CONSUMED annotation seems reasonable here.
void SafeCFRelease(CFTypeRef CF_CONSUMED cf) {
  if (cf)
    CFRelease(cf); // no-warning (when inlined)
}

// The same thing, just with a different naming style.
CFTypeRef retainCFType(CFTypeRef cf) CF_RETURNS_RETAINED {
  if (cf) {
    return CFRetain(cf);
  }
  return cf;
}

void releaseCFType(CFTypeRef CF_CONSUMED cf) {
  if (cf)
    CFRelease(cf); // no-warning (when inlined)
}

void escape(CFTypeRef cf);

void makeSureTestsWork() {
  CFTypeRef cf = CFCreate();
  CFRelease(cf);
  CFRelease(cf); // expected-warning{{Reference-counted object is used after it is released}}
}

// Make sure we understand that the second SafeCFRetain doesn't return an
// object with +1 retain count, which we won't be able to release twice.
void falseOverrelease(CFTypeRef cf) {
  SafeCFRetain(cf);
  SafeCFRetain(cf);
  SafeCFRelease(cf);
  SafeCFRelease(cf); // no-warning after inlining this.
}

// Regular CFRelease() should behave similarly.
void sameWithNormalRelease(CFTypeRef cf) {
  SafeCFRetain(cf);
  SafeCFRetain(cf);
  CFRelease(cf);
  CFRelease(cf); // no-warning
}

// Make sure we understand that the second SafeCFRetain doesn't return an
// object with +1 retain count, which would no longer be owned by us after
// it escapes to escape() and released once.
void falseReleaseNotOwned(CFTypeRef cf) {
  SafeCFRetain(cf);
  SafeCFRetain(cf);
  escape(cf);
  SafeCFRelease(cf);
  SafeCFRelease(cf); // no-warning after inlining this.
}

void testTheOtherNamingConvention(CFTypeRef cf) {
  retainCFType(cf);
  retainCFType(cf);
  releaseCFType(cf);
  releaseCFType(cf); // no-warning
}