[analyzer] Implement a prototype checker for detecting Year 2038 related issues.

[appcs]

Summary

Defines a prototype checker in the Clang Static Analyzer for proper definition/use of time.h related functionality. The intention for this work is to audit user code for identifying potential issues in the light of the "Year 2038" (aka: "Y2K38") problem.

Checks implemented:

0. Warn if the time_t type is not defined to be a signed integer type, at-least 64-bits in size, having file scope. When the size of the time_t type is less than 64-bits, report the actual size in the warning.

1. Warn when a time_t value is cast to: a. A non-integer type. b. An integer type of lesser width. c. An unsigned integer type.

[appcs]

Thank you very much for the feedback. I have added a little functionality to demonstrate the working of a prototype checker for a some sample Y2K38 issues. There are some TODO's in the test files indicative of some subsequent checking that we will add.

[Szelethus]

That is nice! I love the doc you put up there, I wish every checker had something like that.

If you don't mind, I'll add the [analyzer] tag to your title and reword it a bit. Many of us use Herald to automatically subscribe to revisions that has analyzer in the title name. This is the case here, but [analyzer].* is preferred.

edit: I realized what I wrote here was wrong, so I removed it. Oops :)

edit2.: I wonder whether you could turn this into a simple clang-tidy check.

include/clang/StaticAnalyzer/Checkers/Checkers.td

526

Are you planning to add more time.h related functionality? If not, maybe you could specialize this description, explicitly mentioning the Y2K38 problem.

Buuuuut mentioning would be great idea anyways, because this is a little vague just yet.

lib/StaticAnalyzer/Checkers/TimeChecker.cpp

73

IdentifierInfo actually has a handy isStr method.
T.getBaseTypeIdentifier()->isStr("time_t")

Little bit of shooting in the dark, but, as far as I'm aware, QualType::getAsString has all the sugar and typedef you want to get rid of, but IdentifierInfo::getName() (which is used in isStr() too) is stripped of that.

97

QualType is essentially a wrapper around Type, and can be used similarly to a smart pointer. For example, if you'd like to know that a type is an integer type, you can just do:

QualType T = /* whatever */;
if (T->isIntegerType())
  doStuff();

Prefer QualType::isNull() to checking QualType::getTypePtr().

There are very few cases where you actually need to obtain the underlaying Type.

This is used in a lot of places in your code, but I'll only mention it here, just grep getTypePtr :).

103

Use early exit.
https://llvm.org/docs/CodingStandards.html#use-early-exits-and-continue-to-simplify-code

109–110

Variables should start with a capital letter. (not just here)
https://llvm.org/docs/CodingStandards.html#name-types-functions-variables-and-enumerators-properly

109–110

Why not reuse the string and the stream object outside this block? You have the same 2 lines of code in 3 branches.

211–220

Can you put this on top of the file? AFAIK as much as ODR lets it, usually checker classes are up there.

test/Analysis/TimeChecker-0.c

1–3

Is there a need for this file? Never seen anything like it (didn't look super hard though).

test/Analysis/TimeChecker-1.c

1

1. Prefer %clang_analyze_cc1 to %clang + -Xclang's
2. Always run core checkers too. -analyzer-checker=core,alpha.unix.Time
3. You can actually use newlines to organize the RUN line, although this could just fit into 80 columns.

Sooo:

// RUN: %clang_analyze_cc1 -analyzer-checker=core,alpha.unix.Time \
// RUN:   -verify %s

[george.karpenkov]

test/Analysis/TimeChecker-1.c

1

@Szelethus your second point is actually not correct for syntactic checkers.

test/Analysis/TimeChecker-11.c

7

If those are "TODO", should the patch be marked as "[WIP]"?

[Szelethus]

test/Analysis/TimeChecker-1.c

1

Oops, sorry about that.

[appcs]

test/Analysis/TimeChecker-11.c

7

The TODO are out of the scope of this prototype patch - (which is not WIP) - I put them in because we wanted a sense of where this checker is headed; I'll take them out as a part of the overall edit based on the feedback so far, for the re-spin. Thanks.

[appcs]

Incorporated code review feedback; thank you @Szelethus and @george.karpenkov

[appcs]

lib/StaticAnalyzer/Checkers/TimeChecker.cpp

64

PS: Moved class TimeChecker up here; (kindly explain the term 'ODR', thank you).

73

Also: T.getAsString() == T.getBaseTypeIdentifier()->getName().str()

97

Eliminated all uses of getTypePtr()

test/Analysis/TimeChecker-0.c

1–3

Done; Renamed TimeChecker-<i>.c to TimeChecker-<i-1>.c; Added:TimeChecker-12.c

test/Analysis/TimeChecker-1.c

1

Was 80 columns after change

test/Analysis/TimeChecker-11.c

7

Removed all TODO's (those warning messages will appear in subsequent functionality).

[Szelethus]

lib/StaticAnalyzer/Checkers/TimeChecker.cpp

64

Sorry about that O:) One Definition Rule: https://en.wikipedia.org/wiki/One_Definition_Rule

