[lld-macho][nfc] Use alignToPowerOf2 instead of alignTo when possible

[int3]

Summary

Skips the divide operation which is generally expensive. Not that it
matters in this diff, the code changed is not particularly hot, but just
for principle & consistency...

[oontvoo]

LG

[MaskRay]

I did the same for lld/ELF. Not that it mattered much, but generated code sequence was slightly better.

lld/MachO/Writer.cpp

public:
   ExportSection *exportSection;
 };
 
 class LCSubFramework final : public LoadCommand {
 public:
   LCSubFramework(StringRef umbrella) : umbrella(umbrella) {}
 
   uint32_t getSize() const override {
-    return alignTo(sizeof(sub_framework_command) + umbrella.size() + 1,
+    return alignToPowerOf2(sizeof(sub_framework_command) + umbrella.size() + 1,
                            target->wordSize);
   }
 
   void writeTo(uint8_t *buf) const override {
     auto *c = reinterpret_cast<sub_framework_command *>(buf);
     buf += sizeof(sub_framework_command);
 
     c->cmd = LC_SUB_FRAMEWORK;
     c->cmdsize = getSize();
private:
   const StringRef path = "/usr/lib/dyld";
 };
 
 class LCRPath final : public LoadCommand {
 public:
   explicit LCRPath(StringRef path) : path(path) {}
 
   uint32_t getSize() const override {
-    return alignTo(sizeof(rpath_command) + path.size() + 1, target->wordSize);
+    return alignToPowerOf2(sizeof(rpath_command) + path.size() + 1,
+                           target->wordSize);
   }
 
   void writeTo(uint8_t *buf) const override {
     auto *c = reinterpret_cast<rpath_command *>(buf);
     buf += sizeof(rpath_command);
 
     c->cmd = LC_RPATH;
     c->cmdsize = getSize();
     c->path = sizeof(rpath_command);
 
     memcpy(buf, path.data(), path.size());
     buf[path.size()] = '\0';
   }
 
 private:
   StringRef path;
 };
 
 class LCDyldEnv final : public LoadCommand {
 public:
   explicit LCDyldEnv(StringRef name) : name(name) {}
 
   uint32_t getSize() const override {
-    return alignTo(sizeof(dyld_env_command) + name.size() + 1,
+    return alignToPowerOf2(sizeof(dyld_env_command) + name.size() + 1,
                            target->wordSize);
   }
 
   void writeTo(uint8_t *buf) const override {
     auto *c = reinterpret_cast<dyld_env_command *>(buf);
     buf += sizeof(dyld_env_command);
 
     c->cmd = LC_DYLD_ENVIRONMENT;
     c->cmdsize = getSize();
for (OutputSegment *seg : outputSegments) {
     if (seg == linkEditSegment)
       continue;
     seg->addr = addr;
     assignAddresses(seg);
     // codesign / libstuff checks for segment ordering by verifying that
     // `fileOff + fileSize == next segment fileOff`. So we call alignTo() before
     // (instead of after) computing fileSize to ensure that the segments are
     // contiguous. We handle addr / vmSize similarly for the same reason.
-    fileOff = alignTo(fileOff, pageSize);
-    addr = alignTo(addr, pageSize);
+    fileOff = alignToPowerOf2(fileOff, pageSize);
+    addr = alignToPowerOf2(addr, pageSize);
     seg->vmSize = addr - seg->addr;
     seg->fileSize = fileOff - seg->fileOff;
     seg->assignAddressesToStartEndSymbols();
   }
 }
 
 void Writer::finalizeLinkEditSegment() {
   TimeTraceScope timeScope("Finalize __LINKEDIT segment");