Quick Compiler: Shoot the Camel

Another step towards moving the Quick Compiler from the old
Dalvik coding style to Art's coding style.  In this CL, Camel-case
locals, struct variables and arguments are converted to lower-case
with underscore names.  Most of the name changes were formulistic,
but I also took this opportunity to change the old "printMe" into
the more traditional "verbose", and shorten cUnit to cu.

No logic changes.

Change-Id: I64b69b28a8357d5cc0abc1dc975954c91abd9b45

1 files changed, 74 insertions, 74 deletions

diff --git a/src/compiler/codegen/ralloc_util.h b/src/compiler/codegen/ralloc_util.h
index 31fda52c82..4e897ca580 100644
--- a/src/compiler/codegen/ralloc_util.h
+++ b/src/compiler/codegen/ralloc_util.h
@@ -30,140 +30,140 @@ namespace art {
 /* Static register use counts */
 struct RefCounts {
   int count;
-  int sReg;
-  bool doubleStart;   // Starting vReg for a double
+  int s_reg;
+  bool double_start;   // Starting v_reg for a double
 };
 
 
 /*
- * Get the "real" sreg number associated with an sReg slot.  In general,
- * sReg values passed through codegen are the SSA names created by
- * dataflow analysis and refer to slot numbers in the cUnit->regLocation
+ * Get the "real" sreg number associated with an s_reg slot.  In general,
+ * s_reg values passed through codegen are the SSA names created by
+ * dataflow analysis and refer to slot numbers in the cu->reg_location
  * array.  However, renaming is accomplished by simply replacing RegLocation
- * entries in the cUnit->reglocation[] array.  Therefore, when location
+ * entries in the cu->reglocation[] array.  Therefore, when location
  * records for operands are first created, we need to ask the locRecord
  * identified by the dataflow pass what it's new name is.
  */
 
-inline int oatSRegHi(int lowSreg) {
+inline int GetSRegHi(int lowSreg) {
   return (lowSreg == INVALID_SREG) ? INVALID_SREG : lowSreg + 1;
 }
 
 
-inline bool oatLiveOut(CompilationUnit* cUnit, int sReg) {
+inline bool oat_live_out(CompilationUnit* cu, int s_reg) {
   //For now.
   return true;
 }
 
 inline int oatSSASrc(MIR* mir, int num) {
-  DCHECK_GT(mir->ssaRep->numUses, num);
-  return mir->ssaRep->uses[num];
+  DCHECK_GT(mir->ssa_rep->num_uses, num);
+  return mir->ssa_rep->uses[num];
 }
 
-void ClobberSReg(CompilationUnit* cUnit, int sReg);
-RegLocation EvalLoc(CompilationUnit* cUnit, RegLocation loc,
-                              int regClass, bool update);
+void ClobberSReg(CompilationUnit* cu, int s_reg);
+RegLocation EvalLoc(CompilationUnit* cu, RegLocation loc,
+                              int reg_class, bool update);
 /* Mark a temp register as dead.  Does not affect allocation state. */
-void Clobber(CompilationUnit* cUnit, int reg);
-RegLocation UpdateLoc(CompilationUnit* cUnit, RegLocation loc);
+void Clobber(CompilationUnit* cu, int reg);
+RegLocation UpdateLoc(CompilationUnit* cu, RegLocation loc);
 
-/* see comments for updateLoc */
-RegLocation UpdateLocWide(CompilationUnit* cUnit, RegLocation loc);
+/* see comments for update_loc */
+RegLocation UpdateLocWide(CompilationUnit* cu, RegLocation loc);
 
-RegLocation UpdateRawLoc(CompilationUnit* cUnit, RegLocation loc);
+RegLocation UpdateRawLoc(CompilationUnit* cu, RegLocation loc);
 
-void MarkLive(CompilationUnit* cUnit, int reg, int sReg);
+void MarkLive(CompilationUnit* cu, int reg, int s_reg);
 
-void MarkTemp(CompilationUnit* cUnit, int reg);
+void MarkTemp(CompilationUnit* cu, int reg);
 
-void UnmarkTemp(CompilationUnit* cUnit, int reg);
+void UnmarkTemp(CompilationUnit* cu, int reg);
 
-void MarkDirty(CompilationUnit* cUnit, RegLocation loc);
+void MarkDirty(CompilationUnit* cu, RegLocation loc);
 
-void MarkPair(CompilationUnit* cUnit, int lowReg, int highReg);
+void MarkPair(CompilationUnit* cu, int low_reg, int high_reg);
 
-void MarkClean(CompilationUnit* cUnit, RegLocation loc);
+void MarkClean(CompilationUnit* cu, RegLocation loc);
 
-void ResetDef(CompilationUnit* cUnit, int reg);
+void ResetDef(CompilationUnit* cu, int reg);
 
-void ResetDefLoc(CompilationUnit* cUnit, RegLocation rl);
+void ResetDefLoc(CompilationUnit* cu, RegLocation rl);
 
 /* Set up temp & preserved register pools specialized by target */
-void CompilerInitPool(RegisterInfo* regs, int* regNums, int num);
+void CompilerInitPool(RegisterInfo* regs, int* reg_nums, int num);
 
 /*
  * Mark the beginning and end LIR of a def sequence.  Note that
  * on entry start points to the LIR prior to the beginning of the
  * sequence.
  */
-void MarkDef(CompilationUnit* cUnit, RegLocation rl, LIR* start,
+void MarkDef(CompilationUnit* cu, RegLocation rl, LIR* start,
                        LIR* finish);
 /*
  * Mark the beginning and end LIR of a def sequence.  Note that
  * on entry start points to the LIR prior to the beginning of the
  * sequence.
  */
-void MarkDefWide(CompilationUnit* cUnit, RegLocation rl,
+void MarkDefWide(CompilationUnit* cu, RegLocation rl,
                            LIR* start, LIR* finish);
 
 
 // Get the LocRecord associated with an SSA name use.
-RegLocation GetSrc(CompilationUnit* cUnit, MIR* mir, int num);
-RegLocation GetSrcWide(CompilationUnit* cUnit, MIR* mir, int low);
+RegLocation GetSrc(CompilationUnit* cu, MIR* mir, int num);
+RegLocation GetSrcWide(CompilationUnit* cu, MIR* mir, int low);
 // Non-width checking version
-RegLocation GetRawSrc(CompilationUnit* cUnit, MIR* mir, int num);
+RegLocation GetRawSrc(CompilationUnit* cu, MIR* mir, int num);
 
 // Get the LocRecord associated with an SSA name def.
-RegLocation GetDest(CompilationUnit* cUnit, MIR* mir);
-RegLocation GetDestWide(CompilationUnit* cUnit, MIR* mir);
+RegLocation GetDest(CompilationUnit* cu, MIR* mir);
+RegLocation GetDestWide(CompilationUnit* cu, MIR* mir);
 // Non-width checking version
-RegLocation GetRawDest(CompilationUnit* cUnit, MIR* mir);
+RegLocation GetRawDest(CompilationUnit* cu, MIR* mir);
 
-RegLocation GetReturnWide(CompilationUnit* cUnit, bool isDouble);
+RegLocation GetReturnWide(CompilationUnit* cu, bool is_double);
 
 /* Clobber all regs that might be used by an external C call */
-void ClobberCalleeSave(CompilationUnit* cUnit);
+void ClobberCalleeSave(CompilationUnit* cu);
 
-RegisterInfo *IsTemp(CompilationUnit* cUnit, int reg);
+RegisterInfo *IsTemp(CompilationUnit* cu, int reg);
 
-RegisterInfo *IsPromoted(CompilationUnit* cUnit, int reg);
+RegisterInfo *IsPromoted(CompilationUnit* cu, int reg);
 
-bool IsDirty(CompilationUnit* cUnit, int reg);
+bool IsDirty(CompilationUnit* cu, int reg);
 
-void MarkInUse(CompilationUnit* cUnit, int reg);
+void MarkInUse(CompilationUnit* cu, int reg);
 
-int AllocTemp(CompilationUnit* cUnit);
+int AllocTemp(CompilationUnit* cu);
 
-int AllocTempFloat(CompilationUnit* cUnit);
+int AllocTempFloat(CompilationUnit* cu);
 
 //REDO: too many assumptions.
-int AllocTempDouble(CompilationUnit* cUnit);
+int AllocTempDouble(CompilationUnit* cu);
 
-void FreeTemp(CompilationUnit* cUnit, int reg);
+void FreeTemp(CompilationUnit* cu, int reg);
 
-void ResetDefLocWide(CompilationUnit* cUnit, RegLocation rl);
+void ResetDefLocWide(CompilationUnit* cu, RegLocation rl);
 
-void ResetDefTracking(CompilationUnit* cUnit);
+void ResetDefTracking(CompilationUnit* cu);
 
-RegisterInfo *IsLive(CompilationUnit* cUnit, int reg);
+RegisterInfo *IsLive(CompilationUnit* cu, int reg);
 
 /* To be used when explicitly managing register use */
-void LockCallTemps(CompilationUnit* cUnit);
+void LockCallTemps(CompilationUnit* cu);
 
-void FreeCallTemps(CompilationUnit* cUnit);
+void FreeCallTemps(CompilationUnit* cu);
 
-void FlushAllRegs(CompilationUnit* cUnit);
+void FlushAllRegs(CompilationUnit* cu);
 
-RegLocation GetReturnWideAlt(CompilationUnit* cUnit);
+RegLocation GetReturnWideAlt(CompilationUnit* cu);
 
-RegLocation GetReturn(CompilationUnit* cUnit, bool isFloat);
+RegLocation GetReturn(CompilationUnit* cu, bool is_float);
 
-RegLocation GetReturnAlt(CompilationUnit* cUnit);
+RegLocation GetReturnAlt(CompilationUnit* cu);
 
-/* Clobber any temp associated with an sReg.  Could be in either class */
+/* Clobber any temp associated with an s_reg.  Could be in either class */
 
 /* Return a temp if one is available, -1 otherwise */
-int AllocFreeTemp(CompilationUnit* cUnit);
+int AllocFreeTemp(CompilationUnit* cu);
 
 /* Attempt to allocate a callee-save register */
 /*
@@ -171,44 +171,44 @@ int AllocFreeTemp(CompilationUnit* cUnit);
  * register.  No check is made to see if the register was previously
  * allocated.  Use with caution.
  */
-void LockTemp(CompilationUnit* cUnit, int reg);
+void LockTemp(CompilationUnit* cu, int reg);
 
-RegLocation WideToNarrow(CompilationUnit* cUnit, RegLocation rl);
+RegLocation WideToNarrow(CompilationUnit* cu, RegLocation rl);
 
 /*
  * Free all allocated temps in the temp pools.  Note that this does
  * not affect the "liveness" of a temp register, which will stay
  * live until it is either explicitly killed or reallocated.
  */
-void ResetRegPool(CompilationUnit* cUnit);
+void ResetRegPool(CompilationUnit* cu);
 
-void ClobberAllRegs(CompilationUnit* cUnit);
+void ClobberAllRegs(CompilationUnit* cu);
 
-void FlushRegWide(CompilationUnit* cUnit, int reg1, int reg2);
+void FlushRegWide(CompilationUnit* cu, int reg1, int reg2);
 
-void FlushReg(CompilationUnit* cUnit, int reg);
+void FlushReg(CompilationUnit* cu, int reg);
 
-void DoPromotion(CompilationUnit* cUnit);
-int VRegOffset(CompilationUnit* cUnit, int reg);
-int SRegOffset(CompilationUnit* cUnit, int reg);
-void RecordCorePromotion(CompilationUnit* cUnit, int reg, int sReg);
-void RecordFpPromotion(CompilationUnit* cUnit, int reg, int sReg);
+void DoPromotion(CompilationUnit* cu);
+int VRegOffset(CompilationUnit* cu, int reg);
+int SRegOffset(CompilationUnit* cu, int reg);
+void RecordCorePromotion(CompilationUnit* cu, int reg, int s_reg);
+void RecordFpPromotion(CompilationUnit* cu, int reg, int s_reg);
 
 
 /* Architecture-dependent register allocation routines. */
-int AllocTypedTempPair(CompilationUnit* cUnit,
-                                 bool fpHint, int regClass);
+int AllocTypedTempPair(CompilationUnit* cu,
+                                 bool fp_hint, int reg_class);
 
-int AllocTypedTemp(CompilationUnit* cUnit, bool fpHint, int regClass);
+int AllocTypedTemp(CompilationUnit* cu, bool fp_hint, int reg_class);
 
 void oatDumpFPRegPool(CompilationUnit* cUint);
-RegisterInfo* GetRegInfo(CompilationUnit* cUnit, int reg);
+RegisterInfo* GetRegInfo(CompilationUnit* cu, int reg);
 void NopLIR(LIR* lir);
 bool oatIsFPReg(int reg);
 uint32_t oatFPRegMask(void);
-void AdjustSpillMask(CompilationUnit* cUnit);
-void MarkPreservedSingle(CompilationUnit* cUnit, int vReg, int reg);
-int ComputeFrameSize(CompilationUnit* cUnit);
+void AdjustSpillMask(CompilationUnit* cu);
+void MarkPreservedSingle(CompilationUnit* cu, int v_reg, int reg);
+int ComputeFrameSize(CompilationUnit* cu);
 
 }  // namespace art