Remove now-dead code for !HAVE_INT64_TIMESTAMP.

This is a basically mechanical removal of #ifdef HAVE_INT64_TIMESTAMP
tests and the negative-case controlled code.

Discussion: https://postgr.es/m/26788.1487455319@sss.pgh.pa.us

10 files changed, 6 insertions, 889 deletions

diff --git a/src/backend/commands/variable.c b/src/backend/commands/variable.c
index 15dbaf3fd21..d75bddd87b2 100644
--- a/src/backend/commands/variable.c
+++ b/src/backend/commands/variable.c
@@ -308,11 +308,7 @@ check_timezone(char **newval, void **extra, GucSource source)
 		}
 
 		/* Here we change from SQL to Unix sign convention */
-#ifdef HAVE_INT64_TIMESTAMP
 		gmtoffset = -(interval->time / USECS_PER_SEC);
-#else
-		gmtoffset = -interval->time;
-#endif
 		new_tz = pg_tzset_offset(gmtoffset);
 
 		pfree(interval);
diff --git a/src/backend/utils/adt/date.c b/src/backend/utils/adt/date.c
index 0a100a30eaf..76ab9496e2e 100644
--- a/src/backend/utils/adt/date.c
+++ b/src/backend/utils/adt/date.c
@@ -590,13 +590,9 @@ date2timestamp(DateADT dateVal)
 			ereport(ERROR,
 					(errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
 					 errmsg("date out of range for timestamp")));
-#ifdef HAVE_INT64_TIMESTAMP
+
 		/* date is days since 2000, timestamp is microseconds since same... */
 		result = dateVal * USECS_PER_DAY;
-#else
-		/* date is days since 2000, timestamp is seconds since same... */
-		result = dateVal * (double) SECS_PER_DAY;
-#endif
 	}
 
 	return result;
@@ -633,11 +629,7 @@ date2timestamptz(DateADT dateVal)
 		tm->tm_sec = 0;
 		tz = DetermineTimeZoneOffset(tm, session_timezone);
 
-#ifdef HAVE_INT64_TIMESTAMP
 		result = dateVal * USECS_PER_DAY + tz * USECS_PER_SEC;
-#else
-		result = dateVal * (double) SECS_PER_DAY + tz;
-#endif
 
 		/*
 		 * Since it is possible to go beyond allowed timestamptz range because
@@ -673,13 +665,8 @@ date2timestamp_no_overflow(DateADT dateVal)
 		result = DBL_MAX;
 	else
 	{
-#ifdef HAVE_INT64_TIMESTAMP
 		/* date is days since 2000, timestamp is microseconds since same... */
 		result = dateVal * (double) USECS_PER_DAY;
-#else
-		/* date is days since 2000, timestamp is seconds since same... */
-		result = dateVal * (double) SECS_PER_DAY;
-#endif
 	}
 
 	return result;
@@ -1250,12 +1237,8 @@ time_in(PG_FUNCTION_ARGS)
 static int
 tm2time(struct pg_tm * tm, fsec_t fsec, TimeADT *result)
 {
-#ifdef HAVE_INT64_TIMESTAMP
 	*result = ((((tm->tm_hour * MINS_PER_HOUR + tm->tm_min) * SECS_PER_MINUTE) + tm->tm_sec)
 			   * USECS_PER_SEC) + fsec;
-#else
-	*result = ((tm->tm_hour * MINS_PER_HOUR + tm->tm_min) * SECS_PER_MINUTE) + tm->tm_sec + fsec;
-#endif
 	return 0;
 }
 
@@ -1269,7 +1252,6 @@ tm2time(struct pg_tm * tm, fsec_t fsec, TimeADT *result)
 static int
 time2tm(TimeADT time, struct pg_tm * tm, fsec_t *fsec)
 {
-#ifdef HAVE_INT64_TIMESTAMP
 	tm->tm_hour = time / USECS_PER_HOUR;
 	time -= tm->tm_hour * USECS_PER_HOUR;
 	tm->tm_min = time / USECS_PER_MINUTE;
@@ -1277,24 +1259,6 @@ time2tm(TimeADT time, struct pg_tm * tm, fsec_t *fsec)
 	tm->tm_sec = time / USECS_PER_SEC;
 	time -= tm->tm_sec * USECS_PER_SEC;
 	*fsec = time;
-#else
-	double		trem;
-
-recalc:
-	trem = time;
-	TMODULO(trem, tm->tm_hour, (double) SECS_PER_HOUR);
-	TMODULO(trem, tm->tm_min, (double) SECS_PER_MINUTE);
-	TMODULO(trem, tm->tm_sec, 1.0);
-	trem = TIMEROUND(trem);
-	/* roundoff may need to propagate to higher-order fields */
-	if (trem >= 1.0)
-	{
-		time = ceil(time);
-		goto recalc;
-	}
-	*fsec = trem;
-#endif
-
 	return 0;
 }
 
@@ -1317,9 +1281,6 @@ time_out(PG_FUNCTION_ARGS)
 
 /*
  *		time_recv			- converts external binary format to time
- *
- * We make no attempt to provide compatibility between int and float
- * time representations ...
  */
 Datum
 time_recv(PG_FUNCTION_ARGS)
@@ -1332,21 +1293,12 @@ time_recv(PG_FUNCTION_ARGS)
 	int32		typmod = PG_GETARG_INT32(2);
 	TimeADT		result;
 
-#ifdef HAVE_INT64_TIMESTAMP
 	result = pq_getmsgint64(buf);
 
 	if (result < INT64CONST(0) || result > USECS_PER_DAY)
 		ereport(ERROR,
 				(errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
 				 errmsg("time out of range")));
-#else
-	result = pq_getmsgfloat8(buf);
-
-	if (result < 0 || result > (double) SECS_PER_DAY)
-		ereport(ERROR,
-				(errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
-				 errmsg("time out of range")));
-#endif
 
 	AdjustTimeForTypmod(&result, typmod);
 
@@ -1363,11 +1315,7 @@ time_send(PG_FUNCTION_ARGS)
 	StringInfoData buf;
 
 	pq_begintypsend(&buf);
-#ifdef HAVE_INT64_TIMESTAMP
 	pq_sendint64(&buf, time);
-#else
-	pq_sendfloat8(&buf, time);
-#endif
 	PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
 }
 
@@ -1410,12 +1358,8 @@ make_time(PG_FUNCTION_ARGS)
 						tm_hour, tm_min, sec)));
 
 	/* This should match tm2time */
-#ifdef HAVE_INT64_TIMESTAMP
 	time = (((tm_hour * MINS_PER_HOUR + tm_min) * SECS_PER_MINUTE)
 			* USECS_PER_SEC) + rint(sec * USECS_PER_SEC);
-#else
-	time = ((tm_hour * MINS_PER_HOUR + tm_min) * SECS_PER_MINUTE) + sec;
-#endif
 
 	PG_RETURN_TIMEADT(time);
 }
@@ -1459,7 +1403,6 @@ time_scale(PG_FUNCTION_ARGS)
 static void
 AdjustTimeForTypmod(TimeADT *time, int32 typmod)
 {
-#ifdef HAVE_INT64_TIMESTAMP
 	static const int64 TimeScales[MAX_TIME_PRECISION + 1] = {
 		INT64CONST(1000000),
 		INT64CONST(100000),
@@ -1479,42 +1422,15 @@ AdjustTimeForTypmod(TimeADT *time, int32 typmod)
 		INT64CONST(5),
 		INT64CONST(0)
 	};
-#else
-	/* note MAX_TIME_PRECISION differs in this case */
-	static const double TimeScales[MAX_TIME_PRECISION + 1] = {
-		1.0,
-		10.0,
-		100.0,
-		1000.0,
-		10000.0,
-		100000.0,
-		1000000.0,
-		10000000.0,
-		100000000.0,
-		1000000000.0,
-		10000000000.0
-	};
-#endif
 
 	if (typmod >= 0 && typmod <= MAX_TIME_PRECISION)
 	{
-		/*
-		 * Note: this round-to-nearest code is not completely consistent about
-		 * rounding values that are exactly halfway between integral values.
-		 * On most platforms, rint() will implement round-to-nearest-even, but
-		 * the integer code always rounds up (away from zero).  Is it worth
-		 * trying to be consistent?
-		 */
-#ifdef HAVE_INT64_TIMESTAMP
 		if (*time >= INT64CONST(0))
 			*time = ((*time + TimeOffsets[typmod]) / TimeScales[typmod]) *
 				TimeScales[typmod];
 		else
 			*time = -((((-*time) + TimeOffsets[typmod]) / TimeScales[typmod]) *
 					  TimeScales[typmod]);
-#else
-		*time = rint((double) *time * TimeScales[typmod]) / TimeScales[typmod];
-#endif
 	}
 }
 
@@ -1589,12 +1505,7 @@ time_cmp(PG_FUNCTION_ARGS)
 Datum
 time_hash(PG_FUNCTION_ARGS)
 {
-	/* We can use either hashint8 or hashfloat8 directly */
-#ifdef HAVE_INT64_TIMESTAMP
 	return hashint8(fcinfo);
-#else
-	return hashfloat8(fcinfo);
-#endif
 }
 
 Datum
@@ -1760,17 +1671,12 @@ timestamp_time(PG_FUNCTION_ARGS)
 				(errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
 				 errmsg("timestamp out of range")));
 
-#ifdef HAVE_INT64_TIMESTAMP
-
 	/*
 	 * Could also do this with time = (timestamp / USECS_PER_DAY *
 	 * USECS_PER_DAY) - timestamp;
 	 */
 	result = ((((tm->tm_hour * MINS_PER_HOUR + tm->tm_min) * SECS_PER_MINUTE) + tm->tm_sec) *
 			  USECS_PER_SEC) + fsec;
-#else
-	result = ((tm->tm_hour * MINS_PER_HOUR + tm->tm_min) * SECS_PER_MINUTE) + tm->tm_sec + fsec;
-#endif
 
 	PG_RETURN_TIMEADT(result);
 }
@@ -1796,17 +1702,12 @@ timestamptz_time(PG_FUNCTION_ARGS)
 				(errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
 				 errmsg("timestamp out of range")));
 
-#ifdef HAVE_INT64_TIMESTAMP
-
 	/*
 	 * Could also do this with time = (timestamp / USECS_PER_DAY *
 	 * USECS_PER_DAY) - timestamp;
 	 */
 	result = ((((tm->tm_hour * MINS_PER_HOUR + tm->tm_min) * SECS_PER_MINUTE) + tm->tm_sec) *
 			  USECS_PER_SEC) + fsec;