[appcs]

lib/StaticAnalyzer/Checkers/TimeChecker.cpp

64

Thank you; understood the ODR. However, I am not able to get the implication of the ODR on the placement of the class TimeChecker - sorry, if I am missing something basic here - please let me know. Is the placement of the TimeChecker class as you expected it? (If so, is this patch good to commit?) Thank you!

[Szelethus]

lib/StaticAnalyzer/Checkers/TimeChecker.cpp

64

In my checker (UninitializedObject), if I recall correctly, the checker class uses some types I need to define earlier, so I can't place it on top of the file because of that.

My point basically was that try to keep declarations on top, definitions below that. Your solution is perfect imo.

I'll revisit this patch shorty, but I'm a bit busy at the moment :)

[appcs]

lib/StaticAnalyzer/Checkers/TimeChecker.cpp

64

Thank you, yes, I understand and will bear in mind the point about declarations on top and definitions beneath. Appreciate your help very much, thank you.

[Szelethus]

Let's talk about more general topics: Your checker's name is "TimeChecker", not "Y2K38Checker" or something similar, do you have plans on expanding this checker to cover more time.h related functionality?

[appcs]

In D53185#1284536, @Szelethus wrote:

Let's talk about more general topics: Your checker's name is "TimeChecker", not "Y2K38Checker" or something similar, do you have plans on expanding this checker to cover more time.h related functionality?

Yes, going forward, I plan to detect general indications of use of improperly implemented time.h functionality or improper use of time.h facility, e.g.:

• Warn if a typedef for time_t does not come from a header file with the standard header name: 'time.h'
• Warn if a typedef for the time_t type is not found in the translation unit.
• Verify time.h function signatures.
• Not using double difftime(time_t time1, time_t time0) to find the time difference between time1 and time0. ...
  
  While Y2K38 is the immediate problem needing addressing and the motivation for taking a closer look at time_t usage in one's program, the idea is to be sure of using time.h facility correctly and fully, in general; while at it. Also, vice-versa, if the user is checking their usage of time.h related functionality, then now is the time to act on any lurking Y2K38 issues. I imagine that there is analysis to be developed, modeled on how a user would trace through their time_t values (def and use) as they debug issues, so that the TimeChecker makes inferences that the user would eventually make.

[Szelethus]

In D53185#1284790, @appcs wrote:

In D53185#1284536, @Szelethus wrote:

Let's talk about more general topics: Your checker's name is "TimeChecker", not "Y2K38Checker" or something similar, do you have plans on expanding this checker to cover more time.h related functionality?

Yes, going forward, I plan to detect general indications of use of improperly implemented time.h functionality or improper use of time.h facility, e.g.:

• Warn if a typedef for time_t does not come from a header file with the standard header name: 'time.h'
• Warn if a typedef for the time_t type is not found in the translation unit.
• Verify time.h function signatures.
• Not using double difftime(time_t time1, time_t time0) to find the time difference between time1 and time0. ...
  
  While Y2K38 is the immediate problem needing addressing and the motivation for taking a closer look at time_t usage in one's program, the idea is to be sure of using time.h facility correctly and fully, in general; while at it. Also, vice-versa, if the user is checking their usage of time.h related functionality, then now is the time to act on any lurking Y2K38 issues. I imagine that there is analysis to be developed, modeled on how a user would trace through their time_t values (def and use) as they debug issues, so that the TimeChecker makes inferences that the user would eventually make.

I'm sadly not an expert on this particular topic, but it sounds good to me! The main reason why I asked this question is that I was curious whether you only do AST based analysis, and it seems to me that you do. A natural question that arises with AST based checkers is whether a simpler clang-tidy check could do the job just as well. Were there any particular reasons why you picked the static analyzer instead?

I realize that I should've asked this question before a barrage of lower lever observations :/ I'm not at all saying that this patch should be remade, please don't get me wrong, but in any case, sorry about this, certainly a lesson for me too on how I should leave feedback on patches.

[appcs]

ping

[Szelethus]

Sorry, I wasn't aware you're looking for more feedback. Feel free to ping once a week.

I have two questions.

1. As I've stated before, have you looked into the possibility of doing a clang-tidy check?
2. Is there any particular reason behind using RecursiveASTVisitor, as opposed to AST matchers?

[NoQ]

I think the idea is great, thanks!

One important thing to notice here is that it seems that time_t is allowed to be a float/double in C11 and is unspecified in C++ (i.e., might as well be a struct). So i suspect that we can't really ban these types entirely. But having it to be an integer type that's too small is definitely bad.

