Merge pull request #323 from deeglaze/remove_using_std

Remove using namespace std

Signed-off-by: Zhang Lili Z <lili.z.zhang@intel.com>

Author: lzha101

common/src/sgx_profile.cpp

@@ -38,15 +38,14 @@
 #include "sgx_profile.h"
 #include "se_time.h"
 #include <string.h>
-using namespace std;
 
 typedef struct _profile_item_t{
     const char *str;  /* tag */
     int  flag;        /* 0: start, 1: end */
     long long time;   /* current time */
 } profile_item_t;
 
-static vector<profile_item_t> profile_items;
+static std::vector<profile_item_t> profile_items;
 static int alloc_size;
 static int used_size;
 const int MALLOC_SIZE = 1000;
@@ -108,7 +107,7 @@ extern "C" void profile_output(const char* filename)
 {
     int i,j;
 
-    ofstream fs;
+    std::ofstream fs;
     fs.open(filename); /* do not overwritten previous value */
 
     fs << "freq: " << freq <<endl;

psw/ae/aesm_service/source/aesm_wrapper/inc/CAESMServer.h

@@ -39,8 +39,6 @@
 #include "AESMQueueManager.h"
 #include <stdexcept>
 
-using namespace std;
-
 /*
  * Encapsulates all AESM server logic
  */

psw/ae/aesm_service/source/oal/internal_log.cpp

@@ -59,7 +59,6 @@ static ae_error_t init_log_file(void)
 }
 
 #include <string>
-using namespace std;
 
 static const char *get_sgx_status_t_string(sgx_status_t status);
 static const char *get_ae_error_t_string(ae_error_t ae_error);

psw/ae/aesm_service/source/upse/interface_psda.cpp

@@ -44,9 +44,6 @@
 #define BREAK_IF_TRUE(x, Sts, ErrCode)  if (x)    { Sts = ErrCode; break; }
 #define BREAK_IF_FALSE(x, Sts, ErrCode) if (!(x)) { Sts = ErrCode; break; }
 
-using namespace std;
-
-
 static JVM_COMM_BUFFER commBuf_s1, commBuf_s3;
 static INT32 responseCode;
 

psw/urts/enclave.cpp

@@ -45,8 +45,6 @@
 #include "rts.h"
 
 
-using namespace std;
-
 int do_ecall(const int fn, const void *ocall_table, const void *ms, CTrustThread *trust_thread);
 int do_ocall(const bridge_fn_t bridge, void *ms);
 

psw/urts/linux/misc.cpp

@@ -34,10 +34,8 @@
 #include <dirent.h>
 #include <vector>
 
-using namespace std;
-
 //get all thread id of current process.
-void get_thread_set(vector<se_thread_id_t> &thread_vector)
+void get_thread_set(std::vector<se_thread_id_t> &thread_vector)
 {
     DIR*   dir = NULL;
     struct dirent* dirent = NULL;

psw/urts/loader.cpp

@@ -103,7 +103,7 @@ void* CLoader::get_symbol_address(const char * const symbol)
 }
 
 // is_relocation_page returns true if the specified RVA is a writable relocation page based on the bitmap.
-bool CLoader::is_relocation_page(const uint64_t rva, vector<uint8_t> *bitmap)
+bool CLoader::is_relocation_page(const uint64_t rva, std::vector<uint8_t> *bitmap)
 {
     uint64_t page_frame = rva >> SE_PAGE_SHIFT;
     //NOTE:
@@ -181,7 +181,7 @@ int CLoader::build_mem_region(const section_info_t &sec_info)
     return SGX_SUCCESS;
 }
 
-int CLoader::build_sections(vector<uint8_t> *bitmap)
+int CLoader::build_sections(std::vector<uint8_t> *bitmap)
 {
     int ret = SGX_SUCCESS;
     std::vector<Section*> sections = m_parser.get_sections();
@@ -372,7 +372,7 @@ int CLoader::build_context(const uint64_t start_rva, layout_entry_t *layout)
                 ptcs->ogs_base += rva;
                 if(!(attributes & PAGE_ATTR_EREMOVE))
                 {
-                    m_tcs_list.push_back(make_pair(GET_PTR(tcs_t, m_start_addr, rva), false));
+                  m_tcs_list.push_back(std::make_pair(GET_PTR(tcs_t, m_start_addr, rva), false));
                 }
                 sinfo.flags = layout->si_flags;
                 if(SGX_SUCCESS != (ret = build_pages(rva, ((uint64_t)layout->page_count) << SE_PAGE_SHIFT, added_page, sinfo, attributes)))
@@ -417,7 +417,7 @@ int CLoader::build_context(const uint64_t start_rva, layout_entry_t *layout)
 #ifndef SE_SIM
         if(layout->id == LAYOUT_ID_TCS_DYN)
         {
-            m_tcs_list.push_back(make_pair(GET_PTR(tcs_t, m_start_addr, rva), true));
+          m_tcs_list.push_back(std::make_pair(GET_PTR(tcs_t, m_start_addr, rva), true));
         }
 #endif
     }
