johann/cpu_features
1
0
Fork 0
mirror of https://github.com/google/cpu_features.git synced 2025-04-28 07:23:37 +02:00
Code Issues Releases Wiki Activity

Merge pull request #35 from Leandros/master

Browse Source 
Explicitly namespace every extern identifier
This commit is contained in:
Guillaume Chatelet 2018-05-04 09:50:07 +02:00 committed by GitHub
commit a5093bbe7c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
17 changed files with 245 additions and 190 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
include/internal/filesystem.h
View File

@ -24,14 +24,14 @@
CPU_FEATURES_START_CPP_NAMESPACE
// Same as linux "open(filename, O_RDONLY)", retries automatically on EINTR.
int OpenFile(const char* filename);
int CpuFeatures_OpenFile(const char* filename);
// Same as linux "read(file_descriptor, buffer, buffer_size)", retries
// automatically on EINTR.
int ReadFile(int file_descriptor, void* buffer, size_t buffer_size);
int CpuFeatures_ReadFile(int file_descriptor, void* buffer, size_t buffer_size);
// Same as linux "close(file_descriptor)".
void CloseFile(int file_descriptor);
void CpuFeatures_CloseFile(int file_descriptor);
CPU_FEATURES_END_CPP_NAMESPACE

2
include/internal/hwcaps.h
View File

@ -66,7 +66,7 @@ typedef struct {
uint32_t hwcaps2;
} HardwareCapabilities;
HardwareCapabilities GetHardwareCapabilities(void);
HardwareCapabilities CpuFeatures_GetHardwareCapabilities(void);
CPU_FEATURES_END_CPP_NAMESPACE

8
include/internal/linux_features_aggregator.h
View File

