Index: include/llvm/Target/TargetLowering.h
===================================================================
--- include/llvm/Target/TargetLowering.h	(revision 41716)
+++ include/llvm/Target/TargetLowering.h	(working copy)
@@ -22,6 +22,7 @@
 #ifndef LLVM_TARGET_TARGETLOWERING_H
 #define LLVM_TARGET_TARGETLOWERING_H
 
+#include "llvm/Templates.h"
 #include "llvm/CodeGen/SelectionDAGNodes.h"
 #include "llvm/CodeGen/RuntimeLibcalls.h"
 #include "llvm/ADT/APFloat.h"
@@ -155,7 +156,7 @@
     void setTypeAction(MVT::ValueType VT, LegalizeAction Action) {
       assert(!MVT::isExtendedVT(VT));
       assert(unsigned(VT >> 4) < 
-             sizeof(ValueTypeActions)/sizeof(ValueTypeActions[0]));
+             llvm::lengthof(ValueTypeActions));
       ValueTypeActions[VT>>4] |= Action << ((VT*2) & 31);
     }
   };
@@ -711,7 +712,7 @@
   /// with the specified type and indicate what to do about it.
   void setOperationAction(unsigned Op, MVT::ValueType VT,
                           LegalizeAction Action) {
-    assert(VT < 32 && Op < sizeof(OpActions)/sizeof(OpActions[0]) &&
+    assert(VT < 32 && Op < llvm::lengthof(OpActions) &&
            "Table isn't big enough!");
     OpActions[Op] &= ~(uint64_t(3UL) << VT*2);
     OpActions[Op] |= (uint64_t)Action << VT*2;
@@ -721,7 +722,7 @@
   /// work with the with specified type and indicate what to do about it.
   void setLoadXAction(unsigned ExtType, MVT::ValueType VT,
                       LegalizeAction Action) {
-    assert(VT < 32 && ExtType < sizeof(LoadXActions)/sizeof(LoadXActions[0]) &&
+    assert(VT < 32 && ExtType < llvm::lengthof(LoadXActions) &&
            "Table isn't big enough!");
     LoadXActions[ExtType] &= ~(uint64_t(3UL) << VT*2);
     LoadXActions[ExtType] |= (uint64_t)Action << VT*2;
@@ -742,7 +743,7 @@
   void setIndexedLoadAction(unsigned IdxMode, MVT::ValueType VT,
                             LegalizeAction Action) {
     assert(VT < 32 && IdxMode <
-           sizeof(IndexedModeActions[0]) / sizeof(IndexedModeActions[0][0]) &&
+           llvm::lengthof(IndexedModeActions[0]) &&
            "Table isn't big enough!");
     IndexedModeActions[0][IdxMode] &= ~(uint64_t(3UL) << VT*2);
     IndexedModeActions[0][IdxMode] |= (uint64_t)Action << VT*2;
@@ -755,7 +756,7 @@
   void setIndexedStoreAction(unsigned IdxMode, MVT::ValueType VT,
                              LegalizeAction Action) {
     assert(VT < 32 && IdxMode <
-           sizeof(IndexedModeActions[1]) / sizeof(IndexedModeActions[1][0]) &&
+           llvm::lengthof(IndexedModeActions[1]) &&
            "Table isn't big enough!");
     IndexedModeActions[1][IdxMode] &= ~(uint64_t(3UL) << VT*2);
     IndexedModeActions[1][IdxMode] |= (uint64_t)Action << VT*2;
Index: include/llvm/Templates.h
===================================================================
--- include/llvm/Templates.h	(revision 0)
+++ include/llvm/Templates.h	(revision 0)
@@ -0,0 +1,39 @@
+//===- Templates.h - Miscellaneous Templates ------------------*- C++ -*-===//
+//
+//                      The LLVM Compiler Infrastructure
+//
+// This file was developed by Sterling Stein and is distributed under the
+// University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===--------------------------------------------------------------------===//
+//
+// This file provides miscellaneous templates.
+//
+//===--------------------------------------------------------------------===//
+
+#ifndef LLVM_TEMPLATES_H
+#define LLVM_TEMPLATES_H
+
+#include <cstring> //For size_t
+
+namespace llvm {
+
+  /// Find where an array ends (for ending iterators)
+  /// This returns a pointer to the byte immediately
+  /// after the end of an array.
+  template<class T, std::size_t N>
+  inline T *endof(T (&x)[N])
+  {
+    return x+N;
+  }
+
+  /// Find the length of an array.
+  template<class T, std::size_t N>
+  inline size_t lengthof(T (&x)[N])
+  {
+    return N;
+  }
+
+}
+
+#endif
Index: lib/Analysis/BasicAliasAnalysis.cpp
===================================================================
--- lib/Analysis/BasicAliasAnalysis.cpp	(revision 41716)
+++ lib/Analysis/BasicAliasAnalysis.cpp	(working copy)
@@ -23,6 +23,7 @@
 #include "llvm/Instructions.h"
 #include "llvm/Intrinsics.h"
 #include "llvm/Pass.h"
+#include "llvm/Templates.h"
 #include "llvm/Target/TargetData.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
@@ -888,14 +889,10 @@
   static bool Initialized = false;
   if (!Initialized) {
     NoMemoryTable->insert(NoMemoryTable->end(),
-                          DoesntAccessMemoryFns, 
-                          DoesntAccessMemoryFns+
-                sizeof(DoesntAccessMemoryFns)/sizeof(DoesntAccessMemoryFns[0]));
+                          DoesntAccessMemoryFns, endof(DoesntAccessMemoryFns));
 
     OnlyReadsMemoryTable->insert(OnlyReadsMemoryTable->end(),
-                                OnlyReadsMemoryFns, 
-                                OnlyReadsMemoryFns+
-                      sizeof(OnlyReadsMemoryFns)/sizeof(OnlyReadsMemoryFns[0]));
+                                OnlyReadsMemoryFns, endof(OnlyReadsMemoryFns));
 
     // Sort the table the first time through.
     std::sort(NoMemoryTable->begin(), NoMemoryTable->end(), StringCompare());
Index: lib/CodeGen/IntrinsicLowering.cpp
===================================================================
--- lib/CodeGen/IntrinsicLowering.cpp	(revision 41716)
+++ lib/CodeGen/IntrinsicLowering.cpp	(working copy)
@@ -15,6 +15,7 @@
 #include "llvm/DerivedTypes.h"
 #include "llvm/Module.h"
 #include "llvm/Instructions.h"
+#include "llvm/Templates.h"
 #include "llvm/Type.h"
 #include "llvm/CodeGen/IntrinsicLowering.h"
 #include "llvm/Support/Streams.h"
@@ -421,7 +422,7 @@
     CI->getOperand(2),
     CI->getOperand(3)
   };
-  return new CallInst(F, Args, Args+sizeof(Args)/sizeof(Args[0]), CI->getName(), CI);
+  return new CallInst(F, Args, endof(Args), CI->getName(), CI);
 }
 
 /// Convert the llvm.part.set.iX.iY.iZ intrinsic. This intrinsic takes 
@@ -587,7 +588,7 @@
     CI->getOperand(3),
     CI->getOperand(4)
   };
-  return new CallInst(F, Args, Args+sizeof(Args)/sizeof(Args[0]), CI->getName(), CI);
+  return new CallInst(F, Args, endof(Args), CI->getName(), CI);
 }
 
 
Index: lib/CodeGen/SelectionDAG/TargetLowering.cpp
===================================================================
--- lib/CodeGen/SelectionDAG/TargetLowering.cpp	(revision 41716)
+++ lib/CodeGen/SelectionDAG/TargetLowering.cpp	(working copy)
@@ -145,8 +145,7 @@
   ShiftAmountTy = SetCCResultTy = PointerTy = getValueType(TD->getIntPtrType());
   ShiftAmtHandling = Undefined;
   memset(RegClassForVT, 0,MVT::LAST_VALUETYPE*sizeof(TargetRegisterClass*));
-  memset(TargetDAGCombineArray, 0, 
-         sizeof(TargetDAGCombineArray)/sizeof(TargetDAGCombineArray[0]));
+  memset(TargetDAGCombineArray, 0, lengthof(TargetDAGCombineArray));
   maxStoresPerMemset = maxStoresPerMemcpy = maxStoresPerMemmove = 8;
   allowUnalignedMemoryAccesses = false;
   UseUnderscoreSetJmp = false;
Index: lib/System/Unix/Signals.inc
===================================================================
--- lib/System/Unix/Signals.inc	(revision 41716)
+++ lib/System/Unix/Signals.inc	(working copy)
@@ -13,6 +13,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "Unix.h"
+#include "llvm/Templates.h"
 #include <vector>
 #include <algorithm>
 #if HAVE_EXECINFO_H
@@ -40,7 +41,7 @@
 const int IntSigs[] = {
   SIGHUP, SIGINT, SIGQUIT, SIGPIPE, SIGTERM, SIGUSR1, SIGUSR2
 };
-const int *IntSigsEnd = IntSigs + sizeof(IntSigs)/sizeof(IntSigs[0]);
+const int *IntSigsEnd = endof(IntSigs);
 
 // KillSigs - Signals that are synchronous with the program that will cause it
 // to die.
@@ -50,7 +51,7 @@
   , SIGEMT
 #endif
 };
