illegal hardware instruction in clang - c++

Question

This is my code snippet (the header file is trivial so not appear here).
#include<string>
#include<list>
#include<optional>
#include<malloc.h>
#include "include/common.h"
using std::list;
using std::string;
using std::optional;
optional<list<string>> split(string content, const char *delimiter) {
char *buf = (char *)malloc(content.length());
memcpy(buf, content.c_str(), content.length());
const char *head = strtok(buf, delimiter);
const char *foll = buf; // follow ptr
list<string> l;
if(head == NULL){
return std::nullopt;
}
while(head != nullptr) {
DBG("%s", head);
// DBG("%s", foll);
// foll = head;
head = strtok(NULL, delimiter);
}
}
int main(){
string s("123 12312 123213a as dasd as asd");
split(s, " ");
}
and compile it with clang -o String String.cpp -g -std=c++17 -I../ -lstdc++
But it will crash when I execute it.
squ in 🌐 squ-virtual-machine in tinyhttpd/src on master [?]
❯ ./String
[x] split(), String.cpp:25 : 123
[x] split(), String.cpp:25 : 12312
[x] split(), String.cpp:25 : 123213a
[x] split(), String.cpp:25 : as
[x] split(), String.cpp:25 : dasd
[x] split(), String.cpp:25 : as
[x] split(), String.cpp:25 : asd
[1] 192159 illegal hardware instruction ./String
I use lldb to debug it and find this.
Process 192296 stopped
* thread #1, name = 'String', stop reason = signal SIGILL: illegal instruction operand
frame #0: 0x0000000000401458 String`split(content=error: summary string parsing error, delimiter=" ") at String.cpp:24:5
21 return std::nullopt;
22 }
23
-> 24 while(head != nullptr) {
25 DBG("%s", head);
26 // DBG("%s", foll);
27 // foll = head;
(lldb) p head
(const char *) $0 = 0x0000000000000000
(lldb) n
Process 192296 exited with status = 4 (0x00000004)
So I don't understand why the NULL compared with nullptr will throw this exception.

Answer 1

Example of splitting a string using current C++, without any low level pointer arithemtic and or manual memory allocation.
#include <iostream>
#include <string>
#include <string_view>
#include <vector>
#include <set>
// returns vector of string views to avoid copying of string data
// this function can split on multiple delimiters.
auto split_string(std::string_view string, std::string_view delimiters)
{
std::vector<std::string_view> substrings;
if (delimiters.size() == 0ul)
{
substrings.emplace_back(string);
return substrings;
}
auto start_pos = string.find_first_not_of(delimiters);
auto end_pos = start_pos;
auto max_length = string.length();
while (start_pos < max_length)
{
end_pos = std::min(max_length, string.find_first_of(delimiters, start_pos));
if (end_pos != start_pos)
{
substrings.emplace_back(&string[start_pos], end_pos - start_pos);
start_pos = string.find_first_not_of(delimiters, end_pos);
}
}
return substrings;
}
int main()
{
auto words = split_string("aaa aa abc aaa", " ");
for (const auto& word : words)
{
std::cout << word << "\n";
}
return 0;
}

Answer 2

You can avoid C-style code and use some useful features of C++ standard library to split a string.
A simple and efficient solution:
#include <iostream>
#include <string>
#include <string_view>
#include <vector>
#include <limits>
#include <cstddef>
[[ nodiscard ]] std::vector< std::string_view >
split( const std::string_view inputStr, const std::string_view delimiter = " \t" )
{
std::vector< std::string_view > foundTokens { };
if ( inputStr.empty( ) ) [[ unlikely ]]
{
return foundTokens;
}
using std::size_t;
for ( size_t start { inputStr.find_first_not_of( delimiter ) }, end { }
; start != std::string_view::npos; )
{
end = inputStr.find_first_of( delimiter, start );
foundTokens.emplace_back( inputStr.substr( start, end - start ) );
start = inputStr.find_first_not_of( delimiter, end );
}
return foundTokens;
}
int main( )
{
const std::string text { "123 12312 123213a as dasd as asd" };
constexpr std::string_view delimiter { " \t" };
std::vector<std::string_view> tokens { split( text, delimiter ) };
if ( tokens.empty( ) )
{
std::cout << "No tokens were found\n";
}
else
{
std::cout << "Found tokens are the following:\n";
for ( const auto token : tokens )
{
std::cout << token << "\n";
}
}
}
Note: The string that you pass to the above function as the first argument should be alive after the function returns because the string_views in the returned vector point to the buffer of the inputStr. In other words, those returned string_views cannot outlive the original string that was passed to the above function's inputStr parameter. Otherwise those returned string_views will point to deleted memory and thus the program will have undefined behavior. In case you really don't want this kind of behavior you can replace all instances of std::string_views with std::strings and that will prevent the issue from happening though at the expense of less efficient code.