-#else
-	result = ((tm->tm_hour * MINS_PER_HOUR + tm->tm_min) * SECS_PER_MINUTE) + tm->tm_sec + fsec;
-#endif
 
 	PG_RETURN_TIMEADT(result);
 }
@@ -1865,8 +1766,6 @@ interval_time(PG_FUNCTION_ARGS)
 {
 	Interval   *span = PG_GETARG_INTERVAL_P(0);
 	TimeADT		result;
-
-#ifdef HAVE_INT64_TIMESTAMP
 	int64		days;
 
 	result = span->time;
@@ -1880,11 +1779,6 @@ interval_time(PG_FUNCTION_ARGS)
 		days = (-result + USECS_PER_DAY - 1) / USECS_PER_DAY;
 		result += days * USECS_PER_DAY;
 	}
-#else
-	result = span->time;
-	if (result >= (double) SECS_PER_DAY || result < 0)
-		result -= floor(result / (double) SECS_PER_DAY) * (double) SECS_PER_DAY;
-#endif
 
 	PG_RETURN_TIMEADT(result);
 }
@@ -1918,19 +1812,10 @@ time_pl_interval(PG_FUNCTION_ARGS)
 	Interval   *span = PG_GETARG_INTERVAL_P(1);
 	TimeADT		result;
 
-#ifdef HAVE_INT64_TIMESTAMP
 	result = time + span->time;
 	result -= result / USECS_PER_DAY * USECS_PER_DAY;
 	if (result < INT64CONST(0))
 		result += USECS_PER_DAY;
-#else
-	TimeADT		time1;
-
-	result = time + span->time;
-	TMODULO(result, time1, (double) SECS_PER_DAY);
-	if (result < 0)
-		result += SECS_PER_DAY;
-#endif
 
 	PG_RETURN_TIMEADT(result);
 }
@@ -1945,19 +1830,10 @@ time_mi_interval(PG_FUNCTION_ARGS)
 	Interval   *span = PG_GETARG_INTERVAL_P(1);
 	TimeADT		result;
 
-#ifdef HAVE_INT64_TIMESTAMP
 	result = time - span->time;
 	result -= result / USECS_PER_DAY * USECS_PER_DAY;
 	if (result < INT64CONST(0))
 		result += USECS_PER_DAY;
-#else
-	TimeADT		time1;
-
-	result = time - span->time;
-	TMODULO(result, time1, (double) SECS_PER_DAY);
-	if (result < 0)
-		result += SECS_PER_DAY;
-#endif
 
 	PG_RETURN_TIMEADT(result);
 }
@@ -1995,27 +1871,15 @@ time_part(PG_FUNCTION_ARGS)
 		switch (val)
 		{
 			case DTK_MICROSEC:
-#ifdef HAVE_INT64_TIMESTAMP
 				result = tm->tm_sec * 1000000.0 + fsec;
-#else
-				result = (tm->tm_sec + fsec) * 1000000;
-#endif
 				break;
 
 			case DTK_MILLISEC:
-#ifdef HAVE_INT64_TIMESTAMP
 				result = tm->tm_sec * 1000.0 + fsec / 1000.0;
-#else
-				result = (tm->tm_sec + fsec) * 1000;
-#endif
 				break;
 
 			case DTK_SECOND:
-#ifdef HAVE_INT64_TIMESTAMP
 				result = tm->tm_sec + fsec / 1000000.0;
-#else
-				result = tm->tm_sec + fsec;
-#endif
 				break;
 
 			case DTK_MINUTE:
@@ -2047,11 +1911,7 @@ time_part(PG_FUNCTION_ARGS)
 	}
 	else if (type == RESERV && val == DTK_EPOCH)
 	{
-#ifdef HAVE_INT64_TIMESTAMP
 		result = time / 1000000.0;
-#else
-		result = time;
-#endif
 	}
 	else
 	{
@@ -2076,12 +1936,8 @@ time_part(PG_FUNCTION_ARGS)
 static int
 tm2timetz(struct pg_tm * tm, fsec_t fsec, int tz, TimeTzADT *result)
 {
-#ifdef HAVE_INT64_TIMESTAMP
 	result->time = ((((tm->tm_hour * MINS_PER_HOUR + tm->tm_min) * SECS_PER_MINUTE) + tm->tm_sec) *
 					USECS_PER_SEC) + fsec;
-#else
-	result->time = ((tm->tm_hour * MINS_PER_HOUR + tm->tm_min) * SECS_PER_MINUTE) + tm->tm_sec + fsec;
-#endif
 	result->zone = tz;
 
 	return 0;
@@ -2156,21 +2012,12 @@ timetz_recv(PG_FUNCTION_ARGS)
 
 	result = (TimeTzADT *) palloc(sizeof(TimeTzADT));
 
-#ifdef HAVE_INT64_TIMESTAMP
 	result->time = pq_getmsgint64(buf);
 
 	if (result->time < INT64CONST(0) || result->time > USECS_PER_DAY)
 		ereport(ERROR,
 				(errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
 				 errmsg("time out of range")));
-#else
-	result->time = pq_getmsgfloat8(buf);
-
-	if (result->time < 0 || result->time > (double) SECS_PER_DAY)
-		ereport(ERROR,
-				(errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
-				 errmsg("time out of range")));
-#endif
 
 	result->zone = pq_getmsgint(buf, sizeof(result->zone));
 
@@ -2195,11 +2042,7 @@ timetz_send(PG_FUNCTION_ARGS)
 	StringInfoData buf;
 
 	pq_begintypsend(&buf);
-#ifdef HAVE_INT64_TIMESTAMP
 	pq_sendint64(&buf, time->time);
-#else
-	pq_sendfloat8(&buf, time->time);
-#endif
 	pq_sendint(&buf, time->zone, sizeof(time->zone));
 	PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
 }
@@ -2229,27 +2072,12 @@ timetz2tm(TimeTzADT *time, struct pg_tm * tm, fsec_t *fsec, int *tzp)
 {
 	TimeOffset	trem = time->time;
 
-#ifdef HAVE_INT64_TIMESTAMP
 	tm->tm_hour = trem / USECS_PER_HOUR;
 	trem -= tm->tm_hour * USECS_PER_HOUR;
 	tm->tm_min = trem / USECS_PER_MINUTE;
 	trem -= tm->tm_min * USECS_PER_MINUTE;
 	tm->tm_sec = trem / USECS_PER_SEC;
 	*fsec = trem - tm->tm_sec * USECS_PER_SEC;
-#else
-recalc:
-	TMODULO(trem, tm->tm_hour, (double) SECS_PER_HOUR);
-	TMODULO(trem, tm->tm_min, (double) SECS_PER_MINUTE);
-	TMODULO(trem, tm->tm_sec, 1.0);
-	trem = TIMEROUND(trem);
-	/* roundoff may need to propagate to higher-order fields */
-	if (trem >= 1.0)
-	{
-		trem = ceil(time->time);
-		goto recalc;
-	}
-	*fsec = trem;
-#endif
 
 	if (tzp != NULL)
 		*tzp = time->zone;
@@ -2286,13 +2114,8 @@ timetz_cmp_internal(TimeTzADT *time1, TimeTzADT *time2)
 				t2;
 
 	/* Primary sort is by true (GMT-equivalent) time */
-#ifdef HAVE_INT64_TIMESTAMP
 	t1 = time1->time + (time1->zone * USECS_PER_SEC);
 	t2 = time2->time + (time2->zone * USECS_PER_SEC);
-#else
-	t1 = time1->time + time1->zone;
-	t2 = time2->time + time2->zone;
-#endif
 
 	if (t1 > t2)
 		return 1;
@@ -2382,17 +2205,10 @@ timetz_hash(PG_FUNCTION_ARGS)
 
 	/*
 	 * To avoid any problems with padding bytes in the struct, we figure the
-	 * field hashes separately and XOR them.  This also provides a convenient
-	 * framework for dealing with the fact that the time field might be either
-	 * double or int64.
+	 * field hashes separately and XOR them.
 	 */
-#ifdef HAVE_INT64_TIMESTAMP
 	thash = DatumGetUInt32(DirectFunctionCall1(hashint8,
 											   Int64GetDatumFast(key->time)));
-#else
-	thash = DatumGetUInt32(DirectFunctionCall1(hashfloat8,
-											 Float8GetDatumFast(key->time)));
-#endif
 	thash ^= DatumGetUInt32(hash_uint32(key->zone));
 	PG_RETURN_UINT32(thash);
 }
@@ -2435,23 +2251,12 @@ timetz_pl_interval(PG_FUNCTION_ARGS)
 	Interval   *span = PG_GETARG_INTERVAL_P(1);
 	TimeTzADT  *result;
 
-#ifndef HAVE_INT64_TIMESTAMP
-	TimeTzADT	time1;
-#endif
-
 	result = (TimeTzADT *) palloc(sizeof(TimeTzADT));
 
-#ifdef HAVE_INT64_TIMESTAMP
 	result->time = time->time + span->time;
 	result->time -= result->time / USECS_PER_DAY * USECS_PER_DAY;
 	if (result->time < INT64CONST(0))
 		result->time += USECS_PER_DAY;
-#else
-	result->time = time->time + span->time;
-	TMODULO(result->time, time1.time, (double) SECS_PER_DAY);
-	if (result->time < 0)
-		result->time += SECS_PER_DAY;
-#endif
 
 	result->zone = time->zone;
 
@@ -2468,23 +2273,12 @@ timetz_mi_interval(PG_FUNCTION_ARGS)
 	Interval   *span = PG_GETARG_INTERVAL_P(1);
 	TimeTzADT  *result;
 
-#ifndef HAVE_INT64_TIMESTAMP
-	TimeTzADT	time1;
-#endif
-
 	result = (TimeTzADT *) palloc(sizeof(TimeTzADT));
 
-#ifdef HAVE_INT64_TIMESTAMP
 	result->time = time->time - span->time;
 	result->time -= result->time / USECS_PER_DAY * USECS_PER_DAY;
 	if (result->time < INT64CONST(0))
 		result->time += USECS_PER_DAY;
-#else
-	result->time = time->time - span->time;
-	TMODULO(result->time, time1.time, (double) SECS_PER_DAY);
-	if (result->time < 0)
-		result->time += SECS_PER_DAY;
-#endif
 
 	result->zone = time->zone;
 
@@ -2710,11 +2504,7 @@ datetimetz_timestamptz(PG_FUNCTION_ARGS)
 			ereport(ERROR,
 					(errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
 					 errmsg("date out of range for timestamp")));
-#ifdef HAVE_INT64_TIMESTAMP
 		result = date * USECS_PER_DAY + time->time + time->zone * USECS_PER_SEC;
-#else
-		result = date * (double) SECS_PER_DAY + time->time + time->zone;
-#endif
 
 		/*
 		 * Since it is possible to go beyond allowed timestamptz range because
@@ -2779,27 +2569,15 @@ timetz_part(PG_FUNCTION_ARGS)
 				break;
 
 			case DTK_MICROSEC:
-#ifdef HAVE_INT64_TIMESTAMP
 				result = tm->tm_sec * 1000000.0 + fsec;
-#else
-				result = (tm->tm_sec + fsec) * 1000000;
-#endif
 				break;
 
 			case DTK_MILLISEC:
-#ifdef HAVE_INT64_TIMESTAMP
 				result = tm->tm_sec * 1000.0 + fsec / 1000.0;
-#else
-				result = (tm->tm_sec + fsec) * 1000;
-#endif
 				break;
 
 			case DTK_SECOND:
-#ifdef HAVE_INT64_TIMESTAMP
 				result = tm->tm_sec + fsec / 1000000.0;
-#else
-				result = tm->tm_sec + fsec;
-#endif
 				break;
 
 			case DTK_MINUTE:
@@ -2827,11 +2605,7 @@ timetz_part(PG_FUNCTION_ARGS)
 	}
 	else if (type == RESERV && val == DTK_EPOCH)
 	{
-#ifdef HAVE_INT64_TIMESTAMP
 		result = time->time / 1000000.0 + time->zone;
-#else
-		result = time->time + time->zone;
-#endif
 	}
 	else
 	{
@@ -2917,19 +2691,11 @@ timetz_zone(PG_FUNCTION_ARGS)
 
 	result = (TimeTzADT *) palloc(sizeof(TimeTzADT));
 
-#ifdef HAVE_INT64_TIMESTAMP
 	result->time = t->time + (t->zone - tz) * USECS_PER_SEC;
 	while (result->time < INT64CONST(0))
 		result->time += USECS_PER_DAY;
 	while (result->time >= USECS_PER_DAY)
 		result->time -= USECS_PER_DAY;
-#else
-	result->time = t->time + (t->zone - tz);
-	while (result->time < 0)
-		result->time += SECS_PER_DAY;
-	while (result->time >= SECS_PER_DAY)
-		result->time -= SECS_PER_DAY;
-#endif
 
 	result->zone = tz;
 
@@ -2954,27 +2720,15 @@ timetz_izone(PG_FUNCTION_ARGS)
 				 DatumGetCString(DirectFunctionCall1(interval_out,
 												  PointerGetDatum(zone))))));
 
-#ifdef HAVE_INT64_TIMESTAMP
 	tz = -(zone->time / USECS_PER_SEC);
-#else
-	tz = -(zone->time);
-#endif
 
 	result = (TimeTzADT *) palloc(sizeof(TimeTzADT));
 
-#ifdef HAVE_INT64_TIMESTAMP
 	result->time = time->time + (time->zone - tz) * USECS_PER_SEC;
 	while (result->time < INT64CONST(0))
 		result->time += USECS_PER_DAY;
 	while (result->time >= USECS_PER_DAY)
 		result->time -= USECS_PER_DAY;
-#else
-	result->time = time->time + (time->zone - tz);
-	while (result->time < 0)
-		result->time += SECS_PER_DAY;
-	while (result->time >= SECS_PER_DAY)
-		result->time -= SECS_PER_DAY;
-#endif
 
 	result->zone = tz;
 
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8424372bfe1..30db3bf7e59 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -43,11 +43,6 @@ static int DecodeTime(char *str, int fmask, int range,
 static const datetkn *datebsearch(const char *key, const datetkn *base, int nel);
 static int DecodeDate(char *str, int fmask, int *tmask, bool *is2digits,
 		   struct pg_tm * tm);
-
-#ifndef HAVE_INT64_TIMESTAMP
-static char *TrimTrailingZeros(char *str);
-#endif   /* HAVE_INT64_TIMESTAMP */
-
 static char *AppendSeconds(char *cp, int sec, fsec_t fsec,
 			  int precision, bool fillzeros);
 static void AdjustFractSeconds(double frac, struct pg_tm * tm, fsec_t *fsec,
@@ -401,28 +396,6 @@ GetCurrentTimeUsec(struct pg_tm * tm, fsec_t *fsec, int *tzp)
 }
 
 
-/* TrimTrailingZeros()
- * ... resulting from printing numbers with full precision.
- *
- * Returns a pointer to the new end of string.  No NUL terminator is put
- * there; callers are responsible for NUL terminating str themselves.
- *
- * Before Postgres 8.4, this always left at least 2 fractional digits,
- * but conversations on the lists suggest this isn't desired
- * since showing '0.10' is misleading with values of precision(1).
- */
-#ifndef HAVE_INT64_TIMESTAMP
-static char *
-TrimTrailingZeros(char *str)
-{
-	int			len = strlen(str);
-
-	while (len > 1 && *(str + len - 1) == '0' && *(str + len - 2) != '.')
-		len--;
-	return str + len;
-}
-#endif   /* HAVE_INT64_TIMESTAMP */
-
 /*
  * Append seconds and fractional seconds (if any) at *cp.
  *
@@ -439,14 +412,12 @@ AppendSeconds(char *cp, int sec, fsec_t fsec, int precision, bool fillzeros)
 {
 	Assert(precision >= 0);
 
-#ifdef HAVE_INT64_TIMESTAMP
-	/* fsec_t is just an int32 */
-
 	if (fillzeros)
 		cp = pg_ltostr_zeropad(cp, Abs(sec), 2);
 	else
 		cp = pg_ltostr(cp, Abs(sec));
 
+	/* fsec_t is just an int32 */
 	if (fsec != 0)
 	{
 		int32		value = Abs(fsec);
@@ -490,25 +461,6 @@ AppendSeconds(char *cp, int sec, fsec_t fsec, int precision, bool fillzeros)
 	}
 	else
 		return cp;
-#else
-	/* fsec_t is a double */
-
-	if (fsec == 0)
-	{
-		if (fillzeros)
-			return pg_ltostr_zeropad(cp, Abs(sec), 2);
-		else
-			return pg_ltostr(cp, Abs(sec));
-	}
-	else
-	{
-		if (fillzeros)
-			sprintf(cp, "%0*.*f", precision + 3, precision, fabs(sec + fsec));
-		else
-			sprintf(cp, "%.*f", precision, fabs(sec + fsec));
-		return TrimTrailingZeros(cp);
-	}
-#endif   /* HAVE_INT64_TIMESTAMP */
 }
 
 