Another thing to think about eventually is how much of this checker can be enabled by default and how much can only be opt-in. For instance, how many projects define their own time_t in a valid manner for good reasons and therefore don't want our advice on where to put it?

Also feel free to make a new directory for your tests in test/Analysis/... and give files within it expressive names.

I have a few minor comments and i think we can land an alpha version so that to unblock your further work.

lib/StaticAnalyzer/Checkers/TimeChecker.cpp

120

Do we care about vector types here? Maybe stick to the usual isIntegerType()/isSignedIntegerType()/isUnsignedIntegerType()?

159

Why is this considered to be a bug?

In particular, i don't see anything wrong with casting time_t to double or with casting it to void (which is a common way of suppressing "unused variable" or "unused return value" warnings).

180

For "file scope", i'd try something like isa<TranslationUnitDecl>(TD->getDeclContext()). That'll include typedefs within classes and namespaces.

[appcs]

Thank you @Szelethus for the guidance. Thank you @NoQ for further input. Please see inline:

In D53185#1322212, @NoQ wrote:

I think the idea is great, thanks!

Thank you!

One important thing to notice here is that it seems that time_t is allowed to be a float/double in C11 and is unspecified in C++ (i.e., might as well be a struct). So i suspect that we can't really ban these types entirely. But having it to be an integer type that's too small is definitely bad.

I'll relax the constraint so that when time_t is defined to be an integer type, it must be at least 64-bits. I'll add tests so that when C11, it does not complain on 'float'/'double' and also so that when C++, I'll add tests that ensure that it does not complain about whatever (variety of) type is used to define time_t.

Another thing to think about eventually is how much of this checker can be enabled by default and how much can only be opt-in. For instance, how many projects define their own time_t in a valid manner for good reasons and therefore don't want our advice on where to put it?

Sure, keeping some behaviour default and some of it opt-in will make it more usable; we'll do that eventually.

Also feel free to make a new directory for your tests in test/Analysis/... and give files within it expressive names.

Will do.

I have a few minor comments and i think we can land an alpha version so that to unblock your further work.

Will re-spin along with the above and the other three review feedback comments for TimeChecker.cpp

Thank you, so much!

include/clang/StaticAnalyzer/Checkers/Checkers.td

 def SimpleStreamChecker : Checker<"SimpleStream">,
   HelpText<"Check for misuses of stream APIs">,
   DescFile<"SimpleStreamChecker.cpp">;
 
 def BlockInCriticalSectionChecker : Checker<"BlockInCriticalSection">,
   HelpText<"Check for calls to blocking functions inside a critical section">,
   DescFile<"BlockInCriticalSectionChecker.cpp">;
 