-const int *KillSigsEnd = KillSigs + sizeof(KillSigs)/sizeof(KillSigs[0]);
+const int *KillSigsEnd = endof(KillSigs);
 
 #ifdef HAVE_BACKTRACE
 void* StackTrace[256];
@@ -68,7 +69,7 @@
 void PrintStackTrace() {
 #ifdef HAVE_BACKTRACE
   // Use backtrace() to output a backtrace on Linux systems with glibc.
-  int depth = backtrace(StackTrace, sizeof(StackTrace)/sizeof(StackTrace[0]));
+  int depth = backtrace(StackTrace, lengthof(StackTrace));
   
   // Create a one-way unix pipe.  The backtracing process writes to PipeFDs[1],
   // the c++filt process reads from PipeFDs[0].
Index: lib/Target/PowerPC/PPCISelLowering.cpp
===================================================================
--- lib/Target/PowerPC/PPCISelLowering.cpp	(revision 41716)
+++ lib/Target/PowerPC/PPCISelLowering.cpp	(working copy)
@@ -16,6 +16,7 @@
 #include "PPCPredicates.h"
 #include "PPCTargetMachine.h"
 #include "PPCPerfectShuffle.h"
+#include "llvm/Templates.h"
 #include "llvm/ADT/VectorExtras.h"
 #include "llvm/Analysis/ScalarEvolutionExpressions.h"
 #include "llvm/CodeGen/CallingConvLower.h"
@@ -1264,9 +1265,9 @@
     PPC::V9, PPC::V10, PPC::V11, PPC::V12, PPC::V13
   };
 