@@ -521,14 +473,6 @@ AppendSeconds(char *cp, int sec, fsec_t fsec, int precision, bool fillzeros)
 static char *
 AppendTimestampSeconds(char *cp, struct pg_tm * tm, fsec_t fsec)
 {
-	/*
-	 * In float mode, don't print fractional seconds before 1 AD, since it's
-	 * unlikely there's any precision left ...
-	 */
-#ifndef HAVE_INT64_TIMESTAMP
-	if (tm->tm_year <= 0)
-		fsec = 0;
-#endif
 	return AppendSeconds(cp, tm->tm_sec, fsec, MAX_TIMESTAMP_PRECISION, true);
 }
 
@@ -547,11 +491,7 @@ AdjustFractSeconds(double frac, struct pg_tm * tm, fsec_t *fsec, int scale)
 	sec = (int) frac;
 	tm->tm_sec += sec;
 	frac -= sec;
-#ifdef HAVE_INT64_TIMESTAMP
 	*fsec += rint(frac * 1000000);
-#else
-	*fsec += frac;
-#endif
 }
 
 /* As above, but initial scale produces days */
@@ -582,11 +522,7 @@ ParseFractionalSecond(char *cp, fsec_t *fsec)
 	/* check for parse failure */
 	if (*cp != '\0' || errno != 0)
 		return DTERR_BAD_FORMAT;
-#ifdef HAVE_INT64_TIMESTAMP
 	*fsec = rint(frac * 1000000);
-#else
-	*fsec = frac;
-#endif
 	return 0;
 }
 
