diff --git a/runtime/vm/compiler/aot/aot_call_specializer.cc b/runtime/vm/compiler/aot/aot_call_specializer.cc
index 1e6a8b3..6e363f4 100644
--- a/runtime/vm/compiler/aot/aot_call_specializer.cc
+++ b/runtime/vm/compiler/aot/aot_call_specializer.cc
@@ -415,6 +415,44 @@
          TryOptimizeDoubleOperation(instr, op_kind);
 }
 
+// Modulo against a constant power-of-two can be optimized into a mask.
+// x % y -> x & (y - 1)
+Definition* AotCallSpecializer::TryOptimizeMod(TemplateDartCall<0>* instr,
+                                               Token::Kind op_kind,
+                                               Value* left_value,
+                                               Value* right_value) {
+  if (!right_value->BindsToConstant()) {
+    return nullptr;
+  }
+
+  const Object& rhs = right_value->BoundConstant();
+  int64_t modulus =
+      abs(rhs.IsSmi() ? Smi::Cast(rhs).Value() : Mint::Cast(rhs).value());
+  if (!Utils::IsPowerOfTwo(modulus) || !Smi::IsValid(modulus - 1)) {
+    return nullptr;
+  }
+
+  left_value = PrepareStaticOpInput(left_value, kMintCid, instr);
+
+#if defined(TARGET_ARCH_ARM)
+  Definition* right_definition = new (Z) UnboxedConstantInstr(
+      Smi::ZoneHandle(Z, Smi::New(modulus - 1)), kUnboxedInt32);
+  InsertBefore(instr, right_definition, /*env=*/NULL, FlowGraph::kValue);
+  right_definition = new (Z)
+      UnboxedIntConverterInstr(kUnboxedInt32, kUnboxedInt64,
+                               new (Z) Value(right_definition), DeoptId::kNone);
+  InsertBefore(instr, right_definition, /*env=*/NULL, FlowGraph::kValue);
+#else
+  Definition* right_definition = new (Z) UnboxedConstantInstr(
+      Smi::ZoneHandle(Z, Smi::New(modulus - 1)), kUnboxedInt64);
+  InsertBefore(instr, right_definition, /*env=*/NULL, FlowGraph::kValue);
+#endif
+  right_value = new (Z) Value(right_definition);
+  return new (Z)
+      BinaryInt64OpInstr(Token::kBIT_AND, left_value, right_value,
+                         DeoptId::kNone, Instruction::kNotSpeculative);
+}
+
 bool AotCallSpecializer::TryOptimizeIntegerOperation(TemplateDartCall<0>* instr,
                                                      Token::Kind op_kind) {
   if (instr->type_args_len() != 0) {
@@ -500,10 +538,13 @@
         }
         break;
       }
-#if defined(TARGET_ARCH_X64) || defined(TARGET_ARCH_ARM64)
-        // TODO(ajcbik): 32-bit archs too?
       case Token::kMOD:
+        replacement = TryOptimizeMod(instr, op_kind, left_value, right_value);
+        if (replacement != nullptr) break;
       case Token::kTRUNCDIV:
+#if !defined(TARGET_ARCH_X64) && !defined(TARGET_ARCH_ARM64)
+        // TODO(ajcbik): 32-bit archs too?
+        break;
 #endif
       case Token::kSHL:
       case Token::kSHR:
diff --git a/runtime/vm/compiler/aot/aot_call_specializer.h b/runtime/vm/compiler/aot/aot_call_specializer.h
index 404f2ba..c40aa8b 100644
--- a/runtime/vm/compiler/aot/aot_call_specializer.h
+++ b/runtime/vm/compiler/aot/aot_call_specializer.h
@@ -66,6 +66,11 @@
   bool TryExpandCallThroughGetter(const Class& receiver_class,
                                   InstanceCallInstr* call);
 
+  Definition* TryOptimizeMod(TemplateDartCall<0>* instr,
+                             Token::Kind op_kind,
+                             Value* left_value,
+                             Value* right_value);
+
   Precompiler* precompiler_;
 
   bool has_unique_no_such_method_;
diff --git a/tests/language_2/vm/bitnot_int_test.dart b/tests/language_2/vm/bitnot_int_test.dart
new file mode 100644
index 0000000..f52d66b
--- /dev/null
+++ b/tests/language_2/vm/bitnot_int_test.dart
@@ -0,0 +1,45 @@
+// Copyright (c) 2019, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// VMOptions=--no_background_compilation --optimization_counter_threshold=10
+
+import "package:expect/expect.dart";
+
+// Tests for long bit-not under 64-bit arithmetic wrap-around semantics.
+
+final int maxInt32 = 2147483647;
+final int minInt32 = -2147483648;
+final int maxInt64 = 0x7fffffffffffffff;
+final int minInt64 = 0x8000000000000000;
+
+int bitnot(int x) {
+  return ~x;
+}
+
+doConstant() {
+  Expect.equals(0, bitnot(-1));
+  Expect.equals(-1, bitnot(0));
+  Expect.equals(-2, bitnot(1));
+
+  Expect.equals(minInt32, bitnot(maxInt32));
+  Expect.equals(maxInt32, bitnot(minInt32));
+  Expect.equals(minInt64, bitnot(maxInt64));
+  Expect.equals(maxInt64, bitnot(minInt64)); // sic!
+}
+
+doVar() {
+  int d = 0;
+  for (int i = -88; i < 10; i++) {
+    d += bitnot(i);
+  }
+  Expect.equals(3773, d);
+}
+
+main() {
+  // Repeat tests to enter JIT (when applicable).
+  for (int i = 0; i < 20; i++) {
+    doConstant();
+    doVar();
+  }
+}
diff --git a/tests/language_2/vm/modtruncdiv_int_test.dart b/tests/language_2/vm/modtruncdiv_int_test.dart
index 7a84d1a..b51811d 100644
--- a/tests/language_2/vm/modtruncdiv_int_test.dart
+++ b/tests/language_2/vm/modtruncdiv_int_test.dart
@@ -79,6 +79,13 @@
   Expect.equals(1, mod(maxInt32 + 1, maxInt32));
   Expect.equals(maxInt32 - 2, mod(minInt32 - 1, maxInt32));
   Expect.equals(0, mod(minInt32 + 1, maxInt32));
+
+  Expect.equals(15, mod(-1, 16));
+  Expect.equals(15, mod(-17, 16));
+  Expect.equals(100, mod(100, 1 << 32));
+  Expect.equals((1 << 32) - 1, mod((1 << 35) - 1, 1 << 32));
+  Expect.equals(maxInt64, mod(-1, 1 << 63));
+  Expect.equals(0, mod(minInt64, 1 << 63));
 }
 
 doTruncDivConstants() {