-  const unsigned Num_GPR_Regs = sizeof(GPR_32)/sizeof(GPR_32[0]);
+  const unsigned Num_GPR_Regs = lengthof(GPR_32);
   const unsigned Num_FPR_Regs = isMachoABI ? 13 : 8;
-  const unsigned Num_VR_Regs  = sizeof( VR)/sizeof( VR[0]);
+  const unsigned Num_VR_Regs  = lengthof( VR);
 
   unsigned GPR_idx = 0, FPR_idx = 0, VR_idx = 0;
   
@@ -1583,9 +1584,9 @@
     PPC::V2, PPC::V3, PPC::V4, PPC::V5, PPC::V6, PPC::V7, PPC::V8,
     PPC::V9, PPC::V10, PPC::V11, PPC::V12, PPC::V13
   };
-  const unsigned NumGPRs = sizeof(GPR_32)/sizeof(GPR_32[0]);
+  const unsigned NumGPRs = lengthof(GPR_32);
   const unsigned NumFPRs = isMachoABI ? 13 : 8;
-  const unsigned NumVRs  = sizeof( VR)/sizeof( VR[0]);
+  const unsigned NumVRs  = lengthof( VR);
   
   const unsigned *GPR = isPPC64 ? GPR_64 : GPR_32;
 
@@ -2399,7 +2400,7 @@
       -8, 8, -9, 9, -10, 10, -11, 11, -12, 12, -13, 13, 14, -14, 15, -15, -16
     };
     