@@ -1162,12 +1098,7 @@ DecodeDateTime(char **field, int *ftype, int nf,
 								time = strtod(cp, &cp);
 								if (*cp != '\0' || errno != 0)
 									return DTERR_BAD_FORMAT;
-
-#ifdef HAVE_INT64_TIMESTAMP
 								time *= USECS_PER_DAY;
-#else
-								time *= SECS_PER_DAY;
-#endif
 								dt2time(time,
 										&tm->tm_hour, &tm->tm_min,
 										&tm->tm_sec, fsec);
@@ -2070,12 +2001,7 @@ DecodeTimeOnly(char **field, int *ftype, int nf,
 								time = strtod(cp, &cp);
 								if (*cp != '\0' || errno != 0)
 									return DTERR_BAD_FORMAT;
-
-#ifdef HAVE_INT64_TIMESTAMP
 								time *= USECS_PER_DAY;
-#else
-								time *= SECS_PER_DAY;
-#endif
 								dt2time(time,
 										&tm->tm_hour, &tm->tm_min,
 										&tm->tm_sec, fsec);
@@ -2338,12 +2264,7 @@ DecodeTimeOnly(char **field, int *ftype, int nf,
 	/* test for > 24:00:00 */
 		(tm->tm_hour == HOURS_PER_DAY &&
 		 (tm->tm_min > 0 || tm->tm_sec > 0 || *fsec > 0)) ||
-#ifdef HAVE_INT64_TIMESTAMP
-		*fsec < INT64CONST(0) || *fsec > USECS_PER_SEC
-#else
-		*fsec < 0 || *fsec > 1
-#endif
-		)
+		*fsec < INT64CONST(0) || *fsec > USECS_PER_SEC)
 		return DTERR_FIELD_OVERFLOW;
 
 	if ((fmask & DTK_TIME_M) != DTK_TIME_M)
@@ -2695,18 +2616,11 @@ DecodeTime(char *str, int fmask, int range,
 		return DTERR_BAD_FORMAT;
 
 	/* do a sanity check */
-#ifdef HAVE_INT64_TIMESTAMP
 	if (tm->tm_hour < 0 || tm->tm_min < 0 || tm->tm_min > MINS_PER_HOUR - 1 ||
 		tm->tm_sec < 0 || tm->tm_sec > SECS_PER_MINUTE ||
 		*fsec < INT64CONST(0) ||
 		*fsec > USECS_PER_SEC)
 		return DTERR_FIELD_OVERFLOW;
-#else
-	if (tm->tm_hour < 0 || tm->tm_min < 0 || tm->tm_min > MINS_PER_HOUR - 1 ||
-		tm->tm_sec < 0 || tm->tm_sec > SECS_PER_MINUTE ||
-		*fsec < 0 || *fsec > 1)
-		return DTERR_FIELD_OVERFLOW;
-#endif
 
 	return 0;
 }
@@ -2923,11 +2837,7 @@ DecodeNumberField(int len, char *str, int fmask,
 		frac = strtod(cp, NULL);
 		if (errno != 0)
 			return DTERR_BAD_FORMAT;
-#ifdef HAVE_INT64_TIMESTAMP
 		*fsec = rint(frac * 1000000);
-#else
-		*fsec = frac;
-#endif
 		/* Now truncate off the fraction for further processing */
 		*cp = '\0';
 		len = strlen(str);
@@ -3336,11 +3246,7 @@ DecodeInterval(char **field, int *ftype, int nf, int range,
 				switch (type)
 				{
 					case DTK_MICROSEC:
-#ifdef HAVE_INT64_TIMESTAMP
 						*fsec += rint(val + fval);
-#else
-						*fsec += (val + fval) * 1e-6;
-#endif
 						tmask = DTK_M(MICROSECOND);
 						break;
 
@@ -3348,21 +3254,13 @@ DecodeInterval(char **field, int *ftype, int nf, int range,
 						/* avoid overflowing the fsec field */
 						tm->tm_sec += val / 1000;
 						val -= (val / 1000) * 1000;
-#ifdef HAVE_INT64_TIMESTAMP
 						*fsec += rint((val + fval) * 1000);
-#else
-						*fsec += (val + fval) * 1e-3;
-#endif
 						tmask = DTK_M(MILLISECOND);
 						break;
 
 					case DTK_SECOND:
 						tm->tm_sec += val;
-#ifdef HAVE_INT64_TIMESTAMP
 						*fsec += rint(fval * 1000000);
-#else
-						*fsec += fval;
-#endif
 
 						/*
 						 * If any subseconds were specified, consider this
@@ -3484,12 +3382,8 @@ DecodeInterval(char **field, int *ftype, int nf, int range,
 	{
 		int			sec;
 
-#ifdef HAVE_INT64_TIMESTAMP
 		sec = *fsec / USECS_PER_SEC;
 		*fsec -= sec * USECS_PER_SEC;
-#else
-		TMODULO(*fsec, sec, 1.0);
-#endif
 		tm->tm_sec += sec;
 	}
 
diff --git a/src/backend/utils/adt/formatting.c b/src/backend/utils/adt/formatting.c
index 247234564e3..e552c8d20b6 100644
--- a/src/backend/utils/adt/formatting.c
+++ b/src/backend/utils/adt/formatting.c
@@ -2434,23 +2434,13 @@ DCH_to_char(FormatNode *node, bool is_interval, TmToChar *in, char *out, Oid col
 				s += strlen(s);
 				break;
 			case DCH_MS:		/* millisecond */
-#ifdef HAVE_INT64_TIMESTAMP
 				sprintf(s, "%03d", (int) (in->fsec / INT64CONST(1000)));
-#else
-				/* No rint() because we can't overflow and we might print US */
-				sprintf(s, "%03d", (int) (in->fsec * 1000));
-#endif
 				if (S_THth(n->suffix))
 					str_numth(s, s, S_TH_TYPE(n->suffix));
 				s += strlen(s);
 				break;
 			case DCH_US:		/* microsecond */
-#ifdef HAVE_INT64_TIMESTAMP
 				sprintf(s, "%06d", (int) in->fsec);
-#else
-				/* don't use rint() because we can't overflow 1000 */
-				sprintf(s, "%06d", (int) (in->fsec * 1000000));
-#endif
 				if (S_THth(n->suffix))
 					str_numth(s, s, S_TH_TYPE(n->suffix));
 				s += strlen(s);
@@ -3793,17 +3783,10 @@ do_to_timestamp(text *date_txt, text *fmt,
 		}
 	}
 
-#ifdef HAVE_INT64_TIMESTAMP
 	if (tmfc.ms)
 		*fsec += tmfc.ms * 1000;
 	if (tmfc.us)
 		*fsec += tmfc.us;
-#else
-	if (tmfc.ms)
-		*fsec += (double) tmfc.ms / 1000;
-	if (tmfc.us)
-		*fsec += (double) tmfc.us / 1000000;
-#endif
 
 	/* Range-check date fields according to bit mask computed above */
 	if (fmask != 0)
@@ -3826,12 +3809,7 @@ do_to_timestamp(text *date_txt, text *fmt,
 	if (tm->tm_hour < 0 || tm->tm_hour >= HOURS_PER_DAY ||
 		tm->tm_min < 0 || tm->tm_min >= MINS_PER_HOUR ||
 		tm->tm_sec < 0 || tm->tm_sec >= SECS_PER_MINUTE ||
-#ifdef HAVE_INT64_TIMESTAMP
-		*fsec < INT64CONST(0) || *fsec >= USECS_PER_SEC
-#else
-		*fsec < 0 || *fsec >= 1
-#endif
-		)
+		*fsec < INT64CONST(0) || *fsec >= USECS_PER_SEC)
 		DateTimeParseError(DTERR_FIELD_OVERFLOW, date_str, "timestamp");
 
 	DEBUG_TM(tm);
diff --git a/src/backend/utils/adt/misc.c b/src/backend/utils/adt/misc.c
index 66d09bcb0cd..0116fa08a61 100644
--- a/src/backend/utils/adt/misc.c
+++ b/src/backend/utils/adt/misc.c
@@ -535,12 +535,7 @@ pg_sleep(PG_FUNCTION_ARGS)
 	 * less than the specified time when WaitLatch is terminated early by a
 	 * non-query-canceling signal such as SIGHUP.
 	 */
-
-#ifdef HAVE_INT64_TIMESTAMP
 #define GetNowFloat()	((float8) GetCurrentTimestamp() / 1000000.0)
-#else
-#define GetNowFloat()	GetCurrentTimestamp()
-#endif
 
 	endtime = GetNowFloat() + secs;
 
diff --git a/src/backend/utils/adt/nabstime.c b/src/backend/utils/adt/nabstime.c
index c9d0b0d7fbc..6da769e562c 100644
--- a/src/backend/utils/adt/nabstime.c
+++ b/src/backend/utils/adt/nabstime.c
@@ -818,14 +818,10 @@ interval_reltime(PG_FUNCTION_ARGS)
 	month = interval->month % MONTHS_PER_YEAR;
 	day = interval->day;
 
-#ifdef HAVE_INT64_TIMESTAMP
 	span = ((INT64CONST(365250000) * year + INT64CONST(30000000) * month +
 			 INT64CONST(1000000) * day) * INT64CONST(86400)) +
 		interval->time;
 	span /= USECS_PER_SEC;
-#else
-	span = (DAYS_PER_YEAR * year + (double) DAYS_PER_MONTH * month + day) * SECS_PER_DAY + interval->time;
-#endif
 
 	if (span < INT_MIN || span > INT_MAX)
 		time = INVALID_RELTIME;
@@ -859,7 +855,6 @@ reltime_interval(PG_FUNCTION_ARGS)
 			break;
 
 		default:
-#ifdef HAVE_INT64_TIMESTAMP
 			year = reltime / SECS_PER_YEAR;
 			reltime -= year * SECS_PER_YEAR;
 			month = reltime / (DAYS_PER_MONTH * SECS_PER_DAY);
@@ -868,13 +863,6 @@ reltime_interval(PG_FUNCTION_ARGS)
 			reltime -= day * SECS_PER_DAY;
 
 			result->time = (reltime * USECS_PER_SEC);
-#else
-			TMODULO(reltime, year, SECS_PER_YEAR);
-			TMODULO(reltime, month, DAYS_PER_MONTH * SECS_PER_DAY);
-			TMODULO(reltime, day, SECS_PER_DAY);
-
-			result->time = reltime;
-#endif
 			result->month = MONTHS_PER_YEAR * year + month;
 			result->day = day;
 			break;
diff --git a/src/backend/utils/adt/rangetypes.c b/src/backend/utils/adt/rangetypes.c
index da82d0b3001..e518523a70b 100644
--- a/src/backend/utils/adt/rangetypes.c
+++ b/src/backend/utils/adt/rangetypes.c
@@ -1443,12 +1443,7 @@ tsrange_subdiff(PG_FUNCTION_ARGS)
 	Timestamp	v2 = PG_GETARG_TIMESTAMP(1);
 	float8		result;
 
-#ifdef HAVE_INT64_TIMESTAMP
 	result = ((float8) v1 - (float8) v2) / USECS_PER_SEC;
-#else
-	result = v1 - v2;
-#endif
-
 	PG_RETURN_FLOAT8(result);
 }
 
@@ -1459,12 +1454,7 @@ tstzrange_subdiff(PG_FUNCTION_ARGS)
 	Timestamp	v2 = PG_GETARG_TIMESTAMP(1);
 	float8		result;
 
-#ifdef HAVE_INT64_TIMESTAMP
 	result = ((float8) v1 - (float8) v2) / USECS_PER_SEC;
-#else
-	result = v1 - v2;
-#endif
-
 	PG_RETURN_FLOAT8(result);
 }
 
diff --git a/src/backend/utils/adt/selfuncs.c b/src/backend/utils/adt/selfuncs.c
index 13cb1facd49..8b05e8f9f79 100644
--- a/src/backend/utils/adt/selfuncs.c
+++ b/src/backend/utils/adt/selfuncs.c
@@ -4212,31 +4212,17 @@ convert_timevalue_to_scalar(Datum value, Oid typid)
 				 * average month length of 365.25/12.0 days.  Not too
 				 * accurate, but plenty good enough for our purposes.
 				 */
-#ifdef HAVE_INT64_TIMESTAMP
 				return interval->time + interval->day * (double) USECS_PER_DAY +
 					interval->month * ((DAYS_PER_YEAR / (double) MONTHS_PER_YEAR) * USECS_PER_DAY);
-#else
-				return interval->time + interval->day * SECS_PER_DAY +
-					interval->month * ((DAYS_PER_YEAR / (double) MONTHS_PER_YEAR) * (double) SECS_PER_DAY);
-#endif
 			}
 		case RELTIMEOID:
-#ifdef HAVE_INT64_TIMESTAMP
 			return (DatumGetRelativeTime(value) * 1000000.0);
-#else
-			return DatumGetRelativeTime(value);
-#endif
 		case TINTERVALOID:
 			{
 				TimeInterval tinterval = DatumGetTimeInterval(value);
 
-#ifdef HAVE_INT64_TIMESTAMP
 				if (tinterval->status != 0)
 					return ((tinterval->data[1] - tinterval->data[0]) * 1000000.0);
-#else
-				if (tinterval->status != 0)
-					return tinterval->data[1] - tinterval->data[0];
-#endif
 				return 0;		/* for lack of a better idea */
 			}
 		case TIMEOID:
@@ -4246,11 +4232,7 @@ convert_timevalue_to_scalar(Datum value, Oid typid)
 				TimeTzADT  *timetz = DatumGetTimeTzADTP(value);
 
 				/* use GMT-equivalent time */
-#ifdef HAVE_INT64_TIMESTAMP
 				return (double) (timetz->time + (timetz->zone * 1000000.0));
-#else
-				return (double) (timetz->time + timetz->zone);
-#endif
 			}
 	}
 
