tree 4826ffb9200b294318989f1f36f18ba6e6ef08cb
parent 28df6bad8e70d9930040464791296e192aaa03ef
author Jim Stichnoth <stichnot@chromium.org> 1454867427 -0800
committer Jim Stichnoth <stichnot@chromium.org> 1454867427 -0800

Subzero: Clean up some uses of *_cast<>.

Some casts to size_t for use as array indexes are simply unnecessary.

Some explicit declaration types are changed to "auto" to avoid redundancy with the static_cast type.

A few llvm::dyn_cast<> operations are changed to llvm::cast<>, and vice versa.

A few explicit declaration types are changed to "auto" when used with llvm::cast<> and llvm::dynamic_cast<>.  Some of these were missed during an earlier cleansing because of multi-line issues.

There are still a few opportunities related to Variable register numbers, but they are ignored for now because they are being addressed in another CL.

BUG= none
R=jpp@chromium.org

Review URL: https://codereview.chromium.org/1674033002 .
