merge in lmp-release history after reset to c891e24073

For silvermont, the __popcountsi2 symbol does not get exported by libc.
But for atom, this symbol is exported. Since we already exported this symbol
for previous releases, it's better to just follow through and force
the export, but only for 32 bit. x86 64 bit will not export this symbol.

Bug: 17681440
Change-Id: I6c62245f0960910f64baaaf6d9d090bf3ea5f435

tests/sys_resource_test.cpp

@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-#include <sys/resource.h>
-
 #include <gtest/gtest.h>
 
+#include <sys/resource.h>
+
 #if defined(__GLIBC__)
 /* The host glibc we're currently building with doesn't have prlimit64 yet. */
 static int prlimit64(pid_t, int resource, const struct rlimit64* new_limit, struct rlimit64* old_limit) {
@@ -29,7 +29,7 @@ static int prlimit64(pid_t, int resource, const struct rlimit64* new_limit, stru
 }
 #endif
 
-TEST(sys_resource, rlimit_struct_size) {
+TEST(sys_resource, smoke) {
 #if defined(__LP64__) || defined(__GLIBC__)
   ASSERT_EQ(sizeof(rlimit), sizeof(rlimit64));
   ASSERT_EQ(8U, sizeof(rlim_t));
@@ -37,75 +37,51 @@ TEST(sys_resource, rlimit_struct_size) {
   ASSERT_NE(sizeof(rlimit), sizeof(rlimit64));
   ASSERT_EQ(4U, sizeof(rlim_t));
 #endif
-}
 
-class SysResourceTest : public ::testing::Test {
- protected:
-  virtual void SetUp() {
-    ASSERT_EQ(0, getrlimit(RLIMIT_CORE, &l32_));
-    ASSERT_EQ(0, getrlimit64(RLIMIT_CORE, &l64_));
-    ASSERT_EQ(0, prlimit64(0, RLIMIT_CORE, NULL, &pr_l64_));
-  }
-
-  void CheckResourceLimits();
-
- protected:
-  rlimit l32_;
-  rlimit64 l64_;
-  rlimit64 pr_l64_;
-};
-
-void SysResourceTest::CheckResourceLimits() {
-  ASSERT_EQ(0, getrlimit(RLIMIT_CORE, &l32_));
-  ASSERT_EQ(0, getrlimit64(RLIMIT_CORE, &l64_));
-  ASSERT_EQ(0, prlimit64(0, RLIMIT_CORE, NULL, &pr_l64_));
-  ASSERT_EQ(l64_.rlim_cur, pr_l64_.rlim_cur);
-  if (l64_.rlim_cur == RLIM64_INFINITY) {
-    ASSERT_EQ(RLIM_INFINITY, l32_.rlim_cur);
+  // Read with getrlimit, getrlimit64, and prlimit64.
+  // (prlimit is prlimit64 on LP64 and unimplemented on 32-bit.)
+  rlimit l32;
+  rlimit64 l64;
+  rlimit64 pr_l64;
+  ASSERT_EQ(0, getrlimit(RLIMIT_CORE, &l32));
+  ASSERT_EQ(0, getrlimit64(RLIMIT_CORE, &l64));
+  ASSERT_EQ(0, prlimit64(0, RLIMIT_CORE, NULL, &pr_l64));
+  ASSERT_EQ(l64.rlim_cur, l32.rlim_cur);
+  ASSERT_EQ(l64.rlim_cur, pr_l64.rlim_cur);
+  ASSERT_EQ(l64.rlim_max, pr_l64.rlim_max);
+  if (l64.rlim_max == RLIM64_INFINITY) {
+    ASSERT_EQ(RLIM_INFINITY, l32.rlim_max);
   } else {
-    ASSERT_EQ(l64_.rlim_cur, l32_.rlim_cur);
+    ASSERT_EQ(l64.rlim_max, l32.rlim_max);
   }
 
-  ASSERT_EQ(l64_.rlim_max, pr_l64_.rlim_max);
-  if (l64_.rlim_max == RLIM64_INFINITY) {
-    ASSERT_EQ(RLIM_INFINITY, l32_.rlim_max);
-  } else {
-    ASSERT_EQ(l64_.rlim_max, l32_.rlim_max);
-  }
-}
+  // Write with setrlimit and read back with everything.
+  l32.rlim_cur = 123;
+  ASSERT_EQ(0, setrlimit(RLIMIT_CORE, &l32));
+  ASSERT_EQ(0, getrlimit(RLIMIT_CORE, &l32));
+  ASSERT_EQ(0, getrlimit64(RLIMIT_CORE, &l64));
+  ASSERT_EQ(0, prlimit64(0, RLIMIT_CORE, NULL, &pr_l64));
+  ASSERT_EQ(123U, l32.rlim_cur);
+  ASSERT_EQ(l64.rlim_cur, l32.rlim_cur);
+  ASSERT_EQ(l64.rlim_cur, pr_l64.rlim_cur);
 
-// Force rlim_max to be bigger than a constant so we can continue following test.
-// Change resource limit setting with "ulimit -Hc" in the shell if this test fails.
-TEST_F(SysResourceTest, RLIMIT_CORE_rlim_max_not_zero) {
-  ASSERT_TRUE(l32_.rlim_max == RLIM_INFINITY || l32_.rlim_max >= 456U) <<
-    "RLIMIT_CORE rlim_max = " << l32_.rlim_max;
-}
+  // Write with setrlimit64 and read back with everything.
+  l64.rlim_cur = 456;
+  ASSERT_EQ(0, setrlimit64(RLIMIT_CORE, &l64));
+  ASSERT_EQ(0, getrlimit(RLIMIT_CORE, &l32));
+  ASSERT_EQ(0, getrlimit64(RLIMIT_CORE, &l64));
+  ASSERT_EQ(0, prlimit64(0, RLIMIT_CORE, NULL, &pr_l64));
+  ASSERT_EQ(456U, l32.rlim_cur);
+  ASSERT_EQ(l64.rlim_cur, l32.rlim_cur);
+  ASSERT_EQ(l64.rlim_cur, pr_l64.rlim_cur);
 
-TEST_F(SysResourceTest, get_resource_limit_equal) {
-  CheckResourceLimits();
-}
-
-TEST_F(SysResourceTest, setrlimit) {
-  l32_.rlim_cur = 123U;
-  ASSERT_EQ(0, setrlimit(RLIMIT_CORE, &l32_));
-  CheckResourceLimits();
-  ASSERT_EQ(123U, l32_.rlim_cur);
-}
-
-TEST_F(SysResourceTest, setrlimit64) {
-  l64_.rlim_cur = 456U;
-  ASSERT_EQ(0, setrlimit64(RLIMIT_CORE, &l64_));
-  CheckResourceLimits();
-  ASSERT_EQ(456U, l64_.rlim_cur);
-}
-
-TEST_F(SysResourceTest, prlimit64) {
-  pr_l64_.rlim_cur = pr_l64_.rlim_max;
-  ASSERT_EQ(0, prlimit64(0, RLIMIT_CORE, &pr_l64_, NULL));
-  CheckResourceLimits();
-  ASSERT_EQ(pr_l64_.rlim_max, pr_l64_.rlim_cur);
-}
-
-TEST_F(SysResourceTest, prlimit) {
-  // prlimit is prlimit64 on LP64 and unimplemented on 32-bit. So we only test prlimit64.
+  // Write with prlimit64 and read back with everything.
+  l64.rlim_cur = 789;
+  ASSERT_EQ(0, prlimit64(0, RLIMIT_CORE, &l64, NULL));
+  ASSERT_EQ(0, getrlimit(RLIMIT_CORE, &l32));
+  ASSERT_EQ(0, getrlimit64(RLIMIT_CORE, &l64));
+  ASSERT_EQ(0, prlimit64(0, RLIMIT_CORE, NULL, &pr_l64));
+  ASSERT_EQ(789U, l32.rlim_cur);
+  ASSERT_EQ(l64.rlim_cur, l32.rlim_cur);
+  ASSERT_EQ(l64.rlim_cur, pr_l64.rlim_cur);
 }