diff --git a/src/backend/utils/adt/timestamp.c b/src/backend/utils/adt/timestamp.c
index 997a551bd87..4be1999119c 100644
--- a/src/backend/utils/adt/timestamp.c
+++ b/src/backend/utils/adt/timestamp.c
@@ -234,9 +234,6 @@ timestamp_out(PG_FUNCTION_ARGS)
 
 /*
  *		timestamp_recv			- converts external binary format to timestamp
- *
- * We make no attempt to provide compatibility between int and float
- * timestamp representations ...
  */
 Datum
 timestamp_recv(PG_FUNCTION_ARGS)
@@ -252,16 +249,7 @@ timestamp_recv(PG_FUNCTION_ARGS)
 			   *tm = &tt;
 	fsec_t		fsec;
 
-#ifdef HAVE_INT64_TIMESTAMP
 	timestamp = (Timestamp) pq_getmsgint64(buf);
-#else
-	timestamp = (Timestamp) pq_getmsgfloat8(buf);
-
-	if (isnan(timestamp))
-		ereport(ERROR,
-				(errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
-				 errmsg("timestamp cannot be NaN")));
-#endif
 
 	/* range check: see if timestamp_out would like it */
 	if (TIMESTAMP_NOT_FINITE(timestamp))
@@ -287,11 +275,7 @@ timestamp_send(PG_FUNCTION_ARGS)
 	StringInfoData buf;
 
 	pq_begintypsend(&buf);
-#ifdef HAVE_INT64_TIMESTAMP
 	pq_sendint64(&buf, timestamp);
-#else
-	pq_sendfloat8(&buf, timestamp);
-#endif
 	PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
 }
 
@@ -348,7 +332,6 @@ timestamp_scale(PG_FUNCTION_ARGS)
 static void
 AdjustTimestampForTypmod(Timestamp *time, int32 typmod)
 {
-#ifdef HAVE_INT64_TIMESTAMP
 	static const int64 TimestampScales[MAX_TIMESTAMP_PRECISION + 1] = {
 		INT64CONST(1000000),
 		INT64CONST(100000),
@@ -368,17 +351,6 @@ AdjustTimestampForTypmod(Timestamp *time, int32 typmod)
 		INT64CONST(5),
 		INT64CONST(0)
 	};
-#else
-	static const double TimestampScales[MAX_TIMESTAMP_PRECISION + 1] = {
-		1,
-		10,
-		100,
-		1000,
-		10000,
-		100000,
-		1000000
-	};
-#endif
 
 	if (!TIMESTAMP_NOT_FINITE(*time)
 		&& (typmod != -1) && (typmod != MAX_TIMESTAMP_PRECISION))
@@ -389,14 +361,6 @@ AdjustTimestampForTypmod(Timestamp *time, int32 typmod)
 				  errmsg("timestamp(%d) precision must be between %d and %d",
 						 typmod, 0, MAX_TIMESTAMP_PRECISION)));
 
-		/*
-		 * Note: this round-to-nearest code is not completely consistent about
-		 * rounding values that are exactly halfway between integral values.
-		 * On most platforms, rint() will implement round-to-nearest-even, but
-		 * the integer code always rounds up (away from zero).  Is it worth
-		 * trying to be consistent?
-		 */
-#ifdef HAVE_INT64_TIMESTAMP
 		if (*time >= INT64CONST(0))
 		{
 			*time = ((*time + TimestampOffsets[typmod]) / TimestampScales[typmod]) *
@@ -407,9 +371,6 @@ AdjustTimestampForTypmod(Timestamp *time, int32 typmod)
 			*time = -((((-*time) + TimestampOffsets[typmod]) / TimestampScales[typmod])
 					  * TimestampScales[typmod]);
 		}
-#else
-		*time = rint((double) *time * TimestampScales[typmod]) / TimestampScales[typmod];
-#endif
 	}
 }
 
@@ -628,7 +589,6 @@ make_timestamp_internal(int year, int month, int day,
 						hour, min, sec)));
 
 	/* This should match tm2time */
-#ifdef HAVE_INT64_TIMESTAMP
 	time = (((hour * MINS_PER_HOUR + min) * SECS_PER_MINUTE)
 			* USECS_PER_SEC) + rint(sec * USECS_PER_SEC);
 
@@ -650,10 +610,6 @@ make_timestamp_internal(int year, int month, int day,
 				 errmsg("timestamp out of range: %d-%02d-%02d %d:%02d:%02g",
 						year, month, day,
 						hour, min, sec)));
-#else
-	time = ((hour * MINS_PER_HOUR + min) * SECS_PER_MINUTE) + sec;
-	result = date * SECS_PER_DAY + time;
-#endif
 
 	/* final range check catches just-out-of-range timestamps */
 	if (!IS_VALID_TIMESTAMP(result))
@@ -783,12 +739,8 @@ float8_timestamptz(PG_FUNCTION_ARGS)
 		/* Convert UNIX epoch to Postgres epoch */
 		seconds -= ((POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) * SECS_PER_DAY);
 
-#ifdef HAVE_INT64_TIMESTAMP
 		seconds = rint(seconds * USECS_PER_SEC);
 		result = (int64) seconds;
-#else
-		result = seconds;
-#endif
 
 		/* Recheck in case roundoff produces something just out of range */
 		if (!IS_VALID_TIMESTAMP(result))
@@ -831,9 +783,6 @@ timestamptz_out(PG_FUNCTION_ARGS)
 
 /*
  *		timestamptz_recv			- converts external binary format to timestamptz
- *
- * We make no attempt to provide compatibility between int and float
- * timestamp representations ...
  */
 Datum
 timestamptz_recv(PG_FUNCTION_ARGS)
@@ -850,11 +799,7 @@ timestamptz_recv(PG_FUNCTION_ARGS)
 			   *tm = &tt;
 	fsec_t		fsec;
 
-#ifdef HAVE_INT64_TIMESTAMP
 	timestamp = (TimestampTz) pq_getmsgint64(buf);
-#else
-	timestamp = (TimestampTz) pq_getmsgfloat8(buf);
-#endif
 
 	/* range check: see if timestamptz_out would like it */
 	if (TIMESTAMP_NOT_FINITE(timestamp))
@@ -880,11 +825,7 @@ timestamptz_send(PG_FUNCTION_ARGS)
 	StringInfoData buf;
 
 	pq_begintypsend(&buf);
-#ifdef HAVE_INT64_TIMESTAMP
 	pq_sendint64(&buf, timestamp);
-#else
-	pq_sendfloat8(&buf, timestamp);
-#endif
 	PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
 }
 
@@ -1047,11 +988,7 @@ interval_recv(PG_FUNCTION_ARGS)
 
 	interval = (Interval *) palloc(sizeof(Interval));
 
-#ifdef HAVE_INT64_TIMESTAMP
 	interval->time = pq_getmsgint64(buf);
-#else
-	interval->time = pq_getmsgfloat8(buf);
-#endif
 	interval->day = pq_getmsgint(buf, sizeof(interval->day));
 	interval->month = pq_getmsgint(buf, sizeof(interval->month));
 
@@ -1070,11 +1007,7 @@ interval_send(PG_FUNCTION_ARGS)
 	StringInfoData buf;
 
 	pq_begintypsend(&buf);
-#ifdef HAVE_INT64_TIMESTAMP
 	pq_sendint64(&buf, interval->time);
-#else
-	pq_sendfloat8(&buf, interval->time);
-#endif
 	pq_sendint(&buf, interval->day, sizeof(interval->day));
 	pq_sendint(&buf, interval->month, sizeof(interval->month));
 	PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