+def TimeChecker : Checker<"Time">,
+  HelpText<"Check time.h related functionality">,
+  DescFile<"TimeChecker.cpp">;
+
 } // end "alpha.unix"
 
 let ParentPackage = CString in {
 
 def CStringNullArg : Checker<"NullArg">,
   HelpText<"Check for null pointers being passed as arguments to C string functions">,
   DescFile<"CStringChecker.cpp">;
 

lib/StaticAnalyzer/Checkers/CMakeLists.txt

add_clang_library(clangStaticAnalyzerCheckers
   ReturnUndefChecker.cpp
   RunLoopAutoreleaseLeakChecker.cpp
   SimpleStreamChecker.cpp
   StackAddrEscapeChecker.cpp
   StdLibraryFunctionsChecker.cpp
   StreamChecker.cpp
   TaintTesterChecker.cpp
   TestAfterDivZeroChecker.cpp
+  TimeChecker.cpp
   TraversalChecker.cpp
   TrustNonnullChecker.cpp
   UndefBranchChecker.cpp
   UndefCapturedBlockVarChecker.cpp
   UndefResultChecker.cpp
   UndefinedArraySubscriptChecker.cpp
   UndefinedAssignmentChecker.cpp
   UninitializedObject/UninitializedObjectChecker.cpp

lib/StaticAnalyzer/Checkers/TimeChecker.cpp

+//===-- TimeChecker.cpp -------------------------------------------*- C++ -*--//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Defines a checker for proper definition/use of time.h related functionality.
+//
+// Reference used:
+//
+//  ISO/IEC 9899:TC3 Committee Draft - September 7, 2007 WG14/N1256
+//  http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1256.pdf
+//  Section 7.23 Date and time <time.h>
+//
+// The intention for this work is to audit user code for identifying potential
+// issues in the light of the "Year 2038" (aka: "Y2K38") problem.
+//
+// Checks implemented:
+//
+// 0. Warn if the time_t type is not defined to be a signed integer type,
+//    at-least 64-bits in size, having file scope. (When the size of the time_t
+//    type is less than 64-bits, report the actual size in the warning).
+//
+// 1. Warn when a time_t value is cast to:
+//    a. A non-integer type
+//    b. An integer type of lesser width
+//    c. An unsigned integer type
+//
+//===----------------------------------------------------------------------===//
+
+#include "ClangSACheckers.h"
+#include "clang/AST/RecursiveASTVisitor.h"
+#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
+#include "clang/StaticAnalyzer/Core/Checker.h"
+#include "clang/StaticAnalyzer/Core/CheckerManager.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
+
+using namespace clang;
+using namespace ento;
+
+namespace {
+class TimeVisitor : public RecursiveASTVisitor<TimeVisitor> {
+  BugReporter &BR;
+  const CheckerBase *Checker;
+  AnalysisDeclContext *AC;
+
+  bool hasTimeTypeSynonym(QualType T);
+
+public:
+  explicit TimeVisitor(BugReporter &B, const CheckerBase *Checker,
+                       AnalysisDeclContext *A)
+      : BR(B), Checker(Checker), AC(A) {}
+
+  bool VisitCastExpr(const CastExpr *CE);
+  bool VisitTypedefNameDecl(const TypedefNameDecl *TD);
+};
+} // namespace
+
+/// Peel through layers of typedefs, to check if there's a time_t type in there
+/// somewhere.
+bool TimeVisitor::hasTimeTypeSynonym(QualType T) {
+
+  const Type *TPtr = nullptr;
+  const TypedefType *TDPtr = nullptr;
+
+  while ((TPtr = T.getTypePtr()) && (TDPtr = dyn_cast<TypedefType>(TPtr)) &&
+         TDPtr->isSugared()) {
+
+    if (T.getBaseTypeIdentifier() &&
+        (T.getBaseTypeIdentifier()->getName().str() == "time_t"))
+      return true;
+    else
+      T = TDPtr->desugar();
+  }
+
+  return false;
+}
+
+/// Audit cast-expressions on a time_t value.
+bool TimeVisitor::VisitCastExpr(const CastExpr *CE) {
+
+  if (!CE)
+    return true;
+
+  ASTContext &Ctx = AC->getASTContext();
+  const Expr *E = CE->getSubExpr();
+
+  if (!E)
+    return true;
+
+  QualType ToTy = Ctx.getCanonicalType(CE->getType());
+  QualType OrigTy = Ctx.getCanonicalType(E->getType());
+
+  if (!OrigTy.getTypePtr() || !ToTy.getTypePtr())
+    return true;
+
+  if (!OrigTy.getTypePtr()->isIntegerType())
+    return true;
+
+  if (hasTimeTypeSynonym(E->getType())) {
+
+    if (ToTy.getTypePtr()->hasIntegerRepresentation()) {
+
+      if (Ctx.getIntWidth(CE->getType()) < Ctx.getIntWidth(E->getType())) {
+
+        SmallString<128> buf;
+        llvm::raw_svector_ostream output(buf);
+
+        output << "Y2K38 Issue: ";
+        output << (dyn_cast<ExplicitCastExpr>(CE) ? "Explicit" : "Implicit");
+        output << " cast of time_t value to a type of lesser width";
+
+        SourceRange Sr[1] = {CE->getSourceRange()};
+        PathDiagnosticLocation Loc(CE, BR.getSourceManager(), AC);
+        BR.EmitBasicReport(
+            AC->getDecl(), Checker,
+            "Y2K38 Issue: Cast of time_t value to a type of lesser width",
+            categories::LogicError, output.str(), Loc, Sr);
+      }
+
+      if (!ToTy.getTypePtr()->hasSignedIntegerRepresentation()) {
+
+        SmallString<128> buf;
+        llvm::raw_svector_ostream output(buf);
+
+        output << "Y2K38 Issue: ";
+        output << (dyn_cast<ExplicitCastExpr>(CE) ? "Explicit" : "Implicit");
+        output << " cast of time_t value to an unsigned type";
+
+        SourceRange Sr[1] = {E->getSourceRange()};
+        PathDiagnosticLocation Loc(E, BR.getSourceManager(), AC);
+        BR.EmitBasicReport(
+            AC->getDecl(), Checker,
+            "Y2K38 Issue: Cast of time_t value to an unsigned type",
+            categories::LogicError, output.str(), Loc, Sr);
+      }
+    } else {
+
+      SmallString<128> buf;
+      llvm::raw_svector_ostream output(buf);
+
+      output << "Y2K38 Issue: ";
+      output << (dyn_cast<ExplicitCastExpr>(CE) ? "Explicit" : "Implicit");
+      output << " cast of time_t value to a non-integer type";
+
+      SourceRange Sr[1] = {E->getSourceRange()};
+      PathDiagnosticLocation Loc(E, BR.getSourceManager(), AC);
+      BR.EmitBasicReport(
+          AC->getDecl(), Checker,
+          "Y2K38 Issue: Cast of time_t value to a non-integer type",
+          categories::LogicError, output.str(), Loc, Sr);
+    }
+  }
+
+  return true;
+}
+
+/// Audit typedef's on the time_t type.
+bool TimeVisitor::VisitTypedefNameDecl(const TypedefNameDecl *TD) {
+
+  if (!TD)
+    return true;
+
+  ASTContext &Ctx = AC->getASTContext();
+
+  if (TD->getName().str() == "time_t") {
+
+    QualType T = TD->getUnderlyingType();
+    if (!T.getTypePtr()->isIntegerType() ||
+        !T.getTypePtr()->hasSignedIntegerRepresentation() ||
+        Ctx.getIntWidth(T) < 64 /* bits */ ||
+        TD->isLexicallyWithinFunctionOrMethod()) {
+      SourceRange Sr[1] = {TD->getSourceRange()};
+      PathDiagnosticLocation Loc(TD, BR.getSourceManager());
+      BR.EmitBasicReport(
+          AC->getDecl(), Checker, "Y2K38 Issue: time_t incorrectly defined",
+          categories::LogicError,
+          "Y2K38 Issue: time_t expected to be a signed "
+          "integer type, at-least 64-bits in size, having file scope",
+          Loc, Sr);
+    }
+    if (TD->isLexicallyWithinFunctionOrMethod()) {
+      SourceRange Sr[1] = {TD->getSourceRange()};
+      PathDiagnosticLocation Loc(TD, BR.getSourceManager());
+      BR.EmitBasicReport(
+          AC->getDecl(), Checker, "Y2K38 Issue: time_t incorrectly defined",
+          categories::LogicError,
+          "Y2K38 Issue: time_t declaration is local to function", Loc, Sr);
+    }
+    if (Ctx.getIntWidth(T) < 64 /* bits */) {
+
+      SmallString<128> buf;
+      llvm::raw_svector_ostream output(buf);
+
+      output << "Y2K38 Issue: time_t size is " << Ctx.getIntWidth(T) << " bits";
+
+      SourceRange Sr[1] = {TD->getSourceRange()};
+      PathDiagnosticLocation Loc(TD, BR.getSourceManager());
+      BR.EmitBasicReport(AC->getDecl(), Checker,
+                         "Y2K38 Issue: time_t incorrectly defined",
+                         categories::LogicError, output.str(), Loc, Sr);
+    }
+  }
+
+  return true;
+}
+
+namespace {
+class TimeChecker : public Checker<check::ASTDecl<TranslationUnitDecl>> {
+public:
+  void checkASTDecl(const Decl *D, AnalysisManager &Mgr,
+                    BugReporter &BR) const {
+    TimeVisitor Visitor(BR, this, Mgr.getAnalysisDeclContext(D));
+    Visitor.TraverseDecl(const_cast<Decl *>(D));
+  }
+};
+} // end anonymous namespace
+
+void ento::registerTimeChecker(CheckerManager &mgr) {
+  mgr.registerChecker<TimeChecker>();
+}

test/Analysis/TimeChecker-0.c

+// RUN: %clang_cc1 -analyzer-checker-help | FileCheck %s
+
+CHECK: alpha.unix.Time Check time.h related functionality

test/Analysis/TimeChecker-1.c

+// RUN: %clang --analyze -Xclang -analyzer-checker=alpha.unix.Time -Xclang -verify %s
+
+typedef signed char int8_t;
+
+typedef long int __time_t;
+typedef __time_t time_t;
+// TODO: EXPECTED-WARNING-RE@9 {{Y2K38 Issue: The type 'time_t' is defined in file '{{(.*)}}/TimeChecker-1.c' which has a non-standard name; expected to see type 'time_t' defined in standard header named: 'time.h'}}
+
+int8_t ImplicitCastOnVar(void) {
+
+ time_t t = 0;
+
+ return t; // expected-warning {{Y2K38 Issue: Implicit cast of time_t value to a type of lesser width}}
+}
+
+int8_t ImplicitCastOnVal(void) {
+
+ return ((time_t) 0); // expected-warning {{Y2K38 Issue: Implicit cast of time_t value to a type of lesser width}}
+}
+
+_Bool Bad10E(void) {
+
+ time_t t = 0;
+
+ return (_Bool) t;
+ // expected-warning@25 {{Y2K38 Issue: Explicit cast of time_t value to a type of lesser width}}
+ // expected-warning@25 {{Y2K38 Issue: Explicit cast of time_t value to an unsigned type}}
+}
+
+_Bool Bad10I(void) {
+
+ time_t t = 0;
+
+ return t;
+ // expected-warning@34 {{Y2K38 Issue: Implicit cast of time_t value to a type of lesser width}}
+ // expected-warning@34 {{Y2K38 Issue: Implicit cast of time_t value to an unsigned type}}
+}
+
+struct tm {
+ char t;
+};
+
+extern time_t mktime(struct tm *tm);
+
+char *Bad11E(void) {
+ return (char *) mktime(0); // expected-warning {{Y2K38 Issue: Explicit cast of time_t value to a non-integer type}}
+}
+
+char *Bad11I(void) {
+ return mktime(0); // expected-warning {{Y2K38 Issue: Implicit cast of time_t value to a non-integer type}}
+}
+
+typedef time_t time_t_0;
+typedef time_t_0 time_t_1;
+typedef time_t_1 time_t_2;
+typedef time_t_2 time_t_3;
+typedef time_t_3 time_t_4;
+typedef time_t_4 time_t_5;
+typedef time_t_5 time_t_6;
+typedef time_t_6 time_t_7;
+
+char Bad12E(void) {
+
+ time_t_7 t = 0;
+
+ return (char) t; // expected-warning {{Y2K38 Issue: Explicit cast of time_t value to a type of lesser width}}
+}
+
+char Bad12I(void) {
+
+ time_t_7 t = 0;
+
+ return t; // expected-warning {{Y2K38 Issue: Implicit cast of time_t value to a type of lesser width}}
+}
+
+struct foo13 {
+
+ time_t t;
+
+};
+
+char *Bad13(void) {
+
+ struct foo13 FOO;
+
+ FOO.t = 0x0;
+
+ return (char *) FOO.t; // expected-warning {{Y2K38 Issue: Explicit cast of time_t value to a non-integer type}}
+}
+
+char *Bad14E(void) {
+
+ time_t t = 0;
+
+ return (char *) t; // expected-warning {{Y2K38 Issue: Explicit cast of time_t value to a non-integer type}}
+}
+
+char *Bad14I(void) {
+
+ time_t t = 0;
+
+ return t; // expected-warning {{Y2K38 Issue: Implicit cast of time_t value to a non-integer type}}
+}
+
+int Bad21E(void) {
+
+ time_t t = 0;
+ int n = 0;
+
+ n = n + (int) t; // expected-warning {{Y2K38 Issue: Explicit cast of time_t value to a type of lesser width}}
+
+ return n;
+}
+
+int Bad21I(void) {
+
+ time_t t = 0;
+ int n = 0;
+
+ n = n + t; // TODO: Do we catch this?! n gets promoted to a long;
+            // then, the result of the long addition is downcast to int
+
+ return n;
+}
+
+extern int gorp(int x);
+
+int Bad22(void) {
+
+ time_t t = 0;
+
+ gorp(t); // expected-warning {{Y2K38 Issue: Implicit cast of time_t value to a type of lesser width}}
+ return 0;
+}
+
+int8_t f4(void) {
+
+ time_t t = 0;
+ int8_t c = 0;
+
+ c = (int8_t) t; // expected-warning {{Y2K38 Issue: Explicit cast of time_t value to a type of lesser width}}
+
+ return c;
+}
+
+typedef char A2C[2];
+
+void Bad5(void) {
+
+ time_t t = 0;
+ A2C a2c = { 0, 0 };
+
+ a2c[0] = t; // expected-warning {{Y2K38 Issue: Implicit cast of time_t value to a type of lesser width}}
+ a2c[1] = (char) t; // expected-warning {{Y2K38 Issue: Explicit cast of time_t value to a type of lesser width}}
+}
+
+float Bad6E(void) {
+
+ time_t t = 0;
+ float f;
+
+ f = (float) t; // expected-warning {{Y2K38 Issue: Explicit cast of time_t value to a non-integer type}}
+
+ return f;
+}
+
+float Bad6I(void) {
+
+ time_t t = 0;
+ float f;
+
+ f = t; // expected-warning {{Y2K38 Issue: Implicit cast of time_t value to a non-integer type}}
+
+ return f;
+}
+
+double Bad7E(void) {
+
+ time_t t = 0;
+ double f;
+
+ f = (double) t; // expected-warning {{Y2K38 Issue: Explicit cast of time_t value to a non-integer type}}
+
+ return f;
+}
+
+double Bad7I(void) {
+
+ time_t t = 0;
+ double f;
+
+ f = t; // expected-warning {{Y2K38 Issue: Implicit cast of time_t value to a non-integer type}}
+
+ return f;
+}
+
+unsigned long int Bad8E(void) {
+
+ time_t t = 0;
+
+ return (unsigned long int) t; // expected-warning {{Y2K38 Issue: Explicit cast of time_t value to an unsigned type}}
+}
+
+unsigned long int Bad8I(void) {
+
+ time_t t = 0;
+
+ return t; // expected-warning {{Y2K38 Issue: Implicit cast of time_t value to an unsigned type}}
+}
+
+void Bad9(void) {
+
+ time_t t = 0;
+
+ return (void) t; // expected-warning {{Y2K38 Issue: Explicit cast of time_t value to a non-integer type}}
+}

test/Analysis/TimeChecker-10.c

+// RUN: %clang --analyze -Xclang -analyzer-checker=alpha.unix.Time -Xclang -verify %s
+
+typedef signed char int8_t;
+typedef struct time_t_ {
+  int8_t t[8];
+} time_t;
+// expected-warning@6 {{Y2K38 Issue: time_t expected to be a signed integer type, at-least 64-bits in size}}
+// TODO: EXPECTED-WARNING-RE@7 {{Y2K38 Issue: The type 'time_t' is defined in file '{{(.*)}}/TimeChecker-10.c' which has a non-standard name; expected to see type 'time_t' defined in standard header named: 'time.h'}}

test/Analysis/TimeChecker-11.c

+// RUN: %clang --analyze -Xclang -analyzer-checker=alpha.unix.Time -Xclang -verify %s
+
+int unwise(void) {
+
+ typedef long int __time_t;
+ typedef __time_t time_t;
+ // TODO: EXPECTED-WARNING-RE@8 {{Y2K38 Issue: The type 'time_t' is defined in file '{{(.*)}}/TimeChecker-11.c' which has a non-standard name; expected to see type 'time_t' defined in standard header named: 'time.h'}}
+ // expected-warning@6 {{Y2K38 Issue: time_t declaration is local to function}}
+ // expected-warning@6 {{Y2K38 Issue: time_t expected to be a signed integer type, at-least 64-bits in size, having file scope}}
+
+ return 0;
+}

test/Analysis/TimeChecker-12.c

+// RUN: %clang --analyze -Xclang -analyzer-checker=alpha.unix.Time -Xclang -verify %s
+
+#include <time.h>
+
+extern int wrap(int n);
+
+int test(void) {
+
+ return wrap(time(NULL)); // expected-warning {{Y2K38 Issue: Implicit cast of time_t value to a type of lesser width}}
+}

test/Analysis/TimeChecker-2.c

+// RUN: %clang --analyze -Xclang -analyzer-checker=alpha.unix.Time -Xclang -verify %s
+
+typedef unsigned char __time_t;
+typedef __time_t time_t;
+// expected-warning@4 {{Y2K38 Issue: time_t expected to be a signed integer type, at-least 64-bits in size, having file scope}}
+// expected-warning@4 {{Y2K38 Issue: time_t size is 8 bits}}
+// TODO: EXPECTED-WARNING-RE@4 {{Y2K38 Issue: The type 'time_t' is defined in file '{{(.*)}}/TimeChecker-2.c' which has a non-standard name; expected to see type 'time_t' defined in standard header named: 'time.h'}}

test/Analysis/TimeChecker-3.c

+// RUN: %clang --analyze -Xclang -analyzer-checker=alpha.unix.Time -Xclang -verify %s
+
+typedef signed char __time_t;
+typedef __time_t time_t;
+// expected-warning@4 {{Y2K38 Issue: time_t expected to be a signed integer type, at-least 64-bits in size}}
+// expected-warning@4 {{Y2K38 Issue: time_t size is 8 bits}}
+// TODO: EXPECTED-WARNING-RE@4 {{Y2K38 Issue: The type 'time_t' is defined in file '{{(.*)}}/TimeChecker-3.c' which has a non-standard name; expected to see type 'time_t' defined in standard header named: 'time.h'}}

test/Analysis/TimeChecker-4.c

+// RUN: %clang --analyze -Xclang -analyzer-checker=alpha.unix.Time -Xclang -verify %s
+
+typedef long int _time_t;
+// expected-no-diagnostics
+// TODO: EXPECTED-WARNING-RE@3 {{Y2K38 Issue: No typedef for type 'time_t' in translation unit '{{(.*)}}/TimeChecker-4.c'}}

test/Analysis/TimeChecker-5.c

+// RUN: %clang --analyze -Xclang -analyzer-checker=alpha.unix.Time -Xclang -verify %s
+
+typedef char T0;
+typedef T0 T1;
+typedef T1 T2;
+typedef T2 T3;
+typedef T3 T4;
+typedef T4 T5;
+typedef T5 T6;
+typedef T6 T7;
+typedef T7 time_t;
+typedef time_t T8;
+// expected-warning@11 {{Y2K38 Issue: time_t expected to be a signed integer type, at-least 64-bits in size, having file scope}}
+// expected-warning@11 {{Y2K38 Issue: time_t size is 8 bits}}
+// TODO: EXPECTED-WARNING-RE@11 {{Y2K38 Issue: The type 'time_t' is defined in file '{{(.*)}}/TimeChecker-5.c' which has a non-standard name; expected to see type 'time_t' defined in standard header named: 'time.h'}}

test/Analysis/TimeChecker-6.c

+// RUN: %clang --analyze -Xclang -analyzer-checker=alpha.unix.Time -Xclang -verify %s
+
+typedef long int T0;
+typedef T0 T1;
+typedef T1 T2;
+typedef T2 T3;
+typedef T3 T4;
+typedef T4 T5;
+typedef T5 T6;
+typedef T6 T7;
+typedef T7 time_t;
+typedef time_t T8;
+// expected-no-diagnostics
+// TODO: EXPECTED-WARNING-RE@11 {{Y2K38 Issue: The type 'time_t' is defined in file '{{(.*)}}/TimeChecker-6.c' which has a non-standard name; expected to see type 'time_t' defined in standard header named: 'time.h'}}

test/Analysis/TimeChecker-7.c

+// RUN: %clang --analyze -Xclang -analyzer-checker=alpha.unix.Time -Xclang -verify %s
+
+typedef signed char int8_t;
+typedef struct time_t_ {
+  int8_t t[256];
+} time_t;
+// expected-warning@6 {{Y2K38 Issue: time_t expected to be a signed integer type, at-least 64-bits in size, having file scope}}
+// TODO: EXPECTED-WARNING-RE@6 {{Y2K38 Issue: The type 'time_t' is defined in file '{{(.*)}}/TimeChecker-7.c' which has a non-standard name; expected to see type 'time_t' defined in standard header named: 'time.h'}}

test/Analysis/TimeChecker-8.c

+// RUN: %clang --analyze -Xclang -analyzer-checker=alpha.unix.Time -Xclang -verify %s
+
+typedef unsigned long int __time_t;
+typedef __time_t time_t;
+// expected-warning@4 {{Y2K38 Issue: time_t expected to be a signed integer type, at-least 64-bits in size, having file scope}}
+// TODO: EXPECTED-WARNING-RE@4 {{Y2K38 Issue: The type 'time_t' is defined in file '{{(.*)}}/TimeChecker-8.c' which has a non-standard name; expected to see type 'time_t' defined in standard header named: 'time.h'}}
+
+time_t Bad(void) {
+
+ time_t t = 0;
+
+ return t;
+}
+// expected-warning@12 {{Y2K38 Issue: Implicit cast of time_t value to an unsigned type}}

test/Analysis/TimeChecker-9.c

+// RUN: %clang --analyze -Xclang -analyzer-checker=alpha.unix.Time -Xclang -verify %s
+
+typedef short __time_t;
+typedef __time_t time_t;
+// expected-warning@4 {{Y2K38 Issue: time_t expected to be a signed integer type, at-least 64-bits in size}}
+// expected-warning@4 {{Y2K38 Issue: time_t size is 16 bits}}
+// TODO: EXPECTED-WARNING-RE@4 {{Y2K38 Issue: The type 'time_t' is defined in file '{{(.*)}}/TimeChecker-9.c' which has a non-standard name; expected to see type 'time_t' defined in standard header named: 'time.h'}}
+
+time_t Bad(void) {
+
+ time_t t = 0;
+
+ return t;
+}

www/analyzer/alpha_checks.html

 <div class="example"><pre>
 void test(char *y) {
   char x[4];
   if (strlen(y) == 4)
     strncpy(x, y, 5); // warn
 }
 </pre></div></div></td></tr>
 
+
+<tr><td><div class="namedescr expandable"><span class="name">
+alpha.unix.Time</span><span class="lang">
+(C)</span><div class="descr">
+Check for "Year 2038" (aka: "Y2K38") related issues; applies
+to 'Date and time' &lt;time.h&gt; related functionality:<div class=functions>
+time_t time(time_t *timer);<br>
+time_t mktime(struct tm *timeptr);</div></div></div></td>
+<td><div class="exampleContainer expandable">
+<div class="example"><pre>
+#include &lt;time.h&gt;
+
+time_t a_minute_from_now(void) {
+
+  return ((int) time(NULL) + 60 /* seconds */);
+  // warn: Y2K38 Issue: Explicit cast of time_t value to a type of lesser width
+}
+</pre></div>
+<div class="example"><pre>
+#include &lt;time.h&gt;
+
+extern int wrap(int n);
+
+int test(void) {
+
+  return wrap(time(NULL));
+  // warn: Y2K38 Issue: Implicit cast of time_t value to a type of lesser width
+}
+</pre></div>
+<div class="example"><pre>
+// spurious implementation of time.h functionality...
+
+typedef unsigned char __time_t;
+typedef __time_t time_t;
+
+// warn: Y2K38 Issue: time_t expected to be a signed integer type,
+//       at-least 64-bits in size, having file scope
+//
+// warn: Y2K38 Issue: time_t size is 8 bits
+</pre></div></div></td></tr>
+
 </tbody></table>
 
 </div> <!-- page -->
 </div> <!-- content -->
 </body>
 </html>