-    for (unsigned idx = 0; idx < sizeof(SplatCsts)/sizeof(SplatCsts[0]); ++idx){
+    for (unsigned idx = 0; idx < lengthof(SplatCsts); ++idx){
       // Indirect through the SplatCsts array so that we favor 'vsplti -1' for
       // cases which are ambiguous (e.g. formation of 0x8000_0000).  'vsplti -1'
       int i = SplatCsts[idx];
Index: lib/Target/PowerPC/PPCInstrInfo.cpp
===================================================================
--- lib/Target/PowerPC/PPCInstrInfo.cpp	(revision 41716)
+++ lib/Target/PowerPC/PPCInstrInfo.cpp	(working copy)
@@ -15,11 +15,12 @@
 #include "PPCPredicates.h"
 #include "PPCGenInstrInfo.inc"
 #include "PPCTargetMachine.h"
+#include "llvm/Templates.h"
 #include "llvm/CodeGen/MachineInstrBuilder.h"
 using namespace llvm;
 
 PPCInstrInfo::PPCInstrInfo(PPCTargetMachine &tm)
-  : TargetInstrInfo(PPCInsts, sizeof(PPCInsts)/sizeof(PPCInsts[0])), TM(tm),
+  : TargetInstrInfo(PPCInsts, lengthof(PPCInsts)), TM(tm),
     RI(*TM.getSubtargetImpl(), *this) {}
 
 /// getPointerRegClass - Return the register class to use to hold pointers.
Index: lib/Target/ARM/ARMInstrInfo.cpp
===================================================================
--- lib/Target/ARM/ARMInstrInfo.cpp	(revision 41716)
+++ lib/Target/ARM/ARMInstrInfo.cpp	(working copy)
@@ -17,6 +17,7 @@
 #include "ARMAddressingModes.h"
 #include "ARMGenInstrInfo.inc"
 #include "ARMMachineFunctionInfo.h"
+#include "llvm/Templates.h"
 #include "llvm/CodeGen/LiveVariables.h"
 #include "llvm/CodeGen/MachineInstrBuilder.h"
 #include "llvm/CodeGen/MachineJumpTableInfo.h"
@@ -28,7 +29,7 @@
                                   cl::desc("Enable ARM 2-addr to 3-addr conv"));
 
 ARMInstrInfo::ARMInstrInfo(const ARMSubtarget &STI)
-  : TargetInstrInfo(ARMInsts, sizeof(ARMInsts)/sizeof(ARMInsts[0])),
+  : TargetInstrInfo(ARMInsts, lengthof(ARMInsts)),
     RI(*this, STI) {
 }
 
Index: lib/Target/Alpha/AlphaInstrInfo.cpp
===================================================================
--- lib/Target/Alpha/AlphaInstrInfo.cpp	(revision 41716)
+++ lib/Target/Alpha/AlphaInstrInfo.cpp	(working copy)
@@ -14,11 +14,12 @@
 #include "Alpha.h"
 #include "AlphaInstrInfo.h"
 #include "AlphaGenInstrInfo.inc"
+#include "llvm/Templates.h"
 #include "llvm/CodeGen/MachineInstrBuilder.h"
 using namespace llvm;
 
 AlphaInstrInfo::AlphaInstrInfo()
-  : TargetInstrInfo(AlphaInsts, sizeof(AlphaInsts)/sizeof(AlphaInsts[0])),
+  : TargetInstrInfo(AlphaInsts, lengthof(AlphaInsts)),
     RI(*this) { }
 
 
Index: lib/Target/X86/X86RegisterInfo.cpp
===================================================================
--- lib/Target/X86/X86RegisterInfo.cpp	(revision 41716)
+++ lib/Target/X86/X86RegisterInfo.cpp	(working copy)
@@ -20,6 +20,7 @@
 #include "X86TargetMachine.h"
 #include "llvm/Constants.h"
 #include "llvm/Function.h"
+#include "llvm/Templates.h"
 #include "llvm/Type.h"
 #include "llvm/CodeGen/ValueTypes.h"
 #include "llvm/CodeGen/MachineInstrBuilder.h"
@@ -392,16 +393,13 @@
   return NULL;
 }
 