@@ -1385,7 +1318,6 @@ interval_scale(PG_FUNCTION_ARGS)
 static void
 AdjustIntervalForTypmod(Interval *interval, int32 typmod)
 {
-#ifdef HAVE_INT64_TIMESTAMP
 	static const int64 IntervalScales[MAX_INTERVAL_PRECISION + 1] = {
 		INT64CONST(1000000),
 		INT64CONST(100000),
@@ -1405,17 +1337,6 @@ AdjustIntervalForTypmod(Interval *interval, int32 typmod)
 		INT64CONST(5),
 		INT64CONST(0)
 	};
-#else
-	static const double IntervalScales[MAX_INTERVAL_PRECISION + 1] = {
-		1,
-		10,
-		100,
-		1000,
-		10000,
-		100000,
-		1000000
-	};
-#endif
 
 	/*
 	 * Unspecified range and precision? Then not necessary to adjust. Setting
@@ -1473,21 +1394,13 @@ AdjustIntervalForTypmod(Interval *interval, int32 typmod)
 		}
 		else if (range == INTERVAL_MASK(HOUR))
 		{
-#ifdef HAVE_INT64_TIMESTAMP
 			interval->time = (interval->time / USECS_PER_HOUR) *
 				USECS_PER_HOUR;
-#else
-			interval->time = ((int) (interval->time / SECS_PER_HOUR)) * (double) SECS_PER_HOUR;
-#endif
 		}
 		else if (range == INTERVAL_MASK(MINUTE))
 		{
-#ifdef HAVE_INT64_TIMESTAMP
 			interval->time = (interval->time / USECS_PER_MINUTE) *
 				USECS_PER_MINUTE;
-#else
-			interval->time = ((int) (interval->time / SECS_PER_MINUTE)) * (double) SECS_PER_MINUTE;
-#endif
 		}
 		else if (range == INTERVAL_MASK(SECOND))
 		{
@@ -1497,24 +1410,16 @@ AdjustIntervalForTypmod(Interval *interval, int32 typmod)
 		else if (range == (INTERVAL_MASK(DAY) |
 						   INTERVAL_MASK(HOUR)))
 		{
-#ifdef HAVE_INT64_TIMESTAMP
 			interval->time = (interval->time / USECS_PER_HOUR) *
 				USECS_PER_HOUR;
-#else
-			interval->time = ((int) (interval->time / SECS_PER_HOUR)) * (double) SECS_PER_HOUR;
-#endif
 		}
 		/* DAY TO MINUTE */
 		else if (range == (INTERVAL_MASK(DAY) |
 						   INTERVAL_MASK(HOUR) |
 						   INTERVAL_MASK(MINUTE)))
 		{
-#ifdef HAVE_INT64_TIMESTAMP
 			interval->time = (interval->time / USECS_PER_MINUTE) *
 				USECS_PER_MINUTE;
-#else
-			interval->time = ((int) (interval->time / SECS_PER_MINUTE)) * (double) SECS_PER_MINUTE;
-#endif
 		}
 		/* DAY TO SECOND */
 		else if (range == (INTERVAL_MASK(DAY) |
@@ -1528,12 +1433,8 @@ AdjustIntervalForTypmod(Interval *interval, int32 typmod)
 		else if (range == (INTERVAL_MASK(HOUR) |
 						   INTERVAL_MASK(MINUTE)))
 		{
-#ifdef HAVE_INT64_TIMESTAMP
 			interval->time = (interval->time / USECS_PER_MINUTE) *
 				USECS_PER_MINUTE;
-#else
-			interval->time = ((int) (interval->time / SECS_PER_MINUTE)) * (double) SECS_PER_MINUTE;
-#endif
 		}
 		/* HOUR TO SECOND */
 		else if (range == (INTERVAL_MASK(HOUR) |
@@ -1560,14 +1461,6 @@ AdjustIntervalForTypmod(Interval *interval, int32 typmod)
 				   errmsg("interval(%d) precision must be between %d and %d",
 						  precision, 0, MAX_INTERVAL_PRECISION)));
 
-			/*
-			 * Note: this round-to-nearest code is not completely consistent
-			 * about rounding values that are exactly halfway between integral
-			 * values.  On most platforms, rint() will implement
-			 * round-to-nearest-even, but the integer code always rounds up
-			 * (away from zero).  Is it worth trying to be consistent?
-			 */
-#ifdef HAVE_INT64_TIMESTAMP
 			if (interval->time >= INT64CONST(0))
 			{
 				interval->time = ((interval->time +
@@ -1582,11 +1475,6 @@ AdjustIntervalForTypmod(Interval *interval, int32 typmod)
 									IntervalScales[precision]) *
 								   IntervalScales[precision]);
 			}
-#else
-			interval->time = rint(((double) interval->time) *
-								  IntervalScales[precision]) /
-				IntervalScales[precision];
-#endif
 		}
 	}
 }
@@ -1619,16 +1507,10 @@ make_interval(PG_FUNCTION_ARGS)
 	result->month = years * MONTHS_PER_YEAR + months;
 	result->day = weeks * 7 + days;
 
-#ifdef HAVE_INT64_TIMESTAMP
 	secs = rint(secs * USECS_PER_SEC);
 	result->time = hours * ((int64) SECS_PER_HOUR * USECS_PER_SEC) +
 		mins * ((int64) SECS_PER_MINUTE * USECS_PER_SEC) +
 		(int64) secs;
-#else
-	result->time = hours * (double) SECS_PER_HOUR +
-		mins * (double) SECS_PER_MINUTE +
-		secs;
-#endif
 
 	PG_RETURN_INTERVAL_P(result);
 }
@@ -1693,59 +1575,10 @@ GetCurrentTimestamp(void)
 
 	result = (TimestampTz) tp.tv_sec -
 		((POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) * SECS_PER_DAY);
-
-#ifdef HAVE_INT64_TIMESTAMP
-	result = (result * USECS_PER_SEC) + tp.tv_usec;
-#else
-	result = result + (tp.tv_usec / 1000000.0);
-#endif
-
-	return result;
-}
-
-/*
- * GetCurrentIntegerTimestamp -- get the current operating system time as int64
- *
- * Result is the number of microseconds since the Postgres epoch. If compiled
- * with --enable-integer-datetimes, this is identical to GetCurrentTimestamp(),
- * and is implemented as a macro.
- */
-#ifndef HAVE_INT64_TIMESTAMP
-int64
-GetCurrentIntegerTimestamp(void)
-{
-	int64		result;
-	struct timeval tp;
-
-	gettimeofday(&tp, NULL);
-
-	result = (int64) tp.tv_sec -
-		((POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) * SECS_PER_DAY);
-
 	result = (result * USECS_PER_SEC) + tp.tv_usec;
 
 	return result;
 }
-#endif
-
-/*
- * IntegerTimestampToTimestampTz -- convert an int64 timestamp to native format
- *
- * When compiled with --enable-integer-datetimes, this is implemented as a
- * no-op macro.
- */
-#ifndef HAVE_INT64_TIMESTAMP
-TimestampTz
-IntegerTimestampToTimestampTz(int64 timestamp)
-{
-	TimestampTz result;
-
-	result = timestamp / USECS_PER_SEC;
-	result += (timestamp % USECS_PER_SEC) / 1000000.0;
-
-	return result;
-}
-#endif
 
 /*
  * GetSQLCurrentTimestamp -- implements CURRENT_TIMESTAMP, CURRENT_TIMESTAMP(n)
@@ -1799,13 +1632,8 @@ TimestampDifference(TimestampTz start_time, TimestampTz stop_time,
 	}
 	else
 	{
-#ifdef HAVE_INT64_TIMESTAMP
 		*secs = (long) (diff / USECS_PER_SEC);
 		*microsecs = (int) (diff % USECS_PER_SEC);
-#else
-		*secs = (long) diff;
-		*microsecs = (int) ((diff - *secs) * 1000000.0);
-#endif
 	}
 }
 
@@ -1823,11 +1651,7 @@ TimestampDifferenceExceeds(TimestampTz start_time,
 {
 	TimestampTz diff = stop_time - start_time;
 
-#ifdef HAVE_INT64_TIMESTAMP
 	return (diff >= msec * INT64CONST(1000));
-#else
-	return (diff * 1000.0 >= msec);
-#endif
 }
 
 /*
@@ -1848,10 +1672,7 @@ time_t_to_timestamptz(pg_time_t tm)
 
 	result = (TimestampTz) tm -
 		((POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) * SECS_PER_DAY);
-
-#ifdef HAVE_INT64_TIMESTAMP
 	result *= USECS_PER_SEC;
-#endif
 
 	return result;
 }
@@ -1871,13 +1692,8 @@ timestamptz_to_time_t(TimestampTz t)
 {
 	pg_time_t	result;
 
-#ifdef HAVE_INT64_TIMESTAMP
 	result = (pg_time_t) (t / USECS_PER_SEC +
 				 ((POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) * SECS_PER_DAY));
-#else
-	result = (pg_time_t) (t +
-				 ((POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) * SECS_PER_DAY));
-#endif
 
 	return result;
 }
@@ -1917,21 +1733,12 @@ dt2time(Timestamp jd, int *hour, int *min, int *sec, fsec_t *fsec)
 
 	time = jd;
 
-#ifdef HAVE_INT64_TIMESTAMP
 	*hour = time / USECS_PER_HOUR;
 	time -= (*hour) * USECS_PER_HOUR;
 	*min = time / USECS_PER_MINUTE;
 	time -= (*min) * USECS_PER_MINUTE;
 	*sec = time / USECS_PER_SEC;
 	*fsec = time - (*sec * USECS_PER_SEC);
-#else
-	*hour = time / SECS_PER_HOUR;
-	time -= (*hour) * SECS_PER_HOUR;
-	*min = time / SECS_PER_MINUTE;
-	time -= (*min) * SECS_PER_MINUTE;
-	*sec = time;
-	*fsec = time - *sec;
-#endif
 }	/* dt2time() */
 
 
@@ -1957,7 +1764,6 @@ timestamp2tm(Timestamp dt, int *tzp, struct pg_tm * tm, fsec_t *fsec, const char
 	if (attimezone == NULL)
 		attimezone = session_timezone;
 
-#ifdef HAVE_INT64_TIMESTAMP
 	time = dt;
 	TMODULO(time, date, USECS_PER_DAY);
 
@@ -1976,42 +1782,6 @@ timestamp2tm(Timestamp dt, int *tzp, struct pg_tm * tm, fsec_t *fsec, const char
 
 	j2date((int) date, &tm->tm_year, &tm->tm_mon, &tm->tm_mday);
 	dt2time(time, &tm->tm_hour, &tm->tm_min, &tm->tm_sec, fsec);
-#else
-	time = dt;
-	TMODULO(time, date, (double) SECS_PER_DAY);
-
-	if (time < 0)
-	{
-		time += SECS_PER_DAY;
-		date -= 1;
-	}
-
-	/* add offset to go from J2000 back to standard Julian date */
-	date += POSTGRES_EPOCH_JDATE;
-
-recalc_d:
-	/* Julian day routine does not work for negative Julian days */
-	if (date < 0 || date > (Timestamp) INT_MAX)
-		return -1;
-
-	j2date((int) date, &tm->tm_year, &tm->tm_mon, &tm->tm_mday);
-recalc_t:
-	dt2time(time, &tm->tm_hour, &tm->tm_min, &tm->tm_sec, fsec);
-
-	*fsec = TSROUND(*fsec);
-	/* roundoff may need to propagate to higher-order fields */
-	if (*fsec >= 1.0)
-	{
-		time = ceil(time);
-		if (time >= (double) SECS_PER_DAY)
-		{
-			time = 0;
-			date += 1;
-			goto recalc_d;
-		}
-		goto recalc_t;
-	}
-#endif
 
 	/* Done if no TZ conversion wanted */
 	if (tzp == NULL)
@@ -2034,13 +1804,8 @@ recalc_t:
 	 * coding avoids hardwiring any assumptions about the width of pg_time_t,
 	 * so it should behave sanely on machines without int64.
 	 */
-#ifdef HAVE_INT64_TIMESTAMP
 	dt = (dt - *fsec) / USECS_PER_SEC +
 		(POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) * SECS_PER_DAY;
-#else
-	dt = rint(dt - *fsec +
-			  (POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) * SECS_PER_DAY);
-#endif
 	utime = (pg_time_t) dt;
 	if ((Timestamp) utime == dt)
 	{
@@ -2100,7 +1865,6 @@ tm2timestamp(struct pg_tm * tm, fsec_t fsec, int *tzp, Timestamp *result)
 	date = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - POSTGRES_EPOCH_JDATE;
 	time = time2t(tm->tm_hour, tm->tm_min, tm->tm_sec, fsec);
 
-#ifdef HAVE_INT64_TIMESTAMP
 	*result = date * USECS_PER_DAY + time;
 	/* check for major overflow */
 	if ((*result - time) / USECS_PER_DAY != date)
@@ -2116,9 +1880,6 @@ tm2timestamp(struct pg_tm * tm, fsec_t fsec, int *tzp, Timestamp *result)
 		*result = 0;			/* keep compiler quiet */
 		return -1;
 	}
-#else
-	*result = date * SECS_PER_DAY + time;
-#endif
 	if (tzp != NULL)
 		*result = dt2local(*result, -(*tzp));
 
@@ -2147,7 +1908,6 @@ interval2tm(Interval span, struct pg_tm * tm, fsec_t *fsec)
 	tm->tm_mday = span.day;
 	time = span.time;
 
-#ifdef HAVE_INT64_TIMESTAMP
 	tfrac = time / USECS_PER_HOUR;
 	time -= tfrac * USECS_PER_HOUR;
 	tm->tm_hour = tfrac;
@@ -2161,23 +1921,6 @@ interval2tm(Interval span, struct pg_tm * tm, fsec_t *fsec)
 	tfrac = time / USECS_PER_SEC;
 	*fsec = time - (tfrac * USECS_PER_SEC);
 	tm->tm_sec = tfrac;
-#else
-recalc:
-	TMODULO(time, tfrac, (double) SECS_PER_HOUR);
-	tm->tm_hour = tfrac;		/* could overflow ... */
-	TMODULO(time, tfrac, (double) SECS_PER_MINUTE);
-	tm->tm_min = tfrac;
-	TMODULO(time, tfrac, 1.0);
-	tm->tm_sec = tfrac;
-	time = TSROUND(time);
-	/* roundoff may need to propagate to higher-order fields */
-	if (time >= 1.0)
-	{
-		time = ceil(span.time);
-		goto recalc;
-	}
-	*fsec = time;
-#endif
 
 	return 0;
 }
@@ -2191,15 +1934,9 @@ tm2interval(struct pg_tm * tm, fsec_t fsec, Interval *span)
 		return -1;
 	span->month = total_months;
 	span->day = tm->tm_mday;
-#ifdef HAVE_INT64_TIMESTAMP
 	span->time = (((((tm->tm_hour * INT64CONST(60)) +
 					 tm->tm_min) * INT64CONST(60)) +
 				   tm->tm_sec) * USECS_PER_SEC) + fsec;
-#else
-	span->time = (((tm->tm_hour * (double) MINS_PER_HOUR) +
-				   tm->tm_min) * (double) SECS_PER_MINUTE) +
-		tm->tm_sec + fsec;
-#endif
 
 	return 0;
 }