@ -43,13 +43,15 @@ typedef struct {
// For every config, looks into flags_line for the presence of the
// corresponding proc_cpuinfo_flag, calls `set_bit` accordingly.
// Note: features is a pointer to the underlying Feature struct.
void SetFromFlags(const size_t configs_size, const CapabilityConfig* configs,
const StringView flags_line, void* const features);
void CpuFeatures_SetFromFlags(const size_t configs_size,
const CapabilityConfig* configs,
const StringView flags_line,
void* const features);
// For every config, looks into hwcaps for the presence of the feature. Calls
// `set_bit` with true if the hardware capability is found.
// Note: features is a pointer to the underlying Feature struct.
void OverrideFromHwCaps(const size_t configs_size,
void CpuFeatures_OverrideFromHwCaps(const size_t configs_size,
const CapabilityConfig* configs,
const HardwareCapabilities hwcaps,
void* const features);

34
include/internal/string_view.h
View File

@ -46,54 +46,60 @@ static inline StringView view(const char* str, const size_t size) {
static inline StringView str(const char* str) { return view(str, strlen(str)); }
// Returns the index of the first occurrence of c in view or -1 if not found.
int IndexOfChar(const StringView view, char c);
int CpuFeatures_StringView_IndexOfChar(const StringView view, char c);
// Returns the index of the first occurrence of sub_view in view or -1 if not
// found.
int IndexOf(const StringView view, const StringView sub_view);
int CpuFeatures_StringView_IndexOf(const StringView view,
const StringView sub_view);
// Returns whether a is equal to b (same content).
bool IsEquals(const StringView a, const StringView b);
bool CpuFeatures_StringView_IsEquals(const StringView a, const StringView b);
// Returns whether a starts with b.
bool StartsWith(const StringView a, const StringView b);
bool CpuFeatures_StringView_StartsWith(const StringView a, const StringView b);
// Removes count characters from the beginning of view or kEmptyStringView if
// count if greater than view.size.
StringView PopFront(const StringView view, size_t count);
StringView CpuFeatures_StringView_PopFront(const StringView view, size_t count);
// Removes count characters from the end of view or kEmptyStringView if count if
// greater than view.size.
StringView PopBack(const StringView str_view, size_t count);
StringView CpuFeatures_StringView_PopBack(const StringView str_view,
size_t count);
// Keeps the count first characters of view or view if count if greater than
// view.size.
StringView KeepFront(const StringView view, size_t count);
StringView CpuFeatures_StringView_KeepFront(const StringView view,
size_t count);
// Retrieves the first character of view. If view is empty the behavior is
// undefined.
char Front(const StringView view);
char CpuFeatures_StringView_Front(const StringView view);
// Retrieves the last character of view. If view is empty the behavior is
// undefined.
char Back(const StringView view);
char CpuFeatures_StringView_Back(const StringView view);
// Removes leading and tailing space characters.
StringView TrimWhitespace(StringView view);
StringView CpuFeatures_StringView_TrimWhitespace(StringView view);
// Convert StringView to positive integer. e.g. "42", "0x2a".
// Returns -1 on error.
int ParsePositiveNumber(const StringView view);
int CpuFeatures_StringView_ParsePositiveNumber(const StringView view);
// Copies src StringView to dst buffer.
void CopyString(const StringView src, char* dst, size_t dst_size);
void CpuFeatures_StringView_CopyString(const StringView src, char* dst,
size_t dst_size);
// Checks if line contains the specified whitespace separated word.
bool HasWord(const StringView line, const char* const word);
bool CpuFeatures_StringView_HasWord(const StringView line,
const char* const word);
// Get key/value from line. key and value are separated by ": ".
// key and value are cleaned up from leading and trailing whitespaces.
bool GetAttributeKeyValue(const StringView line, StringView* key,
bool CpuFeatures_StringView_GetAttributeKeyValue(const StringView line,
StringView* key,
StringView* value);
CPU_FEATURES_END_CPP_NAMESPACE

29
src/cpuinfo_aarch64.c
View File

@ -46,24 +46,24 @@ static bool HandleAarch64Line(const LineResult result,
Aarch64Info* const info) {
StringView line = result.line;
StringView key, value;
if (GetAttributeKeyValue(line, &key, &value)) {
if (IsEquals(key, str("Features"))) {
SetFromFlags(kConfigsSize, kConfigs, value, &info->features);
} else if (IsEquals(key, str("CPU implementer"))) {
info->implementer = ParsePositiveNumber(value);
} else if (IsEquals(key, str("CPU variant"))) {
info->variant = ParsePositiveNumber(value);
} else if (IsEquals(key, str("CPU part"))) {
info->part = ParsePositiveNumber(value);
} else if (IsEquals(key, str("CPU revision"))) {
info->revision = ParsePositiveNumber(value);
if (CpuFeatures_StringView_GetAttributeKeyValue(line, &key, &value)) {
if (CpuFeatures_StringView_IsEquals(key, str("Features"))) {
CpuFeatures_SetFromFlags(kConfigsSize, kConfigs, value, &info->features);
} else if (CpuFeatures_StringView_IsEquals(key, str("CPU implementer"))) {
info->implementer = CpuFeatures_StringView_ParsePositiveNumber(value);
} else if (CpuFeatures_StringView_IsEquals(key, str("CPU variant"))) {
info->variant = CpuFeatures_StringView_ParsePositiveNumber(value);
} else if (CpuFeatures_StringView_IsEquals(key, str("CPU part"))) {
info->part = CpuFeatures_StringView_ParsePositiveNumber(value);
} else if (CpuFeatures_StringView_IsEquals(key, str("CPU revision"))) {
info->revision = CpuFeatures_StringView_ParsePositiveNumber(value);
}
}
return !result.eof;
}
static void FillProcCpuInfoData(Aarch64Info* const info) {
const int fd = OpenFile("/proc/cpuinfo");
const int fd = CpuFeatures_OpenFile("/proc/cpuinfo");
if (fd >= 0) {
StackLineReader reader;
StackLineReader_Initialize(&reader, fd);
@ -72,7 +72,7 @@ static void FillProcCpuInfoData(Aarch64Info* const info) {
break;
}
}
CloseFile(fd);
CpuFeatures_CloseFile(fd);
}
}
@ -85,7 +85,8 @@ Aarch64Info GetAarch64Info(void) {
Aarch64Info info = kEmptyAarch64Info;
FillProcCpuInfoData(&info);
OverrideFromHwCaps(kConfigsSize, kConfigs, GetHardwareCapabilities(),
CpuFeatures_OverrideFromHwCaps(kConfigsSize, kConfigs,
CpuFeatures_GetHardwareCapabilities(),
&info.features);
return info;

50
src/cpuinfo_arm.c
View File

@ -62,8 +62,8 @@ typedef struct {
static int IndexOfNonDigit(StringView str) {
size_t index = 0;
while (str.size && isdigit(Front(str))) {
str = PopFront(str, 1);
while (str.size && isdigit(CpuFeatures_StringView_Front(str))) {
str = CpuFeatures_StringView_PopFront(str, 1);
++index;
}
return index;
@ -73,26 +73,29 @@ static bool HandleArmLine(const LineResult result, ArmInfo* const info,
ProcCpuInfoData* const proc_info) {
StringView line = result.line;
StringView key, value;
if (GetAttributeKeyValue(line, &key, &value)) {
if (IsEquals(key, str("Features"))) {
SetFromFlags(kConfigsSize, kConfigs, value, &info->features);
} else if (IsEquals(key, str("CPU implementer"))) {
info->implementer = ParsePositiveNumber(value);
} else if (IsEquals(key, str("CPU variant"))) {
info->variant = ParsePositiveNumber(value);
} else if (IsEquals(key, str("CPU part"))) {
info->part = ParsePositiveNumber(value);
} else if (IsEquals(key, str("CPU revision"))) {
info->revision = ParsePositiveNumber(value);
} else if (IsEquals(key, str("CPU architecture"))) {
if (CpuFeatures_StringView_GetAttributeKeyValue(line, &key, &value)) {
if (CpuFeatures_StringView_IsEquals(key, str("Features"))) {
CpuFeatures_SetFromFlags(kConfigsSize, kConfigs, value, &info->features);
} else if (CpuFeatures_StringView_IsEquals(key, str("CPU implementer"))) {
info->implementer = CpuFeatures_StringView_ParsePositiveNumber(value);
} else if (CpuFeatures_StringView_IsEquals(key, str("CPU variant"))) {
info->variant = CpuFeatures_StringView_ParsePositiveNumber(value);
} else if (CpuFeatures_StringView_IsEquals(key, str("CPU part"))) {
info->part = CpuFeatures_StringView_ParsePositiveNumber(value);
} else if (CpuFeatures_StringView_IsEquals(key, str("CPU revision"))) {
info->revision = CpuFeatures_StringView_ParsePositiveNumber(value);
} else if (CpuFeatures_StringView_IsEquals(key, str("CPU architecture"))) {
// CPU architecture is a number that may be followed by letters. e.g.
// "6TEJ", "7".
const StringView digits = KeepFront(value, IndexOfNonDigit(value));
info->architecture = ParsePositiveNumber(digits);
} else if (IsEquals(key, str("Processor"))) {
proc_info->processor_reports_armv6 = IndexOf(value, str("(v6l)")) >= 0;
} else if (IsEquals(key, str("Hardware"))) {
proc_info->hardware_reports_goldfish = IsEquals(value, str("Goldfish"));
const StringView digits =
CpuFeatures_StringView_KeepFront(value, IndexOfNonDigit(value));
info->architecture = CpuFeatures_StringView_ParsePositiveNumber(digits);
} else if (CpuFeatures_StringView_IsEquals(key, str("Processor"))) {
proc_info->processor_reports_armv6 =
CpuFeatures_StringView_IndexOf(value, str("(v6l)")) >= 0;
} else if (CpuFeatures_StringView_IsEquals(key, str("Hardware"))) {
proc_info->hardware_reports_goldfish =
CpuFeatures_StringView_IsEquals(value, str("Goldfish"));
}
}
return !result.eof;
@ -148,7 +151,7 @@ static void FixErrors(ArmInfo* const info,
static void FillProcCpuInfoData(ArmInfo* const info,
ProcCpuInfoData* proc_cpu_info_data) {
const int fd = OpenFile("/proc/cpuinfo");
const int fd = CpuFeatures_OpenFile("/proc/cpuinfo");
if (fd >= 0) {
StackLineReader reader;
StackLineReader_Initialize(&reader, fd);
@ -158,7 +161,7 @@ static void FillProcCpuInfoData(ArmInfo* const info,
break;
}
}
CloseFile(fd);
CpuFeatures_CloseFile(fd);
}
}
@ -174,7 +177,8 @@ ArmInfo GetArmInfo(void) {
ProcCpuInfoData proc_cpu_info_data = kEmptyProcCpuInfoData;
FillProcCpuInfoData(&info, &proc_cpu_info_data);
OverrideFromHwCaps(kConfigsSize, kConfigs, GetHardwareCapabilities(),
CpuFeatures_OverrideFromHwCaps(kConfigsSize, kConfigs,
CpuFeatures_GetHardwareCapabilities(),
&info.features);
FixErrors(&info, &proc_cpu_info_data);

13
src/cpuinfo_mips.c
View File

@ -32,16 +32,16 @@ static bool HandleMipsLine(const LineResult result,
MipsFeatures* const features) {
StringView key, value;
// See tests for an example.
if (GetAttributeKeyValue(result.line, &key, &value)) {
if (IsEquals(key, str("ASEs implemented"))) {
SetFromFlags(kConfigsSize, kConfigs, value, features);
if (CpuFeatures_StringView_GetAttributeKeyValue(result.line, &key, &value)) {
if (CpuFeatures_StringView_IsEquals(key, str("ASEs implemented"))) {
CpuFeatures_SetFromFlags(kConfigsSize, kConfigs, value, features);
}
}
return !result.eof;
}
static void FillProcCpuInfoData(MipsFeatures* const features) {
const int fd = OpenFile("/proc/cpuinfo");
const int fd = CpuFeatures_OpenFile("/proc/cpuinfo");
if (fd >= 0) {
StackLineReader reader;
StackLineReader_Initialize(&reader, fd);
@ -50,7 +50,7 @@ static void FillProcCpuInfoData(MipsFeatures* const features) {
break;
}
}
CloseFile(fd);
CpuFeatures_CloseFile(fd);
}
}
@ -63,7 +63,8 @@ MipsInfo GetMipsInfo(void) {
MipsInfo info = kEmptyMipsInfo;
FillProcCpuInfoData(&info.features);
OverrideFromHwCaps(kConfigsSize, kConfigs, GetHardwareCapabilities(),
CpuFeatures_OverrideFromHwCaps(kConfigsSize, kConfigs,
CpuFeatures_GetHardwareCapabilities(),
&info.features);
return info;
}

16
src/filesystem.c
View File

@ -21,18 +21,21 @@
#if defined(_MSC_VER)
#include <io.h>
int OpenFile(const char* filename) { return _open(filename, _O_RDONLY); }
int CpuFeatures_OpenFile(const char* filename) {
return _open(filename, _O_RDONLY);
}
void CloseFile(int file_descriptor) { _close(file_descriptor); }
void CpuFeatures_CloseFile(int file_descriptor) { _close(file_descriptor); }
int ReadFile(int file_descriptor, void* buffer, size_t buffer_size) {
int CpuFeatures_ReadFile(int file_descriptor, void* buffer,
size_t buffer_size) {
return _read(file_descriptor, buffer, buffer_size);
}
#else
#include <unistd.h>
int OpenFile(const char* filename) {
int CpuFeatures_OpenFile(const char* filename) {
int result;
do {
result = open(filename, O_RDONLY);
@ -40,9 +43,10 @@ int OpenFile(const char* filename) {
return result;
}
void CloseFile(int file_descriptor) { close(file_descriptor); }
void CpuFeatures_CloseFile(int file_descriptor) { close(file_descriptor); }
int ReadFile(int file_descriptor, void* buffer, size_t buffer_size) {
int CpuFeatures_ReadFile(int file_descriptor, void* buffer,
size_t buffer_size) {
int result;
do {
result = read(file_descriptor, buffer, buffer_size);

10
src/hwcaps.c
View File

@ -110,13 +110,13 @@ static uint32_t GetElfHwcapFromProcSelfAuxv(uint32_t hwcap_type) {
} entry;
uint32_t result = 0;
const char filepath[] = "/proc/self/auxv";
const int fd = OpenFile(filepath);
const int fd = CpuFeatures_OpenFile(filepath);
if (fd < 0) {
D("Could not open %s\n", filepath);
return 0;
}
for (;;) {
const int ret = ReadFile(fd, (char*)&entry, sizeof entry);
const int ret = CpuFeatures_ReadFile(fd, (char*)&entry, sizeof entry);
if (ret < 0) {
D("Error while reading %s\n", filepath);
break;
@ -130,7 +130,7 @@ static uint32_t GetElfHwcapFromProcSelfAuxv(uint32_t hwcap_type) {
break;
}
}
CloseFile(fd);
CpuFeatures_CloseFile(fd);
return result;
}
@ -145,7 +145,7 @@ static uint32_t GetHardwareCapabilitiesFor(uint32_t type) {
return hwcaps;
}
HardwareCapabilities GetHardwareCapabilities(void) {
HardwareCapabilities CpuFeatures_GetHardwareCapabilities(void) {
HardwareCapabilities capabilities;
capabilities.hwcaps = GetHardwareCapabilitiesFor(AT_HWCAP);
capabilities.hwcaps2 = GetHardwareCapabilitiesFor(AT_HWCAP2);
@ -159,7 +159,7 @@ HardwareCapabilities GetHardwareCapabilities(void) {
////////////////////////////////////////////////////////////////////////////////
const HardwareCapabilities kEmptyHardwareCapabilities;
HardwareCapabilities GetHardwareCapabilities(void) {
HardwareCapabilities CpuFeatures_GetHardwareCapabilities(void) {
return kEmptyHardwareCapabilities;
}
#endif

11
src/linux_features_aggregator.c
View File

@ -15,12 +15,15 @@
#include "internal/linux_features_aggregator.h"
#include "internal/string_view.h"
void SetFromFlags(const size_t configs_size, const CapabilityConfig* configs,
const StringView flags_line, void* const features) {
void CpuFeatures_SetFromFlags(const size_t configs_size,
const CapabilityConfig* configs,
const StringView flags_line,
void* const features) {
size_t i = 0;
for (; i < configs_size; ++i) {
const CapabilityConfig config = configs[i];
config.set_bit(features, HasWord(flags_line, config.proc_cpuinfo_flag));
config.set_bit(features, CpuFeatures_StringView_HasWord(
flags_line, config.proc_cpuinfo_flag));
}
}
@ -34,7 +37,7 @@ static bool IsHwCapsSet(const HardwareCapabilities hwcaps_mask,
IsSet(hwcaps_mask.hwcaps2, hwcaps.hwcaps2);
}
void OverrideFromHwCaps(const size_t configs_size,
void CpuFeatures_OverrideFromHwCaps(const size_t configs_size,
const CapabilityConfig* configs,
const HardwareCapabilities hwcaps,
void* const features) {

17
src/stack_line_reader.c
View File

@ -28,8 +28,8 @@ void StackLineReader_Initialize(StackLineReader* reader, int fd) {
// Replaces the content of buffer with bytes from the file.
static int LoadFullBuffer(StackLineReader* reader) {
const int read =
ReadFile(reader->fd, reader->buffer, STACK_LINE_READER_BUFFER_SIZE);
const int read = CpuFeatures_ReadFile(reader->fd, reader->buffer,
STACK_LINE_READER_BUFFER_SIZE);
assert(read >= 0);
reader->view.ptr = reader->buffer;
reader->view.size = read;
@ -40,7 +40,7 @@ static int LoadFullBuffer(StackLineReader* reader) {
static int LoadMore(StackLineReader* reader) {
char* const ptr = reader->buffer + reader->view.size;
const size_t size_to_read = STACK_LINE_READER_BUFFER_SIZE - reader->view.size;
const int read = ReadFile(reader->fd, ptr, size_to_read);
const int read = CpuFeatures_ReadFile(reader->fd, ptr, size_to_read);
assert(read >= 0);
assert(read <= (int)size_to_read);
reader->view.size += read;
@ -48,7 +48,7 @@ static int LoadMore(StackLineReader* reader) {
}
static int IndexOfEol(StackLineReader* reader) {
return IndexOfChar(reader->view, '\n');
return CpuFeatures_StringView_IndexOfChar(reader->view, '\n');
}
// Relocate buffer's pending bytes at the beginning of the array and fills the
@ -71,7 +71,8 @@ static void SkipToNextLine(StackLineReader* reader) {
} else {
const int eol_index = IndexOfEol(reader);
if (eol_index >= 0) {
reader->view = PopFront(reader->view, eol_index + 1);
reader->view =
CpuFeatures_StringView_PopFront(reader->view, eol_index + 1);
break;
}
}
@ -120,8 +121,10 @@ LineResult StackLineReader_NextLine(StackLineReader* reader) {
return CreateTruncatedLineResult(reader->view);
}
{
StringView line = KeepFront(reader->view, eol_index);
reader->view = PopFront(reader->view, eol_index + 1);
StringView line =
CpuFeatures_StringView_KeepFront(reader->view, eol_index);
reader->view =
CpuFeatures_StringView_PopFront(reader->view, eol_index + 1);
return CreateValidLineResult(line);
}
}

85
src/string_view.c
View File

@ -18,7 +18,7 @@
#include <ctype.h>
#include <string.h>
int IndexOfChar(const StringView view, char c) {
int CpuFeatures_StringView_IndexOfChar(const StringView view, char c) {
if (view.ptr && view.size) {
const char* const found = (const char*)memchr(view.ptr, c, view.size);
if (found) {
@ -28,67 +28,74 @@ int IndexOfChar(const StringView view, char c) {
return -1;
}
int IndexOf(const StringView view, const StringView sub_view) {
int CpuFeatures_StringView_IndexOf(const StringView view,
const StringView sub_view) {
if (sub_view.size) {
StringView remainder = view;
while (remainder.size >= sub_view.size) {
const int found_index = IndexOfChar(remainder, sub_view.ptr[0]);
const int found_index =
CpuFeatures_StringView_IndexOfChar(remainder, sub_view.ptr[0]);
if (found_index < 0) break;
remainder = PopFront(remainder, found_index);
if (StartsWith(remainder, sub_view)) {
remainder = CpuFeatures_StringView_PopFront(remainder, found_index);
if (CpuFeatures_StringView_StartsWith(remainder, sub_view)) {
return remainder.ptr - view.ptr;
}
remainder = PopFront(remainder, 1);
remainder = CpuFeatures_StringView_PopFront(remainder, 1);
}
}
return -1;
}
bool IsEquals(const StringView a, const StringView b) {
bool CpuFeatures_StringView_IsEquals(const StringView a, const StringView b) {
if (a.size == b.size) {
return a.ptr == b.ptr || memcmp(a.ptr, b.ptr, b.size) == 0;
}
return false;
}
bool StartsWith(const StringView a, const StringView b) {
bool CpuFeatures_StringView_StartsWith(const StringView a, const StringView b) {
return a.ptr && b.ptr && b.size && a.size >= b.size
? memcmp(a.ptr, b.ptr, b.size) == 0
: false;
}
StringView PopFront(const StringView str_view, size_t count) {
StringView CpuFeatures_StringView_PopFront(const StringView str_view,
size_t count) {
if (count > str_view.size) {
return kEmptyStringView;
}
return view(str_view.ptr + count, str_view.size - count);
}
StringView PopBack(const StringView str_view, size_t count) {
StringView CpuFeatures_StringView_PopBack(const StringView str_view,
size_t count) {
if (count > str_view.size) {
return kEmptyStringView;
}
return view(str_view.ptr, str_view.size - count);
}
StringView KeepFront(const StringView str_view, size_t count) {
StringView CpuFeatures_StringView_KeepFront(const StringView str_view,
size_t count) {
return count <= str_view.size ? view(str_view.ptr, count) : str_view;
}
char Front(const StringView view) {
char CpuFeatures_StringView_Front(const StringView view) {
assert(view.size);
assert(view.ptr);
return view.ptr[0];
}
char Back(const StringView view) {
char CpuFeatures_StringView_Back(const StringView view) {
assert(view.size);
return view.ptr[view.size - 1];
}
StringView TrimWhitespace(StringView view) {
while (view.size && isspace(Front(view))) view = PopFront(view, 1);
while (view.size && isspace(Back(view))) view = PopBack(view, 1);
StringView CpuFeatures_StringView_TrimWhitespace(StringView view) {
while (view.size && isspace(CpuFeatures_StringView_Front(view)))
view = CpuFeatures_StringView_PopFront(view, 1);
while (view.size && isspace(CpuFeatures_StringView_Back(view)))
view = CpuFeatures_StringView_PopBack(view, 1);
return view;
}
@ -103,19 +110,21 @@ static int HexValue(const char c) {
static int ParsePositiveNumberWithBase(const StringView view, int base) {
int result = 0;
StringView remainder = view;
for (; remainder.size; remainder = PopFront(remainder, 1)) {
const int value = HexValue(Front(remainder));
for (; remainder.size;
remainder = CpuFeatures_StringView_PopFront(remainder, 1)) {
const int value = HexValue(CpuFeatures_StringView_Front(remainder));
if (value < 0 || value >= base) return -1;
result = (result * base) + value;
}
return result;
}
int ParsePositiveNumber(const StringView view) {
int CpuFeatures_StringView_ParsePositiveNumber(const StringView view) {
if (view.size) {
const StringView hex_prefix = str("0x");
if (StartsWith(view, hex_prefix)) {
const StringView span_no_prefix = PopFront(view, hex_prefix.size);
if (CpuFeatures_StringView_StartsWith(view, hex_prefix)) {
const StringView span_no_prefix =
CpuFeatures_StringView_PopFront(view, hex_prefix.size);
return ParsePositiveNumberWithBase(span_no_prefix, 16);
}
return ParsePositiveNumberWithBase(view, 10);
@ -123,7 +132,8 @@ int ParsePositiveNumber(const StringView view) {
return -1;
}
void CopyString(const StringView src, char* dst, size_t dst_size) {
void CpuFeatures_StringView_CopyString(const StringView src, char* dst,
size_t dst_size) {
if (dst_size > 0) {
const size_t max_copy_size = dst_size - 1;
const size_t copy_size =
@ -133,31 +143,40 @@ void CopyString(const StringView src, char* dst, size_t dst_size) {
}
}
bool HasWord(const StringView line, const char* const word_str) {
bool CpuFeatures_StringView_HasWord(const StringView line,
const char* const word_str) {
const StringView word = str(word_str);
StringView remainder = line;
for (;;) {
const int index_of_word = IndexOf(remainder, word);
const int index_of_word = CpuFeatures_StringView_IndexOf(remainder, word);
if (index_of_word < 0) {
return false;
} else {
const StringView before = KeepFront(line, index_of_word);
const StringView after = PopFront(line, index_of_word + word.size);
const bool valid_before = before.size == 0 || Back(before) == ' ';
const bool valid_after = after.size == 0 || Front(after) == ' ';
const StringView before =
CpuFeatures_StringView_KeepFront(line, index_of_word);
const StringView after =
CpuFeatures_StringView_PopFront(line, index_of_word + word.size);
const bool valid_before =
before.size == 0 || CpuFeatures_StringView_Back(before) == ' ';
const bool valid_after =
after.size == 0 || CpuFeatures_StringView_Front(after) == ' ';
if (valid_before && valid_after) return true;
remainder = PopFront(remainder, index_of_word + word.size);
remainder =
CpuFeatures_StringView_PopFront(remainder, index_of_word + word.size);
}
}
return false;
}
bool GetAttributeKeyValue(const StringView line, StringView* key,
bool CpuFeatures_StringView_GetAttributeKeyValue(const StringView line,
StringView* key,
StringView* value) {
const StringView sep = str(": ");
const int index_of_separator = IndexOf(line, sep);
const int index_of_separator = CpuFeatures_StringView_IndexOf(line, sep);
if (index_of_separator < 0) return false;
*value = TrimWhitespace(PopFront(line, index_of_separator + sep.size));
*key = TrimWhitespace(KeepFront(line, index_of_separator));
*value = CpuFeatures_StringView_TrimWhitespace(
CpuFeatures_StringView_PopFront(line, index_of_separator + sep.size));
*key = CpuFeatures_StringView_TrimWhitespace(
CpuFeatures_StringView_KeepFront(line, index_of_separator));
return true;
}

7
test/filesystem_for_testing.cc
View File

@ -81,7 +81,7 @@ FakeFilesystem& GetEmptyFilesystem() {
return *kFilesystem;
}
extern "C" int OpenFile(const char* filename) {
extern "C" int CpuFeatures_OpenFile(const char* filename) {
auto* const file = kFilesystem->FindFileOrNull(filename);
if (file) {
file->Open();
@ -90,11 +90,12 @@ extern "C" int OpenFile(const char* filename) {
return -1;
}
extern "C" void CloseFile(int file_descriptor) {
extern "C" void CpuFeatures_CloseFile(int file_descriptor) {
kFilesystem->FindFileOrDie(file_descriptor)->Close();
}
extern "C" int ReadFile(int file_descriptor, void* buf, size_t count) {
extern "C" int CpuFeatures_ReadFile(int file_descriptor, void* buf,
size_t count) {
return kFilesystem->FindFileOrDie(file_descriptor)
->Read(file_descriptor, buf, count);
}

2
test/hwcaps_for_testing.cc
View File

@ -25,7 +25,7 @@ void SetHardwareCapabilities(uint32_t hwcaps, uint32_t hwcaps2) {
g_hardware_capabilities->hwcaps2 = hwcaps2;
}
HardwareCapabilities GetHardwareCapabilities(void) {
HardwareCapabilities CpuFeatures_GetHardwareCapabilities(void) {
return *g_hardware_capabilities;
}

15
test/linux_features_aggregator_test.cc
View File

@ -42,7 +42,8 @@ class LinuxFeatureAggregatorTest : public testing::Test {
TEST_F(LinuxFeatureAggregatorTest, FromFlagsEmpty) {
Features features;
SetFromFlags(kConfigs.size(), kConfigs.data(), str(""), &features);
CpuFeatures_SetFromFlags(kConfigs.size(), kConfigs.data(), str(""),
&features);
EXPECT_FALSE(features.a);
EXPECT_FALSE(features.b);
EXPECT_FALSE(features.c);
@ -50,7 +51,8 @@ TEST_F(LinuxFeatureAggregatorTest, FromFlagsEmpty) {
TEST_F(LinuxFeatureAggregatorTest, FromFlagsAllSet) {
Features features;
SetFromFlags(kConfigs.size(), kConfigs.data(), str("a c b"), &features);
CpuFeatures_SetFromFlags(kConfigs.size(), kConfigs.data(), str("a c b"),
&features);
EXPECT_TRUE(features.a);
EXPECT_TRUE(features.b);
EXPECT_TRUE(features.c);
@ -58,7 +60,8 @@ TEST_F(LinuxFeatureAggregatorTest, FromFlagsAllSet) {
TEST_F(LinuxFeatureAggregatorTest, FromFlagsOnlyA) {
Features features;
SetFromFlags(kConfigs.size(), kConfigs.data(), str("a"), &features);
CpuFeatures_SetFromFlags(kConfigs.size(), kConfigs.data(), str("a"),
&features);
EXPECT_TRUE(features.a);
EXPECT_FALSE(features.b);
EXPECT_FALSE(features.c);
@ -69,7 +72,8 @@ TEST_F(LinuxFeatureAggregatorTest, FromHwcapsNone) {
capability.hwcaps = 0; // matches none
capability.hwcaps2 = 0; // matches none
Features features;
OverrideFromHwCaps(kConfigs.size(), kConfigs.data(), capability, &features);
CpuFeatures_OverrideFromHwCaps(kConfigs.size(), kConfigs.data(), capability,
&features);
EXPECT_FALSE(features.a);
EXPECT_FALSE(features.b);
EXPECT_FALSE(features.c);
@ -80,7 +84,8 @@ TEST_F(LinuxFeatureAggregatorTest, FromHwcapsSet) {
capability.hwcaps = 0b0010; // matches b but not a
capability.hwcaps2 = 0b1111; // matches c
Features features;
OverrideFromHwCaps(kConfigs.size(), kConfigs.data(), capability, &features);
CpuFeatures_OverrideFromHwCaps(kConfigs.size(), kConfigs.data(), capability,
&features);
EXPECT_FALSE(features.a);
EXPECT_TRUE(features.b);
EXPECT_TRUE(features.c);

2
test/stack_line_reader_test.cc
View File

@ -20,7 +20,7 @@
namespace cpu_features {
bool operator==(const StringView& a, const StringView& b) {
return IsEquals(a, b);
return CpuFeatures_StringView_IsEquals(a, b);
}
namespace {

106
test/string_view_test.cc
View File

@ -19,7 +19,7 @@
namespace cpu_features {
bool operator==(const StringView& a, const StringView& b) {
return IsEquals(a, b);
return CpuFeatures_StringView_IsEquals(a, b);
}
namespace {
@ -35,95 +35,101 @@ TEST(StringViewTest, Build) {
EXPECT_EQ(view.size, 4);
}
TEST(StringViewTest, IndexOfChar) {
TEST(StringViewTest, CpuFeatures_StringView_IndexOfChar) {
// Found.
EXPECT_EQ(IndexOfChar(str("test"), 'e'), 1);
EXPECT_EQ(CpuFeatures_StringView_IndexOfChar(str("test"), 'e'), 1);
// Not found.
EXPECT_EQ(IndexOfChar(str("test"), 'z'), -1);
EXPECT_EQ(CpuFeatures_StringView_IndexOfChar(str("test"), 'z'), -1);
// Empty.
EXPECT_EQ(IndexOfChar(kEmptyStringView, 'z'), -1);
EXPECT_EQ(CpuFeatures_StringView_IndexOfChar(kEmptyStringView, 'z'), -1);
}
TEST(StringViewTest, IndexOf) {
TEST(StringViewTest, CpuFeatures_StringView_IndexOf) {
// Found.
EXPECT_EQ(IndexOf(str("test"), str("es")), 1);
EXPECT_EQ(CpuFeatures_StringView_IndexOf(str("test"), str("es")), 1);
// Not found.
EXPECT_EQ(IndexOf(str("test"), str("aa")), -1);
EXPECT_EQ(CpuFeatures_StringView_IndexOf(str("test"), str("aa")), -1);
// Empty.
EXPECT_EQ(IndexOf(kEmptyStringView, str("aa")), -1);
EXPECT_EQ(IndexOf(str("aa"), kEmptyStringView), -1);
EXPECT_EQ(CpuFeatures_StringView_IndexOf(kEmptyStringView, str("aa")), -1);
EXPECT_EQ(CpuFeatures_StringView_IndexOf(str("aa"), kEmptyStringView), -1);
}
TEST(StringViewTest, StartsWith) {
EXPECT_TRUE(StartsWith(str("test"), str("te")));
EXPECT_FALSE(StartsWith(str("test"), str("")));
EXPECT_FALSE(StartsWith(str("test"), kEmptyStringView));
EXPECT_FALSE(StartsWith(kEmptyStringView, str("test")));
TEST(StringViewTest, CpuFeatures_StringView_StartsWith) {
EXPECT_TRUE(CpuFeatures_StringView_StartsWith(str("test"), str("te")));
EXPECT_FALSE(CpuFeatures_StringView_StartsWith(str("test"), str("")));
EXPECT_FALSE(
CpuFeatures_StringView_StartsWith(str("test"), kEmptyStringView));
EXPECT_FALSE(
CpuFeatures_StringView_StartsWith(kEmptyStringView, str("test")));
}
TEST(StringViewTest, IsEquals) {
EXPECT_TRUE(IsEquals(kEmptyStringView, kEmptyStringView));
EXPECT_TRUE(IsEquals(kEmptyStringView, str("")));
EXPECT_TRUE(IsEquals(str(""), kEmptyStringView));
EXPECT_TRUE(IsEquals(str("a"), str("a")));
EXPECT_FALSE(IsEquals(str("a"), str("b")));
EXPECT_FALSE(IsEquals(str("a"), kEmptyStringView));
EXPECT_FALSE(IsEquals(kEmptyStringView, str("a")));
TEST(StringViewTest, CpuFeatures_StringView_IsEquals) {
EXPECT_TRUE(
CpuFeatures_StringView_IsEquals(kEmptyStringView, kEmptyStringView));
EXPECT_TRUE(CpuFeatures_StringView_IsEquals(kEmptyStringView, str("")));
EXPECT_TRUE(CpuFeatures_StringView_IsEquals(str(""), kEmptyStringView));
EXPECT_TRUE(CpuFeatures_StringView_IsEquals(str("a"), str("a")));
EXPECT_FALSE(CpuFeatures_StringView_IsEquals(str("a"), str("b")));
EXPECT_FALSE(CpuFeatures_StringView_IsEquals(str("a"), kEmptyStringView));
EXPECT_FALSE(CpuFeatures_StringView_IsEquals(kEmptyStringView, str("a")));
}
TEST(StringViewTest, PopFront) {
EXPECT_EQ(PopFront(str("test"), 2), str("st"));
EXPECT_EQ(PopFront(str("test"), 0), str("test"));
EXPECT_EQ(PopFront(str("test"), 4), str(""));
EXPECT_EQ(PopFront(str("test"), 100), str(""));
TEST(StringViewTest, CpuFeatures_StringView_PopFront) {
EXPECT_EQ(CpuFeatures_StringView_PopFront(str("test"), 2), str("st"));
EXPECT_EQ(CpuFeatures_StringView_PopFront(str("test"), 0), str("test"));
EXPECT_EQ(CpuFeatures_StringView_PopFront(str("test"), 4), str(""));
EXPECT_EQ(CpuFeatures_StringView_PopFront(str("test"), 100), str(""));
}
TEST(StringViewTest, ParsePositiveNumber) {
EXPECT_EQ(ParsePositiveNumber(str("42")), 42);
EXPECT_EQ(ParsePositiveNumber(str("0x2a")), 42);
EXPECT_EQ(ParsePositiveNumber(str("0x2A")), 42);
TEST(StringViewTest, CpuFeatures_StringView_ParsePositiveNumber) {
EXPECT_EQ(CpuFeatures_StringView_ParsePositiveNumber(str("42")), 42);
EXPECT_EQ(CpuFeatures_StringView_ParsePositiveNumber(str("0x2a")), 42);
EXPECT_EQ(CpuFeatures_StringView_ParsePositiveNumber(str("0x2A")), 42);
EXPECT_EQ(ParsePositiveNumber(str("-0x2A")), -1);
EXPECT_EQ(ParsePositiveNumber(str("abc")), -1);
EXPECT_EQ(ParsePositiveNumber(str("")), -1);
EXPECT_EQ(CpuFeatures_StringView_ParsePositiveNumber(str("-0x2A")), -1);
EXPECT_EQ(CpuFeatures_StringView_ParsePositiveNumber(str("abc")), -1);
EXPECT_EQ(CpuFeatures_StringView_ParsePositiveNumber(str("")), -1);
}
TEST(StringViewTest, CopyString) {
TEST(StringViewTest, CpuFeatures_StringView_CopyString) {
char buf[4];
buf[0] = 'X';
// Empty
CopyString(str(""), buf, sizeof(buf));
CpuFeatures_StringView_CopyString(str(""), buf, sizeof(buf));
EXPECT_STREQ(buf, "");
// Less
CopyString(str("a"), buf, sizeof(buf));
CpuFeatures_StringView_CopyString(str("a"), buf, sizeof(buf));
EXPECT_STREQ(buf, "a");
// exact
CopyString(str("abc"), buf, sizeof(buf));
CpuFeatures_StringView_CopyString(str("abc"), buf, sizeof(buf));
EXPECT_STREQ(buf, "abc");
// More
CopyString(str("abcd"), buf, sizeof(buf));
CpuFeatures_StringView_CopyString(str("abcd"), buf, sizeof(buf));
EXPECT_STREQ(buf, "abc");
}
TEST(StringViewTest, HasWord) {
TEST(StringViewTest, CpuFeatures_StringView_HasWord) {
// Find flags at beginning, middle and end.
EXPECT_TRUE(HasWord(str("first middle last"), "first"));
EXPECT_TRUE(HasWord(str("first middle last"), "middle"));
EXPECT_TRUE(HasWord(str("first middle last"), "last"));
EXPECT_TRUE(
CpuFeatures_StringView_HasWord(str("first middle last"), "first"));
EXPECT_TRUE(
CpuFeatures_StringView_HasWord(str("first middle last"), "middle"));
EXPECT_TRUE(CpuFeatures_StringView_HasWord(str("first middle last"), "last"));
// Do not match partial flags
EXPECT_FALSE(HasWord(str("first middle last"), "irst"));
EXPECT_FALSE(HasWord(str("first middle last"), "mid"));
EXPECT_FALSE(HasWord(str("first middle last"), "las"));
EXPECT_FALSE(
CpuFeatures_StringView_HasWord(str("first middle last"), "irst"));
EXPECT_FALSE(CpuFeatures_StringView_HasWord(str("first middle last"), "mid"));
EXPECT_FALSE(CpuFeatures_StringView_HasWord(str("first middle last"), "las"));
}
TEST(StringViewTest, GetAttributeKeyValue) {
TEST(StringViewTest, CpuFeatures_StringView_GetAttributeKeyValue) {
const StringView line = str(" key : first middle last ");
StringView key, value;
EXPECT_TRUE(GetAttributeKeyValue(line, &key, &value));
EXPECT_TRUE(CpuFeatures_StringView_GetAttributeKeyValue(line, &key, &value));
EXPECT_EQ(key, str("key"));
EXPECT_EQ(value, str("first middle last"));
}
@ -131,7 +137,7 @@ TEST(StringViewTest, GetAttributeKeyValue) {
TEST(StringViewTest, FailingGetAttributeKeyValue) {
const StringView line = str("key first middle last");
StringView key, value;
EXPECT_FALSE(GetAttributeKeyValue(line, &key, &value));
EXPECT_FALSE(CpuFeatures_StringView_GetAttributeKeyValue(line, &key, &value));
}
} // namespace