@@ -486,7 +486,7 @@ int CLoader::build_image(SGXLaunchToken * const lc, sgx_attributes_t * const sec
     // If load_enclave_ex try to load the enclave for the 2nd time,
     // the enclave image is already patched, and parser cannot read the information.
     // For linux, there's no map conflict. We assume load_enclave_ex will not do the retry.
-    vector<uint8_t> bitmap;
+    std::vector<uint8_t> bitmap;
     if(!m_parser.get_reloc_bitmap(bitmap))
         return SGX_ERROR_INVALID_ENCLAVE;
 
@@ -564,12 +564,12 @@ int CLoader::validate_layout_table()
 {
     layout_t *layout_start = GET_PTR(layout_t, m_metadata, m_metadata->dirs[DIR_LAYOUT].offset);
     layout_t *layout_end = GET_PTR(layout_t, m_metadata, m_metadata->dirs[DIR_LAYOUT].offset + m_metadata->dirs[DIR_LAYOUT].size);
-    vector<pair<uint64_t, uint64_t>> rva_vector;
+    std::vector<std::pair<uint64_t, uint64_t>> rva_vector;
     for (layout_t *layout = layout_start; layout < layout_end; layout++)
     {
         if(!IS_GROUP_ID(layout->entry.id))  // layout entry
         {
-            rva_vector.push_back(make_pair(layout->entry.rva, ((uint64_t)layout->entry.page_count) << SE_PAGE_SHIFT));
+          rva_vector.push_back(std::make_pair(layout->entry.rva, ((uint64_t)layout->entry.page_count) << SE_PAGE_SHIFT));
             if(layout->entry.content_offset)
             {
                 if(false == is_metadata_buffer(layout->entry.content_offset, layout->entry.content_size))
@@ -598,15 +598,15 @@ int CLoader::validate_layout_table()
                     {
                         return SGX_ERROR_INVALID_METADATA;
                     }
-                    rva_vector.push_back(make_pair(entry->rva + load_step, ((uint64_t)entry->page_count) << SE_PAGE_SHIFT));
+                    rva_vector.push_back(std::make_pair(entry->rva + load_step, ((uint64_t)entry->page_count) << SE_PAGE_SHIFT));
                     // no need to check integer overflow for entry->rva + load_step, because
                     // entry->rva and load_step are less than enclave_size, whose size is no more than 37 bit
                 }
             }
         }
     }
     sort(rva_vector.begin(), rva_vector.end());
-    for (vector<pair<uint64_t, uint64_t>>::iterator it = rva_vector.begin(); it != rva_vector.end(); it++)
+    for (std::vector<std::pair<uint64_t, uint64_t>>::iterator it = rva_vector.begin(); it != rva_vector.end(); it++)
     {
         if(!IS_PAGE_ALIGNED(it->first))
         {

psw/urts/loader.h

@@ -77,7 +77,7 @@ class CLoader: private Uncopyable
     int build_contexts(layout_t *layout_start, layout_t *layout_end, uint64_t delta);
     int build_partial_page(const uint64_t rva, const uint64_t size, const void *source, const sec_info_t &sinfo, const uint32_t attr);
     int build_pages(const uint64_t start_rva, const uint64_t size, const void *source, const sec_info_t &sinfo, const uint32_t attr);
-    bool is_relocation_page(const uint64_t rva, vector<uint8_t> *bitmap);
+  bool is_relocation_page(const uint64_t rva, std::vector<uint8_t> *bitmap);
 
     bool is_ae(const enclave_css_t *enclave_css);
     bool is_metadata_buffer(uint32_t offset, uint32_t size);
@@ -86,7 +86,7 @@ class CLoader: private Uncopyable
     int validate_patch_table();
     int validate_metadata();
     int get_debug_flag(const token_t * const launch);
-    virtual int build_sections(vector<uint8_t> *bitmap);
+  virtual int build_sections(std::vector<uint8_t> *bitmap);
     int set_context_protection(layout_t *layout_start, layout_t *layout_end, uint64_t delta);
 
     uint8_t             *m_mapped_file_base;

psw/urts/parser/binparser.h

@@ -41,8 +41,6 @@
 #include <stdint.h>
 #include <vector>
 #include <string>
-using std::vector;
-using std::string;
 
 #define ENCLAVE_MAX_SIZE_32 0xffffffff
 #define ENCLAVE_MAX_SIZE_64 0x1fffffffff
@@ -77,17 +75,17 @@ class BinParser {
     virtual const uint8_t* get_start_addr() const = 0;
 
     // Get a vector of sections to be loaded
-    virtual const vector<Section *>& get_sections() const = 0;
+    virtual const std::vector<Section *>& get_sections() const = 0;
 
     // Get the TLS section
     virtual const Section* get_tls_section() const = 0;
 
     virtual uint64_t get_symbol_rva(const char* name) const = 0;
 
-    virtual bool get_reloc_bitmap(vector<uint8_t> &bitmap) = 0;
+    virtual bool get_reloc_bitmap(std::vector<uint8_t> &bitmap) = 0;
 
     virtual void get_reloc_entry_offset(const char* sec_name,
-                                        vector<uint64_t>& offsets) = 0;
+                                        std::vector<uint64_t>& offsets) = 0;
 
     // !We need to put this method into BinParser class since
     // !the `global_data_t' is platform-dependent as the parser.
@@ -107,7 +105,7 @@ class BinParser {
 
     virtual sgx_status_t get_info(enclave_diff_info_t *enclave_diff_info) = 0;
 
-    virtual void get_executable_sections(vector<const char *>& xsec_names) const = 0;
+    virtual void get_executable_sections(std::vector<const char *>& xsec_names) const = 0;
     virtual bool set_memory_protection(uint64_t enclave_base_addr, bool is_after_initialization) = 0;
     virtual void get_pages_to_protect(uint64_t, std::vector<std::tuple<uint64_t, uint64_t, uint32_t>>&) const = 0;
     virtual bool has_init_section() const = 0;

psw/urts/parser/elfparser.cpp

@@ -184,7 +184,7 @@ bool parse_dyn(const ElfW(Ehdr) *elf_hdr, ElfW(Dyn)* dyn_info)
  * We only need to search `.dynsym' for undefined symbols.
  */
 bool check_symbol_table(const ElfW(Ehdr) *elf_hdr, const ElfW(Dyn) *dyn_info,
-                        map<string, uint64_t>& sym_table)
+                        std::map<std::string, uint64_t>& sym_table)
 {
     const ElfW(Shdr) *sh_symtab = get_section_by_addr(elf_hdr, dyn_info[DT_SYMTAB].d_un.d_ptr);
 
@@ -245,7 +245,7 @@ bool check_symbol_table(const ElfW(Ehdr) *elf_hdr, const ElfW(Dyn) *dyn_info,
     // If the enclave if compiled/linked with -fpie/-pie, and setting the
     // enclave entry to `enclave_entry', the `st_name' for `enclave_entry'
     // will be 0 in `.dynsym'.
-    map<string, uint64_t>::const_iterator it = sym_table.find("enclave_entry");
+    std::map<std::string, uint64_t>::const_iterator it = sym_table.find("enclave_entry");
     if (it == sym_table.end())
     {
         sym_table["enclave_entry"] = (uint64_t)elf_hdr->e_entry;
@@ -504,7 +504,7 @@ Section* build_section(const uint8_t* raw_data, uint64_t size, uint64_t virtual_
 }
 
 bool build_regular_sections(const uint8_t* start_addr,
-                            vector<Section *>& sections,
+                            std::vector<Section *>& sections,
                             const Section*& tls_sec,
                             uint64_t& metadata_offset,
                             uint64_t& metadata_block_size)
@@ -565,7 +565,7 @@ bool build_regular_sections(const uint8_t* start_addr,
     return true;
 }
 
-const Section* get_max_rva_section(const vector<Section*> sections)
+const Section* get_max_rva_section(const std::vector<Section*> sections)
 {
     size_t sec_size = sections.size();
 
@@ -672,7 +672,7 @@ const uint8_t* ElfParser::get_start_addr() const
     return m_start_addr;
 }
 
-const vector<Section *>& ElfParser::get_sections() const
+const std::vector<Section *>& ElfParser::get_sections() const
 {
     return m_sections;
 }
@@ -684,7 +684,7 @@ const Section* ElfParser::get_tls_section() const
 
 uint64_t ElfParser::get_symbol_rva(const char* name) const
 {
-    map<string, uint64_t>::const_iterator it = m_sym_table.find(name);
+    std::map<std::string, uint64_t>::const_iterator it = m_sym_table.find(name);
     if (it != m_sym_table.end())
         return it->second;
     else
@@ -700,7 +700,7 @@ bool ElfParser::has_text_reloc() const
     return false;
 }
 
-bool ElfParser::get_reloc_bitmap(vector<uint8_t>& bitmap)
+bool ElfParser::get_reloc_bitmap(std::vector<uint8_t>& bitmap)
 {
     // Clear the `bitmap' so that it is in a known state
     bitmap.clear();
@@ -781,7 +781,7 @@ bool ElfParser::get_reloc_bitmap(vector<uint8_t>& bitmap)
     return true;
 }
 
-void ElfParser::get_reloc_entry_offset(const char* sec_name, vector<uint64_t>& offsets)
+void ElfParser::get_reloc_entry_offset(const char* sec_name, std::vector<uint64_t>& offsets)
 {
     if (sec_name == NULL)
         return;
@@ -859,7 +859,7 @@ sgx_status_t ElfParser::get_info(enclave_diff_info_t *enclave_diff_info)
     return SGX_SUCCESS;
 }
 
-void ElfParser::get_executable_sections(vector<const char *>& xsec_names) const
+void ElfParser::get_executable_sections(std::vector<const char *>& xsec_names) const
 {
     xsec_names.clear();
 

psw/urts/parser/elfparser.h

@@ -39,9 +39,6 @@
 #include <string>
 #include <map>
 
-using std::map;
-using std::string;
-
 class ElfParser : public BinParser, private Uncopyable {
 public:
     // The `start_addr' cannot be NULL
@@ -63,11 +60,11 @@ class ElfParser : public BinParser, private Uncopyable {
 
     // The `section' here is a section in PE's concept.
     // It is in fact a `segment' in ELF's view.
-    const vector<Section *>& get_sections() const;
+    const std::vector<Section *>& get_sections() const;
     const Section* get_tls_section() const;
     uint64_t get_symbol_rva(const char* name) const;
 
-    bool get_reloc_bitmap(vector<uint8_t> &bitmap);
+    bool get_reloc_bitmap(std::vector<uint8_t> &bitmap);
     bool has_text_reloc() const;
     uint32_t get_global_data_size();
     bool update_global_data(const metadata_t *const metadata,
@@ -86,11 +83,11 @@ class ElfParser : public BinParser, private Uncopyable {
     // To check whether current enclave has any TEXTREL:
     //   get_reloc_entry_offset(".text", offsets);
     void get_reloc_entry_offset(const char* sec_name,
-                                vector<uint64_t>& offsets);
+                                std::vector<uint64_t>& offsets);
 
     sgx_status_t modify_info(enclave_diff_info_t *enclave_diff_info);
     sgx_status_t get_info(enclave_diff_info_t *enclave_diff_info);
-    void get_executable_sections(vector<const char *>& xsec_names) const;
+    void get_executable_sections(std::vector<const char *>& xsec_names) const;
     bool is_enclave_encrypted() const;
 
     bool set_memory_protection(uint64_t enclave_base_addr, bool is_after_initialization);
@@ -99,18 +96,18 @@ class ElfParser : public BinParser, private Uncopyable {
     bool has_init_section() const;
 
 private:
-    const uint8_t*      m_start_addr;
-    uint64_t            m_len;
-    bin_fmt_t           m_bin_fmt;
-    vector<Section *>   m_sections;
-    const Section*      m_tls_section;
-    uint64_t            m_metadata_offset;
-    uint64_t            m_metadata_block_size;/*multiple metadata block size*/
+    const uint8_t*         m_start_addr;
+    uint64_t               m_len;
+    bin_fmt_t              m_bin_fmt;
+    std::vector<Section *> m_sections;
+    const Section*         m_tls_section;
+    uint64_t               m_metadata_offset;
+    uint64_t               m_metadata_block_size;/*multiple metadata block size*/
 
-    ElfW(Dyn)           m_dyn_info[DT_NUM + DT_ADDRNUM];
+    ElfW(Dyn)              m_dyn_info[DT_NUM + DT_ADDRNUM];
 
     // A map from symbol name to its RVA
-    map<string, uint64_t> m_sym_table;
+    std::map<std::string, uint64_t> m_sym_table;
 };
 
 #endif

psw/urts/section_info.h

@@ -36,16 +36,14 @@
 #include "util.h"
 #include <vector>
 
-using namespace std;
-
 typedef struct _section_info_t
 {
     const uint8_t *raw_data;          //The file pointer to the first page of the section.
     uint64_t raw_data_size;     //The size of the section or the size of the initialized section on disk.
     uint64_t rva;               //The address of the first byte of the section relative to the image base when section is loaded into memory.
     uint64_t virtual_size;      //The total size of the section when loaded into memory.
     si_flags_t flag;            //the attribute of memory region.
-    vector<uint8_t> *bitmap;    //bitmap of the total image page, if bit is 1, the page should be writable.
+    std::vector<uint8_t> *bitmap;    //bitmap of the total image page, if bit is 1, the page should be writable.
     //the first bit of scetion in the bitmap is bitmap[(rva >> PAGE_SHIFT) / 8] & (1 << ((rva >> PAGE_SHIFT) % 8))
     //if the bitmap is NULL, then no restrict on page attribute.
 } section_info_t;