@@ -2207,21 +1944,13 @@ tm2interval(struct pg_tm * tm, fsec_t fsec, Interval *span)
 static TimeOffset
 time2t(const int hour, const int min, const int sec, const fsec_t fsec)
 {
-#ifdef HAVE_INT64_TIMESTAMP
 	return (((((hour * MINS_PER_HOUR) + min) * SECS_PER_MINUTE) + sec) * USECS_PER_SEC) + fsec;
-#else
-	return (((hour * MINS_PER_HOUR) + min) * SECS_PER_MINUTE) + sec + fsec;
-#endif
 }
 
 static Timestamp
 dt2local(Timestamp dt, int tz)
 {
-#ifdef HAVE_INT64_TIMESTAMP
 	dt -= (tz * USECS_PER_SEC);
-#else
-	dt -= tz;
-#endif
 	return dt;
 }
 
@@ -2288,44 +2017,11 @@ SetEpochTimestamp(void)
  * The comparison functions are among them. - thomas 2001-09-25
  *
  *		timestamp_relop - is timestamp1 relop timestamp2
- *
- *		collate invalid timestamp at the end
  */
 int
 timestamp_cmp_internal(Timestamp dt1, Timestamp dt2)
 {
-#ifdef HAVE_INT64_TIMESTAMP
 	return (dt1 < dt2) ? -1 : ((dt1 > dt2) ? 1 : 0);
-#else
-
-	/*
-	 * When using float representation, we have to be wary of NaNs.
-	 *
-	 * We consider all NANs to be equal and larger than any non-NAN. This is
-	 * somewhat arbitrary; the important thing is to have a consistent sort
-	 * order.
-	 */
-	if (isnan(dt1))
-	{
-		if (isnan(dt2))
-			return 0;			/* NAN = NAN */
-		else
-			return 1;			/* NAN > non-NAN */
-	}
-	else if (isnan(dt2))
-	{
-		return -1;				/* non-NAN < NAN */
-	}
-	else
-	{
-		if (dt1 > dt2)
-			return 1;
-		else if (dt1 < dt2)
-			return -1;
-		else
-			return 0;
-	}
-#endif
 }
 
 Datum
@@ -2413,12 +2109,7 @@ timestamp_sortsupport(PG_FUNCTION_ARGS)
 Datum
 timestamp_hash(PG_FUNCTION_ARGS)
 {
-	/* We can use either hashint8 or hashfloat8 directly */
-#ifdef HAVE_INT64_TIMESTAMP
 	return hashint8(fcinfo);
-#else
-	return hashfloat8(fcinfo);
-#endif
 }
 
 
@@ -2597,8 +2288,6 @@ timestamptz_cmp_timestamp(PG_FUNCTION_ARGS)
 
 /*
  *		interval_relop	- is interval1 relop interval2
- *
- *		collate invalid interval at the end
  */
 static inline TimeOffset
 interval_cmp_value(const Interval *interval)
@@ -2606,14 +2295,8 @@ interval_cmp_value(const Interval *interval)
 	TimeOffset	span;
 
 	span = interval->time;
-
-#ifdef HAVE_INT64_TIMESTAMP
 	span += interval->month * INT64CONST(30) * USECS_PER_DAY;
 	span += interval->day * INT64CONST(24) * USECS_PER_HOUR;
-#else
-	span += interval->month * ((double) DAYS_PER_MONTH * SECS_PER_DAY);
-	span += interval->day * ((double) HOURS_PER_DAY * SECS_PER_HOUR);
-#endif
 
 	return span;
 }
@@ -2695,7 +2378,7 @@ interval_cmp(PG_FUNCTION_ARGS)
  *
  * We must produce equal hashvals for values that interval_cmp_internal()
  * considers equal.  So, compute the net span the same way it does,
- * and then hash that, using either int64 or float8 hashing.
+ * and then hash that.
  */
 Datum
 interval_hash(PG_FUNCTION_ARGS)
@@ -2703,11 +2386,7 @@ interval_hash(PG_FUNCTION_ARGS)
 	Interval   *interval = PG_GETARG_INTERVAL_P(0);
 	TimeOffset	span = interval_cmp_value(interval);
 
-#ifdef HAVE_INT64_TIMESTAMP
 	return DirectFunctionCall1(hashint8, Int64GetDatumFast(span));
-#else
-	return DirectFunctionCall1(hashfloat8, Float8GetDatumFast(span));
-#endif
 }
 
 /* overlaps_timestamp() --- implements the SQL OVERLAPS operator.
@@ -2946,11 +2625,7 @@ interval_justify_interval(PG_FUNCTION_ARGS)
 	result->day = span->day;
 	result->time = span->time;
 
-#ifdef HAVE_INT64_TIMESTAMP
 	TMODULO(result->time, wholeday, USECS_PER_DAY);
-#else
-	TMODULO(result->time, wholeday, (double) SECS_PER_DAY);
-#endif
 	result->day += wholeday;	/* could overflow... */
 
 	wholemonth = result->day / DAYS_PER_MONTH;
@@ -2972,20 +2647,12 @@ interval_justify_interval(PG_FUNCTION_ARGS)
 
 	if (result->day > 0 && result->time < 0)
 	{
-#ifdef HAVE_INT64_TIMESTAMP
 		result->time += USECS_PER_DAY;
-#else
-		result->time += (double) SECS_PER_DAY;
-#endif
 		result->day--;
 	}
 	else if (result->day < 0 && result->time > 0)
 	{
-#ifdef HAVE_INT64_TIMESTAMP
 		result->time -= USECS_PER_DAY;
-#else
-		result->time -= (double) SECS_PER_DAY;
-#endif
 		result->day++;
 	}
 
@@ -3012,29 +2679,17 @@ interval_justify_hours(PG_FUNCTION_ARGS)
 	result->day = span->day;
 	result->time = span->time;
 
-#ifdef HAVE_INT64_TIMESTAMP
 	TMODULO(result->time, wholeday, USECS_PER_DAY);
-#else
-	TMODULO(result->time, wholeday, (double) SECS_PER_DAY);
-#endif
 	result->day += wholeday;	/* could overflow... */
 
 	if (result->day > 0 && result->time < 0)
 	{
-#ifdef HAVE_INT64_TIMESTAMP
 		result->time += USECS_PER_DAY;
-#else
-		result->time += (double) SECS_PER_DAY;
-#endif
 		result->day--;
 	}
 	else if (result->day < 0 && result->time > 0)
 	{
-#ifdef HAVE_INT64_TIMESTAMP
 		result->time -= USECS_PER_DAY;
-#else
-		result->time -= (double) SECS_PER_DAY;
-#endif
 		result->day++;
 	}
 
@@ -3492,16 +3147,12 @@ interval_mul(PG_FUNCTION_ARGS)
 
 	/* cascade units down */
 	result->day += (int32) month_remainder_days;
-#ifdef HAVE_INT64_TIMESTAMP
 	result_double = rint(span->time * factor + sec_remainder * USECS_PER_SEC);
 	if (result_double > PG_INT64_MAX || result_double < PG_INT64_MIN)
 		ereport(ERROR,
 				(errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
 				 errmsg("interval out of range")));
 	result->time = (int64) result_double;
-#else
-	result->time = span->time * factor + sec_remainder;
-#endif
 
 	PG_RETURN_INTERVAL_P(result);
 }
@@ -3553,12 +3204,7 @@ interval_div(PG_FUNCTION_ARGS)
 
 	/* cascade units down */
 	result->day += (int32) month_remainder_days;
-#ifdef HAVE_INT64_TIMESTAMP
 	result->time = rint(span->time / factor + sec_remainder * USECS_PER_SEC);
-#else
-	/* See TSROUND comment in interval_mul(). */
-	result->time = span->time / factor + sec_remainder;
-#endif
 
 	PG_RETURN_INTERVAL_P(result);
 }