-#define ARRAY_SIZE(TABLE)  \
-   (sizeof(TABLE)/sizeof(TABLE[0]))
-
 #ifdef NDEBUG
 #define ASSERT_SORTED(TABLE)
 #else
 #define ASSERT_SORTED(TABLE)                                              \
   { static bool TABLE##Checked = false;                                   \
     if (!TABLE##Checked) {                                                \
-       assert(TableIsSorted(TABLE, ARRAY_SIZE(TABLE)) &&                  \
+       assert(TableIsSorted(TABLE, lengthof(TABLE)) &&                    \
               "All lookup tables must be sorted for efficient access!");  \
        TABLE##Checked = true;                                             \
     }                                                                     \
@@ -590,7 +588,7 @@
     };
     ASSERT_SORTED(OpcodeTable);
     OpcodeTablePtr = OpcodeTable;
-    OpcodeTableSize = ARRAY_SIZE(OpcodeTable);
+    OpcodeTableSize = lengthof(OpcodeTable);
     isTwoAddrFold = true;
   } else if (i == 0) { // If operand 0
     if (MI->getOpcode() == X86::MOV16r0)
@@ -675,7 +673,7 @@
 
     ASSERT_SORTED(OpcodeTable);
     OpcodeTablePtr = OpcodeTable;
-    OpcodeTableSize = ARRAY_SIZE(OpcodeTable);
+    OpcodeTableSize = lengthof(OpcodeTable);
   } else if (i == 1) {
     static const TableEntry OpcodeTable[] = {
       { X86::CMP16rr,         X86::CMP16rm },
@@ -784,7 +782,7 @@
 
     ASSERT_SORTED(OpcodeTable);
     OpcodeTablePtr = OpcodeTable;
-    OpcodeTableSize = ARRAY_SIZE(OpcodeTable);
+    OpcodeTableSize = lengthof(OpcodeTable);
   } else if (i == 2) {
     static const TableEntry OpcodeTable[] = {
       { X86::ADC32rr,         X86::ADC32rm },
@@ -979,7 +977,7 @@
 
     ASSERT_SORTED(OpcodeTable);
     OpcodeTablePtr = OpcodeTable;
-    OpcodeTableSize = ARRAY_SIZE(OpcodeTable);
+    OpcodeTableSize = lengthof(OpcodeTable);
   }
   
   // If table selected...
Index: lib/Target/X86/X86InstrInfo.cpp
===================================================================
--- lib/Target/X86/X86InstrInfo.cpp	(revision 41716)
+++ lib/Target/X86/X86InstrInfo.cpp	(working copy)
@@ -17,13 +17,14 @@
 #include "X86InstrBuilder.h"
 #include "X86Subtarget.h"
 #include "X86TargetMachine.h"
+#include "llvm/Templates.h"
 #include "llvm/CodeGen/MachineInstrBuilder.h"
 #include "llvm/CodeGen/LiveVariables.h"
 #include "llvm/CodeGen/SSARegMap.h"
 using namespace llvm;
 
 X86InstrInfo::X86InstrInfo(X86TargetMachine &tm)
-  : TargetInstrInfo(X86Insts, sizeof(X86Insts)/sizeof(X86Insts[0])),
+  : TargetInstrInfo(X86Insts, lengthof(X86Insts)),
     TM(tm), RI(tm, *this) {
 }
 
Index: lib/Target/X86/X86FloatingPoint.cpp
===================================================================
--- lib/Target/X86/X86FloatingPoint.cpp	(revision 41716)
+++ lib/Target/X86/X86FloatingPoint.cpp	(working copy)
@@ -31,6 +31,7 @@
 #define DEBUG_TYPE "x86-codegen"
 #include "X86.h"
 #include "X86InstrInfo.h"
+#include "llvm/Templates.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/CodeGen/MachineInstrBuilder.h"
 #include "llvm/CodeGen/LiveVariables.h"
@@ -299,16 +300,13 @@
   return -1;
 }
 
-#define ARRAY_SIZE(TABLE)  \
-   (sizeof(TABLE)/sizeof(TABLE[0]))
-
 #ifdef NDEBUG
 #define ASSERT_SORTED(TABLE)
 #else
 #define ASSERT_SORTED(TABLE)                                              \
   { static bool TABLE##Checked = false;                                   \
     if (!TABLE##Checked) {                                                \
-       assert(TableIsSorted(TABLE, ARRAY_SIZE(TABLE)) &&                  \
+       assert(TableIsSorted(TABLE, lengthof(TABLE)) &&                    \
               "All lookup tables must be sorted for efficient access!");  \
        TABLE##Checked = true;                                             \
     }                                                                     \
@@ -487,7 +485,7 @@
 
 static unsigned getConcreteOpcode(unsigned Opcode) {
   ASSERT_SORTED(OpcodeTable);
-  int Opc = Lookup(OpcodeTable, ARRAY_SIZE(OpcodeTable), Opcode);
+  int Opc = Lookup(OpcodeTable, lengthof(OpcodeTable), Opcode);
   assert(Opc != -1 && "FP Stack instruction not in OpcodeTable!");
   return Opc;
 }
@@ -535,7 +533,7 @@
   RegMap[Stack[--StackTop]] = ~0;     // Update state
 
   // Check to see if there is a popping version of this instruction...
-  int Opcode = Lookup(PopTable, ARRAY_SIZE(PopTable), I->getOpcode());
+  int Opcode = Lookup(PopTable, lengthof(PopTable), I->getOpcode());
   if (Opcode != -1) {
     I->setInstrDescriptor(TII->get(Opcode));
     if (Opcode == X86::UCOM_FPPr)
@@ -830,7 +828,7 @@
       InstTable = ReverseSTiTable;
   }
 
-  int Opcode = Lookup(InstTable, ARRAY_SIZE(ForwardST0Table), MI->getOpcode());
+  int Opcode = Lookup(InstTable, lengthof(ForwardST0Table), MI->getOpcode());
   assert(Opcode != -1 && "Unknown TwoArgFP pseudo instruction!");
 
   // NotTOS - The register which is not on the top of stack...
Index: lib/Target/IA64/IA64InstrInfo.cpp
===================================================================
--- lib/Target/IA64/IA64InstrInfo.cpp	(revision 41716)
+++ lib/Target/IA64/IA64InstrInfo.cpp	(working copy)
@@ -14,12 +14,13 @@
 #include "IA64InstrInfo.h"
 #include "IA64.h"
 #include "IA64InstrBuilder.h"
+#include "llvm/Templates.h"
 #include "llvm/CodeGen/MachineInstrBuilder.h"
 #include "IA64GenInstrInfo.inc"
 using namespace llvm;
 
 IA64InstrInfo::IA64InstrInfo()
-  : TargetInstrInfo(IA64Insts, sizeof(IA64Insts)/sizeof(IA64Insts[0])),
+  : TargetInstrInfo(IA64Insts, lengthof(IA64Insts)),
     RI(*this) {
 }
 
Index: lib/Target/Mips/MipsInstrInfo.cpp
===================================================================
--- lib/Target/Mips/MipsInstrInfo.cpp	(revision 41716)
+++ lib/Target/Mips/MipsInstrInfo.cpp	(working copy)
@@ -13,6 +13,7 @@
 
 #include "Mips.h"
 #include "MipsInstrInfo.h"
+#include "llvm/Templates.h"
 #include "llvm/CodeGen/MachineInstrBuilder.h"
 #include "MipsGenInstrInfo.inc"
 
@@ -20,7 +21,7 @@
 
 // TODO: Add the subtarget support on this constructor
 MipsInstrInfo::MipsInstrInfo(MipsTargetMachine &tm)
-  : TargetInstrInfo(MipsInsts, sizeof(MipsInsts)/sizeof(MipsInsts[0])),
+  : TargetInstrInfo(MipsInsts, lengthof(MipsInsts)),
     TM(tm), RI(*this) {}
 
 static bool isZeroImm(const MachineOperand &op) {
Index: lib/Target/Sparc/SparcInstrInfo.cpp
===================================================================
--- lib/Target/Sparc/SparcInstrInfo.cpp	(revision 41716)
+++ lib/Target/Sparc/SparcInstrInfo.cpp	(working copy)
@@ -13,12 +13,13 @@
 
 #include "SparcInstrInfo.h"
 #include "Sparc.h"
+#include "llvm/Templates.h"
 #include "llvm/CodeGen/MachineInstrBuilder.h"
 #include "SparcGenInstrInfo.inc"
 using namespace llvm;
 
 SparcInstrInfo::SparcInstrInfo(SparcSubtarget &ST)
-  : TargetInstrInfo(SparcInsts, sizeof(SparcInsts)/sizeof(SparcInsts[0])),
+  : TargetInstrInfo(SparcInsts, lengthof(SparcInsts)),
     RI(ST, *this) {
 }
 
Index: lib/VMCore/Mangler.cpp
===================================================================
--- lib/VMCore/Mangler.cpp	(revision 41716)
+++ lib/VMCore/Mangler.cpp	(working copy)
@@ -14,6 +14,7 @@
 #include "llvm/Support/Mangler.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/Module.h"
+#include "llvm/Templates.h"
 #include "llvm/ADT/StringExtras.h"
 using namespace llvm;
 
@@ -185,9 +186,7 @@
 Mangler::Mangler(Module &M, const char *prefix)
   : Prefix(prefix), UseQuotes(false), PreserveAsmNames(false),
     Count(0), TypeCounter(0) {
-  std::fill(AcceptableChars, 
-          AcceptableChars+sizeof(AcceptableChars)/sizeof(AcceptableChars[0]),
-            0);
+  std::fill(AcceptableChars, endof(AcceptableChars), 0);
 
   // Letters and numbers are acceptable.
   for (unsigned char X = 'a'; X <= 'z'; ++X)