@@ -3571,11 +3217,6 @@ interval_div(PG_FUNCTION_ARGS)
  * intervals, where the first is the running sum and the second contains
  * the number of values so far in its 'time' field.  This is a bit ugly
  * but it beats inventing a specialized datatype for the purpose.
- *
- * NOTE: The inverse transition function cannot guarantee exact results
- * when using float8 timestamps.  However, int8 timestamps are now the
- * norm, and the probable range of values is not so wide that disastrous
- * cancellation is likely even with float8, so we'll ignore the risk.
  */
 
 Datum
@@ -3776,11 +3417,7 @@ timestamp_age(PG_FUNCTION_ARGS)
 		/* propagate any negative fields into the next higher field */
 		while (fsec < 0)
 		{
-#ifdef HAVE_INT64_TIMESTAMP
 			fsec += USECS_PER_SEC;
-#else
-			fsec += 1.0;
-#endif
 			tm->tm_sec--;
 		}
 
@@ -3901,11 +3538,7 @@ timestamptz_age(PG_FUNCTION_ARGS)
 		/* propagate any negative fields into the next higher field */
 		while (fsec < 0)
 		{
-#ifdef HAVE_INT64_TIMESTAMP
 			fsec += USECS_PER_SEC;
-#else
-			fsec += 1.0;
-#endif
 			tm->tm_sec--;
 		}
 
@@ -4076,17 +3709,10 @@ timestamp_trunc(PG_FUNCTION_ARGS)
 				break;
 
 			case DTK_MILLISEC:
-#ifdef HAVE_INT64_TIMESTAMP
 				fsec = (fsec / 1000) * 1000;
-#else
-				fsec = floor(fsec * 1000) / 1000;
-#endif
 				break;
 
 			case DTK_MICROSEC:
-#ifndef HAVE_INT64_TIMESTAMP
-				fsec = floor(fsec * 1000000) / 1000000;
-#endif
 				break;
 
 			default:
@@ -4229,18 +3855,10 @@ timestamptz_trunc(PG_FUNCTION_ARGS)
 			case DTK_SECOND:
 				fsec = 0;
 				break;
-
 			case DTK_MILLISEC:
-#ifdef HAVE_INT64_TIMESTAMP
 				fsec = (fsec / 1000) * 1000;
-#else
-				fsec = floor(fsec * 1000) / 1000;
-#endif
 				break;
 			case DTK_MICROSEC:
-#ifndef HAVE_INT64_TIMESTAMP
-				fsec = floor(fsec * 1000000) / 1000000;
-#endif
 				break;
 
 			default:
@@ -4326,18 +3944,10 @@ interval_trunc(PG_FUNCTION_ARGS)
 				case DTK_SECOND:
 					fsec = 0;
 					break;
-
 				case DTK_MILLISEC:
-#ifdef HAVE_INT64_TIMESTAMP
 					fsec = (fsec / 1000) * 1000;
-#else
-					fsec = floor(fsec * 1000) / 1000;
-#endif
 					break;
 				case DTK_MICROSEC:
-#ifndef HAVE_INT64_TIMESTAMP
-					fsec = floor(fsec * 1000000) / 1000000;
-#endif
 					break;
 
 				default:
@@ -4669,27 +4279,15 @@ timestamp_part(PG_FUNCTION_ARGS)
 		switch (val)
 		{
 			case DTK_MICROSEC:
-#ifdef HAVE_INT64_TIMESTAMP
 				result = tm->tm_sec * 1000000.0 + fsec;
-#else
-				result = (tm->tm_sec + fsec) * 1000000;
-#endif
 				break;
 
 			case DTK_MILLISEC:
-#ifdef HAVE_INT64_TIMESTAMP
 				result = tm->tm_sec * 1000.0 + fsec / 1000.0;
-#else
-				result = (tm->tm_sec + fsec) * 1000;
-#endif
 				break;
 
 			case DTK_SECOND:
-#ifdef HAVE_INT64_TIMESTAMP
 				result = tm->tm_sec + fsec / 1000000.0;
-#else
-				result = tm->tm_sec + fsec;
-#endif
 				break;
 
 			case DTK_MINUTE:
@@ -4762,13 +4360,8 @@ timestamp_part(PG_FUNCTION_ARGS)
 
 			case DTK_JULIAN:
 				result = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday);
-#ifdef HAVE_INT64_TIMESTAMP
 				result += ((((tm->tm_hour * MINS_PER_HOUR) + tm->tm_min) * SECS_PER_MINUTE) +
 					tm->tm_sec + (fsec / 1000000.0)) / (double) SECS_PER_DAY;
-#else
-				result += ((((tm->tm_hour * MINS_PER_HOUR) + tm->tm_min) * SECS_PER_MINUTE) +
-						   tm->tm_sec + fsec) / (double) SECS_PER_DAY;
-#endif
 				break;
 
 			case DTK_ISOYEAR:
@@ -4812,15 +4405,11 @@ timestamp_part(PG_FUNCTION_ARGS)
 		{
 			case DTK_EPOCH:
 				epoch = SetEpochTimestamp();
-#ifdef HAVE_INT64_TIMESTAMP
 				/* try to avoid precision loss in subtraction */
 				if (timestamp < (PG_INT64_MAX + epoch))
 					result = (timestamp - epoch) / 1000000.0;
 				else
 					result = ((float8) timestamp - epoch) / 1000000.0;
-#else
-				result = timestamp - epoch;
-#endif
 				break;
 
 			default:
@@ -4906,27 +4495,15 @@ timestamptz_part(PG_FUNCTION_ARGS)
 				break;
 
 			case DTK_MICROSEC:
-#ifdef HAVE_INT64_TIMESTAMP
 				result = tm->tm_sec * 1000000.0 + fsec;
-#else
-				result = (tm->tm_sec + fsec) * 1000000;
-#endif
 				break;
 
 			case DTK_MILLISEC:
-#ifdef HAVE_INT64_TIMESTAMP
 				result = tm->tm_sec * 1000.0 + fsec / 1000.0;
-#else
-				result = (tm->tm_sec + fsec) * 1000;
-#endif
 				break;
 
 			case DTK_SECOND:
-#ifdef HAVE_INT64_TIMESTAMP
 				result = tm->tm_sec + fsec / 1000000.0;
-#else
-				result = tm->tm_sec + fsec;
-#endif
 				break;
 
 			case DTK_MINUTE:
@@ -4987,13 +4564,8 @@ timestamptz_part(PG_FUNCTION_ARGS)
 
 			case DTK_JULIAN:
 				result = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday);
-#ifdef HAVE_INT64_TIMESTAMP
 				result += ((((tm->tm_hour * MINS_PER_HOUR) + tm->tm_min) * SECS_PER_MINUTE) +
 					tm->tm_sec + (fsec / 1000000.0)) / (double) SECS_PER_DAY;
-#else
-				result += ((((tm->tm_hour * MINS_PER_HOUR) + tm->tm_min) * SECS_PER_MINUTE) +
-						   tm->tm_sec + fsec) / (double) SECS_PER_DAY;
-#endif
 				break;
 
 			case DTK_ISOYEAR:
@@ -5035,15 +4607,11 @@ timestamptz_part(PG_FUNCTION_ARGS)
 		{
 			case DTK_EPOCH:
 				epoch = SetEpochTimestamp();
-#ifdef HAVE_INT64_TIMESTAMP
 				/* try to avoid precision loss in subtraction */
 				if (timestamp < (PG_INT64_MAX + epoch))
 					result = (timestamp - epoch) / 1000000.0;
 				else
 					result = ((float8) timestamp - epoch) / 1000000.0;
-#else
-				result = timestamp - epoch;
-#endif
 				break;
 
 			default:
@@ -5099,27 +4667,15 @@ interval_part(PG_FUNCTION_ARGS)
 			switch (val)
 			{
 				case DTK_MICROSEC:
-#ifdef HAVE_INT64_TIMESTAMP
 					result = tm->tm_sec * 1000000.0 + fsec;
-#else
-					result = (tm->tm_sec + fsec) * 1000000;
-#endif
 					break;
 
 				case DTK_MILLISEC:
-#ifdef HAVE_INT64_TIMESTAMP
 					result = tm->tm_sec * 1000.0 + fsec / 1000.0;
-#else
-					result = (tm->tm_sec + fsec) * 1000;
-#endif
 					break;
 
 				case DTK_SECOND:
-#ifdef HAVE_INT64_TIMESTAMP
 					result = tm->tm_sec + fsec / 1000000.0;
-#else
-					result = tm->tm_sec + fsec;
-#endif
 					break;
 
 				case DTK_MINUTE:
@@ -5178,11 +4734,7 @@ interval_part(PG_FUNCTION_ARGS)
 	}
 	else if (type == RESERV && val == DTK_EPOCH)
 	{
-#ifdef HAVE_INT64_TIMESTAMP
 		result = interval->time / 1000000.0;
-#else
-		result = interval->time;
-#endif
 		result += ((double) DAYS_PER_YEAR * SECS_PER_DAY) * (interval->month / MONTHS_PER_YEAR);
 		result += ((double) DAYS_PER_MONTH * SECS_PER_DAY) * (interval->month % MONTHS_PER_YEAR);
 		result += ((double) SECS_PER_DAY) * interval->day;
@@ -5338,11 +4890,7 @@ timestamp_izone(PG_FUNCTION_ARGS)
 				 DatumGetCString(DirectFunctionCall1(interval_out,
 												  PointerGetDatum(zone))))));
 
-#ifdef HAVE_INT64_TIMESTAMP
 	tz = zone->time / USECS_PER_SEC;
-#else
-	tz = zone->time;
-#endif
 
 	result = dt2local(timestamp, tz);
 
@@ -5539,11 +5087,7 @@ timestamptz_izone(PG_FUNCTION_ARGS)
 				 DatumGetCString(DirectFunctionCall1(interval_out,
 												  PointerGetDatum(zone))))));
 
-#ifdef HAVE_INT64_TIMESTAMP
 	tz = -(zone->time / USECS_PER_SEC);
-#else
-	tz = -zone->time;
-#endif
 
 	result = dt2local(timestamp, tz);
 
diff --git a/src/backend/utils/misc/guc.c b/src/backend/utils/misc/guc.c
index 24771389c84..0707f666311 100644
--- a/src/backend/utils/misc/guc.c
+++ b/src/backend/utils/misc/guc.c
@@ -1507,11 +1507,7 @@ static struct config_bool ConfigureNamesBool[] =
 			GUC_REPORT | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
 		},
 		&integer_datetimes,
-#ifdef HAVE_INT64_TIMESTAMP
 		true,
-#else
-		false,
-#endif
 		NULL, NULL, NULL
 	},